In-depth Explanation and Usage of HttpContext in ASP.NET Core | Detailed Explanation of Microsoft.AspNetCore.Http

The author did not study ASP.NET, but went directly to learn ASP.NET Core. After finishing the basics of ASP.NET Core MVC, I began to learn about the operating principles of ASP.NET Core. I discovered that there is a very important "conductor" called HttpContext.

I'll quickly jot down some notes first.

Table of Contents

“Conductor” HttpContext

Preparation for Operating HttpContext

Properties and Methods of HttpContext

Practice and Testing of HttpContext Object

• Request
• Response
• Item

“Conductor” HttpContext

To understand what HttpContext does, first, look at the images.

Figure 1: Internal Network Access Program

Figure 2: Reverse Proxy Access Program

In ASP.NET Core programs, Kestrel is a cross-platform ASP.NET Core web server based on libuv. It’s okay if you don’t know about Kestrel, you can learn about it gradually later.

We can understand that external access to our program is done via Http or Https, for example, https://localhost:44337/Home/Index, which requires a URL to access a specific page.

When accessing a page, cookies, sessions, form submissions, data uploads, authentication, etc., will be created. The conductor between the external environment and the application is HttpContext.

In short, the interaction between the client and the web application is conducted through HttpContext.

Principle

ASP.NET Core is essentially a console program! The ASP.NET Core application does not listen directly to requests, but relies on the HTTP Server to forward each request to the application. The forwarded requests are equivalent to the network requests we make when browsing the web, uploading files, submitting forms, etc., which are packaged and combined into HttpContext.

It's like a customer dining in a restaurant:

1. The customer needs to order food and make service requests.
2. The waiter delivers the menu and requests to the kitchen.
3. The chef prepares the food.
4. The waiter delivers the food to the customer.

HttpContext acts as this waiter, passing information back and forth.

Preparation for Operating HttpContext

Generally speaking, we mainly focus on writing web programs without needing to worry about how the data is conducted. It’s similar to how two computers can exchange data without us needing to know whether they are using wireless WiFi, fiber optics, or copper wire cables.

When necessary, we will need to get familiar with it; enough talk, let’s start with some simple operations involving HttpContext. We will continue to analyze this object later.

If you do not need to practice, you can skip this section directly.

• Open VS (2017)
• Create a new project
• ASP.NET Core Web Application
• Web Application (Model-View-Controller)
• Open Startup.cs and add in ConfigureServices:

services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>(); //don't worry about what this does yet

• Open HomeController.cs and replace the HomeController class with the following code:

  public class HomeController : Controller
    {
        private IHttpContextAccessor _accessor;
        public HomeController(IHttpContextAccessor accessor)
        {
            _accessor = accessor;
        }
        [HttpGet]
        public IActionResult Index(int? id)
        {
            var httpcontext = _accessor.HttpContext;
        </span><span style="color: #0000ff;">return</span><span style="color: #000000;"> View(httpcontext);
    }

}</span></pre>

 

• Open the Views/Home directory and delete all other views except for Index.cshtml.

• Change the code in Index.cshtml to:

@model Microsoft.AspNetCore.Http.HttpContext
@{
    Layout = null;
}

At this point, the preparation is complete.

The purpose of the above code is to pass the HttpContext object to the view for direct use within the view. This way, we only need to test in the view to understand it.

Properties and Methods of HttpContext

In ASP.NET Core, the system allocates a thread for each request, and HttpContext corresponds to one thread. Therefore, its class, methods, properties, etc., are effective for the current request.

Properties

<table>
    <tr>
        <td>RequestBody stream</td>
        <td> @Model.Request.Body</td>
    </tr>
    <tr>
        <td>Content-Length header</td>
        <td>@Model.Request.ContentLength</td>
    </tr>
    <tr>
        <td>Content-Type header</td>
        <td> @Model.Request.ContentType</td>
    </tr>
    <tr>
        <td>Cookies </td>
        <td>@Model.Request.Cookies</td>
    </tr>
    <tr>
        <td>IsHttps</td>
        <td>@Model.Request.IsHttps</td>
    </tr>
    <tr>
        <td>Host </td>
        <td>@Model.Request.Host</td>
    </tr>
</table>

 

---

Item

If you have used ViewData, you can easily understand HttpContext.Item

HttpContext.Item is a dictionary collection of type IDictionary<TModel,TModel>. Its usage is similar to ViewData. (Don't tell me you don't know what ViewBag and ViewData are~)

 Open Index.Cshtml and replace it with the following code

@model Microsoft.AspNetCore.Http.HttpContext
@{
    Layout = null;
}
@{
    List<string> i = new List<string>();
    i.Add("a");
    i.Add("b");
    i.Add("c");
    i.Add("d");
    i.Add("e");
    i.Add("f");
    i.Add("g");
    i.Add("h");
    i.Add("i");
Model.Items[</span><span style="color: #800000;">"</span><span style="color: #800000;">Test</span><span style="color: #800000;">"</span>] =<span style="color: #000000;"> i;       
</span><span style="color: #008000;">/*</span><span style="color: #008000;">
    Model.Items is of dictionary type
    Here set the key as Test
             with value i, its type is List&lt;string&gt;
</span><span style="color: #008000;">*/</span>

foreach(var item in Model.Items["Test"] as List<string>) //Dictionary type, must be cast to the respective type first

{

<br> @item
}

}

Result

 You can use HttpContext.Item to store useful data for the current request's intention.

---

 Other methods of HttpContext are not elaborated here. It is important to note that HttpContext is generated for a specific request.