Call controller's action method from middleware

Here is middleware that examines the request and redirects. It works with either inline middleware or with a middleware class.

public void Configure(IApplicationBuilder app)
{
    // use inline middleware
    app.Use(async (context, next) =>
    {
        // if specific condition does not meet
        if (context.Request.Path.ToString().Equals("/foo"))
        {
            context.Response.Redirect("path/to/controller/action");
        }
        else
        {
            await next.Invoke();
        }
    });

    // or use a middleware class
    app.UseMiddleware<RedirectMiddleware>();

    app.UseMvc();
}

Here is the middleware class.

public class RedirectMiddleware
{
    private readonly RequestDelegate _next;

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

    public async Task Invoke(HttpContext context)
    {
        // if specific condition does not meet
        if (context.Request.Path.ToString().Equals("/bar"))
        {
            context.Response.Redirect("path/to/controller/action");
        }
        else
        {
            await _next.Invoke(context);
        }
    }
}

See Docs » Fundamentals » Middleware for more info.

You can use "Request Editing Middleware" to change the nature of the request as it moves down the pipeline. This fits in with the general "best practices" and will be more efficient than sending a redirect notice back to the browser.

This example redirects to an action method than can return an image:

public class ResolveImageMiddleware
{
    private readonly RequestDelegate _next;

    public ResolveImageMiddleware(RequestDelegate deg)
    {
        _next = deg;
    }

    public async Task InvokeAsync(HttpContext context, AppDbContext db)
    {
        var path = context.Request.Path;
        if (path.HasValue && path.Value.StartsWith("/imgs"))
        {
            context.Request.Path = "/Home/GetImageFromDb";
            context.Request.QueryString = new QueryString("?title=" + path.Value.Replace("/imgs/", ""));
        }

        await _next(context);
    }

}

And create an action method that takes a query and can return a file:

public class HomeController : Controller
{
    private EFImageRepo imageRepository;
    public HomeController(EFImageRepo repo)
    {
        imageRepository = repo;
    }
    public FileResult GetImageFromDb([FromQuery]string title)
    {
        var img = imageRepository.GetImg(title);
        if (img != null)
        {
            byte[] contents = img.ImageBytes;
            return File(contents, "image/jpg");
        }
        return null;
    }
}

If you use a redirect on response, it will cause the user's browser to receive a redirect notice and then send a new request to your application, rather than consuming the original request and spitting out the file right away.

Redirect to different action without an redirect result (302)

You can Redirect a request to a different action without there being an intermediate redirect request the following way.

First you have the middleware look like this. Here we just edit the URL.

CustomRedirectMiddleware.cs

public class CustomRedirectMiddleware(RequestDelegate next)
{
    private readonly RequestDelegate _next = next;


    public async Task InvokeAsync(HttpContext context)
    {
        context.Request.Path = "/Home/Index";
        await _next(context);
    }
}

This can however only work before calling app.UseRouting since the routing middleware fills the IEndpoint feature and its request delegate.

Program.cs

 app.UseRouting();
 app.UseMiddleware<CustomRedirectMiddleware>();

Access Endpoint metadata in RedirectMiddleware

If for whatever reason you need any metadata from the endpoint before you can determine to redirect you must change the startup to this.

Program.cs

 app.UseRouting();
 app.UseMiddleware<CustomRedirectMiddleware>();
 app.UseRouting();

This does by itself however not work. You also have set contexts.Endpoint to null, otherwise the second call to app.UseRouting will just use the results of the first one which will be a request delegate to the old URL.

CustomRedirectMiddleware.cs

 public class CustomRedirectMiddleware(RequestDelegate next)
 {
     private readonly RequestDelegate _next = next;


     public async Task InvokeAsync(HttpContext context)
     {
         // Retrieve the endpoint metadata from the current request.

         var endpointFeature = context.Features.Get<IEndpointFeature>();
         var endpoint = endpointFeature?.Endpoint;

         // ignore static files
         if (endpoint == null || endpoint.Metadata.GetMetadata<ShouldRedirectAttribute>() == null) 
         {
             await _next(context);
             return;
         }

         context.SetEndpoint(null); /* set it to null to make sure the second UseRouting middleware does its work */

         // Rewrite the request path to /Home/Index
         context.Request.Path = "/Home/Index";
         await _next(context);
     }