Comment effectuer une action avant et après le…

En utilisant la programmation orientée aspect avec des interceptors, par exemple avec la bibliothèque Castle Windsor ou AspectCore.

// Exemple d'interface pour un service
public interface IService
{
    void DoSomething(string input);
}

using Castle.DynamicProxy;

// Intercepteur pour la journalisation
public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Action avant le traitement
        Console.WriteLine($"Début de l'appel de la méthode : {invocation.Method.Name}");

        try
        {
            // Exécuter la méthode d'origine
            invocation.Proceed();

            // Action après le traitement réussi
            Console.WriteLine($"Méthode {invocation.Method.Name} exécutée avec succès.");
        }
        catch (Exception ex)
        {
            // Action en cas d'erreur
            Console.WriteLine($"Erreur lors de l'appel de la méthode {invocation.Method.Name} : {ex.Message}");
            throw; // Relancer l'exception
        }
    }
}

// Exemple d'implémentation du service
public class MyService : IService
{
    public void DoSomething(string input)
    {
        Console.WriteLine($"Exécution de l'action avec le paramètre : {input}");
        // Simulation d'une erreur
        // if (input == "erreur") throw new InvalidOperationException("Quelque chose a mal tourné");
    }
}

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

// Enregistrement du service et de l'intercepteur dans le conteneur 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>());

        // Obtenir l'instance proxy du service
        var service = container.Resolve<IService>();

        service.DoSomething("test");
        // service.DoSomething("erreur"); // Décommenter pour tester la gestion des erreurs

        container.Dispose();
    }
}

Il est également possible d'utiliser :

Décorateur (pattern de conception Decorator) : Créer un wrapper autour de la classe d'origine qui effectue des actions avant et après l'appel des méthodes de la classe d'origine.
Tissage de code (Code weaving) : Modifier le bytecode de l'assembly lors de la compilation ou du chargement, en utilisant des outils comme PostSharp.

Comment effectuer une action avant et après le traitement de la requête sans utiliser de middleware ?