délégué de l'événement (en) l'égalité?

Question

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

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

Merci

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 des délégués à un événement.

Dans ce cas, ce qui empêche le corps de la méthode consécutifs en double (par exemple 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 ne se déclenche une fois, même si vous avez enregistré deux fois. Un événement normal (sans le add { }) appeler la fonction serait deux fois.

Cependant:

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

Permettra HandleUserChanged deux fois le feu, parce que le dernier gestionnaire enregistré est jamais celui qui est ajouté. L'opérateur == sur les événements fonctionne sur le gestionnaire dernier. (Merci à Matthew d'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 simple modèle de propriété en ce qu'ils enveloppent essentiellement des champs sous-jacents dans une paire de méthodes transparentes.

La façon dont je le comprends, .Net permet la création de implcit événement (anonyme?) 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 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 effectivement 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.