8. Building Your First ASP.NET Core Application: Project Structure Explained

In the previous article, we completed the steps to create our first ASP.NET Core application. Next, we’ll dive deep into the project’s structure. Understanding this structure is essential for future development—it determines how we organize code and resources, ultimately improving development efficiency.

I. Overview of Project Structure

After creating a typical ASP.NET Core project, a standard directory structure is generated. Below is the basic folder layout of an ASP.NET Core project:

MyFirstAspNetCoreApp/
│
├── wwwroot/
│   ├── css/
│   ├── js/
│   └── lib/
│
├── Controllers/
│   └── HomeController.cs
│
├── Models/
│   └── ExampleModel.cs
│
├── Views/
│   └── Home/
│       └── Index.cshtml
│
├── appsettings.json
├── Program.cs
└── Startup.cs

Detailed Breakdown of Each Component

1. wwwroot/ Folder

The wwwroot folder stores static assets—such as HTML, CSS, JavaScript, and image files—that are served directly to clients. These files are publicly accessible via HTTP requests and effectively represent the web root of your application. For example, if you place a stylesheet at wwwroot/css/style.css, it can be accessed directly at http://localhost:5000/css/style.css.

Note: Ensure all static files reside within the wwwroot folder so they’re correctly served by the web host.

2. Controllers/ Folder

The Controllers/ folder contains controller classes—the core components of the MVC pattern. Controllers handle incoming HTTP requests, process user input, and return appropriate responses (e.g., views or data). Here's a simple example: HomeController.cs:

using Microsoft.AspNetCore.Mvc;

namespace MyFirstAspNetCoreApp.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

In this example, the Index() action method returns the corresponding view.

3. Models/ Folder

The Models/ folder holds data models and business logic. Models typically interact with databases and manage data validation and state. Here's a basic model example: ExampleModel.cs:

namespace MyFirstAspNetCoreApp.Models
{
    public class ExampleModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

4. Views/ Folder

The Views/ folder contains Razor view files responsible for rendering the UI. Views use Razor syntax (*.cshtml) to combine C# logic with HTML markup. For instance, Views/Home/Index.cshtml might look like this:

@{
    ViewData["Title"] = "Home Page";
}

<h1>Hello, ASP.NET Core!</h1>
<p>Welcome to your first ASP.NET Core application.</p>

5. appsettings.json

The appsettings.json file stores configuration settings for the application—such as connection strings, logging levels, and environment-specific values. Example:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}

6. Program.cs

Program.cs serves as the application’s entry point. It contains the Main method, which bootstraps the host and starts the web server. Example:

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

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

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

7. Startup.cs

Startup.cs defines the request processing pipeline and configures services used by the application. In this file, you register dependencies (e.g., MVC), configure middleware, and define routing rules. Example:

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

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute(
                name: "default",
                pattern: "{controller=Home}/{action=Index}/{id?}");
        });
    }
}

Summary

Understanding the purpose and responsibilities of each folder and file enables us to organize and maintain our codebase more effectively. ASP.NET Core provides a flexible, well-structured foundation that helps developers get up and running quickly—and scale confidently.

In the next article, we’ll explore how to run this application and observe its behavior in action. We hope this structural overview gives you a solid foundation to build upon.