delegado de eventos (des) igualdad?

Question

Podría alguien explicar el significado de la siguiente porción de código:

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

gracias

Answer 1

add { } es una construcción muy similar a get { } de propiedades, excepto obras add en eventos. Se está definiendo una funcionalidad personalizada aquí cuando se añade a los delegados a un evento.

En este caso, este cuerpo método evita consecutivos duplicados (es decir, que no pueden registrar el mismo método / manejador dos veces en una fila ).

Así que en este ejemplo:

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

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

Más tarde:

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

El HandleUserChanged método sólo se disparará una vez, a pesar de que se registró dos veces. Un evento normal (sin el add { }) sería invocar la función dos veces.

Sin embargo:

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

permitirá que HandleUserChanged al fuego dos veces, porque la última registrada-guía no es jamás se añade el uno. El operador == en eventos trabaja en el manejador ÚLTIMO. (Gracias a Mateo por traer eso a la atención)

Answer 2

Me parece extraño que m_UserChanged se declara como un evento en lugar de sólo una instancia de delegado (es que la terminología correcta ... me confundo w / delegados). Los eventos son análogos a un modelo simple de la propiedad en que se envuelven en esencia campos subyacentes dentro de un par de métodos transparentes.

A mi modo de entender, .Net permite la creación de implcit evento (anónimo?) Y las propiedades tomando algo como esto:

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

y luego la creación de los respectivos objetos de marcador de posición subyacentes para generar algo más parecido a esto:

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;}}

El objeto subyacente puede ser definido de forma explícita, por supuesto, pero lo que el ejemplo de código anterior se parece es un poco de una fusión entre la declaración de eventos explícitos e implícitos ... parece que en realidad se está haciendo lo siguiente (detrás de las escenas, por así decirlo):

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; 
      } 
  } 
} 

En realidad no importa en el gran esquema de las cosas, no lo creo, pero parece que un descuido.