Abonnement à un seul événement

Question

Je suis assez convaincu que ce n'est pas possible, mais je vais quand même demander.

Afin de faire un abonnement unique coup à des événements, je me retrouve souvent en utilisant ce modèle (inventé l'auto-):

EventHandler handler=null; 
handler = (sender, e) => 
{ 
    SomeEvent -= handler; 
    Initialize(); 
}; 
SomeEvent += handler; 

Il est tout à fait beaucoup de passe-partout, et il fait également ReSharper whinge sur les fermetures modifiées. Y at-il un moyen de transformer ce modèle en une méthode d'extension ou similaire? Une meilleure façon de le faire?

Idéalement, je voudrais quelque chose comme:

SomeEvent.OneShot(handler) 

Answer 1

Ce n'est pas très facile à factoriser à une méthode d'extension, car la seule façon vous pouvez vous référer à un événement en C# est en vous inscrivant (+=) à ou désabonnement (-=) de celui-ci (à moins qu'il ne soit déclaré dans la classe en cours).

Vous pouvez utiliser la même approche que dans les extensions réactives: Observable.FromEvent prend deux délégués pour s'abonner à l'événement et se désabonner. Donc, vous pouvez faire quelque chose comme ça:

public static class EventHelper 
{ 
    public static void SubscribeOneShot(
     Action<EventHandler> subscribe, 
     Action<EventHandler> unsubscribe, 
     EventHandler handler) 
    { 
     EventHandler actualHandler = null; 
     actualHandler = (sender, e) => 
     { 
      unsubscribe(actualHandler); 
      handler(sender, e); 
     }; 
     subscribe(actualHandler); 
    } 
} 

... 

Foo f = new Foo(); 
EventHelper.SubscribeOneShot(
    handler => f.Bar += handler, 
    handler => f.Bar -= handler, 
    (sender, e) => { /* whatever */ }); 

Answer 2

Le code suivant fonctionne pour moi. Ce n'est pas parfait d'avoir à spécifier l'événement via une chaîne, mais je n'ai pas de colle pour résoudre ce problème. Je suppose que ce n'est pas possible dans la version C# actuelle.

using System; 
using System.Reflection; 

namespace TestProject 
{ 
    public delegate void MyEventHandler(object sender, EventArgs e); 

    public class MyClass 
    { 
     public event MyEventHandler MyEvent; 

     public void TriggerMyEvent() 
     { 
      if (MyEvent != null) 
      { 
       MyEvent(null, null); 
      } 
      else 
      { 
       Console.WriteLine("No event handler registered."); 
      } 
     } 
    } 

    public static class MyExt 
    { 
     public static void OneShot<TA>(this TA instance, string eventName, MyEventHandler handler) 
     { 
      EventInfo i = typeof (TA).GetEvent(eventName); 
      MyEventHandler newHandler = null; 
      newHandler = (sender, e) => 
          { 
           handler(sender, e); 
           i.RemoveEventHandler(instance, newHandler); 
          }; 
      i.AddEventHandler(instance, newHandler); 
     } 
    } 

    public class Program 
    { 
     static void Main(string[] args) 
     { 
      MyClass c = new MyClass(); 
      c.OneShot("MyEvent",(sender,e) => Console.WriteLine("Handler executed.")); 
      c.TriggerMyEvent(); 
      c.TriggerMyEvent(); 
     } 
    } 
} 

Answer 3

Je suggère d'utiliser un événement « personnalisé » de sorte que vous avez accès à la liste d'appel, puis déclencher l'événement en utilisant Interlocked.Exchange à lire en même temps et effacer la liste d'appel. Si vous le souhaitez, l'abonnement/désabonnement/levée d'événement peut être effectué de manière thread-safe en utilisant une simple pile de listes chaînées; Lorsque l'événement est déclenché, le code peut, après Interlocked.Exchange, inverser l'ordre des éléments de la pile. Pour la méthode de désinscription, je suggérerais probablement simplement de placer un drapeau dans l'élément de liste d'invocation. Cela pourrait théoriquement provoquer une fuite de mémoire si les événements étaient subséquemment souscrits et désabonnés sans que l'événement ne soit jamais déclenché, mais cela rendrait la méthode de désinscription thread-safe très simple. Si l'on voulait éviter une fuite de mémoire, on pourrait tenir compte du nombre d'événements non inscrits qui sont encore dans la liste; Si un trop grand nombre d'événements non inscrits sont dans la liste lors d'une tentative d'ajout d'un nouveau, la méthode add pourrait parcourir la liste et les supprimer. Toujours réalisable en code thread-safe entièrement sans verrou, mais plus compliqué.