Предотвращение назначения одного и того же обработчика событий несколько раз

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

Багет прав, говоря об использовании явно реализованного события (хотя там есть смесь явной реализации интерфейса и полного синтаксиса события). Вы, вероятно, сможете обойтись без этого:

private EventHandler foo;

public event EventHandler Foo
{
    add
    {
        // First try to remove the handler, then re-add it
        foo -= value;
        foo += value;
    }
    remove
    {
        foo -= value;
    }
}

Это может иметь некоторые странные крайние случаи, если вы когда-либо добавляете или удаляете многоадресные делегаты, но это маловероятно. Он также требует тщательной документации, так как события обычно не работают.

Вы можете реализовать собственное хранилище делегатов и проверять уникальность при добавлении их в событие. См. Пример класса EventOwner2 ниже. Я не знаю, как это работает с точки зрения производительности, но, опять же, это не всегда проблема.

using System;
using System.Collections.Generic;

namespace EventExperiment
{
    class Program
    {
        static void Main(string[] args)
        {
            IEventOwner e=new EventOwner2();
            Subscriber s=new Subscriber(e);
            e.RaiseSome();
            Console.ReadKey();
        }
    }

    /// <summary>
    /// A consumer class, subscribing twice to the event in it's constructor.
    /// </summary>
    public class Subscriber
    {
        public Subscriber(IEventOwner eventOwner)
        {
            eventOwner.SomeEvent += eventOwner_SomeEvent;
            eventOwner.SomeEvent += eventOwner_SomeEvent;
        }

        void eventOwner_SomeEvent(object sender, EventArgs e)
        {
            Console.WriteLine(DateTimeOffset.Now);
        }

    }

    /// <summary>
    /// This interface is not essensial to this point. it is just added for conveniance.
    /// </summary>
    public interface IEventOwner
    {
        event EventHandler<EventArgs> SomeEvent;
        void RaiseSome();
    }

    /// <summary>
    /// A traditional event. This is raised for each subscription.
    /// </summary>
    public class EventOwner1 : IEventOwner
    {
        public event EventHandler<EventArgs> SomeEvent = delegate { };
        public void RaiseSome()
        {
            SomeEvent(this,new EventArgs());
        }
    }
    /// <summary>
    /// A custom event. This is raised only once for each subscriber.
    /// </summary>
    public class EventOwner2 : IEventOwner
    {
        private readonly List<EventHandler<EventArgs>> handlers=new List<EventHandler<EventArgs>>();
        public event EventHandler<EventArgs> SomeEvent
        {
            add
            {
                lock (handlers)
                    if (handlers!=null&&!handlers.Contains(value))
                    {
                        handlers.Add(value);
                    }
            }
            remove
            {
                handlers.Remove(value);
            }
        }
        public void RaiseSome()
        {
            EventArgs args=new EventArgs();
            lock(handlers)
            foreach (EventHandler<EventArgs> handler in handlers)
            {
                handler(this,args);
            }
        }
    }
}

Что такое модификатор доступа у «объекта»?

Если он частный, вам нужно беспокоиться только о том, что содержащий объект устанавливает обработчик событий. Если он внутренний, вам нужно только беспокоиться о том, что содержащая сборка устанавливает обработчик событий. Если он публичный, то он широко открыт.

Если «объект» можно сделать закрытым в содержащем классе, вы можете сделать свои проверки намного более эффективными, управляя назначением обработчика событий в локальном классе.

Если «внутреннее» или «общедоступное» и уникальность является требованием, используйте класс-оболочку, который скрывает «объект» и вместо этого предоставляет метод для назначения обработчика событий с вашими проверками, стоящими за ним, чтобы гарантировать уникальность.