Asp.Net Mvc Application Life Cycle Complete Guide

Step-by-Step Example: ASP.NET MVC Application Life Cycle

Prerequisites:

• An ASP.NET Core MVC framework installed on your system.
• Basic understanding of C# and ASP.NET MVC concepts.

Objective:

• Create a simple ASP.NET MVC application.
• Understand each phase of the application life cycle for incoming requests.
• Implement simple logging in each stage to observe the flow.

Step 1: Creating a New ASP.NET MVC Application

1. Open Visual Studio.

2. Click on Create a new project.

3. Select ASP.NET Core Web App (Model-View-Controller) under C# Web templates and click the Next button.

4. Configure your new project:

   • Name: MvcLifecycleApp
   • Location: Choose a location where you want to save your project.
   • Solution name: MvcLifecycleApp

5. Click on the Next button.

6. Configure the project by choosing the Framework (e.g., .NET 7.0 or latest) and then click Create.

Step 2: Configuring Middleware for Logging

Middleware are components that handle requests and responses in the HTTP pipeline. We will add custom middleware for logging different stages of the request lifecycle.

Middleware: LifecycleLoggerMiddleware.cs

using Microsoft.AspNetCore.Http;
using System.IO;
using System.Threading.Tasks;

public class LifecycleLoggerMiddleware
{
    private readonly RequestDelegate _next;

    public LifecycleLoggerMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Log before calling the next middleware
        await WriteLog(context, "Before middleware");

        // Call the next middleware
        await _next(context);

        // Log after calling the next middleware
        await WriteLog(context, "After middleware");
    }

    private Task WriteLog(HttpContext context, string stage)
    {
        var logPath = Path.Combine(Directory.GetCurrentDirectory(), "lifecycle.log");
        using var fileStream = new FileStream(logPath, FileMode.Append, FileAccess.Write, FileShare.Write);
        using var writer = new StreamWriter(fileStream);
        return writer.WriteLineAsync($"{DateTime.Now} - {stage}: {context.Request.Path}");
    }
}

Register Middleware in Startup.cs (or Program.cs in .NET 6/7)

In newer versions like .NET 6/7, middleware is registered in Program.cs:

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

// Use custom logging middleware
app.Use(async (context, next) =>
{
    await context.Response.WriteAsync("Middleware - Start\n");
    await next();  // Call the next middleware in the pipeline
    await context.Response.WriteAsync("Middleware - End\n");
});

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Middleware<LifecycleLoggerMiddleware>();  // Register the custom middleware

app.Run();

Step 3: Adding Custom Action Filters for Logging

Action filters provide a way to run code just before and after an action method is called.

Custom Action Filter: LifecycleActionFilter.cs

using Microsoft.AspNetCore.Mvc.Filters;
using System;

public class LifecycleActionFilter : IActionFilter
{
    public void OnActionExecuting(ActionExecutingContext context)
    {
        Console.WriteLine($"LifecycleActionFilter.OnActionExecuting: {context.HttpContext.Request.Path}");
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        Console.WriteLine($"LifecycleActionFilter.OnActionExecuted: {context.HttpContext.Request.Path}");
    }
}

Register Action Filter in Startup.cs (or Program.cs in .NET 6/7)

In Program.cs:

builder.Services.AddControllersWithViews(options =>
{
    options.Filters.Add(new LifecycleActionFilter());
});

Step 4: Adding Custom Authorization Filters for Logging

Authorization filters are executed early in the pipeline to determine whether a user has access to a controller or an action method.

Custom Authorization Filter: LifecycleAuthorizationFilter.cs

using Microsoft.AspNetCore.Mvc.Filters;
using System;

public class LifecycleAuthorizationFilter : IAuthorizationFilter
{
    public void OnAuthorization(AuthorizationFilterContext context)
    {
        Console.WriteLine($"LifecycleAuthorizationFilter.OnAuthorization: {context.HttpContext.Request.Path}");
    }
}

Register Authorization Filter in Startup.cs (or Program.cs in .NET 6/7)

In Program.cs:

builder.Services.AddControllersWithViews(options =>
{
    options.Filters.Add(new LifecycleAuthorizationFilter());
    options.Filters.Add(new LifecycleActionFilter());
});

Step 5: Adding a Controller with Custom Result Filters

Result filters provide a way to run code just before and after the execution of an action result.

Custom Result Filter: LifecycleResultFilter.cs

using Microsoft.AspNetCore.Mvc.Filters;
using System;

public class LifecycleResultFilter : IResultFilter
{
    public void OnResultExecuting(ResultExecutingContext context)
    {
        Console.WriteLine($"LifecycleResultFilter.OnResultExecuting: {context.HttpContext.Request.Path}");
    }

    public void OnResultExecuted(ResultExecutedContext context)
    {
        Console.WriteLine($"LifecycleResultFilter.OnResultExecuted: {context.HttpContext.Request.Path}");
    }
}

HomeController Modification to Include Result Filter

using Microsoft.AspNetCore.Mvc;

[ServiceFilter(typeof(LifecycleResultFilter))]
public class HomeController : Controller
{
    public IActionResult Index()
    {
        Console.WriteLine($"HomeController.Index: {Request.Path}");

        // Simulate some processing
        System.Threading.Thread.Sleep(1000);  
        
        return View();
    }

    public IActionResult Privacy()
    {
        Console.WriteLine($"HomeController.Privacy: {Request.Path}");

        // Simulate some processing
        System.Threading.Thread.Sleep(1000);

        return View();
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}

Step 6: Run the Application and Observe Logs

1. Press F5 or click the Run button in Visual Studio to start the application.
2. Navigate to different pages like /Home/Index or /Home/Privacy.
3. Monitor the console output and the lifecycle.log file in your project directory to observe which methods are called at each stage of the request lifecycle.

Explanation of Logs:

• Middleware Logs: You will see logs indicating the start and end of the middleware processing pipeline for each request.
• Authorization Filters Logs: These logs indicate when authorization checks are performed.
• Action Filters Logs: These logs show the pre-action and post-action execution phases.
• Controller Action Logs: These are logged within the individual action methods of the controller.
• Result Filters Logs: These logs indicate when the action result is being executed and after it has finished executing.

Conclusion:

This example demonstrates the basic structure and logging points throughout an ASP.NET MVC application’s life cycle, illustrating how different components interact to process a single HTTP request. By understanding these stages, developers can better design and debug their applications.