evento delegato (dis) uguaglianza?

Question

Qualcuno potrebbe spiegare il significato delle seguenti porzione di codice:

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

grazie

Answer 1

add { } è un costrutto molto simile get { } per le proprietà, ad eccezione delle opere add su eventi. Si sta definendo funzionalità personalizzate qui quando si aggiungono i delegati a un evento.

In questo caso, questo metodo corpo impedisce consecutivi duplicati (cioè non è possibile registrare lo stesso metodo / gestore due volte in una riga ).

Quindi in questo esempio:

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

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

In seguito:

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

Il metodo HandleUserChanged sarà attiva una sola volta, anche se si è registrato due volte. Un evento normale (senza add { }) avrebbe richiamare la funzione due volte.

Tuttavia:

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

permetterà HandleUserChanged al fuoco due volte, perché l'ultima-registrato gestore non è mai quello che viene aggiunto. L'operatore == sugli eventi lavora sull'ultimo gestore. (Un grazie a Matteo per aver portato all'attenzione che)

Answer 2

E mi sembra strano che m_UserChanged è dichiarato come un evento piuttosto che solo un'istanza delegato (è che la terminologia giusta ... mi confondo w / delegati). Gli eventi sono analoghi a un semplice modello Terreno che essenzialmente avvolgono campi sottostanti all'interno di una coppia di metodi trasparenti.

Il modo in cui ho capito, Net permette la creazione di implcit evento (anonimo?) E le proprietà prendendo qualcosa di simile:

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

e quindi la creazione dei rispettivi oggetti segnaposto sottostanti per generare qualcosa di più simile a questo:

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'oggetto sottostante può essere definito in modo esplicito, naturalmente, ma quello che il codice di esempio sopra appare così è un po 'di una fusione tra la dichiarazione di evento espliciti ed impliciti ... sembra che in realtà è stato fatto il seguente (dietro le quinte, per così 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; 
      } 
  } 
} 

E 'davvero non importa nel grande schema delle cose, non credo, ma sembra una svista.