ASP.NET Core Middleware Part – II

In the last post we have discussed the basics of ASP.NET Core Middleware and how it fits into the request processing pipeline. As a next step we will see how we can build the middleware pipeline using request delegates that contain our custom code.

These request delegates are configured in the Configure method of the Startup class. The three extension methods of IApplicationBuilder that are used to build and configure the middleware pipeline are as follows:

• Run – This method add a request delegate in the pipeline which terminates the middleware pipeline.
• Use – This method adds a request delegate in the middleware pipeline which processes the request and passes it onto the next delegate in chain. Similarly processes the response and passes onto the previous delegate in chain (if any).
• Map – This method which branches the middleware pipeline based on the request path and invokes the appropriate delegate based on path provided.

Let’s take a bit deeper look into each of these extension methods.

Run

The signature of this method is as shown below:

This method configures a delegate which accept HttpContext as input and returns a Task object. It terminates the middleware pipeline by generating the response as shown below:

The output displayed in the console will be as expected:

The page will display a simple text output as shown below. This is because the middleware pipeline is terminated by this delegate and none of the MVC related components gets executed.

Use

The signature of this method is as shown below:

The code snippet below shows how the Use method can be used to chain the middleware components.

The output messages in the console will be in the following sequence:

Map

The method signature is as follows:

Then we have implemented two methods with IApplicationBuilder as input parameter as shown below:

The Map methods are called as shown below:

When I am accessing http://localhost:5000, the two request delegates added using the two Use methods and then the request delegate in the Run method is invoked.

When I am accessing http://localhost:5000/map1, the two request delegates added using the two Use methods and then the request delegate in the HandleMap1 method is invoked.

When I am accessing http://localhost:5000/map2 , the two request delegates added using the two Use methods and then the request delegate in the HandleMap2 method is invoked.

Memoization Using C#

Memoization is a technique very commonly used in Functional Programming to improve the performance of a function execution by caching its results. Here, caching helps to avoid the expensive computations of a complex function.

Before getting into the implementation which in my opinion is pretty straightforward to understand let put in few lines on the term itself. This activity of caching the results is similar to memorizing the already computed results but then why “r” is missing and its called memoization ? This is because the term has been derived from memo which is an American English for the Latin word memorandum. So it’s memo-ization.

In order to this we normally write a Higher Order Function (HOF) which accepts the function to be memoized as input and returns a closure of same as type as the input function and wraps it within the logic for caching as shown in the sample below:

Now let’s try to invoke this function. We will use a simple factorial function for memoization here.

We are making three calls to the memoized version of the Factorial function, the last call is made with a repeated parameter.

 

For the first two calls the function will be executed and the results of the third call are picked up from the cache.

We can write the Memoize function in a much more concise manner as shown below:

We can also make the function thread-safe using ConcurrentDictionary for caching.