Cum se poate realiza o acțiune înainte și după procesarea cererii fără a folosi middleware?

Utilizând programarea orientată pe aspecte cu interceptori, de exemplu, cu ajutorul bibliotecii Castle Windsor sau AspectCore.

// Exemplu de interfață pentru un serviciu
public interface IService
{
    void DoSomething(string input);
}

using Castle.DynamicProxy;

// Interceptor pentru logare
public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Acțiune înainte de procesare
        Console.WriteLine($"Începutul apelului metodei: {invocation.Method.Name}");

        try
        {
            // Executarea metodei originale
            invocation.Proceed();

            // Acțiune după procesare cu succes
            Console.WriteLine($"Metoda {invocation.Method.Name} executată cu succes.");
        }
        catch (Exception ex)
        {
            // Acțiune în caz de eroare
            Console.WriteLine($"Eroare la apelarea metodei {invocation.Method.Name}: {ex.Message}");
            throw; // Re-aranjarea excepției
        }
    }
}

// Exemplu de implementare a serviciului
public class MyService : IService
{
    public void DoSomething(string input)
    {
        Console.WriteLine($"Executarea acțiunii cu parametrul: {input}");
        // Simulare de eroare
        // if (input == "eroare") throw new InvalidOperationException("Ceva nu a mers bine");
    }
}

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

// Înregistrarea serviciului și a interceptorului în containerul 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>());

        // Obținerea instanței proxy a serviciului
        var service = container.Resolve<IService>();

        service.DoSomething("test");
        // service.DoSomething("eroare"); // Dezactivare pentru testarea gestionării erorilor

        container.Dispose();
    }
}

De asemenea, se poate folosi:

• Decorator (model de proiectare Decorator): Crearea unui înveliș în jurul clasei originale, care efectuează acțiuni înainte și după apelarea metodelor clasei originale.
• Împletirea codului (Code weaving): Modificarea bytecode-ului asamblării în timpul compilării sau încărcării, folosind instrumente precum PostSharp.