Caching is the process of copying the data and having it in memory instead of getting the data again through an external resource, such as a network, file, or database. The data used in caching is ephemeral and can be removed at any time. As we are directly accessing the data, caching can greatly improve the performance of the application.
Caching can be done in any of the layers—client-side at the browser, at the proxy server (or at some middleware), or at the web/application server. For database layer caching, we might not need to do any custom coding. Based on the type of database server being used, you might need to make some configuration changes. However, most of the databases these days are powerful enough to cache the data as and when it is needed.
We can cache at the client-side if we add the appropriate HTTP response headers. For example, if we want to cache all the static assets, such as CSS, images, and JavaScript files, we can add the max-age response header in the Cache-Control header:
In the preceding screenshot of the Developer Tool window's Network tab, when the requests are fired again, we get HTTP 304 response (Not modified) as the response. This means the same files are not transferred back twice across the wire, as they are available in the browser itself.
Implementing browser caching for static files is pretty easy, and it involves just a couple of steps—adding dependencies and configuring the application.
Add the following NuGet package to the list of dependencies in the project.json file:
"Microsoft.AspNet.StaticFiles": "1.0.0-rc1-final"
Add the following namespaces to the Startup.cs file and configure the application to use those static files:
using Microsoft.AspNet.StaticFiles;
using Microsoft.Net.Http.Headers;
public void Configure(IApplicationBuilder app)
{
app.UseIISPlatformHandler();
app.UseMvc();
app.UseMvc(routes =>
{
routes.MapRoute(name:"default", template:"{controller=Employee}/{action=Index}/{id?}");});
app.UseStaticFiles(new StaticFileOptions
()
{
OnPrepareResponse = (context) =>
{
var headers = context.Context.Response.GetTypedHeaders();
headers.CacheControl = new CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromSeconds(60),
};
}
});
}In response caching, cache-related HTTP headers are added to HTTP responses when MVC actions are returned. The Cache-Control header is the primary HTTP header that gets added to the response.
The preceding diagram shows response caching in action. In the first request, we are calling a Controller's action method; the request comes from the client and passes through the proxy server, actually hitting the web server. As we have added a response cache, any subsequent requests will not be forwarded to the web server, and the responses will be returned from the proxy server itself. This will reduce the number of requests to the web server, which in turn will reduce the load on the web server.
Caching the response of the Controller's action method is pretty easy. Just add the ResponseCache attribute with a duration parameter. In the following action method, we have added the response cache with a duration of 60 seconds, so that, for the next 60 seconds, if any requests come again, the responses will be returned from the proxy server itself instead of going to the web server:
[ResponseCache(Duration = 60)]
public IActionResult Index()
{
EmployeeAddViewModel employeeAddViewModel = new EmployeeAddViewModel();
using (var db = new EmployeeDbContext())
{
employeeAddViewModel.EmployeesList = db.Employees.ToList();
}
return View(employeeAddViewModel);
}