Funzionale C # - usando o di ritorno di azione

Question

Navigando in rete per una migliore gestione di guasto in C #, ho com attraverso il seguente per strategie di attuazione. Il primo è naturale per me, mentre l'altra applicazione non sono certo quello che i suoi vantaggi sono?

1)

static void Fault(Action protectedBlock, Action faultHandler)
{ 
    try
    {
        protectedBlock();
    }
    catch
    {
        faultHandler();
        throw;
    }

}

2)

static Action Fault(Action protectedBlock, Action faultHandler)
{
    return () =>
    {
        try
        {
            protectedBlock();
        }
        catch
        {
            faultHandler();
            throw;
        }
    };
}

è 2) la strategia preferita durante lo sviluppo di funzioni di ordine superiore in C #?

E, mi chiedo, se uno approccio è più efficace rispetto agli altri.

Answer 1

Il secondo caso è come un Faultable Azione Factory. Dove si passa a un delegato di ciò che si vuole fare, protectedBlock, e un delegato di cosa fare quando si verifica un Exception, faultHandler. Le azioni vengono restituiti avvolto in una struttura try / catch come Action aggregato. Il mio problema con entrambi questi metodi è Exception è in realtà di essere catturati in modo che sia mai sta per prendere il tiro non ha informazioni su cui agire.

La differenza di esecuzione tra i 2 è quando in realtà eseguono. Il primo verrà eseguito quando si chiama. Il 2 ° eseguirà ogni volta che il Action restituito viene chiamato. Non credo che la differenza di efficienza sarebbe significativo.

Answer 2

(2) può essere ulteriormente composto, mentre (1) Just corse. Ma né sono esattamente "funzionale", come Action non è una funzione (confrontare con Func<A, R>).

Quindi, con (2) che si poteva fare:

Fault(someAction, Fault(firstTryFaultHandler, lastDitchFaultHandler))();

... il comportamento e ottenere previsto. Che non funziona con (1)

Answer 3

In C #, l'approccio 2 può essere fonte di confusione. Un chiamante potrebbe utilizzare "Guasto (a, b);" in attesa di un e possibilmente b per essere chiamato. Invece, viene creato un lambda, è tornato e scartato. In altre parole, non si fa nulla.

Per quanto riguarda l'efficienza, l'approccio 2 è un po 'uno spreco se la maggior parte delle chiamate sono di forma "Guasto (a, b) ();", vale a dire si richiama il lambda immediatamente. In questa situazione, non è necessario un lambda.

Per queste ragioni, io preferirei approccio 1. Se è necessario all'esecuzione rinviare, è possibile introdurre un lambda in modo esplicito "() => Guasto (a, b)".