Wie kann ich ein einfaches aspektorientiertes Konzept verwenden, um Ausnahmebehandlung ohne Postsharp zu behandeln?

Question

Ich möchte AOP verwenden, um meine Fehlerausnahme in der Konsolenanwendung zu behandeln. (Es ist nicht MVC i Attribut Vase Programmierung verwendet, um Fehler in Mvc zu handhaben, aber dies ist Konsole app) Mein Code unten: (falls Fehler auftritt, sollte ein Fehler yo mein Attribut seitigen Code werfen)

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)] 
public class HandleError : Attribute 
{ 
    public HandleError(string description) 
    { 
     try 
     { 
      this.Description = description; 
     } 
     catch (Exception) 
     { 

      throw; 
     } 

    } 
    public string Description { get; set; } 


} 

dieser Wille Anruf von meiner Methode:

[HandleError("Error occurs here")] 
    public static void MyMethod(string data) 
    { 
     throw new Exception(); 

Eigentlich; Ich möchte AOP verwenden, um Ausnahmen innerhalb meiner Methode zu behandeln. Ich muss Attribute aufrufen, wenn ein Fehler auftritt. Aber wie? (bitte nicht postsharp, es braucht geld. aber ich bin offen für opensource auch) Übrigens; warum es nicht leicht ist, verstehe ich nicht.

Answer 1

Grundsätzlich besteht PostSharp darin, Code zur Kompilierungszeit in Ihre Assembly einzuflechten, die vor und nach den Methoden ausgeführt wird, die mit den Attributen gekennzeichnet sind. Dies ist vom Leistungspunkt her sehr gut, da kein Code verwendet wird, der zur Laufzeit dynamisch erstellt wird.

Einige andere AOP-Frameworks (oder IoC-Container) bieten die Möglichkeit, dynamische Proxies zu generieren, die Code enthalten, der die Aufrufe der Methoden zur Laufzeit abfängt.

Entweder Sie verwenden eines dieser Frameworks (suchen Sie nach IoC und Interception) oder Sie implementieren eine vergleichbare Funktionalität selbst. Grundsätzlich müssen Sie den Code, den Sie abfangen möchten, in eine Klasse verschieben und die Methoden als virtual markieren. Zur Laufzeit dekorieren Sie die Instanz der Klasse mit einer dynamisch erstellten Klasse, die von Ihrer Klasse erbt und die Methoden überschreibt, sodass der zusätzliche Code vor und nach dem Aufruf der Methode ausgeführt wird.

Es könnte jedoch einen einfacheren Ansatz geben, der den Anforderungen einer Konsolenanwendung entspricht. Statt die Methoden mit einem Attribut von Markierung, können Sie auch einige Hilfsfunktionen erstellen, die den Code enthalten, die Sie vor und nach der Methode ausgeführt werden soll:

void Main() 
{ 
    int value = GetValue(123); 
    DoSomething(value); 
} 

void DoSomething(int myParam) 
{ 
    RunAndLogError(() => { 
     // Place code here 
     Console.WriteLine(myParam); 
     }); 
} 

int GetValue(int myParam) 
{ 
    return RunAndLogError(() => { 
     // Place code here 
     return myParam * 2;}); 
} 

void RunAndLogError(Action act) 
{ 
    try 
    { 
     act(); 
    } 
    catch(Exception ex) 
    { 
     // Log error 
     throw; 
    } 
} 

T RunAndLogError<T>(Func<T> fct) 
{ 
    try 
    { 
     return fct(); 
    } 
    catch(Exception ex) 
    { 
     // Log error 
     throw; 
    } 
} 

Wie Sie sehen können, gibt es zwei Überlastungen von RunAndLogError, eine für Void-Methoden, die andere für Methoden, die einen Wert zurückgeben.

Eine andere Option ist die Verwendung eines globalen Ausnahmebehandlers für diesen Zweck; Siehe diese Antwort für Details: .NET Global exception handler in console application