Understanding ASP.NET - Part One - Owin And Katana

Step 2. When the Server receives a request from a client, it then parses the request into predefined pieces of information, stores them into a dictionary object with specific keys, and passes it to the application.

Step 3. The application then passes the environment dictionary to the first OWIN middleware in the pipeline to do its things. The middleware returns a System.Threading.Tasks.Task to tell the server when it has completed its processing.

Remember, OWIN is also part of the application.

Step 4. When the first middleware completes its processing, it then passes the dictionary object to the next middleware in the pipeline and so on, until the request reaches the end of the pipeline. When the application part of the system receives a dictionary object from the last middleware in the pipeline, it generates a response for a client based on the request information in the object.

Step 5. When an application has done preparing a response and adding necessary response headers, it then signals the webserver to do its first write to the response stream. First, the server sends response header information to the client available at that point. After that, no one can modify the response header information because it has already been sent to the client but instead response body can be modified because the connection to the response stream is still open.

Step 6. At this point, the application part of the system passes the dictionary object to the last middleware pipeline allowing it to do its things. Remember at this point connection to the response stream is still open and OWIN middlewares can happily write into the response stream. Whatever will be written to the response stream will be sent back to the client as part of the application response.

When the last middleware has finished its processing, it passes the dictionary object to the previous middleware and so on until the dictionary object reaches the beginning of the pipeline.

Step 7. Once the dictionary object reaches the beginning of the pipeline the application notifies the server that it completed its processing by the returning System.Threading.Tasks.Task.The server then sends a response back to the client before closing the connection to the response stream.

As I told you earlier the application and middleware are exactly the same thing despite the fact that the application is specifically built for generating a response. Middleware can also short-circuit the pipeline and generate and return the response to a client before the request reaches the application.

Environment Dictionary Keys

Owin' specification defined a lot of keys that will be available in the environment dictionary when the server passes a request to OWIN middleware using AppFunc. Here are some keys that you will be using in the OWIN environment dictionary object and the names of keys are nice looking and self-explanatory.

• RequestPath(string): contains information about the requested path.
• RequestHeaders(IDictionary<string, string[]>): contains information about request headers.
• RequestBody(Stream): contains a stream connection to the request body.
• ResponseStatusCode(Int32): contains response status code information.
• ResponseHeaders(IDictionary<string,string[]>): contains information about response headers.
• ResponseBody(Stream): contains the actual response body Stream connection.

You can see all the keys start with owin prefix so we may not mistakenly override any key already defined in the environment dictionary.

In the environment dictionary, there is also a key defined for a call back to register and this call back “OnSendingHeaders” will be called before when the server sends response headers to the client. Registering to call back will give us a nice opportunity to modify the response headers at the last point when they will be just about sent to the client.

[server: OnSendingHeaders(Action<Action<object>, object>)]

There is also a key defined to access the version of OWIN to enable and disable specific features based on different versions of OWIN.

Version(string versionString)

What is Project Katana?

As I have mentioned earlier OWIN is just a specification. Project Katana is Microsoft's implementation of OWIN specification for .Net web developers. Katana is an open-source project and is available at https://github.com/aspnet/AspNetKatana/. Project Katana is not a book implementation of OWIN instead people at Microsoft added some extra features to it for the ease of use of developers. Owin is already included for use in ASP.Net 4 with Project Katana and it’s an integral part of the framework now. Some identity-related features of ASP.Net are implemented as OWIN middlewares and available at Nuget to download. ASP.Net identity features like authentication and authorization are implemented as OWIN middleware so it can be used with any OWIN-based technology. Let me show you an inside look at an ASP.Net MVC project with framework release ASP.Net 4 and above.

Now let’s just create a new ASP.Net MVC application with individual user accounts selected as authentication type.

Now press OK to create the project, once the project is ready open packages.config file from Solution Explorer.

Inside the file, you will see some OWIN packages are already installed in your project and most of them are identity-related related will be used to add OWIN-based authentication and authorization features to the project.

To manage the length of this article we have to wrap up by discussing the summary of what we have learned so far. In the next article, we will learn how we can build our own OWIN pipeline and middleware. I will be writing more on OWIN features included in ASP.Net 4 and above, So I’ll see you in the next writing.

Summary

In this write-up, we have discussed the following concepts briefly.

• Modern web development architecture is based on the individual working components decoupled from other parts of the application.
• The goal of OWIN is to decouple .Net web applications from web servers.
• OWIN application has different working parts (Host, Server, Middleware Pipeline, and Application).
• Katana is a Microsoft implementation of OWIN specification built for .Net web developers, and it's open source, and available at GitHub.