Annullamento dell'iscrizione dal gestore di eventi anonimi all'interno di un metodo statico (metodo di estensione)

Question

Ho un metodo di estensione per sottoscrivere un evento PropertyChanged di un oggetto che implementa INotifyPropertyChanged.

Mi piacerebbe che l'evento si accenda solo una volta. Non di più.

Questo è il mio metodo.

public static void OnPropertyChanged<T>(this INotifyPropertyChanged target, string propertyName, Action action) 
{ 
    if (target == null) 
    { 
     return; 
    } 

    PropertyChangedEventHandler handler = (obj, e) => 
    { 

     if (propertyName == e.PropertyName) 
     { 
      action(); 
     } 

    }; 


    target.PropertyChanged -= handler; 
    target.PropertyChanged += handler; 

} 

Ma non funziona. Non riesco a rimuovere il gestore eventi in modo che l'evento venga attivato ogni volta che chiamo questo metodo.

Ho provato un approccio diverso. Invece di usare metodi annonymous, qualcosa di più tradizionale, in questo modo:

public static void OnPropertyChanged<T>(this INotifyPropertyChanged target, string propertyName, Action action) 
{ 
    if (target == null) 
    { 
     return; 
    } 

    target.PropertyChanged -= target_PropertyChanged; 
    target.PropertyChanged += target_PropertyChanged; 

} 

static void target_PropertyChanged(object sender, PropertyChangedEventArgs e) 
    { 
     //do stuff here 
    } 

E funziona bene. L'evento si attiva solo una volta, ma ho anche bisogno del parametro Action. Non posso usarlo con questo approccio.

Qualsiasi soluzione alternativa o approccio diverso per risolvere questo problema? Esiste qualcosa di strano con metodi anonimi all'interno di metodi statici?

Grazie in anticipo.

Answer 1

Questa è una limitazione dell'utilizzo di metodi anonimi come gestori di eventi. Non possono essere rimossi come si farebbe con un metodo normale (che tecnicamente è un'istanza delegata creata automaticamente tramite una conversione del gruppo metodo) perché i metodi anonimi vengono compilati in una classe contenitore generata dal compilatore e ogni volta viene creata una nuova istanza della classe.

Per preservare il parametro action è possibile creare una classe contenitore che includa il delegato per il gestore eventi all'interno. La classe può essere dichiarata privata all'interno dell'altra classe con cui stai lavorando o resa interna, magari nello spazio dei nomi "Helpers". Sarebbe simile a questa:

class DelegateContainer 
{ 
    public DelegateContainer(Action theAction, string propName) 
    { 
     TheAction = theAction; 
     PopertyName = propName; 
    } 

    public Action TheAction { get; private set; } 
    public string PropertyName { get; private set; } 

    public void PropertyChangedHandler(object sender, PropertyChangedEventArgs e) 
    { 
     if(PropertyName == e.PropertyName) 
      TheAction(); 
    } 
} 

Poi, creare e memorizzare il riferimento al contenitore della tua classe. Si potrebbe creare un membro statico currentContainer e quindi impostare il gestore in questo modo:

private static DelegateContainer currentContainer; 

public static void OnPropertyChanged<T>(this INotifyPropertyChanged target, string propertyName, Action action) 
{ 
    if (target == null) 
    { 
     return; 
    } 

    if(currentContainer != null)   
     target.PropertyChanged -= currentContainer.PropertyChangedHandler; 

    currentContainer = new DelegateContainer(action, propertyName); 
    target.PropertyChanged += currentContainer.PropertyChangedHandler; 
} 

Answer 2

Tecnicamente, non è lo stesso metodo anonimo che si sta tentando di annullare l'iscrizione. .NET crea una nuova istanza di quel metodo ogni volta che viene chiamato il tuo OnPropertyChanged. Ecco perché la disiscrizione non funzionerà.

Answer 3

È possibile ottenere il primo esempio di lavoro se si annulla la sottoscrizione da entro il gestore di eventi stesso.

public static void OnPropertyChanged<T>(this INotifyPropertyChanged target, string propertyName, Action action) 
{ 
    if (target == null) 
    { 
     return; 
    } 

    // Declare the handler first, in order to create 
    // a concrete reference that you can use from within 
    // the delegate 
    PropertyChangedEventHandler handler = null; 
    handler = (obj, e) => 
    { 
     if (propertyName == e.PropertyName) 
     { 
      obj.PropertyChanged -= handler; //un-register yourself 
      action(); 
     } 

    }; 
    target.PropertyChanged += handler; 
} 

Il codice di cui sopra serve come "uno e fatto" gestore di eventi. È possibile registrare un numero illimitato di questi e ognuno verrà eseguito una sola volta prima di annullare la registrazione.

Ricordare che è possibile eseguire uno di questi gestori più volte, se si genera l'evento su più thread in rapida successione. Per evitare ciò, potrebbe essere necessario creare istanze di oggetti di mappatura statici Dictionary(T,T) su "blocca oggetti" e aggiungere un po 'di codice sentry per garantire che un gestore venga eseguito una sola volta. Quelle specifiche di implementazione sembrano essere un po 'al di fuori della portata della tua domanda come attualmente scritto, comunque.