Skip to content
CretDocs

.NET Project Structure

Introduction

Setting up a consistent project structure is crucial for maintainability and collaboration in software development. This template outlines the essential files and their content that should be present in the root of your .NET project. By defining these files, you ensure that every developer has the same configuration and dependencies, leading to a smoother development process.

Benefits:

  • Consistency: Ensures all developers use the same configuration.
  • Simplicity: Reduces the need for individual setup.
  • Reproducibility: Makes it easier to onboard new developers and set up CI/CD pipelines.

Project Structure

In the root of your .NET project, the following files should be present:

  • DirectoryRoot
    • Solution.sln(x)
    • global.json
    • Directory.Build.props
    • nuget.config

Solution File

The solution file organizes multiple projects within a single solution. It serves as the entry point for the development environment.

Solution File (.sln)

The .sln file is the traditional solution file format used in .NET projects. It organizes multiple projects and their dependencies within a single solution, serving as the primary entry point for development environments like Visual Studio.

Solution File (.slnx)

The .slnx file is the recommended solution file format for .NET projects. It provides several enhancements and improvements over the traditional .sln file. This XML-based format is easier to read, follow, and edit without needing Visual Studio. It eliminates the use of GUIDs and other redundant information, making it simpler to manage and merge changes.

As of .NET SDK 9.0.200, .slnx is fully supported. It is now the preferred choice for all new .NET projects.

Solution Filter File (.slnf)

A Solution Filter file allows you to create a subset of the projects in a solution. This is particularly useful for working with large solutions where loading every project can be time-consuming. By using a filter, you can focus on specific parts of the solution without the overhead of loading the entire solution.

{
  "solution": {
    "path": "YourSolution.sln",
    "projects": [
      "MyProject/MyProject.csproj",
      "MyOtherProject/MyOtherProject.csproj"
    ]
  }
}

global.json

This file sets the .NET SDK version for the project, ensuring consistency across all development environments.

{
  "sdk": {
    "version": "<sdk-version>"
  }
}
  • sdk: Specifies the .NET SDK version to use. This ensures that all developers and build environments use the same version, preventing compatibility issues.
    • <sdk-version>: The version of the .NET SDK.

Directory.Build.props

This file contains common properties for all projects within the solution, promoting consistency and reducing duplication.

<Project>
  <PropertyGroup>
    <Version><project-version></Version>
    <AssemblyVersion><assembly-version></AssemblyVersion>
    <Authors><author-name></Authors>
    <Company><company-name></Company>
    <Product><product-name></Product>
    <Copyright>© <current-year> <company-name></Copyright>
    <Description><project-description></Description>
  </PropertyGroup>
</Project>
  • PropertyGroup: Contains properties like versioning, authorship, and company information. This ensures that all projects within the solution share the same metadata, simplifying management and reducing errors.
    • <project-version>: The version of the project.
    • <assembly-version>: The assembly version.
    • <author-name>: The name of the author.
    • <company-name>: The name of the company.
    • <product-name>: The name of the product.
    • <current-year>: The current year.
    • <project-description>: A description of the project.

nuget.config

This file specifies the package sources for NuGet, ensuring that all developers use the same repositories.

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
    <add key="<custom-repo-name>" value="<custom-repo-url>" />
  </packageSources>
  <packageRestore>
    <add key="automatic" value="True" />
  </packageRestore>
</configuration>
  • packageSources: Defines the NuGet repositories. Clearing the existing ones ensures only the specified sources are used.
    • <custom-repo-name>: The name of your custom repository.
    • <custom-repo-url>: The URL of your custom repository.
  • packageRestore: Enables automatic package restore, ensuring that dependencies are restored when the project is built.

Tooling Files

In addition to the essential project files, the following tooling files should be included in your project to ensure a consistent development environment and adherence to best practices:

  • DirectoryRoot
    • Directory.github/
      • copilot-instructions.md
    • Directory.vscode/
      • extensions.json
      • settings.json
    • .gitignore
    • Directory.devcontainer/
      • devcontainer.json

.github/copilot-instructions.md

This file contains guidelines and instructions for using GitHub Copilot effectively within the project. It ensures that all contributors follow consistent practices when leveraging AI-assisted coding tools.

.vscode/extensions.json

This file specifies the recommended Visual Studio Code extensions for the project. It helps developers quickly set up their environment with the necessary tools.

{
  "recommendations": [
    "ms-dotnettools.csdevkit",
    "ms-azuretools.vscode-docker",
    "ms-vscode.powershell"
  ]
}

.vscode/settings.json

This file contains workspace-specific settings for Visual Studio Code, ensuring consistency in formatting, linting, and other configurations.

{
  "[csharp]": {
    "editor.tabSize": 4
  },
  "csharp.debug.justMyCode": false,
  "csharp.debug.logging.moduleLoad": false,
  "files.associations": {
    "*.slnx": "xml"
  },
  "dotnet.defaultSolution": "Solution.sln(x)",
  "github.copilot.chat.codesearch.enabled": true,
}

.gitignore

The .gitignore file specifies intentionally untracked files to ignore. This helps prevent sensitive or unnecessary files from being committed to the repository.

Node.js
node_modules/
.env


# Logs
logs/
*.log


# System Files
.DS_Store
Thumbs.db

Dev Containers

Dev Containers provide a consistent and isolated development environment using Docker. This ensures that all developers work in the same environment, reducing issues caused by differences in local setups.

  • DirectoryRoot
    • Directory.devcontainer/
      • devcontainer.json

.devcontainer/devcontainer.json

This file defines the configuration for the development container, including the image, extensions, and settings.

{
  "name": "C# (.NET)",
  "image": "mcr.microsoft.com/devcontainers/dotnet:1-9.0-bookworm",
  "features": {
    "ghcr.io/devcontainers/features/dotnet:2": {
      "version": "9.0.203"
    },
    "ghcr.io/davzucky/devcontainers-features-wolfi/docker-outside-of-docker:1": {
      "installDocker": true,
      "installBuildx": true,
      "installDockerCompose": true
    }
  },
  "extensions": [
    "ms-dotnettools.csdevkit",
    "ms-azuretools.vscode-docker",
    "ms-vscode.powershell"
  ],
  "settings": {
    "editor.tabSize": 4
  }
}

Benefits:

  • Consistency: Ensures all developers use the same environment.
  • Isolation: Prevents conflicts with local dependencies.
  • Portability: Makes it easy to share the development environment.

References