Can we go back in .net core middleware pipeline - asp.net-core

Question

My question is can we go back to middle ware pipeline let see an example
we have middleware1, middlware2, middleware3 and middlware3 is executing. I want middleware1 to execute again and then control back to middleware3 can we do that ?
Thank in advance

Answer 1

No, you cannot do that. The middlewares are called in a pipeline. That means, there is one middleware which will start and which will pass on to the next middleware in the pipeline, which will then pass on to the next, and so on. Eventually, each middleware has a way to do something afterwards as the pipeline completes.
This generally looks like this:
Request
| → Middleware1
| | run
| | next() → Middleware2
| | | run
| | | next() → Middleware3
| | | | run
| | | | next() → {}
| | | | run after
| | | | return ↵
| | | ←
| | | run after
| | | return ↵
| | ←
| | run after
| | return ↵
| ←
| ⇒ Send response
Since this is a strict pipeline that only goes in a single direction, you cannot randomly jump around. You only get the chance to call the next middleware in the pipeline or return.
What you can do however is invoke the following pipeline multiple times. For example, the StatusCodePages middleware does this to re-execute the pipeline for the status code page when an error occurs:
Request
| → StatusCodePagesMiddleware
| | run
| | next() → Pipeline
| | | … throw an error
| | ← catch exception
| | run after
| | adjust parameters
| | next() → Run pipeline again with modified parameters do display error page
| | return ↵
| ←
| ⇒ Send response
Note that this is a very special thing which only works because the StatusCodePages middleware is usually registered very early and because it wants to rerun the full pipeline.
If you want finer control over this, chances are you shouldn’t even split your logic up into multiple middlewares. It might be a better idea to have a single middleware that just has a very controlled logic inside. That logic could for example be another pipeline, or just a straightforward control flow.