Wie kann man eine Aktion vor und nach der…

Verwenden Sie aspektorientierte Programmierung mit Interceptoren, z. B. mit der Bibliothek Castle Windsor oder AspectCore.

// Beispiel für eine Schnittstelle für einen Service
public interface IService
{
    void DoSomething(string input);
}

using Castle.DynamicProxy;

// Interceptor für Logging
public class LoggingInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Aktion vor der Verarbeitung
        Console.WriteLine($"Methodenaufruf beginnt: {invocation.Method.Name}");

        try
        {
            // Originalmethode ausführen
            invocation.Proceed();

            // Aktion nach erfolgreicher Verarbeitung
            Console.WriteLine($"Methode {invocation.Method.Name} erfolgreich ausgeführt.");
        }
        catch (Exception ex)
        {
            // Aktion bei Fehler
            Console.WriteLine($"Fehler beim Aufruf der Methode {invocation.Method.Name}: {ex.Message}");
            throw; // Ausnahme erneut werfen
        }
    }
}

// Beispiel für eine Service-Implementierung
public class MyService : IService
{
    public void DoSomething(string input)
    {
        Console.WriteLine($"Aktion mit Parameter: {input}");
        // Fehler simulieren
        // if (input == "fehler") throw new InvalidOperationException("Etwas ist schief gelaufen");
    }
}

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

// Registrierung des Service und Interceptors im IoC-Container
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>());

        // Proxy-Instanz des Service erhalten
        var service = container.Resolve<IService>();

        service.DoSomething("Test");
        // service.DoSomething("Fehler"); // Zum Testen der Fehlerbehandlung auskommentieren

        container.Dispose();
    }
}

Auch möglich:

Decorator (Design Pattern): Einen Wrapper um die Originalklasse erstellen, der Aktionen vor und nach dem Aufruf der Methoden der Originalklasse durchführt.
Code weaving: Den Bytecode des Assemblies zur Compile- oder Ladezeit modifizieren, z. B. mit Tools wie PostSharp.

Wie kann man eine Aktion vor und nach der Verarbeitung der Anfrage durchführen, ohne Middleware zu verwenden?