délégué d'événement (in) égalité?

Question

Quelqu'un pourrait-il expliquer la signification de la partie du code suivant:

private event UserChangedHandler m_UserChanged; 
public event UserChangedHandler UserChanged 
{ 
    add 
    { 
     if (m_UserChanged != value) 
     { 
     m_UserChanged += value; 
     } 
    } 
} 

grâce

Answer 1

add { } est une construction peu comme get { } biens immobiliers, à l'exception d'ajouter des travaux sur les événements. Vous définissez des fonctionnalités personnalisées ici lors de l'ajout de délégués à un événement.

Dans ce cas, ce corps de la méthode empêche consécutifs doubles (à savoir on ne peut pas enregistrer le même procédé/gestionnaire deux fois dans une rangée ).

Ainsi, dans cet exemple:

public void HandlerUserChanged(object o, UserChangedEventArgs args) 
{ 
    // some code 
} 

public void HandlerUserChanged2(object o, UserChangedEventArgs args) 
{ 
    // some code 
} 

plus tard:

UserChanged += HandleUserChanged; 
UserChanged += HandleUserChanged; 
UserChanged(this, new UserChangedEventArgs()); 

La méthode HandleUserChanged sera une seule fois le feu, même si vous avez enregistré deux fois. Un événement normal (sans le add { }) appelle la fonction deux fois.

Cependant:

UserChanged += HandleUserChanged; 
UserChanged += HandleUserChanged2; 
UserChanged += HandleUserChanged; 
UserChanged(this, new UserChangedEventArgs()); 

permettra HandleUserChanged au feu deux fois, parce que le gestionnaire dernier enregistré est jamais celui qui est ajouté. L'opérateur == sur les événements fonctionne sur le gestionnaire LAST. (Thankyou Matthieu pour avoir attiré l'attention)

Answer 2

Il me semble étrange que m_UserChanged est déclarée comme un événement plutôt que d'une instance de délégué (est que la bonne terminologie ... je reçois confus w/délégués) . Les événements sont analogues à un modèle de propriété simple en ce qu'ils enveloppent essentiellement les champs sous-jacents dans une paire de méthodes transparentes.

La façon dont je le comprends, .Net permet la création de implcit (anonyme?) Événement et les propriétés en prenant quelque chose comme ceci:

public int Value { get; set;} 
public event EventHandler ValueChanged; 

puis créer les objets d'espace réservé sous-jacents respectifs pour générer quelque chose de plus comme ceci:

private int _Value; 
public int Value { get { return _Value;} set { _Value = value;}} 

private EventHandler _ValueChanged; 
public event EventHandler ValueChange { add { _ValueChanged += value;} remove { _ValueChanged -= value;}} 

l'objet sous-jacent peut être défini de façon explicite bien sûr, mais ce que l'exemple de code ci-dessus ressemble est un peu d'une confusion entre la déclaration d'événements explicites et implicites ... il ressemble à ce qui suit est réelle ment se fait (dans les coulisses, pour ainsi dire):

private UserChangedHandler _m_UserChanged; 
private event UserChangedHandler m_UserChanged { add { _m_UserChanged += value;} remove { _m_UserChanged -= value;}} 
public event UserChangedHandler UserChanged 
{ 
    add 
    { 
     if (m_UserChanged != value) 
     { 
     m_UserChanged += value; 
     } 
    } 
} 

Il ne compte pas vraiment dans le grand schéma des choses, je ne pense pas, mais il ressemble à un oubli.