c#禁用事件一段时间
本文关键字：一段时间 事件 | 更新日期: 2023-09-27 18:17:13
我有这组函数来注销事件listBox1_SelectedValueChanged一段时间。
函数名为:Pause()。
是否有任何方法可以将此作为一个函数，可以对各种事件执行相同的操作，例如:
暂停(listBox1.SelectedValueChanged)
或
暂停(button1.Click)
等。
private System.Windows.Forms.Timer disableEvent = new System.Windows.Forms.Timer();
private void Pause(int forTime = 200)
{
listBox1.SelectedValueChanged -= new EventHandler(listBox1_SelectedValueChanged);
disableEvent.Tick += new EventHandler(disableEvent_Tick);
disableEvent.Interval = (forTime);
disableEvent.Enabled = true;
disableEvent.Start();
}
private void disableEvent_Tick(object sender, EventArgs e)
{
if (disableEvent.Enabled == true)
{
disableEvent.Tick -= new EventHandler(disableEvent_Tick);
disableEvent.Stop();
disableEvent.Enabled = false;
listBox1.SelectedValueChanged += new EventHandler(listBox1_SelectedValueChanged);
}
}
我将使用DateTime字段。即使允许运行，我也会检查SelectedValuedChanged()。(不注销事件)
例如:(pseudo)
public class Class1
{
private DateTime _isEnabledAfter = DateTime.MinValue;
public Class()
{
listBox1.SelectedValueChanged += new EventHandler(listBox1_SelectedValueChanged);
}
public void Pause(int timeMS)
{
// set the _isEnabledAfter in the future.
_isEnabledAfter = DateTime.Now.AddMilliseconds(timeMS);
}
public void listBox1_SelectedValueChanged(object sender, EventArgs e)
{
// is it after _isEnabledAfter?
if(DateTime.Now < _isEnabledAfter)
// nope... do nothing.
return;
// do your thing.
}
}
这将为您节省一些时间和复杂性。
可以是这样的:
public class Class1
{
private TimeEnabledEvent _selectedValueChanged = new TimeEnabledEvent();
public Class1()
{
listBox1.SelectedValueChanged += (s, e) =>
{
if (_selectedValueChanged.IsEnabled)
listBox1_SelectedValueChanged(s, e);
};
_selectedValueChanged.Pause(200);
}
public void listBox1_SelectedValueChanged(object sender, EventArgs e)
{
// do your thing.
}
}
public class TimeEnabledEvent
{
private DateTime _isEnabledAfter = DateTime.MinValue;
public void Pause(int timeMS)
{
// set the _isEnabledAfter in the future.
_isEnabledAfter = DateTime.Now.AddMilliseconds(timeMS);
}
public bool IsEnabled
{
get { return (DateTime.Now >= _isEnabledAfter); }
}
}
更新2:
public partial class Form1 : Form
{
private TimeEnabledEvent _event = new TimeEnabledEvent();
public Form1()
{
InitializeComponent();
listBox1.SelectedValueChanged += _event.Check(ListBox1_SelectedValueChanged);
_event.Pause(1000);
}
private void ListBox1_SelectedValueChanged(object sender, EventArgs e)
{
// do your thing
}
}
internal class TimeEnabledEvent
{
internal EventHandler Check(EventHandler listBox1_SelectedValueChanged)
{
return new EventHandler((ss, ee) =>
{
if (DateTime.Now >= _isEnabledAfter)
listBox1_SelectedValueChanged(ss, ee);
});
}
private DateTime _isEnabledAfter = DateTime.MinValue;
public void Pause(int timeMS)
{
// set the _isEnabledAfter in the future.
_isEnabledAfter = DateTime.Now.AddMilliseconds(timeMS);
}
}
我会使用微软的响应式框架- NuGet系统。"反应" -然后你可以这样做:
bool pause = false;
IObservable<EventPattern<EventArgs>> observable =
Observable
.FromEventPattern<EventHandler, EventArgs>(
h => listBox1.SelectedIndexChanged += h,
h => listBox1.SelectedIndexChanged -= h)
.Where(ep => pause != true);
IDisposable subscription =
observable
.Subscribe(ep => listBox1_SelectedValueChanged(ep.Sender, ep.EventArgs));
现在只要将pause的值从false更改为true就会暂停事件处理。
当您想要分离处理程序时，只需调用subscription.Dispose()。
我会使用WaitHandle来做到这一点，例如ManualResetEvent。如果您想独立挂起多个事件，我会使用不同的ManualResetEvent s。
我将这样实现它:
private ManualResetEvent pauseListBox1;
private ManualResetEvent pauseButton1;
要开始暂停，我将使用:
pauseListBox1.Set();
要结束暂停，我会使用:
pauseListBox1.Reset();
在事件处理程序中，我将使用这个
// Return from the event handler of the even is set
if (WaitHandle.WaitOne(1))
return;
我找到了一种方法(使用了一些来自这个论坛的代码)，它工作，但它有点复杂(好吧，也许非常复杂)这里是代码:
用法(暂停一段时间):listBox1.Pause("listBox1_SelectedValueChanged", 3000);
listBox1.Pause(3000); // to pause all events of listbox1
button3.Pause("button3_Click", 10000);
使用(直到恢复):
cEventSuppressor temp = listBox1.Suppress("listBox1_SelectedValueChanged");
cEventSuppressor temp = listBox1.Suppress(); //to suppress all
使用(在抑制-之后用于恢复):
temp.Resume("listBox1_SelectedValueChanged");
temp.Resume(); //To resume all
:
#region Events
public static class Events
{
public static void Pause(this Control control, string eventName, int forTime)
{
EventTimers et = new EventTimers();
et.PauseEvent(control, eventName, forTime);
}
public static void Pause(this Control control, int forTime)
{
EventTimers et1 = new EventTimers();
et1.PauseEvent(control, forTime);
}
public static cEventSuppressor Suppress(this Control control, string eventName)
{
cEventSuppressor newControl = null;
newControl = new cEventSuppressor(control);
newControl.Suppress(eventName);
return newControl;
}
public static cEventSuppressor Suppress(this Control control)
{
cEventSuppressor newControl = null;
newControl = new cEventSuppressor(control);
newControl.Suppress();
return newControl;
}
}
public class EventTimers
{
private System.Windows.Forms.Timer disableEvent = new System.Windows.Forms.Timer();
private cEventSuppressor suppressedControl { get; set; }
private static string eventName { get; set; }
//Pause specific Event
public void PauseEvent(Control control, string eventName, int forTime)
{
suppressedControl = new cEventSuppressor(control);
suppressedControl.Suppress(eventName);
disableEvent.Tick += new EventHandler(disableEvent_Tick);
disableEvent.Interval = (forTime);
disableEvent.Enabled = true;
disableEvent.Start();
}
private void disableEvent_Tick(object sender, EventArgs e)
{
if (disableEvent.Enabled == true)
{
disableEvent.Tick -= new EventHandler(disableEvent_Tick);
disableEvent.Stop();
disableEvent.Enabled = false;
suppressedControl.Resume(eventName);
}
}
//Pause All Events
public void PauseEvent(Control control, int forTime)
{
suppressedControl = new cEventSuppressor(control);
suppressedControl.Suppress();
disableEvent.Tick += new EventHandler(disableEvent_Tick2);
disableEvent.Interval = (forTime);
disableEvent.Enabled = true;
disableEvent.Start();
}
private void disableEvent_Tick2(object sender, EventArgs e)
{
if (disableEvent.Enabled == true)
{
disableEvent.Tick -= new EventHandler(disableEvent_Tick2);
disableEvent.Stop();
disableEvent.Enabled = false;
suppressedControl.Resume();
}
}
}
public class cEventSuppressor
{
Control _source;
EventHandlerList _sourceEventHandlerList;
FieldInfo _headFI;
Dictionary<object, Delegate[]> suppressedHandlers = new Dictionary<object, Delegate[]>();
PropertyInfo _sourceEventsInfo;
Type _eventHandlerListType;
Type _sourceType;
public cEventSuppressor(Control control)
{
if (control == null)
throw new ArgumentNullException("control", "An instance of a control must be provided.");
_source = control;
_sourceType = _source.GetType();
_sourceEventsInfo = _sourceType.GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic);
_sourceEventHandlerList = (EventHandlerList)_sourceEventsInfo.GetValue(_source, null);
_eventHandlerListType = _sourceEventHandlerList.GetType();
_headFI = _eventHandlerListType.GetField("head", BindingFlags.Instance | BindingFlags.NonPublic);
}
private Dictionary<object, Delegate[]> BuildList()
{
Dictionary<object, Delegate[]> retval = new Dictionary<object, Delegate[]>();
object head = _headFI.GetValue(_sourceEventHandlerList);
if (head != null)
{
Type listEntryType = head.GetType();
FieldInfo delegateFI = listEntryType.GetField("handler", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo keyFI = listEntryType.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo nextFI = listEntryType.GetField("next", BindingFlags.Instance | BindingFlags.NonPublic);
retval = BuildListWalk(retval, head, delegateFI, keyFI, nextFI);
}
return retval;
}
private Dictionary<object, Delegate[]> BuildListWalk(Dictionary<object, Delegate[]> dict,
object entry, FieldInfo delegateFI, FieldInfo keyFI, FieldInfo nextFI)
{
if (entry != null)
{
Delegate dele = (Delegate)delegateFI.GetValue(entry);
object key = keyFI.GetValue(entry);
object next = nextFI.GetValue(entry);
if (dele != null)
{
Delegate[] listeners = dele.GetInvocationList();
if (listeners != null && listeners.Length > 0)
{
dict.Add(key, listeners);
}
}
if (next != null)
{
dict = BuildListWalk(dict, next, delegateFI, keyFI, nextFI);
}
}
return dict;
}
public void Resume()
{
Resume(null);
}
public void Resume(string pMethodName)
{
//if (_handlers == null)
// throw new ApplicationException("Events have not been suppressed.");
Dictionary<object, Delegate[]> toRemove = new Dictionary<object, Delegate[]>();
// goes through all handlers which have been suppressed. If we are resuming,
// all handlers, or if we find the matching handler, add it back to the
// control's event handlers
foreach (KeyValuePair<object, Delegate[]> pair in suppressedHandlers)
{
for (int x = 0; x < pair.Value.Length; x++)
{
string methodName = pair.Value[x].Method.Name;
if (pMethodName == null || methodName.Equals(pMethodName))
{
_sourceEventHandlerList.AddHandler(pair.Key, pair.Value[x]);
toRemove.Add(pair.Key, pair.Value);
}
}
}
// remove all un-suppressed handlers from the list of suppressed handlers
foreach (KeyValuePair<object, Delegate[]> pair in toRemove)
{
for (int x = 0; x < pair.Value.Length; x++)
{
suppressedHandlers.Remove(pair.Key);
}
}
//_handlers = null;
}
public void Suppress()
{
Suppress(null);
}
public void Suppress(string pMethodName)
{
//if (_handlers != null)
// throw new ApplicationException("Events are already being suppressed.");
Dictionary<object, Delegate[]> dict = BuildList();
foreach (KeyValuePair<object, Delegate[]> pair in dict)
{
for (int x = pair.Value.Length - 1; x >= 0; x--)
{
//MethodInfo mi = pair.Value[x].Method;
//string s1 = mi.Name; // name of the method
//object o = pair.Value[x].Target;
// can use this to invoke method pair.Value[x].DynamicInvoke
string methodName = pair.Value[x].Method.Name;
if (pMethodName == null || methodName.Equals(pMethodName))
{
_sourceEventHandlerList.RemoveHandler(pair.Key, pair.Value[x]);
suppressedHandlers.Add(pair.Key, pair.Value);
}
}
}
}
}
#endregion
我将具体回答如何在一般情况下做到这一点。如何改进暂停程序本身已经有了答案。
你确实不能将事件引用传递给另一个方法，但是你可以通过一点反射来做到这一点。例如
private static void Pause<TSource, TEvent>(TSource source, Expression<Func<TSource, TEvent>> eventRef, TEvent handler, int forTime = 200) {
var ev = source.GetType().GetEvent(((MemberExpression)eventRef.Body).Member.Name);
// source.eventRef -= handler;
ev.RemoveMethod.Invoke(source, new object[] { handler });
// do some stuff
// source.eventRef += handler;
ev.AddMethod.Invoke(source, new object[] { handler });
}
Pause(listBox1, c => c.SelectedValueChanged, listBox1_SelectedValueChanged);
不幸的是，只有当事件像这样实现时才有效:
public event SomeDelegate MyEvent;
如果是这样实现的(所有的winform控件事件都是这样实现的)
public event SomeDelegate MyEvent {
add {
// do something
}
remove {
// do something
}
}
它不再工作，因为你不能通过表达式传递这样的事件引用。但是，表达式仅用于方便地获取事件名称。所以你可以显式地传递事件名:
private static void Pause<TSource, TEvent>(TSource source, string eventName, TEvent handler, int forTime = 200) {
var ev = source.GetType().GetEvent(eventName);
// source.eventRef -= handler;
ev.RemoveMethod.Invoke(source, new object[] { handler });
// do some stuff
// source.eventRef += handler;
ev.AddMethod.Invoke(source, new object[] { handler });
}
用法变成
Pause<ListBox, EventHandler>(listBox1, nameof(listBox1.SelectedValueChanged), listBox1_SelectedValueChanged);