What methods exist for working with the request…

In ASP.NET Core, the request lifecycle can be controlled and managed using various methods:

Middleware: This is the primary way to process requests. Middleware forms a pipeline through which each request passes. Each Middleware component performs a specific task (authentication, logging, routing, etc.) or passes the request to the next component.

// Example of simple Middleware
public class MyCustomMiddleware
{
    private readonly RequestDelegate _next;

    public MyCustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Logic before processing the request
        Console.WriteLine("Before request...");

        await _next(context); // Passing control to the next Middleware

        // Logic after processing the request
        Console.WriteLine("After request...");
    }
}

// Register Middleware in Startup.Configure
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... other Middleware
    app.UseMiddleware<MyCustomMiddleware>();
    // ...
}

Filters in MVC/Razor Pages: Filters allow executing logic at various stages of Action processing (before, after Action execution, before/after rendering the result).
- Action filters: For logic before/after executing an Action method.
- Result filters: For logic before/after executing a Result (e.g., ViewResult, JsonResult).
- Exception filters: For handling unhandled exceptions.
- Resource filters: For logic at an early stage of the MVC pipeline, before Model Binding.
- Authorization filters: For authorization.
Model Binding: The process that maps an HTTP request to Action method parameters. You can create your own custom Model Binders.
Routing: Mapping the request URL to an endpoint, usually an Action method of a controller or a Razor Page.
Request Handlers: In minimal APIs or using Endpoint Routing, you can explicitly define handlers for specific routes.
```
// Example of a handler in minimal API
app.MapGet("/hello", () => "Hello World!");
```
Startup.ConfigureServices: Configuration of services and dependencies available throughout the application's and request's lifecycle.
Startup.Configure: Definition of the Middleware pipeline.

These methods allow intercepting, modifying, and processing requests at various stages, providing flexible control over the entire process.

What methods exist for working with the request lifecycle in ASP.NET Core?