如何确保一个事件只订阅一次

Question

我想确保我只在特定类中订阅实例上的事件一次。

例如，我希望能够执行以下操作：

if (*not already subscribed*)
{
    member.Event += new MemeberClass.Delegate(handler);
}

我将如何实施这样的守卫？

Answer 1

我将其添加到所有重复的问题中，只是为了记录。 这种模式对我有用：

myClass.MyEvent -= MyHandler;
myClass.MyEvent += MyHandler;

请注意，每次注册处理程序时执行此操作将确保您的处理程序仅注册一次。

Answer 2

如果您正在谈论您有权访问其源的类上的事件，那么您可以将守卫放在事件定义中。

private bool _eventHasSubscribers = false;
private EventHandler<MyDelegateType> _myEvent;

public event EventHandler<MyDelegateType> MyEvent
{
   add 
   {
      if (_myEvent == null)
      {
         _myEvent += value;
      }
   }
   remove
   {
      _myEvent -= value;
   }
}

这将确保只有一个订阅者可以在提供事件的类的该实例上订阅该事件。

编辑请参阅有关为什么上述代码是一个坏主意并且不是线程安全的评论。

如果您的问题是客户端的单个实例订阅多次（并且您需要多个订阅者），那么客户端代码将需要处理该问题。 所以更换

尚未订阅

客户端类的 bool 成员，该成员在您第一次订阅事件时设置。

编辑（接受后）：根据@Glen T（问题的提交者）的评论，他所采用的已接受解决方案的代码位于客户端类中：

if (alreadySubscribedFlag)
{
    member.Event += new MemeberClass.Delegate(handler);
}

其中alreadySubscribedFlag是其中的成员变量跟踪对特定事件的首次订阅的客户端类。
在这里查看第一个代码片段的人们，请注意 @Rune 的评论 - 以不明显的方式改变订阅事件的行为不是一个好主意。

编辑 2009 年 7 月 31 日：请参阅@Sam Saffron 的评论。 正如我已经说过的，Sam 也同意这里介绍的第一种方法不是修改事件订阅行为的明智方法。 该类的使用者需要了解其内部实现才能理解其行为。 不太好。
@Sam Saffron 还评论了线程安全。 我假设他指的是可能的竞争条件，其中两个订阅者（接近）同时尝试订阅，并且他们可能最终都订阅。 可以使用锁来改善这一点。 如果您计划更改事件订阅的工作方式，那么我建议您阅读有关如何使订阅添加/删除线程安全的属性。

Answer 3

正如其他人所示，您可以覆盖事件的添加/删除属性。 或者，您可能希望放弃事件，而只是让类在其构造函数（或其他方法）中将委托作为参数，而不是触发事件，而是调用提供的委托。

事件意味着任何人都可以订阅它们，而委托是您可以传递给类的一个方法。 如果您仅在真正需要它通常提供的一对多语义时才使用事件，那么您的库的用户可能不会感到惊讶。

Answer 4

您可以使用 Postsharper 仅写入一个属性一次并将其用于普通事件。 重用该代码。 下面给出了代码示例。

[Serializable]
public class PreventEventHookedTwiceAttribute: EventInterceptionAspect
{
    private readonly object _lockObject = new object();
    readonly List<Delegate> _delegates = new List<Delegate>();

    public override void OnAddHandler(EventInterceptionArgs args)
    {
        lock(_lockObject)
        {
            if(!_delegates.Contains(args.Handler))
            {
                _delegates.Add(args.Handler);
                args.ProceedAddHandler();
            }
        }
    }

    public override void OnRemoveHandler(EventInterceptionArgs args)
    {
        lock(_lockObject)
        {
            if(_delegates.Contains(args.Handler))
            {
                _delegates.Remove(args.Handler);
                args.ProceedRemoveHandler();
            }
        }
    }
}

就像这样使用它。

[PreventEventHookedTwice]
public static event Action<string> GoodEvent;

有关详细信息，请参阅实现 Postsharp EventInterceptionAspect 以阻止事件发生处理程序挂接两次

Answer 5

您需要存储一个单独的标志来指示您是否已订阅，或者如果您可以控制 MemberClass，则提供事件的添加和删除方法的实现：

class MemberClass
{
        private EventHandler _event;

        public event EventHandler Event
        {
            add
            {
                if( /* handler not already added */ )
                {
                    _event+= value;
                }
            }
            remove
            {
                _event-= value;
            }
        }
}

决定是否已添加处理程序您需要比较从 GetInitationList() 返回的委托的 _event 和 value。

Answer 6

我知道这是一个老问题，但当前的答案对我不起作用。

查看 C# 模式以防止事件处理程序挂钩两次< /a> （标记为这个问题的重复项），给出了更接近的答案，但仍然不起作用，可能是因为多线程导致新的事件对象不同，或者可能是因为我正在使用自定义事件类。 我最终得到了与上述问题的已接受答案类似的解决方案。

private EventHandler<bar> foo;
public event EventHandler<bar> Foo
{
    add
    {
        if (foo == null || 
            !foo.GetInvocationList().Select(il => il.Method).Contains(value.Method))
        {
            foo += value;
        }
    }

    remove
    {
        if (foo != null)
        {
            EventHandler<bar> eventMethod = (EventHandler<bar>)foo .GetInvocationList().FirstOrDefault(il => il.Method == value.Method);

            if (eventMethod != null)
            {
                foo -= eventMethod;
            }
        }
    }
}

这样，您还必须使用 foo.Invoke(...) 而不是 Foo.Invoke(...) 来触发事件。 如果您尚未使用 System.Linq，则还需要包含它。

这个解决方案并不完全漂亮，但它有效。

Answer 7

我最近做了这个，我会把它放在这里，这样它就保留了：

private bool subscribed;

if(!subscribed)
{
    myClass.MyEvent += MyHandler;
    subscribed = true;
} 

private void MyHandler()
{
    // Do stuff
    myClass.MyEvent -= MyHandler;
    subscribed = false;
}

Answer 8

引发时仅调用 GetInitationList 中的不同元素：

using System.Linq;
....
public event HandlerType SomeEvent;
....
//Raising code
foreach (HandlerType d in (SomeEvent?.GetInvocationList().Distinct() ?? Enumerable.Empty<Delegate>()).ToArray())
     d.Invoke(sender, arg);

示例单元测试：

class CA 
{
    public CA()
    { }
    public void Inc()
        => count++;
    public int count;
}
[TestMethod]
public void TestDistinctDelegates()
{
    var a = new CA();
    Action d0 = () => a.Inc();
    var d = d0;
    d += () => a.Inc();
    d += d0;
    d.Invoke();
    Assert.AreEqual(3, a.count);
    var l = d.GetInvocationList();
    Assert.AreEqual(3, l.Length);
    var distinct = l.Distinct().ToArray();
    Assert.AreEqual(2, distinct.Length);
    foreach (Action di in distinct)
        di.Invoke();
    Assert.AreEqual(3 + distinct.Length, a.count);
}
[TestMethod]
public void TestDistinctDelegates2()
{
    var a = new CA();
    Action d = a.Inc;
    d += a.Inc;
    d.Invoke();
    Assert.AreEqual(2, a.count);
    var distinct = d.GetInvocationList().Distinct().ToArray();
    Assert.AreEqual(1, distinct.Length);
    foreach (Action di in distinct)
        di.Invoke();
    Assert.AreEqual(3, a.count);
}