it-swarm-id.com

Cara menghapus semua penangan acara dari suatu acara

Untuk membuat pengendali acara baru pada kontrol Anda bisa melakukan ini

c.Click += new EventHandler(mainFormButton_Click);

atau ini

c.Click += mainFormButton_Click;

dan untuk menghapus event handler Anda dapat melakukan ini

c.Click -= mainFormButton_Click;

Tetapi bagaimana Anda menghapus semua penangan acara dari suatu acara?

331
Carrick

Saya menemukan solusi di forum MSDN . Kode contoh di bawah ini akan menghapus semua acara Click dari button1.

public partial class Form1 : Form
{
        public Form1()
        {
            InitializeComponent();

            button1.Click += button1_Click;
            button1.Click += button1_Click2;
            button2.Click += button2_Click;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Hello");
        }

        private void button1_Click2(object sender, EventArgs e)
        {
            MessageBox.Show("World");
        }

        private void button2_Click(object sender, EventArgs e)
        {
            RemoveClickEvent(button1);
        }

        private void RemoveClickEvent(Button b)
        {
            FieldInfo f1 = typeof(Control).GetField("EventClick", 
                BindingFlags.Static | BindingFlags.NonPublic);
            object obj = f1.GetValue(b);
            PropertyInfo pi = b.GetType().GetProperty("Events",  
                BindingFlags.NonPublic | BindingFlags.Instance);
            EventHandlerList list = (EventHandlerList)pi.GetValue(b, null);
            list.RemoveHandler(obj, list[obj]);
        }
    }
}
155
xsl

Kalian membuat jalan ini terlalu keras untuk dirimu sendiri. Ini semudah ini:

void OnFormClosing(object sender, FormClosingEventArgs e)
{
    foreach(Delegate d in FindClicked.GetInvocationList())
    {
        FindClicked -= (FindClickedHandler)d;
    }
}
127
Stephen Punak

Dari Menghapus Semua Penangan Acara:

Secara langsung tidak, sebagian besar karena Anda tidak bisa begitu saja mengatur acara ke nol.

Secara tidak langsung, Anda dapat menjadikan acara aktual itu pribadi dan membuat properti di sekitarnya yang melacak semua delegasi yang ditambahkan/dikurangi.

Ambil yang berikut ini:

List<EventHandler> delegates = new List<EventHandler>();

private event EventHandler MyRealEvent;

public event EventHandler MyEvent
{
    add
    {
        MyRealEvent += value;
        delegates.Add(value);
    }

    remove
    {
        MyRealEvent -= value;
        delegates.Remove(value);
    }
}

public void RemoveAllEvents()
{
    foreach(EventHandler eh in delegates)
    {
        MyRealEvent -= eh;
    }
    delegates.Clear();
}
71
Jorge Ferreira

Jawaban yang diterima tidak lengkap. Ini tidak berfungsi untuk acara yang dinyatakan sebagai {add; menghapus;}

Ini kode kerjanya:

public static void ClearEventInvocations(this object obj, string eventName)
{
    var fi = obj.GetType().GetEventField(eventName);
    if (fi == null) return;
    fi.SetValue(obj, null);
}

private static FieldInfo GetEventField(this Type type, string eventName)
{
    FieldInfo field = null;
    while (type != null)
    {
        /* Find events defined as field */
        field = type.GetField(eventName, BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
        if (field != null && (field.FieldType == typeof(MulticastDelegate) || field.FieldType.IsSubclassOf(typeof(MulticastDelegate))))
            break;

        /* Find events defined as property { add; remove; } */
        field = type.GetField("EVENT_" + eventName.ToUpper(), BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic);
        if (field != null)
            break;
        type = type.BaseType;
    }
    return field;
}
57
LionSoft

Tidak ada salahnya untuk menghapus event handler yang tidak ada. Jadi, jika Anda tahu penangan apa yang ada, Anda bisa menghapus semuanya. Saya hanya punya kasus serupa. Ini dapat membantu dalam beberapa kasus.

Seperti:

// Add handlers...
if (something)
{
    c.Click += DoesSomething;
}
else
{
    c.Click += DoesSomethingElse;
}

// Remove handlers...
c.Click -= DoesSomething;
c.Click -= DoesSomethingElse;
37
MdMx

Saya sebenarnya menggunakan metode ini dan itu bekerja dengan sempurna. Saya 'terinspirasi' oleh kode yang ditulis oleh Aeonhack di sini .

Public Event MyEvent()
Protected Overrides Sub Dispose(ByVal disposing As Boolean)
    If MyEventEvent IsNot Nothing Then
        For Each d In MyEventEvent.GetInvocationList ' If this throws an exception, try using .ToArray
            RemoveHandler MyEvent, d
        Next
    End If
End Sub

Bidang MyEventEvent disembunyikan, tetapi memang ada.

Debugging, Anda dapat melihat bagaimana d.target adalah objek yang sebenarnya menangani acara tersebut, dan d.method metodenya. Anda hanya perlu menghapusnya.

Ini bekerja dengan baik. Tidak ada lagi objek yang tidak GC karena penangan acara.

18

Saya benci solusi lengkap yang ditampilkan di sini, saya melakukan campuran dan diuji sekarang, bekerja untuk pengendali acara:

public class MyMain()
    public void MyMethod() {
        AnotherClass.TheEventHandler += DoSomeThing;
    }

    private void DoSomething(object sender, EventArgs e) {
        Debug.WriteLine("I did something");
        AnotherClass.ClearAllDelegatesOfTheEventHandler();
    }

}

public static class AnotherClass {

    public static event EventHandler TheEventHandler;

    public static void ClearAllDelegatesOfTheEventHandler() {

        foreach (Delegate d in TheEventHandler.GetInvocationList())
        {
            TheEventHandler -= (EventHandler)d;
        }
    }
}

Mudah! Terima kasih untuk Stephen Punak.

Saya menggunakannya karena saya menggunakan metode lokal generik untuk menghapus delegasi dan metode lokal dipanggil setelah kasus yang berbeda, ketika delegasi yang berbeda diselesaikan.

7

Jika Anda benar-benar harus melakukan ini ... itu akan membutuhkan refleksi dan beberapa waktu untuk melakukan ini. Penangan event dikelola dalam event-to-delegate-map di dalam kontrol. Anda harus melakukannya

  • Refleksikan dan dapatkan peta ini dalam instance kontrol.
  • Iterate untuk setiap acara, dapatkan delegasi
    • masing-masing delegasi pada gilirannya bisa menjadi rangkaian event handler yang dirantai. Jadi panggil obControl.RemoveHandler (event, handler)

Singkatnya, banyak pekerjaan. Mungkin saja secara teori ... Saya tidak pernah mencoba hal seperti ini.

Lihat apakah Anda dapat memiliki kontrol/disiplin yang lebih baik atas fase berlangganan-berhenti berlangganan untuk kontrol.

5
Gishu

Stephen benar. Ini sangat mudah:

public event EventHandler<Cles_graph_doivent_etre_redessines> les_graph_doivent_etre_redessines;
public void remove_event()
{
    if (this.les_graph_doivent_etre_redessines != null)
    {
        foreach (EventHandler<Cles_graph_doivent_etre_redessines> F_les_graph_doivent_etre_redessines in this.les_graph_doivent_etre_redessines.GetInvocationList())
        {
            this.les_graph_doivent_etre_redessines -= F_les_graph_doivent_etre_redessines;
        }
    }
}
4
mmike

Saya baru saja menemukan Cara menunda acara ketika mengatur properti dari kontrol WinForms. Ini akan menghapus semua acara dari kontrol:

namespace CMessWin05
{
    public class EventSuppressor
    {
        Control _source;
        EventHandlerList _sourceEventHandlerList;
        FieldInfo _headFI;
        Dictionary<object, Delegate[]> _handlers;
        PropertyInfo _sourceEventsInfo;
        Type _eventHandlerListType;
        Type _sourceType;


        public EventSuppressor(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 void BuildList()
        {
            _handlers = 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);
                BuildListWalk(head, delegateFI, keyFI, nextFI);
            }
        }

        private void BuildListWalk(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);

                Delegate[] listeners = dele.GetInvocationList();
                if(listeners != null && listeners.Length > 0)
                    _handlers.Add(key, listeners);

                if (next != null)
                {
                    BuildListWalk(next, delegateFI, keyFI, nextFI);
                }
            }
        }

        public void Resume()
        {
            if (_handlers == null)
                throw new ApplicationException("Events have not been suppressed.");

            foreach (KeyValuePair<object, Delegate[]> pair in _handlers)
            {
                for (int x = 0; x < pair.Value.Length; x++)
                    _sourceEventHandlerList.AddHandler(pair.Key, pair.Value[x]);
            }

            _handlers = null;
        }

        public void Suppress()
        {
            if (_handlers != null)
                throw new ApplicationException("Events are already being suppressed.");

            BuildList();

            foreach (KeyValuePair<object, Delegate[]> pair in _handlers)
            {
                for (int x = pair.Value.Length - 1; x >= 0; x--)
                    _sourceEventHandlerList.RemoveHandler(pair.Key, pair.Value[x]);
            }
        }

    }
}
3
SwDevMan81

Halaman ini banyak membantu saya. Kode yang saya dapatkan dari sini dimaksudkan untuk menghapus acara klik dari sebuah tombol. Saya perlu menghapus acara klik ganda dari beberapa panel dan klik acara dari beberapa tombol. Jadi saya membuat ekstensi kontrol, yang akan menghapus semua penangan acara untuk acara tertentu.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Reflection;
public static class EventExtension
{
    public static void RemoveEvents<T>(this T target, string eventName) where T:Control
    {
        if (ReferenceEquals(target, null)) throw new NullReferenceException("Argument \"target\" may not be null.");
        FieldInfo fieldInfo = typeof(Control).GetField(eventName, BindingFlags.Static | BindingFlags.NonPublic);
        if (ReferenceEquals(fieldInfo, null)) throw new ArgumentException(
            string.Concat("The control ", typeof(T).Name, " does not have a property with the name \"", eventName, "\""), nameof(eventName));
        object eventInstance = fieldInfo.GetValue(target);
        PropertyInfo propInfo = typeof(T).GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);
        EventHandlerList list = (EventHandlerList)propInfo.GetValue(target, null);
        list.RemoveHandler(eventInstance, list[eventInstance]);
    }
}

Sekarang, penggunaan extenstion ini. Jika Anda perlu menghapus acara klik dari sebuah tombol,

Button button = new Button();
button.RemoveEvents(nameof(button.EventClick));

Jika Anda perlu menghapus acara double klik dari panel,

Panel panel = new Panel();
panel.RemoveEvents(nameof(panel.EventDoubleClick));

Saya bukan ahli C #, jadi jika ada bug tolong maafkan saya dan beri tahu saya tentang itu.

2

Wow. Saya menemukan solusi ini, tetapi tidak ada yang bekerja seperti yang saya inginkan. Tapi ini sangat bagus:

EventHandlerList listaEventos;

private void btnDetach_Click(object sender, EventArgs e)
{
    listaEventos = DetachEvents(comboBox1);
}

private void btnAttach_Click(object sender, EventArgs e)
{
    AttachEvents(comboBox1, listaEventos);
}

public EventHandlerList DetachEvents(Component obj)
{
    object objNew = obj.GetType().GetConstructor(new Type[] { }).Invoke(new object[] { });
    PropertyInfo propEvents = obj.GetType().GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);

    EventHandlerList eventHandlerList_obj = (EventHandlerList)propEvents.GetValue(obj, null);
    EventHandlerList eventHandlerList_objNew = (EventHandlerList)propEvents.GetValue(objNew, null);

    eventHandlerList_objNew.AddHandlers(eventHandlerList_obj);
    eventHandlerList_obj.Dispose();

    return eventHandlerList_objNew;
}

public void AttachEvents(Component obj, EventHandlerList eventos)
{
    PropertyInfo propEvents = obj.GetType().GetProperty("Events", BindingFlags.NonPublic | BindingFlags.Instance);

    EventHandlerList eventHandlerList_obj = (EventHandlerList)propEvents.GetValue(obj, null);

    eventHandlerList_obj.AddHandlers(eventos);
}
2
Sergio Cabral

Terkadang kita harus bekerja dengan kontrol ThirdParty dan kita perlu membangun solusi canggung ini. Berbasis di @Anoop Muraleedharan jawaban saya membuat solusi ini dengan tipe inferensi dan dukungan ToolStripItem

    public static void RemoveItemEvents<T>(this T target, string eventName) 
        where T : ToolStripItem
    {            
        RemoveObjectEvents<T>(target, eventName);
    }

    public static void RemoveControlEvents<T>(this T target, string eventName)
        where T : Control
    {
        RemoveObjectEvents<T>(target, eventName);
    }

    private static void RemoveObjectEvents<T>(T target, string Event) where T : class
    {
        var typeOfT = typeof(T);
        var fieldInfo = typeOfT.BaseType.GetField(
            Event, BindingFlags.Static | BindingFlags.NonPublic);
        var provertyValue = fieldInfo.GetValue(target);
        var propertyInfo = typeOfT.GetProperty(
            "Events", BindingFlags.NonPublic | BindingFlags.Instance);
        var eventHandlerList = (EventHandlerList)propertyInfo.GetValue(target, null);
        eventHandlerList.RemoveHandler(provertyValue, eventHandlerList[provertyValue]);
    }

Dan Anda bisa menggunakannya seperti ini

    var toolStripButton = new ToolStripButton();
    toolStripButton.RemoveItemEvents("EventClick");

    var button = new Button();
    button.RemoveControlEvents("EventClick");
0
Jhonattan

Ini bukan jawaban untuk OP, tapi saya pikir saya akan memposting ini di sini kalau-kalau itu bisa membantu orang lain.

  /// <summary>
  /// Method to remove a (single) SocketAsyncEventArgs.Completed event handler. This is 
  /// partially based on information found here: http://stackoverflow.com/a/91853/253938
  /// 
  /// But note that this may not be a good idea, being very .Net implementation-dependent. Note 
  /// in particular use of "m_Completed" instead of "Completed".
  /// </summary>
  private static void RemoveCompletedEventHandler(SocketAsyncEventArgs eventArgs)
  {
     FieldInfo fieldInfo = typeof(SocketAsyncEventArgs).GetField("m_Completed", 
                                                BindingFlags.Instance | BindingFlags.NonPublic);
     eventArgs.Completed -= (EventHandler<SocketAsyncEventArgs>)fieldInfo.GetValue(eventArgs);
  }
0
RenniePet