Best Practices

How to Organize Folder Structure in ASP.NET, Web API, and Console Applications

A complete guide to organizing folder structures in .NET solutions. Learn best practices for ASP.NET, Web API, and console applications with real-world examples

In this article, we’ll explore how to organize code in .NET projects, review best practices for folder structures, and dive into the importance of separating concerns, with a focus on the Models folder and other essential components.

Table of Contents

1. Introduction to Folder Structures in .NET
2. Why Folder Structure Matters
3. Best Practices for Organizing .NET Projects
4. Common Folder Types in .NET Solutions

• Models
• Views
• Controllers
• Services
• Data Access

5. Folder Structures in Different Types of .NET Projects

• ASP.NET MVC
• Web API
• Console Applications

6. Using Feature-Based Folder Structures

7. Layered Architecture Approach

8. Organizing Domain-Driven Design (DDD) Projects

9. Folder Structure Examples

1. Introduction to Folder Structures in .NET

A constant folder structure ensures that all the developers in the team know where to look for the code and how to come up with new features, avoiding an unorganised maze of files.

2. Why Folder Structure Matters

The folder structure will be the backbone of your project’s maintainability and extensibility. Here are some reasons why it matters:

• Scalability: What once was a small project can finally become uncontrollable in terms of technical debt as folder organization defeats scalability.
• Readability: A clean folder structure will allow new developers or collaborators to jump into the project quickly, accelerating onboarding.
• Separation of Concerns: Folders on different code purposes- models, services, repositories, will help maintain an isolation of concerns that could enhance testing and maintenance.
• Efficiency: A structured pattern allows developers to access exactly what they are looking for without wasting time searching for disorganized files.

3. Best Practices for Organizing .NET Projects

Here are some best practices for structuring .NET projects:

• The files should be grouped based on responsibility. For instance, the models should be kept under Models folder, services in a Services folder, etc.
• For large projects, group by feature not layer. This way, different teams can work on completely isolated pieces of the application with minimal overlap.

For example, if I have a Helpers folder, then it should have a utility classes or functions, the Controllers folder should contain only files concerning controllers, and so on.

4. Common Folder Types in .NET Solutions

Models

All core data structures of your application lie within the Models folder. All the classes are information that will be transferred between different layers of the application.

For instance, in an e-commerce application, a Product model might represent the name, description, price, and stock of a product.

The Models folder is one of the biggest enablers of separation of concerns.

Above all, keep these data structures clean and focused on nothing but data with no business logic or UI code in model classes

Views

The Views folder in MVC applications contains all the HTML templates used to render the UI. They are tight-coupling representations of controllers and models.

Controllers

The Controllers folder consists of controllers in your MVC or Web API project. Classes manage incoming requests, process them and return a response typically by interacting with models and views.

Services

The Services folder is where the implementation of your business logic is held. A service contains the core functionality in your application and represents those entities that sit mid-stream between controllers and repositories.

For example, an OrderService might contain how orders get placed; handling validation, payment processing, etc.

Data Access (Repositories)

The Repositories folder is a great abstraction of data access logic.

Another thing you might want to do is to keep your data access code apart from your business logic, and that’s one more reason for the use of repositories and encapsulating all CRUD operations towards the database.

5. Foder Structures in Different Types of .NET Projects

ASP.NET MVC

For ASP.NET MVC applications, the traditional folder structure includes:

• Models/
• Views/
• Controllers/
• Services/
• wwwroot/ (for static files)

In this approach, the focus is on separating the presentation layer (Views) from the logic layer (Controllers and Services) and the data (Models).

Web API

In a Web API project, you may not need Views, so the structure typically looks like this:

• Controllers/
• Models/
• Services/
• DataAccess/ or Repositories/

The key difference is that Web API projects focus on HTTP responses and data processing, eliminating the need for view rendering.

Console Applications

For console applications, folder structures are generally simpler but should still be organized:

• Models/
• Services/
• DataAccess/
• Utils/

Console applications don’t have the concept of controllers or views but still benefit from the separation of models and services.

6. Using Feature-Based Folder Structures

When projects get larger than the traditional MVC might make more sense to use a feature-based folder structure instead of organizing by model, view and controller, you organize by feature:

/Features/
    /Product/
        Models/
        Controllers/
        Views/
        Services/
    /Order/
        Models/
        Controllers/
        Views/
        Services/

7. Layered Architecture Approach

The other common approach is to organize your project into layers. Layered architecture splits up your application into horizontal slices:

• Presentation Layer: It takes care of the user interface or API response.
• Business Logic Layer: The core business logic related to your application (services).
• Data Access Layer: Accessing a database when necessary, or for instance with repositories.

Here’s what a layered folder structure might look like:

/Presentation/
    Controllers/
    Views/
/BusinessLogic/
    Services/
    Models/
/DataAccess/
    Repositories/
    Entities/

This structure improves the separation of concerns and makes it easier to test and maintain layers without affecting other layers.

8. Organizing Domain-Driven Design (DDD) Projects

An example of a DDD-based folder structure could look like:

/Domain/
    Entities/
    ValueObjects/
    Services/
    Repositories/
    Aggregates/
/Infrastructure/
    Repositories/
    Mappings/
/Application/
    Commands/
    Queries/
    Handlers/

Each layer corresponds to a specific role in the DDD architecture, with a focus on isolating domain logic from infrastructure and application logic.

9. Folder Structure Examples

Example 1: Basic ASP.NET MVC Project

/Controllers/
    HomeController.cs
/Models/
    Product.cs
    Order.cs
/Views/
    /Home/
        Index.cshtml
    /Shared/
        _Layout.cshtml
/Services/
    OrderService.cs
/DataAccess/
    ProductRepository.cs

Example 2: Feature-Based Project

/Features/
    /Products/
        Models/
            Product.cs
        Controllers/
            ProductController.cs
        Views/
            ProductView.cshtml
        Services/
            ProductService.cs
    /Orders/
        Models/
            Order.cs
        Controllers/
            OrderController.cs
        Views/
            OrderView.cshtml
        Services/
            OrderService.cs

Example 3: DDD Project Structure

/Domain/
    /Products/
        Product.cs
        ProductService.cs
        ProductRepository.cs
    /Orders/
        Order.cs
        OrderService.cs
        OrderRepository.cs
/Infrastructure/
    /Persistence/
        DatabaseContext.cs
    /Repositories/
        ProductRepository.cs
/Application/
    /Commands/
        CreateProductCommand.cs
    /Queries/
        GetProductByIdQuery.cs

Use concerns separated into rational folders of models, controllers, services, and even repositories to help your team focus on specific responsibilities and therefore boost efficiency as well as maintainability.

Once you’ve reached a certain level of growth with your project, then you’re going to need to reinvent your folder structures to accommodate the new demands, but if you get the foundations right, scaling and working on such a project will be much easier.

You may also like