Come eseguire un'azione prima e dopo l'elaborazione della richiesta senza usare middleware?

Utilizzando la programmazione orientata agli aspetti con intercettori, ad esempio con la libreria Castle Windsor o AspectCore.

// Esempio di interfaccia per un servizio
public interface IService
{
    void DoSomething(string input);
}

using Castle.DynamicProxy;

// Interceptor per il logging
public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Azione prima dell'elaborazione
        Console.WriteLine($"Inizio chiamata metodo: {invocation.Method.Name}");

        try
        {
            // Eseguire il metodo originale
            invocation.Proceed();

            // Azione dopo elaborazione riuscita
            Console.WriteLine($"Metodo {invocation.Method.Name} eseguito con successo.");
        }
        catch (Exception ex)
        {
            // Azione in caso di errore
            Console.WriteLine($"Errore durante la chiamata del metodo {invocation.Method.Name}: {ex.Message}");
            throw; // Rilancia l'eccezione
        }
    }
}

// Esempio di implementazione del servizio
public class MyService : IService
{
    public void DoSomething(string input)
    {
        Console.WriteLine($"Esecuzione azione con parametro: {input}");
        // Simulazione di errore
        // if (input == "errore") throw new InvalidOperationException("Qualcosa è andato storto");
    }
}

using Castle.MicroKernel.Registration;
using Castle.Windsor;

// Registrazione del servizio e dell'interceptor nel contenitore IoC
public class Program
{
    public static void Main(string[] args)
    {
        var container = new WindsorContainer();

        container.Register(Component.For<LoggingInterceptor>());
        container.Register(Component.For<IService>().ImplementedBy<MyService>().Interceptors<LoggingInterceptor>());

        // Ottenere l'istanza proxy del servizio
        var service = container.Resolve<IService>();

        service.DoSomething("test");
        // service.DoSomething("errore"); // Disattivare per testare la gestione degli errori

        container.Dispose();
    }
}

Può anche essere usato:

• Decoratore (Design Pattern Decorator): Creare un wrapper attorno alla classe originale che esegue azioni prima e dopo la chiamata ai metodi della classe originale.
• Code weaving: Modificare il bytecode dell'assembly durante la compilazione o il caricamento, usando strumenti come PostSharp.