c#禁用事件一段时间

Question

我有这组函数来取消注册事件 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);
        }
    }

Answer 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);
    }

}

Answer 2

我会使用微软的反应式框架 - NuGet“System.Reactive” - 然后你可以这样做：

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() 。

Answer 3

我会使用WaitHandle来做到这一点，例如ManualResetEvent 。 如果您想独立挂起多个事件，我会使用不同的ManualResetEvent 。

我会像这样实现它：

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;

Answer 4

我将具体回答您如何以一般方式做到这一点。 如何改进暂停程序本身已经得到解答。

确实，您不能将事件引用传递给另一个方法，但是您可以通过一些反射来做到这一点。 例如

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);

不那么漂亮，但仍然有效。

Answer 5

我找到了一种方法（使用了这个论坛的一些代码），它有效，但它有点复杂（好吧，也许非常复杂）这里是代码：

用法（暂停一段时间）：

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