¿Cómo evitar métodos anónimos en la suscripción de eventos "dinámicos"?

Question

¿Cómo podría refactorizar el método

private void ListenToPropertyChangedEvent(INotifyPropertyChanged source, 
              string propertyName) 
{ 
    source.PropertyChanged += (o, e) => 
    { 
     if (e.PropertyName == propertyName) 
      MyMagicMethod(); 
    }; 
} 

si deseaba evitar el uso del método anónimo aquí?

Answer 1

Implementar el cierre que está implícita creada por el lambda explícita:

private void ListenToPropertyChangedEvent(INotifyPropertyChanged source, 
              string propertyName) 
{ 
    var listener = new MyPropertyChangedListener(propertyName); 
    source.PropertyChanged += listener.Handle; 
} 

class MyPropertyChangedListener 
{ 
    private readonly string propertyName; 

    public MyPropertyChangedListener(string propertyName) 
    { 
     this.propertyName = propertyName; 
    } 

    public void Handle(object sender, PropertyChangedEventArgs e) 
    { 
     if (e.PropertyName == this.propertyName) 
     { 
      // do something 
     } 
    } 
} 

Answer 2

Usted puede manejar esto por tener un solo controlador de eventos para todas las instancias que utiliza un diccionario de instancias de que sigue:

private Dictionary<INotifyPropertyChanged, List<string>> sourceMap = 
    new Dictionary<INotifyPropertyChanged, List<string>>(); 

private void ListenToPropertyChangedEvent(INotifyPropertyChanged source, 
              string propertyName) 
{ 
    if (sourceMap.ContainsKey(source)) 
     sourceMap[source].Add(propertyName); 
    else 
    { 
     source.PropertyChanged += source_PropertyChanged; 
     sourceMap[source] = new List<string> { propertyName }; 
    } 
} 

void source_PropertyChanged(object sender, PropertyChangedEventArgs e) 
{ 
    var source = sender as INotifyPropertyChanged; 
    var list = sourceMap[source]; 
    if (list.Contains(e.PropertyName)) 
     MyMagicMethod(); 
} 

Esta versión no tiene ningún error de comprobación o eliminación, pero demuestra la técnica. Es particularmente valioso si escuchas varias propiedades de la misma fuente. Esto se debe a que solo agrega un único controlador al evento PropertyChanged por instancia.

Answer 3

No estoy seguro exactamente lo que usted está tratando de lograr o por qué usted no desea utilizar los métodos anónimos, pero se puede hacer algo más genérico:

private PropertyChangedEventHandler GetHandler 
     (Func<PropertyChangedEventArgs, bool> test, Action toInvoke) 
    { 
     return new PropertyChangedEventHandler(
      (o, e) => 
      { 
       if (test(e)) 
       toInvoke(); 
      }); 
    } 

A continuación, puede usarlo de esta manera:

source.PropertyChanged += GetHandler     
      (
       p => p.PropertyName == propertyName, MyMagicMethod 
      ); 

De esta forma, su prueba if y el grupo de métodos de destino se pueden intercambiar fácilmente. Su controlador de eventos también está fuertemente tipado en lugar de anónimo.