🚀 Program.cs: Essential Elements for Building ASP.NET Core Applications

When you start a new ASP.NET Core project, the first file you see is Program.cs. It looks small, but it is the entry point and brain of your application.

Think of Program.cs as the control center of your project. Here you decide:

• What features your app will use (services).
• How requests will be handled (middleware).
• Where requests should go (routing).
• How the app will finally run.

Let’s break it down in a simple way.

🔹 1. Create the Builder

At the top of the file, you’ll see:

var builder = WebApplication.CreateBuilder(args);
        

👉 This line prepares your app to start. It gives you access to:

• Configuration (builder.Configuration) → appsettings.json, environment variables, secrets.
• Logging (builder.Logging) → console logs, debug logs, etc.
• Services (builder.Services) → where we register everything the app needs.
• Environment (builder.Environment) → Development, Staging, Production.

🔹 2. Adding Services (Dependency Injection)

ASP.NET Core uses Dependency Injection (DI). We use builder.Services to register all the features our app needs.

Common services you’ll see:

builder.Services.AddControllers();       // Use API controllers
builder.Services.AddRazorPages();        // Use Razor Pages
builder.Services.AddMvc();               // Use MVC (Controllers + Views)
builder.Services.AddEndpointsApiExplorer(); 
builder.Services.AddSwaggerGen();        // Swagger for API docs
builder.Services.AddDbContext<AppDb>();  // Database with EF Core
builder.Services.AddAuthentication();    // For login system
builder.Services.AddAuthorization();     // For role-based security
builder.Services.AddCors();              // Allow cross-origin requests
builder.Services.AddSignalR();           // Real-time communication
builder.Services.AddHostedService<Worker>(); // Background services
        

👉 This step is like “adding furniture and tools inside your house.”

🔹 3. Build the App

After services are added, we build the application:

var app = builder.Build();
        

Now our app is ready to be configured.

🔹 4. Middleware (Request Pipeline)

Every HTTP request passes through a pipeline of middlewares. Each middleware does one job, then passes the request to the next.

Common middlewares:

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage(); // Show detailed errors
    app.UseSwagger();
    app.UseSwaggerUI();
}
else
{
    app.UseExceptionHandler("/Home/Error"); // Friendly error page
    app.UseHsts(); // Security headers
}

app.UseHttpsRedirection();  // Force HTTPS
app.UseStaticFiles();       // Serve CSS, JS, images
app.UseRouting();           // Enable routing
app.UseCors("AllowAll");    // Allow external apps to access
app.UseAuthentication();    // Enable login system
app.UseAuthorization();     // Role & policy checks
        

👉 The order matters a lot — if you change the sequence, some features may not work.

🔹 5. Routing & Endpoints

Now we decide where requests should go.

Common endpoint mappings:

app.MapControllers();                // For APIs
app.MapRazorPages();                 // For Razor Pages
app.MapDefaultControllerRoute();     // For MVC
app.MapGet("/", () => "Hello World");// Minimal API
app.MapHub<ChatHub>("/chatHub");     // SignalR hub for real-time chat
        

👉 This is like saying “When someone knocks at this door, who should answer?”

🔹 6. Run the App

Finally, start the web server:

app.Run();
        

👉 This launches the built-in Kestrel server, and your app goes live.

🔹 7. Extra Things You May See in Program.cs

✅ Database Migration on Startup

Some apps run migrations automatically:

using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    db.Database.Migrate();
}
        

✅ Custom Middleware

You can add your own logic:

app.Use(async (context, next) =>
{
    Console.WriteLine("Request: " + context.Request.Path);
    await next();
});
        

✅ CORS Policy

To allow APIs to be called from Angular/React apps:

builder.Services.AddCors(options =>
{
    options.AddPolicy("AllowAll", 
        policy => policy.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
});

app.UseCors("AllowAll");
        

✅ Logging Setup

builder.Logging.ClearProviders();
builder.Logging.AddConsole();
        

🔑 Easy Way to Remember

The Program.cs file does 5 main jobs:

1. Create the builder → prepare the app.
2. Add services → register features (controllers, Swagger, DB, login).
3. Build the app → finalize setup.
4. Configure middleware → request handling pipeline.
5. Run the app → start the server.

📌 Final Words

If you’re just starting ASP.NET Core:

• builder.Services... → Add the tools you need.
• app.Use... → Add the steps for every request.
• app.Map... → Decide where requests go.
• app.Run(); → Start the app.

Once you master Program.cs, you’ll understand how every ASP.NET Core app starts, runs, and handles requests.