Kombinieren von Aktion und Func in einem Parameter

Question

Ich habe viele Methoden, die einige Protokollierung mit dem gleichen Muster erfordern. Einige Methoden müssen einen Wert zurückgeben, andere nicht. Ich habe eine Methode mit Aktionsparameter erstellt, um zu vermeiden, dass die gesamte Logik kopiert wird. Es sieht wie folgt aus:

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

Jetzt habe ich einige Anrufe, die wie die

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

Aber ich eine Funktion benötigen, die Werte zurückgeben. Was sind die besten Möglichkeiten, dies zu tun? Ich habe zwei jetzt gefunden:

1) Erstellen Sie eine Kopie der Execute-Methode mit Func

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

Dies funktioniert Methode hat aber auch einige Kopie einfügen.

2) Trick die Parameter in einer Aktion sein:

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

Diese nicht kopieren und einfügen erfordert aber sieht nicht so schön.

Gibt es eine Möglichkeit, Action und Func beizutreten, um irgendeine dieser Methoden zu vermeiden oder gibt es eine andere Möglichkeit, dasselbe Ergebnis zu erzielen?

Answer 1

ist eine dritte Option noch Execute überlasten, aber die Action Version Arbeit in Bezug auf die Func Version machen:

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

Natürlich alles einfacher wäre, wenn void mehr waren wie ein „echter“ Typ (wie Unit in F # et al), an welchem ​​Punkt wir nur Task<T> statt Task und Task<T> auch haben könnte ...

Answer 2

erstellen einer Kopie von Execute, die die Func int konvertiert o ein Action. Sie haben nur einmal den hässlichen Code zu schreiben, und Sie müssen nicht mit einer kompletten zweiten Kopie der Execute Methode am Ende:

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

Hier ist eine weitere Option. Anstatt das Protokollierungs-Framework Ihren tatsächlichen Code aufrufen zu lassen, rufen Sie den Protokollierungs-Framework auf. So etwas würde den Trick (stark vereinfacht) machen.

public class LoggerScope : IDisposable { 

    private bool disposed; 

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

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

wie folgt verwendet:

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

Griff Ausnahmen separat durch den Fang und sie nur einmal auf der obersten Ebene des Codes anzumelden.

Vorteile:

• Vermeiden die Notwendigkeit lambdas ganz über den Platz, so dass der Ausnahme-Stack-Trace ist ein bisschen sauberer.
• Sie können der Klasse beliebige kontextbezogene Daten hinzufügen, z. GUID, Timestamp, logischer Aufgabenbeschreibungstext.