Life Cycle Of A .NET Core Application

The life cycle of a .NET Core application involves several stages, from initialization to shutdown. Here we see the different stages in the life cycle of a .NET Core application.

Life Cycle Of A .NET Core Application

Initialization

When a .NET Core application starts, the runtime creates an instance of the host process and initializes it. The host process then loads the application's dependencies and prepares the runtime environment.

public static void Main(string[] args)
{
    CreateHostBuilder(args).Build().Run();
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

Configuration

Once the runtime is initialized, the application's configuration settings are loaded. This can include settings for the application itself, as well as any third-party libraries or services it uses.

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddSingleton<IMyService, MyService>();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Startup

The startup process is where the application's services and middleware are configured. This is typically done in the Startupclass, where the ConfigureServices method is used to configure dependency injection and the Configure the method is used to configure middleware.

Request handling

When a request is received by the application, it is processed by the middleware pipeline. Each middleware component can inspect, modify, or pass on the request to the next component in the pipeline until a response is generated.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.Use(async (context, next) =>
    {
        // Log the request
        logger.LogInformation($"Request {context.Request.Method} {context.Request.Path}");

        await next();
    });
}

Response generation

Once the request has been processed by the middleware pipeline, a response is generated and sent back to the client.

Shutdown

When the application is shutting down, the runtime performs cleanup tasks such as closing connections and releasing resources. This can also include calling any registered shutdown callbacks or disposing of any registered services.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, MyDbContext dbContext)
{
    // ...

    appLifetime.ApplicationStopped.Register(() =>
    {
        // Dispose the database context
        dbContext.Dispose();
    });
}

Overall, the life cycle of a .NET Core application is designed to be flexible and extensible, allowing developers to customize and extend the application's behavior at each stage.