在C#使用字典存储事件示例及实现自定义事件访问器

在C#中，我们可以使用字典作为存储事件的数据结构来方便地处理事件的订阅和触发。以下是一些实现自定义事件访问器的步骤：

1. 声明事件

首先，我们需要声明事件。事件是一种操作，它在特定条件下会被触发。在C#中，事件可以理解为委托的实例化。下面是一个声明事件的示例：

public event Action<string> MyEvent;

这里声明了一个名为MyEvent的事件，它会在满足某个条件时被触发，触发时需要传递一个字符串类型的参数。

2. 存储委托

接下来，我们要使用字典来存储事件的订阅者。这里我们使用了一个泛型字典Dictionary<TKey,TValue>，其中TKey表示键的类型，TValue表示值的类型。键这里可以是任何符合要求的类型，比如字符串、枚举等，值则是事件的订阅者，一般为委托类型。

private readonly Dictionary<string, Action<string>> eventHandlers = new Dictionary<string, Action<string>>();

这里我们声明了一个eventHandlers字典，它的键是字符串类型，值为Action<string>委托类型。

3. 实现事件访问器

接下来，我们实现事件访问器。事件访问器提供了事件的绑定和解除绑定方法，并且可以保证线程安全。在访问器中，我们可以使用Dictionary集合来存储事件的委托实例。

public event Action<string> MyEvent
{
    add
    {
        lock(eventHandlers)
        {
            if(!eventHandlers.ContainsKey(nameof(MyEvent)))
            {
                eventHandlers[nameof(MyEvent)] = value;
            }
            else
            {
                eventHandlers[nameof(MyEvent)] += value;
            }
        }
    }
    remove
    {
        lock(eventHandlers)
        {
            if(eventHandlers.ContainsKey(nameof(MyEvent)))
            {
                eventHandlers[nameof(MyEvent)] -= value;
            }
        }
    }
}

这里实现了一个访问器，它包含了一个线程安全的实现方式。在add方法中，我们使用lock关键字来保证线程安全。如果字典中还没有这个事件的订阅者，那么我们就创建一个新的键值对；否则，我们将新的委托实例添加到已有的委托实例中。

在remove方法中，我们首先检查字典中是否存储了这个事件的委托实例，如果找到了这个实例，我们就移除这个实例。

示例1

下面是一个示例，展示了如何在C#中使用字典来存储事件的订阅者。

public class EventHandlerExample
{
    private readonly Dictionary<string, Action<string>> eventHandlers = new Dictionary<string, Action<string>>();

    public event Action<string> MyEvent
    {
        add
        {
            lock(eventHandlers)
            {
                if(!eventHandlers.ContainsKey(nameof(MyEvent)))
                {
                    eventHandlers[nameof(MyEvent)] = value;
                }
                else
                {
                    eventHandlers[nameof(MyEvent)] += value;
                }
            }
        }
        remove
        {
            lock(eventHandlers)
            {
                if(eventHandlers.ContainsKey(nameof(MyEvent)))
                {
                    eventHandlers[nameof(MyEvent)] -= value;
                }
            }
        }
    }

    public void RaiseMyEvent()
    {
        foreach(var handler in eventHandlers[nameof(MyEvent)].GetInvocationList())
        {
            handler.DynamicInvoke("Invoking MyEvent");
        }
    }
}

//使用示例：
var handlerExample = new EventHandlerExample();
handlerExample.MyEvent += (msg) => Console.WriteLine($"MyEvent invoked: {msg}");
handlerExample.RaiseMyEvent();

在示例中，首先声明了一个名为EventHandlerExample的类。在类内部，我们定义了一个存储事件订阅者的字典。然后我们声明了一个MyEvent事件，并使用实现了事件访问器的方式来订阅和解除订阅事件。

接下来，我们实现了一个RaiseMyEvent方法，用于触发我们的自定义事件。在方法中，我们首先获取存储在字典中的事件订阅者，并依次执行这些委托实例。

示例2

下面是另一个示例，展示了如何封装事件处理方法，从而替代匿名方法的实现方式。

public class EventHandlerExample
{
    private readonly Dictionary<string, Action<string>> eventHandlers = new Dictionary<string, Action<string>>();

    public event Action<string> MyEvent
    {
        add
        {
            lock(eventHandlers)
            {
                if(!eventHandlers.ContainsKey(nameof(MyEvent)))
                {
                    eventHandlers[nameof(MyEvent)] = value;
                }
                else
                {
                    eventHandlers[nameof(MyEvent)] += value;
                }
            }
        }
        remove
        {
            lock(eventHandlers)
            {
                if(eventHandlers.ContainsKey(nameof(MyEvent)))
                {
                    eventHandlers[nameof(MyEvent)] -= value;
                }
            }
        }
    }

    private void OnMyEventInvoked(string msg)
    {
        Console.WriteLine($"MyEvent invoked: {msg}");
    }

    public void RaiseMyEvent()
    {
        eventHandlers[nameof(MyEvent)]?.Invoke("Invoking MyEvent");
    }
}

//使用示例：
var handlerExample = new EventHandlerExample();
handlerExample.MyEvent += handlerExample.OnMyEventInvoked;
handlerExample.RaiseMyEvent();

在示例中，我们首先同样声明了一个名为EventHandlerExample的类。在类内部，我们同样定义了一个存储事件订阅者的字典，并声明了一个MyEvent事件。

接下来，我们实现了一个OnMyEventInvoked方法，它作为MyEvent事件的处理函数。我们将这个方法作为事件处理程序添加到了MyEvent事件中。最后，我们同样实现了一个RaiseMyEvent方法，用于触发我们的自定义事件。

在这个示例中，我们展示了如何将事件处理方法封装成为一个常规的方法，从而避免了使用匿名方法的实现方式，这样可以提高代码的可读性和可维护性。