Combinazione di azione e Func in un parametro

Question

Ho molti metodi che richiedono un po 'di registrazione con lo stesso modello. Alcuni metodi devono restituire un valore, altri no. Ho creato un metodo con parametro Action per evitare copypasting di tutta la logica. Ecco come si presenta:

private void Execute(Action action) 
{ 
    Logger.Start(); 
    try 
    { 
     action(); 
    } 
    catch(Exception exception) 
    { 
     Logger.WriteException(); 
     throw; 
    } 
    finally 
    { 
     Logger.Finish(); 
    } 
} 

ora ho alcune chiamate che in quel modo

public void DoSomething(string parameter) 
{ 
    Execute(() => GetProvider(parameter).DoSomething()); 
} 

ma ho bisogno di qualche funzione che restituiscono valori. Quali sono i modi migliori per farlo? Ho trovato due ora:

1) Creare una copia del metodo Execute con Funz

private T Execute<T>(Func<T> action) 
{ 
    Logger.Start(); 
    try 
    { 
     return action(); 
    } 
    catch(Exception exception) 
    { 
     Logger.WriteException(); 
     throw; 
    } 
    finally 
    { 
     Logger.Finish(); 
    } 
} 

questo metodo funziona, ma ha incollare qualche copia pure.

2) ingannare i parametri in essere un'azione:

public Result DoSomething(string parameter) 
{ 
    Result result = null; 
    Execute(() => result = GetProvider(parameter).DoSomething()); 
    return result; 
} 

Questo non richiede copia incolla, ma non sembra così bello.

C'è un modo per unire Action e Func in qualche modo per evitare uno di questi metodi o potrebbe esserci un altro modo per ottenere lo stesso risultato?

Answer 1

Una terza opzione è quella di ancora sovraccaricare Execute, ma fare il lavoro Action versione in termini di versione Func:

private void Execute(Action action) 
{ 
    // We just ignore the return value here 
    Execute(() => { 
     action(); 
     return 0; 
    }); 
} 

Naturalmente tutto questo sarebbe più semplice se void erano più come un tipo "reale" (come Unit in F # e altri), a quel punto potremmo avere Task<T> invece di Task e Task<T> così ...

Answer 2

creare una copia di Execute che converte il Func int o un Action. Basta scrivere che il codice brutto una volta, e non si finisce con una seconda copia completa del metodo Execute:

private T Execute<T>(Func<T> func) 
{ 
    T result = default(T); 
    this.Execute(() => { result = func(); }); 
    return result; 
} 

... 

public Result DoSomething(string parameter) 
{ 
    return Execute(() => GetProvider(parameter).DoSomething()); 
} 

Answer 3

Ecco un'altra opzione. Invece di fare in modo che il framework di logging chiami il tuo codice reale, chiedi al tuo attuale codice di chiamare il framework di registrazione. Qualcosa del genere farebbe il trucco (molto semplificato).

public class LoggerScope : IDisposable { 

    private bool disposed; 

    public LoggerScope() { 
     Logger.Start(); 
    } 

    public void Dispose() { 
     if(!disposed) { 
      Logger.Finish(); 
      disposed = true; 
     } 
    } 
} 

utilizzati come segue:

 using(var scope = new LoggerScope()) { 
      // actual code goes here 
     } 

eccezioni Gestire separatamente con la cattura e la registrazione solo una volta al livello superiore del vostro codice.

Vantaggi:

• evita la necessità di lambda in tutto il posto, in modo che la traccia dello stack eccezione è un po 'più pulito.
• È possibile aggiungere dati contestuali arbitrari alla classe LoggerScope, ad es. GUID, timestamp, testo di descrizione dell'attività logica.