C# Как узнать, подключено ли событие

Ключевое слово C# event создает тонкую иллюзию, заключающуюся в том, что у события есть список вызовов.

Если вы объявите событие с помощью ключевого слова C# event, компилятор создаст частный делегат в вашем классе и будет управлять им за вас. Всякий раз, когда вы подписываетесь на событие, вызывается сгенерированный компилятором метод add, который добавляет обработчик события в список вызовов делегата. Для события нет явного списка вызовов.

Таким образом, единственный способ получить доступ к списку вызовов делегата — предпочтительно:

• Используйте отражение для доступа к делегату, сгенерированному компилятором, ИЛИ
• Создайте незакрытый делегат (возможно, внутренний) и реализуйте методы добавления/удаления события вручную (это не позволяет компилятору генерировать реализацию события по умолчанию)

Вот пример, демонстрирующий последний метод.

class MyType
{
    internal EventHandler<int> _delegate;
    public event EventHandler<int> MyEvent;
    {
        add { _delegate += value; }
        remove { _delegate -= value; }
    }
}

Если соответствующий объект указал ключевое слово события, то вы можете только добавить (+=) и удалить (-=) обработчики, и ничего более.

Я считаю, что сравнение длины списка вызовов будет работать, но вам нужно работать внутри объекта, чтобы добраться до него.

Также имейте в виду, что операторы += и -= возвращают новый объект события; они не изменяют существующий.

Почему вы хотите знать, связано ли конкретное событие? Чтобы не регистрироваться несколько раз?

Если это так, хитрость заключается в том, чтобы сначала удалить обработчик (-=), поскольку удаление обработчика, которого нет, является законным и ничего не делает. Например:

// Ensure we don't end up being triggered multiple times by the event
myObject.KeyEvent -= KeyEventHandler;
myObject.KeyEvent += KeyEventHandler;

Это можно сделать, но потребуется некоторая хитрость... как упоминалось выше, компилятор генерирует реализацию события, включая его резервное поле. Отражение позволяет вам получить резервное поле по имени, и, получив к нему доступ, вы можете вызвать GetInvocationList(), даже если вы находитесь за пределами самого класса.

Поскольку вы просите использовать отражение для получения события по имени, я предполагаю, что вы также используете отражение для получения типа по имени — я придумываю пример, который покажет, как это сделать.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Text;
using System.Reflection;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string typeName = "ConsoleApplication1.SomeClass, ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null";
            string eventName = "SomeEvent";

            Type declaringType = Type.GetType(typeName);
            object target = Activator.CreateInstance(declaringType);

            EventHandler eventDelegate;
            eventDelegate = GetEventHandler(target, eventName);
            if (eventDelegate == null) { Console.WriteLine("No listeners"); }

            // attach a listener
            SomeClass bleh = (SomeClass)target;
            bleh.SomeEvent += delegate { };
            //

            eventDelegate = GetEventHandler(target, eventName);
            if (eventDelegate == null)
            { 
                Console.WriteLine("No listeners"); 
            }
            else
            { 
                Console.WriteLine("Listeners: " + eventDelegate.GetInvocationList().Length); 
            }

            Console.ReadKey();

        }

        static EventHandler GetEventHandler(object classInstance, string eventName)
        {
            Type classType = classInstance.GetType();
            FieldInfo eventField = classType.GetField(eventName, BindingFlags.GetField
                                                               | BindingFlags.NonPublic
                                                               | BindingFlags.Instance);

            EventHandler eventDelegate = (EventHandler)eventField.GetValue(classInstance);

            // eventDelegate will be null if no listeners are attached to the event
            if (eventDelegate == null)
            {
                return null;
            }

            return eventDelegate;
        }
    }

    class SomeClass
    {
        public event EventHandler SomeEvent;
    }
}

Вы должны иметь возможность получить список вызовов через «событие». Грубо говоря, это будет что-то вроде..

public delegate void MyHandler;
public event MyHandler _MyEvent
public int GetInvocationListLength()
{
   var d = this._MyEvent.GetInvocationList(); //Delegate[]
   return d.Length;
}

Я использовал ваш пример и немного изменил его. регистрация обработчика событий увеличивает количество вызовов. даже при использовании двух разных методов обратного вызова (как показано здесь) или при использовании одного и того же метода обратного вызова.

private void SomeMethod()
{
    // Create a new event handler that takes in the function I want to execute when the event fires
    var myEventHandler = new EventHandler(OnPropertyChanged);

    // Get "p1" number events that got hooked up to myEventHandler
    int p1 = myEventHandler.GetInvocationList().Length; // 1

    // Now actually hook an event up
    myEventHandler += OnPropertyChanged2;

    // Re check "p2" number of events hooked up to myEventHandler
    int p2 = myEventHandler.GetInvocationList().Length; // 2

    myEventHandler.Invoke(null, null); 
// each of the registered callback methods are executed once. 
// or if the same callback is used, then twice.
}

private void OnPropertyChanged2(object? sender, EventArgs e)
{}
private void OnPropertyChanged(object? sender, EventArgs e)
{}

Как уже упоминалось, доступ к eventhandler.GetInvocationList ограничен самим классом, вам необходимо предоставить свойство или метод для получения списка делегатов.

Нравится:

protected Delegate[]? GetInvocations() => PropertyChanged?.GetInvocationList();

в зависимости от вашего использования сделайте его защищенным, внутренним или обоими.