Comment faire en C# d'Événements de derrière les coulisses?

Je suis à l'aide de C#, .NET 3.5. Je comprends comment utiliser les événements, la façon de les déclarer dans ma classe, comment les connecter à partir de quelque part d'autre, etc. Un exemple artificiel:

public class MyList
{
    private List<string> m_Strings = new List<string>();
    public EventHandler<EventArgs> ElementAddedEvent;

    public void Add(string value)
    {
        m_Strings.Add(value);
        if (ElementAddedEvent != null)
            ElementAddedEvent(value, EventArgs.Empty);
    }
}

[TestClass]
public class TestMyList
{
    private bool m_Fired = false;

    [TestMethod]
    public void TestEvents()
    {
        MyList tmp = new MyList();
        tmp.ElementAddedEvent += new EventHandler<EventArgs>(Fired);
        tmp.Add("test");
        Assert.IsTrue(m_Fired);
    }

    private void Fired(object sender, EventArgs args)
    {
        m_Fired = true;
    }
}

Cependant, ce que je ne pas comprendre, c'est quand on déclare un gestionnaire d'événement

public EventHandler<EventArgs> ElementAddedEvent;

Il n'est jamais initialisée - alors quoi, exactement, est ElementAddedEvent? En quoi est-il point? Le suivant ne fonctionnera pas, parce que le Gestionnaire n'est jamais initialisée:

[TestClass]
public class TestMyList
{
    private bool m_Fired = false;

    [TestMethod]
    public void TestEvents()
    {
        EventHandler<EventArgs> somethingHappend;
        somethingHappend += new EventHandler<EventArgs>(Fired);
        somethingHappend(this, EventArgs.Empty);
        Assert.IsTrue(m_Fired);
    }

    private void Fired(object sender, EventArgs args)
    {
        m_Fired = true;
    }
}

Je remarque qu'il y a un Gestionnaire d'événements.CreateDelegate(...), mais toutes les signatures de méthode suggère qu'il est seulement utilisé pour la fixation des Délégués à un Gestionnaire d'événements à travers le ElementAddedEvent += new EventHandler(MyMethod).

Je ne suis pas sûr si ce je suis en train de faire va les aider... mais finalement, je voudrais venir avec un résumé parent DataContext dans LINQ dont les enfants peuvent s'inscrire la table des Types qu'ils veulent ", a observé", donc je peux avoir des événements tels que BeforeUpdate et AfterUpdate, mais qui sont spécifiques à des types. Quelque chose comme ceci:

public class BaseDataContext : DataContext
{
private static Dictionary<Type, Dictionary<ChangeAction, EventHandler>> m_ObservedTypes = new Dictionary<Type, Dictionary<ChangeAction, EventHandler>>();
public static void Observe(Type type)
{
if (m_ObservedTypes.ContainsKey(type) == false)
{
m_ObservedTypes.Add(type, new Dictionary<ChangeAction, EventHandler>());
EventHandler eventHandler = EventHandler.CreateDelegate(typeof(EventHandler), null, null) as EventHandler;
m_ObservedTypes[type].Add(ChangeAction.Insert, eventHandler);
eventHandler = EventHandler.CreateDelegate(typeof(EventHandler), null, null) as EventHandler;
m_ObservedTypes[type].Add(ChangeAction.Update, eventHandler);
eventHandler = EventHandler.CreateDelegate(typeof(EventHandler), null, null) as EventHandler;
m_ObservedTypes[type].Add(ChangeAction.Delete, eventHandler);
}
}
public static Dictionary<Type, Dictionary<ChangeAction, EventHandler>> Events
{
get { return m_ObservedTypes; }
}
}
public class MyClass
{
public MyClass()
{
BaseDataContext.Events[typeof(User)][ChangeAction.Update] += new EventHandler(OnUserUpdate);
}
public void OnUserUpdated(object sender, EventArgs args)
{
//do something
}
}

De penser à ce qui m'a fait réaliser que je ne comprends pas vraiment ce qui se passe sous l'auge avec des événements - et j'aimerais comprendre 🙂

InformationsquelleAutor Matt | 2008-10-17