我有这组功能可以在一段时间内注销事件listBox1_SelectedValueChanged。
调用该函数：暂停（）。
是否有任何方法可以将此作为一个函数执行，可以对各种事件执行相同的操作，例如：
暂停（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);
}
}
答案 0 :(得分：1)
我会使用DateTime字段。我会检查SelectedValuedChanged()事件是否允许运行。 （不要取消注意事件）
例如：（伪）
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);
}
}
答案 1 :(得分：0)
我会使用微软的Reactive Framework - NuGet＆＃34; System.Reactive＆＃34; - 那么你可以这样做：
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()。
答案 2 :(得分：0)
我会使用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;
答案 3 :(得分：0)
我将特别回答你如何以一般方式做到这一点。如何改善暂停程序本身已经得到了解答。
您无法将事件引用传递给另一个方法，但您可以通过一些反射来实现。例如
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);
不太漂亮但仍然有效。
答案 4 :(得分：0)
我找到了一种方法（使用了这个论坛的一些代码），它有效，但它有点复杂（好吧，也许很复杂）这里是代码：
用法（暂停一段时间）：
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