Asp.Net Core Program Cs And Startup Cs Overview Complete Guide

Step 1: Setting up an ASP.NET Core Project

First, you need to create an ASP.NET Core project. You can do this using the .NET CLI or Visual Studio. Here, I'll demonstrate using the .NET CLI.

Using .NET CLI

1. Open a terminal or command prompt.

2. Run the following command to create a new ASP.NET Core web application:

   dotnet new web -n MyAspNetCoreApp
   

3. Navigate into the project directory:

   cd MyAspNetCoreApp
   

Step 2: Overview and Structure

ASP.NET Core 6.0 and Later

In ASP.NET Core 6.0 and later versions, the Program.cs and Startup.cs files have been merged into a single Program.cs file. This change simplifies the structure of the application.

ASP.NET Core 5.0 and Earlier

In ASP.NET Core 5.0 and earlier versions, the configuration and middleware were typically defined in two separate files: Program.cs and Startup.cs.

In this guide, I'll provide examples for both scenarios.

Step 3: Program.cs in ASP.NET Core 6.0 and Later

Minimal API Approach

Starting with ASP.NET Core 6.0, Microsoft introduced a minimalist API approach, which allows you to define your application in a single file.

Example Program.cs (Minimal API)

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

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();

app.MapControllers(); // Map minimal API endpoints

app.Run();

Traditional Approach

If you prefer a more traditional approach, you can separate the configuration and middleware setup from the application building.

Example Program.cs (Traditional)

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

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();

// Configure the middleware pipeline.
app.Configure();

app.Run();

Explanation

• var builder = WebApplication.CreateBuilder(args);: Creates a builder for the WebApplication.
• builder.Services.AddControllers();: Adds the necessary services for MVC controllers.
• var app = builder.Build();: Builds the WebApplication instance.
• if (app.Environment.IsDevelopment()): Adds middleware for development environments.
• app.UseHttpsRedirection();: Redirects HTTP requests to HTTPS.
• app.UseAuthorization();: Enables authorization.
• app.MapControllers();: Maps the controllers to the endpoints.
• app.Run();: Runs the application.

Step 4: Startup.cs in ASP.NET Core 5.0 and Earlier

In versions prior to ASP.NET Core 6.0, the Startup.cs class was used to configure the middleware pipeline and add services to the dependency injection container.

Example Startup.cs

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

public class Startup
{
    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseRouting();
        app.UseAuthorization();

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

Explanation

• ConfigureServices Method: Adds services to the dependency injection container.
  • services.AddControllers();: Adds MVC services.
• Configure Method: Configures the HTTP request pipeline.
  • app.UseDeveloperExceptionPage();: Adds middleware for development exception page.
  • app.UseHttpsRedirection();: Redirects HTTP requests to HTTPS.
  • app.UseRouting();: Enables routing.
  • app.UseAuthorization();: Enables authorization.
  • app.UseEndpoints: Maps HTTP endpoints to controllers.

Step 5: Integrating Startup.cs in ASP.NET Core 6.0 and Later

In ASP.NET Core 6.0 and later, you can still use the Startup.cs file by modifying the Program.cs file to use it.

Modified Program.cs to Use Startup.cs

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

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();
app.UseAuthorization();

// Use Startup class to configure the application.
app.Configure(new Startup());

app.Run();

Explanation

• app.Configure(new Startup());: Calls the Startup class's Configure method to set up the middleware pipeline.

Step 6: Running the Application

After setting up your Program.cs and Startup.cs files, you can run your application to see it in action.

Using .NET CLI

1. Run the application:

   dotnet run
   

2. Open a browser and navigate to https://localhost:5001 (or the port specified in your launchSettings.json).

You should see the default ASP.NET Core web page.

Conclusion

Understanding Program.cs and Startup.cs (or their merged form in ASP.NET Core 6.0 and later) is essential for configuring and running an ASP.NET Core application. By following the steps and examples above, you should have a good grasp of how these files work and can customize your application's behavior.