Est-il nécessaire que quelqu'un soit inscrit à un événement avant de pouvoir le faire?

Question

Cela semble fou, mais j'ai créé un événement dans la classe et j'ai essayé de l'élever sans que personne ne s'enregistre. Cependant, cela donnerait une exception. Est-il nécessaire que quelqu'un s'enregistre avant de soulever l'exception? Si oui, quels sont les travaux?

Answer 1

oui, un événement auquel personne n'est inscrit est nul. La méthode standard des événements de tir est:

event EventHandler MyEvent; 

private void FireMyEvent(EventArgs e) { 
    var handler = MyEvent; 
    if (handler != null) 
     handler(this, e); 
} 

Eric Lippert a écrit un fantastique article pourquoi ce modèle est la façon « correcte » des événements de tir

Answer 2

Vérifier null.

if (Object.Event != null) Object.Event(); 

HTH Alex

Answer 3

Dans .NET, les événements sont (par défaut) traitées comme délégués de multidiffusion. Cela signifie que tant que vous n'aurez pas affecté le premier gestionnaire d'événements à l'événement, la référence d'événement sera null.

Cela a conduit à la manière typique d'élever un être de l'événement:

public event EventHandler Event; 

protected virtual void OnEvent(EventArgs e) 
{ 
    EventHandler @event = Event; // Copy immutable delegate for thread safety. 
    if(@event != null) // Check for null. 
     @event(e); // Raise event. 
} 

Answer 4

Si personne n'a souscrit à l'événement, l'objet événement est null. Il est une pratique courante d'utiliser une méthode OnEvent -comme, par exemple (en supposant que votre événement est appelé MyEvent):

public event EventHandler<MyEventArgs> MyEvent; 

void OnMyEvent(MyEventArgs args) { 
    if(MyEvent != null) MyEvent(this, args); 
} 

Lorsque vous devez soulever l'événement, vous appelez simplement la méthode OnMyEvent.

Answer 5

La solution la plus simple à ce problème est de déclarer l'événement:

public event EventHandlerType MyEvent = delegate { }; 

En d'autres termes, ajouter = delegate { }; à la fin.

Vous n'avez plus besoin d'écrire une charge de courrier indésirable chaque fois que vous déclenchez l'événement.

Answer 6

Oui. S'il n'y a aucun abonné, l'événement sera null et vous obtiendrez une exception NullReferenceException lorsque vous l'appelez. La bonne façon de faire le chèque est comme thecoop a dit, mais il y a un simple « raccourci »:

public event EventHandler Event = delegate {}; 

Cela provoque l'événement pour un abonné par défaut qui ne fait rien, et ne sera donc pas jeter une exception si il y a des abonnés. Il y a un légère surcharge de performance de de faire cela, mais cela supprime le besoin de vérifier les nulls.

Answer 7

Juste pour ajouter, vous pouvez également utiliser des méthodes d'extension.

 public static void RaiseSafe<T>(this EventHandler<T> eventHandler, object sender, T args) 
     where T : EventArgs 
    { 
     if (eventHandler != null) 
      eventHandler(sender, args); 
    } 

Et l'utiliser comme ceci:

MyEvent.RaiseSafe(this,new EventArgs());