Create .NET Solution With 3 Projects: A Step-by-Step Guide

Dec 4, 2025 by Alex Johnson 59 views

Creating a .NET Solution with Three Projects: A Step-by-Step Guide

So, you're looking to build a .NET solution with multiple projects? That's fantastic! Structuring your application into separate projects is a best practice that promotes modularity, maintainability, and testability. In this guide, we'll walk through creating a .NET solution with three projects: EmotionBikes.Core (for your domain/entities), EmotionBikes.Data (leveraging EF Core and a DBContext), and EmotionBikes.App (a console application to tie it all together). Let's dive in!

Understanding the Project Structure

Before we jump into the code, let's quickly understand the purpose of each project. This will help you grasp the overall architecture and how the projects interact.

EmotionBikes.Core: This project will house your core business logic and domain models (entities). Think of it as the heart of your application, defining the fundamental concepts and rules. It should be framework independent, meaning it shouldn't have direct dependencies on external libraries like Entity Framework Core. This allows you to potentially swap out data access technologies in the future without affecting your core logic.
EmotionBikes.Data: This project will be responsible for data access using Entity Framework Core (EF Core). It will contain your DBContext, which represents your database connection and provides methods for interacting with your data. This project will depend on EmotionBikes.Core, as it needs to understand the domain models defined there.
EmotionBikes.App: This project will be our console application, acting as the entry point for our application. It will orchestrate the logic, interact with the user (if needed), and utilize the services provided by the other projects. This project will depend on both EmotionBikes.Core and EmotionBikes.Data.

This separation of concerns is crucial for building robust and scalable applications. By isolating different responsibilities into separate projects, we make our code easier to understand, test, and maintain. When you are structuring your project, think about the long-term benefits of using established best practices to reduce technical debt.

Step 1: Create the Solution and Projects

First things first, let's create the solution and the individual projects. We'll use the .NET CLI (Command Line Interface) for this, which is a powerful and efficient way to manage your .NET projects. If you don't have the .NET CLI installed, you can download it from the official Microsoft website. The .NET CLI is essential for modern .NET development, offering a streamlined way to manage projects and dependencies.

Open your terminal or command prompt.
Navigate to the directory where you want to create your solution.
Run the following command to create a new solution:
```
dotnet new sln EmotionBikes.sln
```
This command creates a new solution file named EmotionBikes.sln. A solution acts as a container for one or more projects.
Next, let's create the individual projects. We'll start with the EmotionBikes.Core project. Navigate into the solution directory:
```
cd EmotionBikes
```
Create the EmotionBikes.Core project:
```
dotnet new classlib -o EmotionBikes.Core
```
This command creates a new class library project named EmotionBikes.Core. Class libraries are typically used for reusable code, like our domain models.
Now, create the EmotionBikes.Data project:
```
dotnet new classlib -o EmotionBikes.Data
```
This creates another class library project, this time for our data access logic.
Finally, create the EmotionBikes.App project:
```
dotnet new console -o EmotionBikes.App
```
This command creates a new console application project named EmotionBikes.App. Console applications are perfect for command-line tools and applications.
Add the projects to the solution. From the solution directory (one level up from the project directories), run these commands:
```
dotnet sln EmotionBikes.sln add EmotionBikes.Core
dotnet sln EmotionBikes.sln add EmotionBikes.Data
dotnet sln EmotionBikes.sln add EmotionBikes.App
```
These commands add the newly created projects to our solution.

Great! You've now created the solution and the three projects. You should have a directory structure that looks something like this:

EmotionBikes/
├── EmotionBikes.sln
├── EmotionBikes.Core/
│   └── EmotionBikes.Core.csproj
├── EmotionBikes.Data/
│   └── EmotionBikes.Data.csproj
└── EmotionBikes.App/
    └── EmotionBikes.App.csproj

Step 2: Add Project References

Now that we have our projects, we need to establish the dependencies between them. As we discussed earlier, EmotionBikes.Data depends on EmotionBikes.Core, and EmotionBikes.App depends on both EmotionBikes.Core and EmotionBikes.Data. We'll use project references to define these dependencies.

Navigate to the EmotionBikes.Data directory:
```
cd EmotionBikes.Data
```
Add a reference to the EmotionBikes.Core project:
```
dotnet add reference ../EmotionBikes.Core
```
This command adds a project reference to EmotionBikes.Core from EmotionBikes.Data. Project references tell the compiler that EmotionBikes.Data needs to be able to access the code in EmotionBikes.Core.
Next, navigate to the EmotionBikes.App directory:
```
cd ../EmotionBikes.App
```
Add references to both EmotionBikes.Core and EmotionBikes.Data:
```
dotnet add reference ../EmotionBikes.Core
dotnet add reference ../EmotionBikes.Data
```
Now, EmotionBikes.App can access code from both EmotionBikes.Core and EmotionBikes.Data.

Project references are a fundamental aspect of multi-project solutions. They allow projects to share code and dependencies, promoting code reuse and modularity. When setting up references, always consider the direction of dependencies to maintain a clean and understandable architecture.

Step 3: Install EF Core Packages in EmotionBikes.Data

The EmotionBikes.Data project will be using Entity Framework Core for data access. We need to install the necessary NuGet packages to get started. NuGet is a package manager for .NET that allows you to easily add libraries and tools to your projects. NuGet packages streamline the process of adding external libraries to your project, saving you the hassle of manual downloads and installations. Managing your package dependencies is crucial for maintaining project stability and avoiding compatibility issues.

Make sure you are in the EmotionBikes.Data directory.
Run the following commands to install the EF Core packages:
```
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Design
```
- Microsoft.EntityFrameworkCore: This is the core EF Core package.
- Microsoft.EntityFrameworkCore.SqlServer: This package provides the SQL Server provider for EF Core. You can choose a different provider if you're using a different database (e.g., Microsoft.EntityFrameworkCore.Sqlite, Npgsql.EntityFrameworkCore.PostgreSQL).
- Microsoft.EntityFrameworkCore.Design: This package is needed for design-time operations like migrations.

Step 4: Define Entities in EmotionBikes.Core

Now, let's define some entities in the EmotionBikes.Core project. Entities represent the objects in your domain model – the things your application works with. For this example, let's create a simple Bike entity.

Navigate to the EmotionBikes.Core directory.
Create a new file named Bike.cs.
Add the following code to Bike.cs:
```
namespace EmotionBikes.Core
{
    public class Bike
    {
        public int Id { get; set; }
        public string Model { get; set; }
        public string Brand { get; set; }
        public decimal Price { get; set; }
    }
}
```
This code defines a simple Bike class with properties for Id, Model, Brand, and Price. These properties represent the data we want to store about each bike.

Domain entities are the foundation of your application's data model. Careful entity design is crucial for ensuring data integrity and application performance. Consider using data annotations or fluent API to configure your entities and relationships within your database.

Step 5: Create the DBContext in EmotionBikes.Data

Next, we'll create a DBContext in the EmotionBikes.Data project. The DBContext represents your connection to the database and provides methods for querying and saving data. We’ll use the DbContext class as the bridge between your application and the database. It handles the database connection, query execution, and data persistence. Proper configuration of your DbContext is critical for performance and data integrity.

Navigate to the EmotionBikes.Data directory.
Create a new file named BikeContext.cs.
Add the following code to BikeContext.cs:
```
using EmotionBikes.Core;
using Microsoft.EntityFrameworkCore;

namespace EmotionBikes.Data
{
    public class BikeContext : DbContext
    {
        public BikeContext(DbContextOptions<BikeContext> options) : base(options)
        {
        }

        public DbSet<Bike> Bikes { get; set; }
    }
}
```
This code defines a BikeContext class that inherits from DbContext. It also defines a DbSet<Bike> property, which represents the table in the database that will store our Bike entities. The constructor takes DbContextOptions<BikeContext> as a parameter, which allows us to configure the database connection.

Step 6: Configure the DBContext in EmotionBikes.App

Now, let's configure the DBContext in our EmotionBikes.App project. We need to tell EF Core which database provider to use and how to connect to the database.

Navigate to the EmotionBikes.App directory.
Open the Program.cs file.
Modify the Program.cs file to look like this:
```
using EmotionBikes.Core;
using EmotionBikes.Data;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System;

namespace EmotionBikes.App
{
    class Program
    {
        static void Main(string[] args)
        {
            // Setup dependency injection
            var serviceProvider = new ServiceCollection()
                .AddDbContext<BikeContext>(options =>
                    options.UseSqlServer("Server=(localdb)\mssqllocaldb;Database=EmotionBikes;Trusted_Connection=True;"))
                .BuildServiceProvider();

            // Get the BikeContext
            var context = serviceProvider.GetService<BikeContext>();

            // Add a bike
            context.Bikes.Add(new Bike { Model = "Mountain Bike", Brand = "Trek", Price = 500 });
            context.SaveChanges();

            // Retrieve bikes
            var bikes = context.Bikes.ToList();

            foreach (var bike in bikes)
            {
                Console.WriteLine({{content}}quot;Bike: {bike.Brand} {bike.Model}, Price: {bike.Price}");
            }

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}
```
Let's break down the changes:
- We've added using statements for the necessary namespaces.
- We've set up dependency injection using ServiceCollection. Dependency injection is a design pattern that allows us to decouple our components and make our code more testable. Dependency Injection (DI) is a critical design pattern for building maintainable and testable applications. Leveraging DI containers like the one provided by Microsoft.Extensions.DependencyInjection simplifies the management of dependencies and promotes loose coupling between components.
- We've registered our BikeContext with the service collection, specifying that we want to use the SQL Server provider and providing a connection string. Remember to replace the connection string with your actual database connection string. Ensure that your connection strings are securely stored and managed, especially in production environments. Consider using environment variables or configuration files to avoid hardcoding sensitive information.
- We've retrieved the BikeContext from the service provider.
- We've added a new Bike to the database.
- We've saved the changes using context.SaveChanges(). The SaveChanges() method is crucial for persisting changes to the database. Always handle potential exceptions that may occur during database operations to ensure the reliability of your application.
- We've retrieved all bikes from the database and printed them to the console.

Step 7: Run Migrations

Before we can run our application, we need to create the database schema. We'll use EF Core migrations for this. Migrations are a way to evolve your database schema over time in a controlled and repeatable manner. EF Core Migrations provide a robust mechanism for managing database schema changes. They ensure that your database schema is always in sync with your entity model. Regularly use migrations to track and apply changes, especially in collaborative development environments.

Open your terminal or command prompt.
Navigate to the EmotionBikes.Data directory.
Run the following command to add a new migration:
```
dotnet ef migrations add InitialCreate --project EmotionBikes.Data --startup-project EmotionBikes.App
```
This command creates a new migration named InitialCreate. The --project flag specifies the project where the migrations should be added (EmotionBikes.Data), and the --startup-project flag specifies the startup project (EmotionBikes.App). The startup project is needed to resolve dependencies and configuration.
Now, run the following command to apply the migration:
```
dotnet ef database update --project EmotionBikes.Data --startup-project EmotionBikes.App
```
This command applies the migration to your database, creating the necessary tables and columns.

Step 8: Run the Application

Finally, we're ready to run our application!

Navigate to the EmotionBikes.App directory.
Run the following command:
```
dotnet run
```
If everything is configured correctly, you should see output similar to this:
```
Bike: Trek Mountain Bike, Price: 500
Press any key to exit...
```
Congratulations! You've successfully created a .NET solution with three projects, configured EF Core, and interacted with the database.

Conclusion

In this guide, we've walked through the process of creating a .NET solution with three projects: EmotionBikes.Core, EmotionBikes.Data, and EmotionBikes.App. We've learned how to structure our application into separate projects, add project references, install NuGet packages, define entities, create a DBContext, configure EF Core, run migrations, and run the application. This is a solid foundation for building more complex and maintainable .NET applications.

Remember to apply these principles to your own projects, and you'll be well on your way to creating robust and scalable software! For further learning, consider exploring advanced topics such as repository patterns, unit testing, and dependency injection containers. Happy coding!

For more information on .NET development and best practices, you can check out the official Microsoft .NET documentation.