Come programmare utilizzando PostSharp in C #

Aspect Oriented Programming (AOP) è un paradigma di programmazione che consente di definire policy per gestire senza problemi le problematiche trasversali nelle applicazioni. AOP può essere utilizzato per rimuovere codice mescolato, scrivere codice più pulito, aumentare l'astrazione e la modularità del codice, ridurre i costi di manutenzione e sviluppo e rendere le applicazioni più gestibili e flessibili. PostSharp è uno degli strumenti più popolari disponibili che può essere utilizzato per implementare AOP nelle applicazioni.

Iniziare

Per iniziare a utilizzare PostSharp, potresti voler installare l'ultima versione stabile utilizzando la console di Gestione pacchetti. In alternativa, puoi installare PostSharp utilizzando la finestra "Gestisci pacchetti NuGet". Per iniziare a utilizzare PostSharp nella tua applicazione, segui questi passaggi.

1. Apri Visual Studio 2015.

2. Nel menu di Visual Studio, fare clic su File> Nuovo> Progetto.

3. Selezionare il modello Applicazione console dall'elenco dei modelli di progetto visualizzati.

4. Salvare il nuovo progetto dell'applicazione console con un nome.

5. Nel menu di Visual Studio, fare clic su Strumenti> Gestione pacchetti NuGet> Gestisci pacchetti NuGet per soluzione.

6. Cerca la versione stabile più recente di PostSharp e fai clic su Installa.

Ed è tutto ciò che devi fare per ora. Quando richiesto, seleziona i progetti in cui desideri installare PostSharp e fai clic su OK. Una volta completata l'installazione, sei pronto per utilizzare PostSharp nella tua applicazione.

Programmazione PostSharp

Una volta installato PostSharp, puoi iniziare a usarlo nella tua applicazione. Per fare ciò, dovrai creare uno o più aspetti da utilizzare per la tua applicazione. Un modo per implementare AOP nelle tue applicazioni è attraverso l'uso di attributi. Una volta definito il tuo aspetto, ti consigliamo di applicare l'aspetto al tuo programma tramite attributi.

Nella finestra Esplora soluzioni, seleziona il progetto, fai clic con il pulsante destro del mouse e aggiungi una nuova classe denominata ExceptionAspect. Nota che l'aspetto necessario per gestire le eccezioni nella tua applicazione dovrebbe derivare dalla classe OnExceptionAspect della libreria PostSharp. OnExceptionAspect include un metodo chiamato OnException che dovrai sovrascrivere per gestire le eccezioni. Il codice seguente illustra la nostra classe di aspetto delle eccezioni personalizzato.

[Serializable]

    public class ExceptionAspect : OnExceptionAspect

    {

        public override void OnException(MethodExecutionArgs args)

        {

            Console.WriteLine("Error occured at: "+

            DateTime.Now.ToShortTimeString() + " Error Message: "+

            args.Exception.Message);

            args.FlowBehavior = FlowBehavior.Continue;

            base.OnException(args);

        }

    }

Ogni aspetto dovrebbe essere serializzabile: si noti l'utilizzo dell'attributo [Serializable] nella classe ExceptionAspect mostrata sopra. Ora che l'aspetto è a posto, puoi applicarlo a uno o più metodi nella tua applicazione utilizzando gli attributi. Il frammento di codice seguente illustra un metodo di esempio per applicare l'aspetto dell'eccezione appena creato.

[ExceptionAspect]

 public static void TestExceptionAspect()

  {

      throw new Exception("This is a test message");

  }

Puoi applicare l'aspetto dell'eccezione personalizzata appena creato a uno o più metodi nell'applicazione, o anche a livello di classe. Se l'aspetto viene applicato a livello di classe, verranno gestite le eccezioni generate da uno dei metodi della classe. Gli aspetti PostSharp possono essere applicati anche all'intero assieme. Questa funzionalità è nota come Multicast e può essere applicata allo spazio dei nomi di destinazione specificando la seguente istruzione nel file AssemblyInfo.cs:

[assembly: ExceptionAspect (AttributeTargetTypes = "PostSharp. *")]

"PostSharp. *" Nello snippet di codice precedente si riferisce a tutti i tipi presenti nello spazio dei nomi PostSharp.

La classe OnMethodBoundaryAspect consente di eseguire codice personalizzato prima e dopo l'esecuzione di un metodo. Mentre il suo metodo OnEntry viene eseguito prima dell'esecuzione di un metodo su cui viene applicato l'aspetto, il metodo OnExit viene eseguito dopo l'esecuzione del metodo. Il listato di codice seguente illustra come misurare il tempo di esecuzione di un metodo utilizzando un aspetto. La classe ExecutionTimeAspect seguente deriva la classe OnMethodBoundaryAspect e sovrascrive i metodi OnEntry e OnExit.

 [Serializable]

    public class ExecutionTimeAspect : OnMethodBoundaryAspect

    {

        [NonSerialized]

        Stopwatch stopWatch;

        public override void OnEntry(MethodExecutionArgs args)

        {

            stopWatch = Stopwatch.StartNew();

            base.OnEntry(args);

        }

        public override void OnExit(MethodExecutionArgs args)

        {

            string method = new

            StackTrace().GetFrame(1).GetMethod().Name;

            string message = string.Format("The method: [{0}] took

            {1}ms to execute.",

                        method, stopWatch.ElapsedMilliseconds);

            Console.WriteLine(message);

            base.OnExit(args);

        }

    }

Puoi anche modificare il metodo OnExit sopra per registrare il tempo di esecuzione dei metodi. Ora che il tuo aspetto è pronto per essere utilizzato, può essere applicato su uno o più metodi per recuperare il tempo di esecuzione.

[ExecutionTimeAspect]

public static void TestExceptionAspect()

{

   //Some code

}

Puoi saperne di più su PostSharp leggendo la documentazione.