Hoe pas je filters toe in pipelines in C#? Kun je…

In C#-pipelines worden filters gebruikt om op verschillende fasen van het verzoek of de taakuitvoering in te grijpen en te interveniëren. In ASP.NET Core-webapplicaties maken ze het mogelijk om logica toe te voegen vóór, na of tijdens de uitvoering van controlleractie-methoden, evenals op andere niveaus van verzoekverwerking.

Voorbeelden van het gebruik van filters in ASP.NET Core:

Authenticatie en Autorisatie (Authentication/Authorization Filters): Bepalen of een gebruiker gemachtigd is om een bepaalde actie uit te voeren.

// Voorbeeld van de Authorize-attribuut
[Authorize]
public class HomeController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
}

Resource-filters (Resource Filters): Worden als eerste uitgevoerd na autorisatie-filters. Ze kunnen caching uitvoeren of de pijplijn onderbreken.

// Voorbeeld van een resource-filter voor caching
public class CacheResourceFilter : IResourceFilter
{
    public void OnResourceExecuting(ResourceExecutingContext context)
    {
        // Logica vóór de uitvoering van de Actie
    }

    public void OnResourceExecuted(ResourceExecutedContext context)
    {
        // Logica na de uitvoering van de Actie, maar vóór het schrijven van het antwoord
    }
}

Actie-filters (Action Filters): Worden vóór en na de uitvoering van de actie-methode van de controller uitgevoerd. Geschikt voor gegevensvalidatie, logging of het aanpassen van parameters en resultaten.

// Voorbeeld van een Action Filter voor logging
public class LogActionFilter : IActionFilter
{
    public void OnActionExecuting(ActionExecutingContext context)
    {
        // Logica vóór de uitvoering van de actie
        Console.WriteLine($"Actie wordt uitgevoerd: {context.ActionDescriptor.DisplayName}");
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        // Logica na de uitvoering van de actie
        Console.WriteLine($"Actie uitgevoerd: {context.ActionDescriptor.DisplayName}");
    }
}

// Toepassen van het Action Filter op een controller-methode
[LogActionFilter]
public IActionResult About()
{
    return View();
}

Exception-filters (Exception Filters): Behandelen onhandige uitzonderingen die optreden tijdens de uitvoering van een actie-methode of andere filters.

// Voorbeeld van een Exception Filter voor foutafhandeling
public class CustomExceptionFilter : IExceptionFilter
{
    public void OnException(ExceptionContext context)
    {
        // Logica voor het afhandelen van de uitzondering
        context.Result = new ContentResult()
        {
            Content = "Er is een fout opgetreden.",
            StatusCode = 500
        };
        context.ExceptionHandled = true; // Aangeeft dat de uitzondering is afgehandeld
    }
}

// Toepassen van het Exception Filter op een controller
[CustomExceptionFilter]
public class ErrorController : Controller
{
    public IActionResult Index()
    {
        throw new Exception("Er is iets misgegaan!");
    }
}

Result-filters (Result Filters): Worden vóór en na de uitvoering van de resultaat-methode van de actie uitgevoerd (bijvoorbeeld vóór of na het uitvoeren van ViewResult, JsonResult, enzovoort).

// Voorbeeld van een Result Filter voor het aanpassen van het resultaat
public class CustomResultFilter : IResultFilter
{
    public void OnResultExecuting(ResultExecutingContext context)
    {
        // Logica vóór de uitvoering van de Result-methode
        Console.WriteLine($"Resultaat-type wordt uitgevoerd: {context.Result.GetType().Name}");
    }

    public void OnResultExecuted(ResultExecutedContext context)
    {
        // Logica na de uitvoering van de Result-methode
        Console.WriteLine($"Resultaat-type uitgevoerd: {context.Result.GetType().Name}");
    }
}

Filters kunnen globaal worden toegepast (voor alle verzoeken), op controller-niveau of op specifiek methodeniveau. De volgorde van uitvoering in de pijplijn wordt bepaald door hun type.

Hoe pas je filters toe in pipelines in C#? Kun je voorbeelden geven van het gebruik ervan?