Clean Architecture With ASP.NET Core WebAPI

1. IMemberRepository - Interface
2. IMemberService - Interface
3. MemberService - Class

Code would be as per below for all these files,

IMemberRepository.cs

using System.Collections.Generic;

namespace Member.Application
{
    public interface IMemberRepository
    {
        List<Domain.Member> GetAllMembers();
    }
}

IMemberService.cs

using System.Collections.Generic;

namespace Member.Application
{
    //This interface is use for Bussiness Rule / USE CASE
    public interface IMemberService
    {
        List<Domain.Member> GetAllMembers();
    }
}

MemberService.cs

using System.Collections.Generic;

namespace Member.Application
{
    //Implement Bussiness Rule / USE CASES
    public class MemberService : IMemberService
    {
        private readonly IMemberRepository memberRepository;
        public MemberService(IMemberRepository memberRepository)
        {
            this.memberRepository = memberRepository;
        }
        List<Domain.Member> IMemberService.GetAllMembers()
        {
            return this.memberRepository.GetAllMembers();
        }
    }
}

Step 3

Now we will create the next Layer called “Member. Infrastructure” as per the below clean architecture diagram.

Create a new class library “Member. Infrastructure” as we created projects.

This Layer will take reference of “Member.Application” and “Member. Domain” Layer.

Now we will implement “IMemberRepository” in this layer. We will create a new class called “MemberRepository”. For demo purposes, I am hardcoding the Members List in this class.

using Member.Application;
using System.Collections.Generic;

namespace Member.Infrastructure
{
    public class MemberRepository : IMemberRepository
    {
        public static List<Domain.Member> lstMembers = new List<Domain.Member>()
        {
           new Domain.Member{  Id =1 ,Name= "Kirtesh Shah", Type ="G" , Address="Vadodara"},
           new Domain.Member{  Id =2 ,Name= "Mahesh Shah", Type ="S" , Address="Dabhoi"},
           new Domain.Member{  Id =3 ,Name= "Nitya Shah", Type ="G" , Address="Mumbai"},
           new Domain.Member{  Id =4 ,Name= "Dilip Shah", Type ="S" , Address="Dabhoi"},
           new Domain.Member{  Id =5 ,Name= "Hansa Shah", Type ="S" , Address="Dabhoi"},
           new Domain.Member{  Id =6 ,Name= "Mita Shah", Type ="G" , Address="Surat"}
        };
        public List<Domain.Member> GetAllMembers()
        {
            return lstMembers;
        }
    }
}

Step 4 - Now we will create a fourth layer called “Member. API”.

Let’s create the last layer as per the below architecture diagram.

This layer could be the Web Application, API, WPF, etc. For this demonstration, we are going to use API.

Click on the Next button. In the next screen Provide the API name and location and create a project.

Please set “Member. API” as the default project and add project dependencies.

Before adding a controller to the project, we should add dependencies injection in the “program.cs” file. Please note that we have the “GetAllMember()” method in the “Member. Infrastructure” project and “IMemberRepository.cs” in the “Member. Application” project.

So let's add the below code to the Program.cs file,

using Member.Application;
using Member.Infrastructure;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
builder.Services.AddScoped < IMemberRepository, MemberRepository > ();
builder.Services.AddScoped < IMemberService, MemberService > ();
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

Now we will add an API Controller called “MembersController.cs”.

using Member.Application;
using Microsoft.AspNetCore.Mvc;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace Member.API.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class MembersController : ControllerBase
    {
        
        private readonly IMemberService memberService;

        public MembersController(IMemberService memberService)
        {
          this.memberService = memberService;
        }
        // GET: api/<MembersController>
        [HttpGet]
        public ActionResult<IList<Domain.Member>> Get()
        {
            return Ok(this.memberService.GetAllMembers());
        }
        
    }
}

In the above code, we have added a constructor to add dependencies injection and the Get() method to get all members.

Now execute your project and notice the output,

Output

That’s all for this article. We have implemented a simple Member API to learn Clean Architecture.

In the next article, we will learn a few more important points about clean architecture.