Mehrfache Zuweisung derselben Event-Handler verhindern

Baget Recht, über die Verwendung einer explizit implementierte event (obwohl es eine Mischung gibt es explizite interface-Implementierung und full-event-syntax). Sie können sich wahrscheinlich Weg mit diesem:

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;
    }
}

Das möglicherweise etwas seltsam Rand der Fälle, wenn Sie jemals das hinzufügen oder entfernen von multicast-Delegaten, aber das ist unwahrscheinlich. Es muss auch eine sorgfältige Dokumentation, da es nicht die Art und Weise, dass Ereignisse, die normalerweise arbeiten.

InformationsquelleAutor der Antwort Jon Skeet

Realisieren Sie Ihre eigenen Speicher der delgates, und prüfen Sie die Einzigartigkeit, wenn Sie Sie hinzufügen, um das Ereignis. Sehen EventOwner2 Klasse unten für ein Beispiel. Ich weiß nicht, wie Sie dies tun, performance-Weise, aber dann wieder, das ist nicht immer ein Problem.

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);
            }
        }
    }
}

InformationsquelleAutor der Antwort Øyvind Skaar