Implementing Onion Architecture In ASP.NET Core 3.0

Introduction

 

Onion Architecture is used to overcome both separation of concern and tightly coupling issues in our application.

 

Separation of Concern (Soc)

 

Wikipedia says “In computer science, separation of concerns (SoC) is a design principle for separating a computer program into distinct sections, such that each section addresses a separate concern. A concern is a set of information that affects the code of a computer program.”

 

SoC applies to web applications to separate the application into different layers, for example based on MVC architecture the application will be separated into Model, View and Controller.

 

Tightly Coupled

 

Tightly coupled object is an object that needs to know about another object. Tightly-coupled objects are highly dependant on each other’s interfaces. If we change one object, we need to change the other object as well.

 

Onion Architecture contains four layers,

1. Domain Layer
2. Repository Layer
3. Service Layer
4. UI/Presentation Layer

Domain/Data Access Layer

 

This is the core layer of the application, the classes in this layer are used to create a table in the database, basically this layer is used to build an entity.

 

Repository Layer

 

This is a generic repository layer which acts as an abstract layer between the data access and business layer of the application which makes a more loosely coupled approach to data access.

 

Service Layer

 

This layer is used communicate between UI and repository layers using Interface. We can call it as a business layer since it holds the business logic for an entity.

 

UI Layer

 

The UI layer can be Web API or Web application or any other UI application. This layer contains the implementation of DI (Dependency Inversion) principle to build a loosely coupled application.

 

Prerequisites

 

Software

 

Visual Studio 2019 16.3.4 & later

 

Onion Architecture in ASP.NET Core 3.0 

 

To implement the onion architecture, we need to create four projects, three class library projects for Domain, Repository and service layer respectively and one ASP.NET Core API project for UI layer.

 

Project Structure 

 

 

 

Step 1 - Create the project for Domain/Data Access Layer

 

Create a Class Library (.NET Core) Project using Visual Studio as shown in the below figure.

 

 

 

In my case I named it as OA_DataAccess.

 

OA_DataAccess class contains three entities, the BaseEntity which holds a common property and the other two entities, which are Product and Product Details.

 

BaseEntity.cs 

public class BaseEntity
    {
        public int ProductId { get; set; }
     }

This class will hold the common properties used in product and product details entity, right now we have only ProductId, but it will grow as the application grows.

 

Product.cs

public class Product : BaseEntity
    {
        public string ProductName { get; set; }
        public virtual ProductDetails ProductDetails { get; set; }
    }

This class inherits from BaseEntity.

 

ProductMap.cs

public class ProductMap
    {
        public ProductMap(EntityTypeBuilder<Product> entityBuilder)
        {

            entityBuilder.HasKey(p => p.ProductId);
            entityBuilder.HasOne(p => p.ProductDetails).WithOne(p => p.Product).HasForeignKey<ProductDetails>(x => x.ProductId);
        }

This class will hold the configuration of Product Entity which is used to create a database table.

 

Make sure Microsoft.EntityFrameworkCore package is added using NuGet package manager.

 

ProductDetail.cs

public class ProductDetails : BaseEntity
    {
        public int StockAvailable { get; set; }
        public decimal Price { get; set; }
        public virtual Product Product{get;set;}
    }

This class Inherits from BaseEntity.

 

ProductDetailMap.cs

public class ProductDetailMap
  {
      public ProductDetailMap(EntityTypeBuilder<ProductDetails> entityBuilder)
      {
          entityBuilder.HasKey(p => p.ProductId);
          entityBuilder.Property(p => p.StockAvailable).IsRequired();
          entityBuilder.Property(p => p.Price);
      }
  }

This class will hold the configuration of ProductDetail Entity which Is used to create a database table for the entity.

 

Step 2 - Create the project for Repository Layer

 

Create one more class library project, in my case I named it as OA_Repository. This layer contains a Datacontext class. The ADO.NET Entity Framework code first approach is used to create a data access context class.

 

Create a class file and name it as ApplicationContext.cs.

public class ApplicationContext :DbContext
 {
     public ApplicationContext(DbContextOptions<ApplicationContext> options) : base(options)
     {
     }
     protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         base.OnModelCreating(modelBuilder);
         new ProductMap(modelBuilder.Entity<Product>());
         new ProductDetailMap(modelBuilder.Entity<ProductDetails>());
     }
 }

Make sure Microsoft.EntityFrameworkCore package is added using NuGet package manager.

 

Now create an Interface and name it as IRepository.cs.

public interface IRepository<T> where T : BaseEntity
    {
        T Get(int id);
        IEnumerable<T> GetAll();

    }

Let’s implement IRepository, create a new class file and name it as Repository.cs

public class Repository<T> : IRepository<T> where T : BaseEntity
    {
        private readonly ApplicationContext context;
        private readonly DbSet<T> entities;
        public Repository(ApplicationContext context)
        {
            this.context = context;
            entities = context.Set<T>();
        }
        public IEnumerable<T> GetAll()
        {
            return entities.AsEnumerable();
        }
        public T Get(int id)
        {
            return entities.SingleOrDefault(p =>p.ProductId  == id);
        }
    }

This a generic repository which implements IRepository to build a loosely coupled application, ASP.NET Core is designed in the way to support and leverage dependency injection.

 

Step 3 - Create the project for Service Layer 

 

This layer communicates between repository and presentation layer. Let’s create one more class project and name it as OA_Service. This project contains an interface and classes which implement the interface.

 

Create a new interface in OA_Service project and name it as IProductService.cs

public interface IProductService
    {
        IEnumerable<OA_DataAccess.Product> GetProduct();
        OA_DataAccess.Product GetProduct(int id);
    }

Create a new interface in OA_Service project and name it as IProductDetailService.cs

public interface IProductDetailsService
    {

        OA_DataAccess.ProductDetails GetProductDetail(int id);
    }

Create a new class and name it as ProductService.cs to Implement IProductService.cs.

public class ProductService: IProductService
    {
        private IRepository<Product> productRepository;
        private IRepository<ProductDetails> productDetailRepository;

        public ProductService(IRepository<Product> productRepository, IRepository<ProductDetails> productDetailRepository)
        {
            this.productRepository = productRepository;
            this.productDetailRepository = productDetailRepository;
        }
        public IEnumerable<Product> GetProduct()
        {
            return productRepository.GetAll();
        }

        public Product GetProduct(int id)
        {
            return productRepository.Get(id);
        }
    }

You can notice we have parameterized constructor which is used to inject dependencies in the object.

 

GetProduct() method is used to get a ProductList from Product Repository.

 

GetProduct(int id) method is used to get a record from Product Repository based on ID.

 

Create a new class and name it as ProductDetailService.cs to Implement IProductDetailService.cs.

public class ProductDetailsService: IProductDetailsService
    {
        private IRepository<ProductDetails> productDetailsRepository;

        public ProductDetailsService(IRepository<ProductDetails> productDetailsRepository)
        {
            this.productDetailsRepository = productDetailsRepository;
        }

        public ProductDetails GetProductDetail(int id)
        {
            return productDetailsRepository.Get(id);
        }
    }

Step 4 - Create ASP.NET WEB API application for UI/Presentation Layer

 

This is an external layer, in our case it is a ASP.NET CORE WEB API project where we are going to create a REST service which is exposed to external clients.

 

Right Click on Solution Add->Project->New Project

 

Choose the template ASP.NET Core Web Application as shown in the below figure.

 

 

 

Next, name the project, in my case it is OA_WebAPI.

 

 

 

Next, choose the API template as shown in the below figure.

 

 

 

Make sure the target framework is ASP.NET 3.0.

 

Once the project is created, go to Startup.cs file and add the below code under ConfigureService method.

services.AddDbContext<ApplicationContext>(options =>   options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
            services.AddTransient<IProductService, ProductService>();
            services.AddTransient<IProductDetailsService, ProductDetailsService>();

Where the application context, repository and services are registered to the dependency injection during application start up.

 

The Default connection string is defined in appsettings.json file.

"ConnectionStrings": {
    "DefaultConnection": "Data Source=DESKTOP-585QGBN;Initial Catalog=OATestDB;User ID=sa; Password=[give your SQL instance password]"
  },

Create a New Web API controller, In my case ProductController.cs.

private readonly IProductService productService;
        private readonly IProductDetailsService productDetailsService;

        public ProductController(IProductService productService, IProductDetailsService productDetailsService)
        {
            this.productService = productService;
            this.productDetailsService = productDetailsService;
        }

   [HttpGet]
        public List<ProductDetails> Get()
        {
            List<ProductDetails> productDetails = new List<ProductDetails>();
            var prodcutList=productService.GetProduct().ToList();
            foreach(var product in prodcutList)
            {
                var productDetailList = productDetailsService.GetProductDetail(product.ProductId);
                ProductDetails details = new ProductDetails
                {
                    ProductId = product.ProductId,
                    ProductName = product.ProductName,
                    Price = productDetailList.Price,
                    StockAvailable = productDetailList.StockAvailable,
                };
                productDetails.Add(details);
            }
            return productDetails;
        }

Now it’s time to create database using migration. Go to package manager console which is available in the bottom task bar of our Visual Studio, or else we can access it from Tools-> NuGet Package Manager-> Package Manager Console.

 

Note

We need to add a migration for our OA_Repository Project, before adding a migration make sure you have added the following packages in the OA_Repository as given below,

• Microsoft.EntityFrameworkCore
• Microsoft.EntityFrameworkCore.Relational
• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools

Choose OA_Repository Project from Package Manager Console and run > Add-Migration MyInitialMigration which will create a set of tables based on our models.

 

 

 

Next run > Update-Database to apply the migration to the database.

 

Now Switch to SSMS where you can notice the database and tables which are newly created based on the migration.

 

 

Now let’s insert a record in Product and ProductDetails table to test the GET Action in product controller which is used to return a product detail.

 

 

Summary

 

We have seen what Onion Architecture  isand how to implement it in ASP.NET Core 3.0.

 

I hope you have enjoyed this article. Your valuable feedback, questions, or comments about this are always welcomed.