Aspnet Project Structure

title: ASP.NET Core Project Structure — Complete Guide to Default Layout description: 'Learn ASP.NET Core project structure: Program.cs, Startup configuration, wwwroot, Controllers, Views, Models folders, and organizing large-scale applications.' date: 2026-06-28 lastmod: 2026-06-28 weight: 13 tags: [backend, aspnet]

ASP.NET Core follows a convention-based project structure with folders for Controllers, Views, Models, wwwroot for static files, and configuration files for environment settings.

## What You'll Learn

By the end of this tutorial, you'll understand every file in a default ASP.NET Core project, organize code using folders and areas, configure environment-specific settings, and structure large applications.

## Real-World Use

A team of 15 developers works on an e-commerce platform. Clear project structure with Areas (Admin, Shop, API) and feature folders enables parallel work without merge conflicts.

## Project Structure Learning Path

```mermaid
flowchart LR
  A[Installation] --> B[Project Structure]
  B --> C[MVC]
  C --> D[Controllers]
  D --> E[Views]
  B --> F{You Are Here}
  style F fill:#f90,color:#fff

Default Project Structure

MyApp/
  Program.cs             # Application entry point
  MyApp.csproj           # Project file (dependencies)
  appsettings.json       # Configuration
  appsettings.Development.json
  Properties/
    launchSettings.json   # Debug profiles
  wwwroot/               # Static files (CSS, JS, images)
  Controllers/
    HomeController.cs
  Views/
    Home/
      Index.cshtml
    Shared/
      _Layout.cshtml
  Models/
    ErrorViewModel.cs
  Areas/                 # Optional: modular sections
  Migrations/            # EF Core migrations

Program.cs Breakdown

var builder = WebApplication.CreateBuilder(args);

// Add services to the container
builder.Services.AddControllersWithViews();
builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

// Configure the HTTP request pipeline
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();     // Serve wwwroot files
app.UseRouting();
app.UseAuthorization();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

Configuration Files

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyApp;Trusted_Connection=True;"
  },
  "AllowedHosts": "*"
}

{
  "profiles": {
    "MyApp": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "applicationUrl": "https://localhost:5001;http://localhost:5000",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

Organizing Large Projects

MyApp/
  src/
    MyApp.Web/           # UI layer
    MyApp.Core/          # Business logic
    MyApp.Infrastructure/ # Data access
    MyApp.Api/           # API endpoints
  tests/
    MyApp.UnitTests/
    MyApp.IntegrationTests/
  docker-compose.yml

Common Mistakes

1. Putting Everything in One Project

Large apps need separation. Split into Web, Core, Infrastructure, and Tests projects.

2. Ignoring wwwroot for Static Files

CSS, JS, and images belong in wwwroot. Don't serve them from other folders.

3. Hardcoding Configuration

Use appsettings.json and Options pattern. Never hardcode connection strings or API keys.

4. Not Using Areas

Areas organize large apps by feature (Admin, Shop, Blog). Each area has its own Controllers/Views/Models.

5. Missing .csproj References

Adding NuGet packages requires dotnet add package or editing the .csproj file.

Practice Questions

1. What is the purpose of Program.cs?

Program.cs is the application entry point. It configures services, the middleware pipeline, and starts the web server.

2. Where should static files be placed?

In the wwwroot folder. They are served by app.UseStaticFiles() middleware.

3. How do you manage environment-specific settings?

Use appsettings.{Environment}.json files. The ASPNETCORE_ENVIRONMENT variable selects the active file.

4. What are Areas in ASP.NET Core?

Areas are logical groupings of controllers, views, and models within a larger application.

5. Challenge: Create a multi-project solution with Web, Core, and Infrastructure projects.

dotnet new sln -n MyApp
dotnet new web -n MyApp.Web -o src/MyApp.Web
dotnet new classlib -n MyApp.Core -o src/MyApp.Core
dotnet new classlib -n MyApp.Infrastructure -o src/MyApp.Infrastructure
dotnet sln add src/MyApp.Web src/MyApp.Core src/MyApp.Infrastructure

FAQ

Mini Project: Create and Explore a New ASP.NET Core Project

Create a project and explore its structure.

dotnet new mvc -n ExploreProject
cd ExploreProject
# Examine each folder
ls -la
cat Program.cs
cat appsettings.json
ls wwwroot/
ls Controllers/
ls Views/
dotnet run

What's Next

ASP.NET Core MVC ASP.NET Core Controllers