Consigli su AOP con C#

Question

Possiedo un'applicazione Webforms ASP.NET 3.5 SP1. Io uso il pattern MVP (controller di supervisione) con DI (autofac). I miei relatori chiamano i contratti di deposito definiti nel mio dominio (DDD) che sono implementati in un progetto di infrastruttura.

I metodi di repository che la chiamata del relatore può eseguire, quindi è necessario registrare le eccezioni e quindi impostare un messaggio di errore nella vista.

In passato avrei aggiunto un altro parametro ai costruttori di Presenter, memorizzato il riferimento in un Presenter di base e chiamato un metodo Log nei miei blocchi Catch. Non mi piace molto, ma ha fatto il lavoro.

Potrei seguire il percorso di utilizzo di una fabbrica per ottenere la classe di registrazione as described here, ma mi piacerebbe esplorare prima AOP, in quanto sembra piuttosto interessante.

ho fatto la lettura sul tempo di compilazione vs AOP runtime, e mi piacerebbe sapere quali esperienze popoli sono con le diverse soluzioni, vantaggi, svantaggi, parole di consiglio, ecc

Dalla scavo ho fatto sembra che ci sono 4 quadri principali per AOP in .NET

• Castello di Windsor - io sono rimasto lontano da questo, in generale, perché un sacco di cose che in realtà non hanno bisogno
• Spring.net - sembra che abbia una buona reputazione ma ispira paura attraverso la sua configurazione xml (io non come non-fluente configurazioni)
• PostSharp - Abilità guidate (mi piace questo), ma ad un certo punto avuto some line number issues, non so se esistono ancora
• unità - un sacco di roba che non ha realmente bisogno

Vedo another question che ha alcune buone risposte ma è da un anno e mezzo fa. Ci sono strutture nuove, "migliori" che sono state sviluppate nel frattempo o miglioramenti apportati a soluzioni esistenti che dovrebbero essere prese in considerazione?

Per riferimento, ho scelto Autofac per DI perché è fluente, semplice da usare, non è stato in grado di trovare commenti negativi e funziona.

Ci sono raccomandazioni su quale framework AOP dovrei provare? Grazie per aver letto tutto questo e per aver aggiunto qualche idea.

Answer 1

Risposta breve, per semplicità e facilità d'uso, davvero non si può sbagliare con PostSharp.

Risposta più lunga: Nella mia mente, dovresti scegliere tra i due quadri a seconda di ciò che stai cercando di ottenere.

Se si desidera che gli aspetti cambino in base al contesto, considerare Spring.NET (o qualsiasi framework aop che inietta il codice in fase di esecuzione in base alla configurazione). Questo ti permette di personalizzare il comportamento dei tuoi oggetti a seconda di cosa stai facendo.Ad esempio, tramite la configurazione, è possibile utilizzare un tipo di registrazione in un'app console e un'altra in un'applicazione Web. Notare che Spring è anche un contenitore DI (e molte altre cose) - va ben oltre l'AOP e vale sicuramente la pena imparare a usare.

D'altra parte, se si desidera che il comportamento sia sempre essere in effetti, indipendentemente dal contesto, quindi PostSharp (compile time weaving) è la soluzione migliore. Questo è effettivamente lo stesso come se si includesse il codice in ogni metodo a cui si applica l'aspetto.

Per quello che stai facendo, ti consiglio di iniziare con PostSharp.

Answer 2

Utilizzo PostSharp da un po 'di tempo e devo dire che mi sto godendo la facilità d'uso e la semplicità dell'implementazione.

Devo anche aggiungere che personalmente, quando utilizzo un framework, cerco sempre di attenermi a un singolo framework di responsabilità, a meno che il framework contenga molti componenti di cui ho bisogno o complimenti al core.

Answer 3

Per gli aspetti di aspetto semplice, passare il corpo del metodo come blocco a un metodo generico che gestisce l'aspetto, ovvero l'implementazione di the «hole in the middle» design pattern.

Esempio:

public class Class 
{ 
    public void MethodWithoutAspect() 
    { 
     var dummy = new string('a', 10); 

     Console.WriteLine(dummy); 
    } 

    public void MethodWithAspect() 
    { 
     Aspect.LogException(() => 
     { 
      var dummy = new string('a', 10); 

      Console.WriteLine(dummy); 
     }); 
    } 
} 

public static class Aspect 
{ 
    public static void LogException(Action block) 
    { 
     try 
     { 
      block(); 
     } 
     catch (Exception e) 
     { 
      Log(e); 
      throw; 
     } 
    } 

    private static void Log(Exception e) 
    { 
     throw new NotImplementedException(); 
    } 
}