Come deve essere chiamato un metodo che crea condizionatori dell'evento auto annullanti la sottoscrizione?

Sembra che quando usi questo codice stai facendo questo:

Decidi che quando termina la fine dell'evento di dialogo, quando la condizione è vera, devi fare qualcosa, solo una volta, quindi annullare l'iscrizione.

Il problema con il suggerimento di Frank Hilemans di usare semplicemente un puntatore a funzione è che la condizione B possa cambiare stato nel tempo da quando decidi di quando si verifica l'evento A. Se questo non è un problema, ti preghiamo di trovare un modo per semplificare.

Altrimenti quello che stai veramente cercando qui è un aiuto semantico. Vuoi qualcosa di facile sugli occhi che i neofiti capiranno a colpo d'occhio. Mentre ci siamo, che ne dici di smettere di far scrivere alle persone il codice che segnala il risultato?

Action<DialogEvent.End> endHandler = null;

endHandler = EventBusLambdaBuilder
    .DoneWhen( e -> Condition(e) )
    .DoOnceThenUnsubscribe( e -> Something() )
    .Build() 
;

EventBus.Subscribe(endHandler);

Ora, se usi enumerazioni o meno non è un'idea che si sta diffondendo ovunque. L'implementazione è ben nascosta. Questo è un qualcosa chiamato DSL (Domain Specific Language). Ma aspetta, questo è C #. Hai argomenti denominati .

endHandler = EventBusLambdaBuilder(
    doneWhen: e -> Condition(e),
    doOnceThenUnsubscribe: e -> Something()
);

Se ciò fornisce tutta la flessibilità di cui hai bisogno, non è necessario andare fino a un DSL. Rende comunque ciò che sta per accadere chiaro senza precisare come.

Stai reinventando la ruota un po 'qui.

Usando System.Reactive.Linq hai il seguente nome e approccio.

Questo

EventBus.SubscribeUntil<DialogEvent.End>(e =>
{
    if (e.Dialog.Name == "MyDialog")
    {
        DoSomething();
        return EventHandlerResult.Unsubscribe;
    }
    return EventHandlerResult.KeepSubscribed;
});

Supponendo che EventBus sia impostato su IObservable diventa questo:

EventBus.Where(e=>e.Dialog.Name=="MyDialog").Take(1).Subscribe(_=>DoSomething());

Se sei preoccupato per le dipendenze, le prestazioni, ecc., potresti forse esaminare il tuo approccio Linq-to-YourEventBus.

Non utilizzare il nome, utilizzare il tipo di delegato

Il naming è una cosa che hai a tua disposizione. Ma hai anche il delegato e i tipi di eventi che puoi usare. Hai ragione di pensare che usare solo il nome è debole; usare il sistema dei tipi a tuo vantaggio è molto più strong.

Suggerisco di definire un tipo di delegato specifico per i gestori che possono annullare la sottoscrizione e fornire a tale delegato un mezzo semplice e facile per eseguire la disiscrizione. In questo modo, l'intenzione viene comunicata agli sviluppatori, che saranno costretti a utilizzare il tipo di delegato speciale e saranno ovvi per chiunque legga il codice. Inoltre, avrai la sicurezza aggiuntiva del controllo in fase di compilazione.

Inoltre, questa tecnica consente di annullare l'iscrizione per essere iniettata nel gestore, offrendo tutti i vantaggi dell'iniezione delle dipendenze-- il gestore, ad esempio, non avrà capito quale istanza di EventBus chiamare per annullare l'iscrizione e puoi facilmente prendere in giro l'interfaccia di annullamento in fase di test delle unità.

Ad esempio:

//Define an interface that we can pass to the handler
public interface IUnsubscribe
{
    void Unsubscribe(TransientEventHandler handler);
}

//Define the handler that accepts our new interface
public delegate  void TransientEventHandler(object sender, EventArgs e, IUnsubscribe unsubscribe);

//Implement the interface in the bus itself
public class EventBus : IUnsubscribe
{
    protected event TransientEventHandler Clicked;

    //Allow regular handlers
    public void Subscribe(EventHandler handler)
    {
        Clicked += delegate (object sender, EventArgs e, IUnsubscribe bus) { handler(sender, e); };
    }

    //Allow transient handlers
    public void Subscribe(TransientEventHandler handler)
    {
        Clicked += handler;
    }

    //Raise the event
    public void OnClicked()
    {
        if (Clicked != null)
        {
            Clicked(this, new EventArgs(), this);
        }
    }

    //Support unsubscription
    public void Unsubscribe(TransientEventHandler handler)
    {
        Clicked -= handler;
    }
}

//Now test it all
public class Program
{
    static private bool unsub = false;

    private static void SimulateClick(EventBus bus)
    {
        bus.OnClicked();
    }

    public static void MyHandler(object sender, EventArgs e, IUnsubscribe unsubscribe)
    {
        Console.WriteLine("MyHandler - Handling click");
        if (unsub)
        {
            Console.WriteLine("MyHandler - Unsubscribing");
            unsubscribe.Unsubscribe(MyHandler);
        }
    }

    public static void Main()
    {
        var e = new EventBus();
        e.Subscribe(MyHandler);

        Console.WriteLine("Main - sending click");
        SimulateClick(e);

        Console.WriteLine("Main - telling handler to unsubscribe next time it runs");
        unsub = true;

        Console.WriteLine("Main - sending click");
        SimulateClick(e);

        Console.WriteLine("Main - sending click");
        SimulateClick(e);

        Console.WriteLine("Main - sending click");
        SimulateClick(e);
    }

}

Output:

Main - sending click
MyHandler - Handling click
Main - telling handler to unsubscribe next time it runs
Main - sending click
MyHandler - Handling click
MyHandler - Unsubscribing
Main - sending click
Main - sending click

Esempio di codice su DotNetFiddle

P.S. per quanto riguarda la tua domanda iniziale, che riguardava la denominazione, suggerirei un nome come Transitorio o Temporaneo , ad es. TransientEventHandler .