delegado de evento (in) igualdade?

Question

Alguém poderia explicar o significado da seguinte parte do código:

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

obrigado

Answer 1

add { } é uma construção muito parecida get { } Para propriedades, exceto adicionar obras sobre eventos. Você está definindo a funcionalidade personalizada aqui ao adicionar delegados a um evento.

Nesse caso, esse corpo de método evita consecutivo duplicata (ou seja, você não pode registrar o mesmo método/manipulador duas vezes em uma sequência).

Então, neste exemplo:

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

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

Mais tarde:

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

O método HandleUserChanged Só disparará uma vez, mesmo que você o tenha registrado duas vezes. Um evento normal (sem o add { }) invocaria a função duas vezes.

No entanto:

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

Permitirá HandleUserChanged Para disparar duas vezes, porque o manipulador de último registro nunca está sendo adicionado. O operador == em eventos funciona no último manipulador. (Obrigado a Matthew por chamar isso à atenção)

Answer 2

Parece -me tão estranho que o M_USERCHANGED seja declarado como um evento e não apenas uma instância delegada (é a terminologia certa ... fico confuso com delegados). Os eventos são análogos a um modelo de propriedade simples, pois embrulham essencialmente os campos subjacentes em um par de métodos transparentes.

Do jeito que eu entendo, o .NET permite a criação de eventos e propriedades do ImplCit (anônimo?), Levando algo assim:

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

e depois criar os respectivos objetos de espaço reservado subjacente para gerar algo mais assim:

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

O objeto subjacente pode ser definido explicitamente, é claro, mas como é a amostra de código acima ):

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

Realmente não importa no grande esquema das coisas, não acho, mas parece uma supervisão.