Per migliorare la nostra comprensione di come interagiscono i middleware in una pipeline OWIN, quest?oggi andremo a misurare il tempo impiegato da un?applicazione per rispondere ad una richiesta HTTP in ingresso.

Lo StopwatchMiddleware che andremo a scrivere si posizionerà all?inizio della pipeline OWIN, in modo che sia il primo a veder passare la Request ma anche l?ultimo a poter influenzare la Response. Questo gli darà l?opportunità di misurare il tempo complessivo richiesto.

La pipeline OWIN, infatti, si configura pressappoco come uno stack di middleware il cui ciclo di vita è sinteticamente illustrato dall?immagine seguente.
Nei punti indicati con Start() e Stop() andremo ad invocare gli omonimi metodi di un oggetto Stopwatch, che useremo per misurare il tempo.

Andiamo quindi ad implementare il nostro StopwatchMiddleware per un?applicazione ASP.NET WebAPI Self-Hosted. Come abbiamo visto nello script precedente ([url]https://www.aspitalia.com/script/1211/Scrivere-Middleware-OWIN-ASP.NET.aspx[/url]), creiamo una nuova classe derivando da OwinMiddleware e facciamo l'override del metodo asincrono Invoke per inserire la nostra logica.

public class StopwatchMiddleware : OwinMiddleware
{
  private readonly OwinMiddleware nextMiddleware;
  private readonly TextWriter logger;

  public StopwatchMiddleware(OwinMiddleware nextMiddleware, TextWriter logger)
    : base(nextMiddleware)
  {
    this.nextMiddleware = nextMiddleware;
    this.logger = logger;
  }

  public override async Task Invoke(IOwinContext context)
  {
    var stopwatch = new Stopwatch();
    
    //Avviamo il cronometro
    stopwatch.Start();
  
    //NEXT!
  //Passiamo il controllo al middleware successivo,
  //che a sua volta lo passerà al suo successivo
    await nextMiddleware.Invoke(context);
    
    //Al ritorno, fermiamo il contrometro
    stopwatch.Stop();
  
    //E logghiamo il tempo impiegato
    logger.WriteLine($"La richiesta a {context.Request.Uri.PathAndQuery} "
      + $"è stata elaborata in {stopwatch.Elapsed}");
  }
}

In questo esempio, è importante notare che abbiamo eseguito della logica in due momenti diversi:

• Abbiamo avviato il cronometro prima di chiamare l?Invoke sul middleware successivo;
• Lo abbiamo fermato dopo l?Invoke, ovvero quando i middleware successivi avevano tutti già completato la loro esecuzione.

Non resta che registrare il nostro middleware in cima al metodo Configuration della classe Startup, in modo che sia il primo della pipeline.

public void Configuration(IAppBuilder app)
{
  //Registriamo il nostro StopwatchMiddleware per primo.
  //Essendo questa un'applicazione console
  //viene fornito Console.Out come TextWriter per il logging.
  app.Use(typeof(StopwatchMiddleware), Console.Out);
  
  //TODO: qui poi registriamo tutti gli altri middleware
  //che vogliamo usare nella pipeline (es. il routing di ASP.NET WebAPI)
}

A questo punto avviamo la nostra applicazione ASP.NET WebAPI Self-Hosted (descritta in un precedente script https://www.aspitalia.com/script/1202/Applicazioni-Web-Basate-OWIN-Selfhosting-ASP.NET-Web-API.aspx) ed iniziamo ad inviare delle richieste. In console cominceranno ad apparire i rispettivi tempi di esecuzione.