Forem: Manik

Dapper Micro-ORM Explained

Manik — Wed, 28 Jan 2026 15:16:29 +0000

What Is Dapper?

Dapper is classed as a micro ORM. That means it is still an Object–Relational Mapper, but it is intentionally lightweight, opinionated, and minimal.

Unlike full-featured ORMs such as Entity Framework or NHibernate, Dapper focuses on performance and control, providing just enough abstraction to map query results to objects—without hiding SQL from the developer.

Put simply:

Dapper executes SQL you write, maps the results to POCOs, and gets out of the way.

It does not:

Generate SQL
Track entities
Manage change detection
Enforce a domain model

And that is precisely why it is fast and predictable.

Why Dapper?

The primary reason teams choose Dapper over Entity Framework is control.

With EF, it’s easy to end up with:

Complex LINQ queries
Unpredictable SQL generation
Poor execution plans
Surprises that only show up in production

With Dapper:

You write the SQL
You know exactly what runs
DBAs can review and optimise queries
Performance issues are visible and diagnosable

--Example: fetching a single column by ID
SELECT EventName
FROM Events
WHERE Id = @Id

There is no translation layer, no expression tree, and no guesswork.

When You Should Not Use Dapper

There are legitimate cases where Dapper is the wrong tool.

1. Heavy reliance on Entity Framework features

If your existing application depends on:

Change tracking
Lazy loading
Cascade updates
EF-specific behaviours

then switching to Dapper will be painful.
Dapper does no entity tracking. It works with plain POCOs. If you expect “EF magic”, you will be disappointed.

2. Teams that cannot or will not write SQL

This is uncomfortable to say, but it’s real.
Junior developers often resist Dapper because:
They must write SQL
They can’t hide behind LINQ
Mistakes are more visible

If your team is still learning ASP.NET and C#, adding SQL into the mix may slow them down initially.

That said: if you work with databases professionally, you should know SQL. Avoiding it only delays the problem.

Who came up with Dapper?

Dapper was created by the team at Stack Overflow.

They built it to solve a real production problem:

LINQ-to-SQL and early ORMs were consuming excessive CPU
SQL generation was opaque and inefficient
Scaling web servers became difficult

Dapper was introduced to:

Reduce overhead
Eliminate SQL generation costs
Improve predictability under load

It has since become one of the most widely used data access libraries in .NET.

What Dapper Actually Is

Dapper is:

A simple object mapper for .NET
Often called the “King of Micro ORMs” for speed
An extension over ADO.NET
At a high level, working with Dapper involves three steps:
Create an IDbConnection
Write SQL for CRUD operations
Execute the SQL using Dapper extension methods

Dapper supports:

SQL Server
PostgreSQL
MySQL
Oracle
SQLite

Core Dapper Extension Methods

Dapper extends IDbConnection with the following commonly used methods:

- Execute
- Executes a command and returns affected row count
- Query
- Executes a query and maps results to objects
- QueryFirst
- Returns the first row (throws if none)
- QueryFirstOrDefault
- Returns first row or default
- QuerySingle
- Expects exactly one row
- QuerySingleOrDefault
- One or zero rows only
- QueryMultiple
- Reads multiple result sets in a single round trip

Dapper supports both synchronous and asynchronous APIs. In modern .NET (6+), you should default to async.

Using Dapper in ASP.NET Web API (.NET 6+)

//Packages Needed
dotnet add package Dapper
dotnet add package Microsoft.Data.SqlClient

DTO

public sealed class EventDto
{
    public int Id { get; init; }
    public string EventName { get; init; } = string.Empty;
}

Interface

public interface IEventRepository
{
    Task<EventDto?> GetByIdAsync(int id);
}

Interface*

public interface IEventRepository
{
    Task<EventDto?> GetByIdAsync(int id);
}

//Repository Using Dapper
public sealed class EventRepository : IEventRepository
{
    private readonly IDbConnection _connection;

    public EventRepository(IDbConnection connection)
    {
        _connection = connection;
    }

    public async Task<EventDto?> GetByIdAsync(int id)
    {
        const string sql = """
            SELECT Id, EventName
            FROM Events
            WHERE Id = @Id
        """;

        return await _connection.QuerySingleOrDefaultAsync<EventDto>(
            sql,
            new { Id = id }
        );
    }
}

Dependency Injection (Program.cs)

builder.Services.AddScoped<IDbConnection>(_ =>
    new SqlConnection(builder.Configuration.GetConnectionString("Default"))
);

builder.Services.AddScoped<IEventRepository, EventRepository>();

This keeps:

Connection lifetime scoped per request
SQL explicit
Dapper isolated behind repositories

Web API Endpoint

[ApiController]
[Route("api/events")]
public sealed class EventsController : ControllerBase
{
    private readonly IEventRepository _repository;

    public EventsController(IEventRepository repository)
    {
        _repository = repository;
    }

    [HttpGet("{id:int}")]
    public async Task<IActionResult> Get(int id)
    {
        var result = await _repository.GetByIdAsync(id);
        return result is null ? NotFound() : Ok(result);
    }
}

Repository Pattern: Reality Check

Let’s be blunt.

Generic repositories + Unit of Work are an anti-pattern in most real systems
They add abstraction without adding clarity
They actively hide performance problems
A repository should:
Work with one aggregate
Express business intent
Use Dapper internally
Own its transaction boundary (per database)

If multiple aggregates must change together:

Your business process is the unit of work
Use domain events
Make handlers idempotent
Avoid distributed transactions

Dapper does not dictate architecture. Bad architecture with Dapper is still bad architecture.

Where Dapper Shines (Real Scenarios)

This is where Dapper earns its keep—especially in legacy systems.

LINQ-to-SQL or EF choking on large datasets

Reporting queries
Historical data
Analytics
Batch processing

Legacy WebForms / ASP.NET MVC apps

EF 4.x / LINQ-to-SQL performance issues
Gradual migration strategy
Co-existence with existing ORM

Stored-procedure-heavy systems

Dapper maps SP results cleanly
No fighting EF abstractions

High-throughput APIs

Reduced allocations
No tracking overhead
Predictable SQL execution

Read-heavy CQRS read models

Dapper for reads
EF or other tools for writes (hybrid approach)

Final Take

Dapper is not a silver bullet.
It will not save bad SQL, bad schema design, or bad architecture.

But if:

You care about performance
You want control
You work with legacy systems
You need predictability at scale

Then Dapper is one of the most reliable tools in the .NET ecosystem.

Learn Dapper
Dapper, Entity Framework and Hybrid Apps

AspNet Core Web API Basics to Advanced Part1

Manik — Mon, 06 Feb 2023 13:47:33 +0000

What is Web API.
API stands for Application Programming Interface, which in simple terms allows two applications to talk to each other.

ASP.NET Web API is Microsoft .Net framework for building HTTP services that can be accessed from any client such as browsers, desktop applications and mobile devices. ASP.NET Web API can be used to build both RESTful and SOAP services.

ASP.NET Web API Core ASP.NET Core is an open-source, cross-platform framework for building modern, cloud-based web apps and we can chose whatever platforms we want to build them on. We can build and run ASP.Net Core applications on Windows, macOS or Linux. Some of the benefits we get when working with ASP.Net core are:

It is a cloud-ready.
Comes with Built-in dependency injection.
Very lightweight.
High-performance and modular HTTP request pipeline.
We can host ASP.Net Core applications on IIS, Nginx, Apache and Docker.

Let us build our first Web API in ASP.NET Core5
To build a project select create a new project.

Select ASP.NET Core Web API

Select where we want to save it.

For the last step, select additional information. I am leaving everything as default but in future series we will investigate other options.

Now build and compile your Web API and you should see your WeatherForecast Endpoint.

AspNet Core Web API Part 2 Database Context >>

How to Web API .Net Core Basics to Advanced Part 6 Second Controller

Manik — Thu, 20 Oct 2022 18:37:02 +0000

Address Controller

As we created a CompanyController in the last article to make things more interesting, let us create an AddressController and AddressTypeController which allows the client to Retrieve, Add, Update, Remove address for a company. In our case let us assume our company may have one address or more than one address and some times clients can request that if we want to send an invoice it should be sent to a different address and for normal correspondence we should use a different address.

*Enough talking lets begin. *

In the image below we have a table structure.

Enough of the theory let us create our Models, Dtos and controllers.
Models/Entity
In our Entity folder I am going to add two files and I am going to name them Address.cs and AddressType.cs to map our data with tables in db.
Address.cs



public class Address
    {
        [Key]
        public int Id { get; set; }
        [Required]
        public Guid GUID { get; set; }
        [Required]
        public Guid CompanyGUID { get; set; }
        [Required]        
        [RegularExpression(@"[a-zA-Z0-9_.-]{2,150}",
             ErrorMessage = "The {0} must be 2 to 150 valid characters which are any digit, any letter and -._@+.")]
        [StringLength(150, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 2)]
        [Display(Name = "HouseNoName")]
        public string HouseNoName { get; set; }
        [Required]
        public string Street { get; set; }      
        public string City { get; set; }
        [Required]
        public string County { get; set; }
        [Required]
        public string PostCode { get; set; }
        public DateTimeOffset Createddate { get; set; }
        public bool IsEnabled { get; set; }
        public bool IsDeleted { get; set; }

        //Forign Key navigation property
        [Required]
        public int CompanyId { get; set; }
        [ForeignKey("CompanyId")]
        public Company Company { get; set; }

        //Forign Key navigation property
        [Required]
        public int AddressTypeId { get; set; }
        [ForeignKey("AddressTypeId")]
        public AddressType AddressType { get; set; }
    }

AddressType.cs



 public class AddressType
    {
        [Key]
        public int Id { get; set; }
        [Required]
        public string AddressTypeName { get; set; }
        public bool IsEnabled { get; set; }
        public bool IsDeleted { get; set; }
    }

Now we can use DB-update command to Update the database schema in our DB as I have shown in my article <<<Part 2 How to Web API Core set up Database Context

Dto
Let us now add two folders (Address-AddressType) in our Dto folder. I am going to use these folders to add our Dto files like we did for company, I am leaving out Dtos Create and Update for you guys.

AddressDto*



public class AddressDto
    {     
        public int Id { get; set; }
        public Guid GUID { get; set; }
        [Required]
        public Guid CompanyGUID { get; set; }
        [Required]       
        [RegularExpression(@"[a-zA-Z0-9_.-]{2,150}",
             ErrorMessage = "The {0} must be 2 to 150 valid characters which are any digit, any letter and -._@+.")]
        [StringLength(150, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 2)]
        [Display(Name = "HouseNoName")]
        public string HouseNoName { get; set; }
        [Required]
        public string Street { get; set; }
        public string City { get; set; }
        public string County { get; set; }
        [Required]
        public string PostCode { get; set; }
        public DateTimeOffset Createddate { get; set; }
        public bool IsEnabled { get; set; }
        public bool IsDeleted { get; set; }

        //Forign Key realtion
        [Required]
        public int CompanyId { get; set; }       
        public CompanyDto Company { get; set; }
        //Forign Key realtion
        [Required]
        public int AddressTypeId { get; set; }       
        public AddressTypeDto AddressType { get; set; }

Controllers
To Add a controller right click the controller folder in solution explorer and select Add->Controller

and you will end up at Add New Scaffold Item Make sure you select API option, default one is MVC, I am going to go with API Controller - Empty option as that is the best way to learn. But I encourage you to explore other templates when you add more Controllers.

Next we are going to name our controller, so our first controller is going to be Address as in image below.

We will end up with the basic template of Web API controller and in the code below I have set up a constructor which expects an object of IAddressService.



sing Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
using System;
using WebApiSeriesCore5.ServiceResponder;
using WebApiSeriesCore5.Services.Contract;
using WebApiSeriesCore5.Dto.Address;

namespace WebApiSeriesCore5.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AddressController : ControllerBase
    {

        private readonly IAddressService _addrService;

        public AddressController(IAddressService addressService)
        {
            _addrService = addressService;
        }
}

How to Use Get Put Post Delete
To start with, we can get a list of addresses for a company and to do that we can use [HttpGet] in our controller as you can see in the example code below.



/// <summary>
/// Get list of all address for a company
/// </summary>
/// <param name="companyGUID"></param>
/// <returns></returns>
//Get/{Guid}
[HttpGet("[action]/{companyGUID:Guid}", Name = "GetCompanyAddressByGUID")]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(AddressDto))]
[ProducesResponseType(StatusCodes.Status400BadRequest)]
[ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
[ProducesDefaultResponseType]
public async Task<IActionResult> GetCompanyAddress(Guid companyGUID)
{
     if(companyGUID == Guid.Empty) { return BadRequest(); }

     ServiceResponse<List<AddressDto>> listCompanyAddress = await _addrService.GetCompanyAddressAsync(companyGUID);

     if (listCompanyAddress.Data == null)
     {
        return NotFound(listCompanyAddress);
     }

    return Ok(listCompanyAddress);
}

Even though I have provided a complete controller in the example below, I would suggest try and add HttpPost, HttPut, HttpPatch and HttpDelete yourself and have fun with them because that it best way to learn when you are enjoying it.



using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
using System;
using WebApiSeriesCore5.ServiceResponder;
using WebApiSeriesCore5.Services.Contract;
using WebApiSeriesCore5.Dto.Address;

namespace WebApiSeriesCore5.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class AddressController : ControllerBase
    {

        private readonly IAddressService _addrService;

        public AddressController(IAddressService addressService)
        {
            _addrService = addressService;
        }

        /// <summary>
        /// Get list of all address for a company
        /// </summary>
        /// <param name="companyGUID"></param>
        /// <returns></returns>
        //Get/{Guid}
        [HttpGet("[action]/{companyGUID:Guid}", Name = "GetCompanyAddressByGUID")]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(AddressDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesDefaultResponseType]
        public async Task<IActionResult> GetCompanyAddress(Guid companyGUID)
        {
            if (companyGUID == Guid.Empty) { return BadRequest(); }

            ServiceResponse<List<AddressDto>> listCompanyAddress = await _addrService.GetCompanyAddressAsync(companyGUID);

            if (listCompanyAddress.Data == null)
            {
                return NotFound(listCompanyAddress);
            }

            return Ok(listCompanyAddress);
        }

        /// <summary>
        /// Get a address by GUID
        /// </summary>
        /// <param name="addressGUID"></param>
        /// <returns></returns>
        //Get/12
        [HttpGet("{addressGUID:Guid}", Name = "GetAddressByGUID")]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(AddressDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesDefaultResponseType]
        public async Task<IActionResult> GetAddress(Guid addressGUID)
        {
            if (addressGUID == Guid.Empty) { return BadRequest(); }

            ServiceResponse<AddressDto> _address = await _addrService.GetByGUIDAsync(addressGUID);

            if (_address.Data == null)
            {
                return NotFound(_address);
            }

            return Ok(_address);
        }

        /// <summary>
        /// Create a new address for a company
        /// </summary>
        /// <param name="createAddressDto"></param>
        /// <returns></returns>
        //POST/Address
        [HttpPost]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(AddressDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<AddressDto>> CreateAddress([FromBody] CreateAddressDto createAddressDto)
        {

            if (createAddressDto == null)
            {
                return BadRequest(ModelState);
            }

            if (!ModelState.IsValid) { return BadRequest(ModelState); }

            var _newAddress = await _addrService.AddAddressAsync(createAddressDto);

            if (_newAddress.Success == false && _newAddress.Message == "Exist")
            {
                ModelState.AddModelError("", "Address Exist");
                return StatusCode(404, ModelState);
            }

            //only for Demo in production never send response back about internal error.
            if (_newAddress.Success == false && _newAddress.Message == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong at repository layer when adding Address {createAddressDto}");
                return StatusCode(500, ModelState);
            }

            //only for Demo in production never send response back about internal error.
            if (_newAddress.Success == false && _newAddress.Message == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong at service layer when adding Address {createAddressDto}");
                return StatusCode(500, ModelState);
            }

            //Return new address created
            return CreatedAtRoute("GetCompanyAddressByGUID", new { CompanyGUID = _newAddress.Data.CompanyGUID }, _newAddress);

        }

        /// <summary>
        /// Update an existing address
        /// </summary>
        /// <param name="addressGUID"></param>
        /// <param name="updateAddressyDto"></param>
        /// <returns></returns>
        //PUT/Address/{Guid}
        [HttpPut("{addressGUID:Guid}", Name = "UpdateAddress")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<IActionResult> UpdateAddress(Guid addressGUID, [FromBody] UpdateAddressDto updateAddressyDto)
        {
            if (updateAddressyDto == null || updateAddressyDto.GUID != addressGUID)
            {
                return BadRequest(ModelState);
            }


            var _updateAddress = await _addrService.UpdateAddressAsync(updateAddressyDto);

            if (_updateAddress.Success == false && _updateAddress.Message == "NotFound")
            {
                ModelState.AddModelError("", "Address Not found");
                return StatusCode(404, ModelState);
            }
            //only for Demo in production never send response back about internal error.
            if (_updateAddress.Success == false && _updateAddress.Message == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong at repository layer when adding Address {updateAddressyDto}");
                return StatusCode(500, ModelState);
            }
            //only for Demo in production never send response back about internal error.
            if (_updateAddress.Success == false && _updateAddress.Message == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong at service layer when adding Address {updateAddressyDto}");
                return StatusCode(500, ModelState);
            }


            return Ok(_updateAddress);
        }

        /// <summary>
        /// Mark a address as deleted.
        /// </summary>
        /// <param name="addressGUID"></param>
        /// <returns></returns>
        //DELETE/Address/{Guid} 
        [HttpDelete("{addressGUID:Guid}", Name = "DeleteAddress")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status409Conflict)] //Can not be removed 
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<IActionResult> DeleteAddress(Guid addressGUID)
        {

            var _deleteAddress = await _addrService.SoftDeleteAddressAsync(addressGUID);

            if (_deleteAddress.Success == false && _deleteAddress.Data == "NotFound")
            {
                ModelState.AddModelError("", "Address Not found");
                return StatusCode(404, ModelState);
            }

            //only for Demo in production never send response back about internal error.
            if (_deleteAddress.Success == false && _deleteAddress.Data == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong at Repository layer when deleting Address");
                return StatusCode(500, ModelState);
            }
            //only for Demo in production never send response back about internal error.
            if (_deleteAddress.Success == false && _deleteAddress.Data == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong at service layer when deleting Address");
                return StatusCode(500, ModelState);
            }

            return NoContent();

        }
    }
}

If you have read my previous article How to Web API .Net Core Basics to Advanced Part 4 Service Layer in which we implemented service layer. I have given below a basic example and left a few methods out. I am hoping you guys will love to try out completing the rest of the code for AddressTypeService, AddressService, AddressRepository and AddressTypeRepository.

Interface for AddressTypeService



public interface IAddressTypeService
    {
      /// <summary>
      /// Return all addresstypes which are not marked as deleted and enabled=false
      /// </summary>
      /// <returns>List Of AddressTypeDto</returns>
      Task<ServiceResponse<List<AddressTypeDto>>> GetAddressTypeAsync();
      /// <summary>
      /// Return addresstype.
      /// </summary>
      /// <param name="Id"></param>
      /// <returns>AddressTypeDto</returns>
      Task<ServiceResponse<AddressTypeDto>> GetByIdAsync(int Id);
}

Implimetation of AddressType



public class AddressTypeService : IAddressTypeWrapper
{
   private readonly IAddressTypeRepository _addrTypeRep;
   private readonly IMapper _mapper;

public AddressTypeService(IAddressTypeRepository addressTypeRepository, IMapper mapper)
{
  _addrTypeRep = addressTypeRepository;
  _mapper = mapper;
 }

 /// <summary>
 /// return all addresstypes which are not marked as deleted and enabled.
 /// </summary>
 /// <returns>AddressTypeDto</returns>
 public async Task<ServiceResponse<List<AddressTypeDto>>> GetAddressTypeAsync()
 {

     ServiceResponse<List<AddressTypeDto>> _response = new();
     var AddressTypeList = await _addrTypeRep.GetAddressesType();

     var AddressTypeListDto = new List<AddressTypeDto>();

     foreach (var item in AddressTypeList)
     {
        AddressTypeListDto.Add(_mapper.Map<AddressTypeDto>(item));
     }

       _response.Success = true;
       _response.Message = "ok";
       _response.Data = AddressTypeListDto;
       return _response;

 }

 /// <summary>
 /// return addresstype.
 /// </summary>
 /// <param name="Id"></param>
 /// <returns>AddressTypeDto</returns>
 public async Task<ServiceResponse<AddressTypeDto>> GetByIdAsync(int Id)
 {
   if (Id <= 0) throw new ArgumentOutOfRangeException("id");

   ServiceResponse<AddressTypeDto> _response = new();

   var _address = await _addrTypeRep.GetAddressTypeByIDAsync(Id);

   if (_address == null)
   {
      _response.Success = true;
      _response.Message = "NotFound";
      _response.Data = null;
      return _response;
   }

   var _addressTypeDto = _mapper.Map<AddressTypeDto>(_address);

   _response.Success = true;
   _response.Message = "ok";
   _response.Data = _addressTypeDto;

   return _response;

}

}
}

Repo AddressType Interface



public interface IAddressTypeRepository
{
Task<ICollection<Entities.AddressType>> GetAddressesType();
Task<Entities.AddressType> GetAddressTypeByIDAsync(int addressTypeId);
}

Repo AddressType



public class AdressTypeRepository : IAddressTypeRepository
    {
        private readonly DataContext dataContext;

        public AdressTypeRepository(DataContext dataContext)
        {
            this.dataContext = dataContext; 
       }
 public async Task<ICollection<Entities.AddressType>> GetAddressesType()
        {
            return await dataContext.AddressTypes.Where(AT => AT.IsDeleted == false && AT.IsEnabled == true).ToListAsync();
        }

 public async Task<Entities.AddressType> GetAddressTypeByIDAsync(int addressTypeId)
        {
            return await dataContext.AddressTypes.SingleOrDefaultAsync(AT => AT.Id == addressTypeId);

        }


}

Address Repo Interface



public interface IAddressRespository
    {   
        /// </summary>
        /// <param name="companyGUID"></param>
        /// <returns>Entites.Address</returns>
        Task<ICollection<Entities.Address>> GetCompanyAddresses(Guid companyGUID);    
        /// </summary>
        /// <param name="addressGUID"></param>
        /// <returns>Entites.Address</returns>
        Task<Entities.Address> GetAddressByGUID(Guid addressGUID);
    }

Address Repo Implimentation



public class AddressRepository : IAddressRespository
    {
        private readonly DataContext _DbContext;

        public AddressRepository(DataContext dataContext)
        {
            _DbContext = dataContext;
        }


        public async Task<ICollection<Entities.Address>> GetCompanyAddresses(Guid companyGUID)
        {           
            return  await _DbContext.Addresses.Include(c => c.Company).Include(t=>t.AddressType).Where(a => a.CompanyGUID == companyGUID && a.IsDeleted==false).ToListAsync();

        }       

        public async Task<Entities.Address> GetAddressByGUID(Guid addressGUID)
        {          
            return await _DbContext.Addresses.Include(c => c.Company).Include(t => t.AddressType).SingleOrDefaultAsync(a => a.GUID == addressGUID && a.IsDeleted == false);
        }

        public async Task<Entities.Address> GetAddressByID(int addressId)
        {           
            return await _DbContext.Addresses.Include(c => c.Company).Include(t => t.AddressType).SingleOrDefaultAsync(a => a.Id == addressId && a.IsDeleted == false);
        }

    }

Hold on now don't get too excited
Yes we are almost done, but before we can fire up our project and view our API endpoints we need two more steps. First we need to setup DI DI-dependency-injection for our service layer in startup.cs file and have it ready to be injected when it is required.

Startup.cs



  // This method gets called by the runtime. Use this method to 
//add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddHealthChecks();

            services.AddDbContext<DataContext>(options => options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));
            //Add Automapper
            services.AddAutoMapper(typeof(Startup));
            //inject Data Access Layer - Repository
            services.AddScoped<ICompanyRepository, CompanyRepository>();
            services.AddScoped<IAddressRespository, AddressRepository>();
            services.AddScoped<IAddressTypeRepository, AdressTypeRepository>();
            //inject Service layer
            services.AddScoped<ICompanyService, CompanyService>();
            services.AddScoped<IAddressService, AddressService>();
            services.AddScoped<IAddressTypeService, AddressTypeService>();

            services.AddControllers();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "WebApiSeriesCore5", Version = "v1" });
            });
        }

Lets us try out HttpGet for our address api

We can see our Address Api endpoint expect a GUID of a company. Because we do not have any records in Address table we should get "not found" response as in example below.

Lets us try out HttpPost for our address api

To add company address we need to provide CompanyGUID and AddressTypeId as in json object below



{
  "companyGUID": "4ad95916-904e-44f5-b22b-9c6bed4ce3ce",
  "houseNoName": "23",
  "street": "Willow gradens",
  "city": "Lockewell",
  "county": "Estone",
  "postCode": "ET12 5RM",
  "createddate": "2022-10-16T10:57:31.339Z",
  "isEnabled": true,
  "isDeleted": false,
  "companyId": 1,
  "addressTypeId": 1
}

and api response after adding an address for a company is below.

and if we call HttpGet for address with company GUID we can now retrive address record for a company.

and json returned by HttpGet



{
  "data": [
    {
      "id": 1,
      "guid": "f0df8134-e42e-45e7-a986-00116a818861",
      "companyGUID": "4ad95916-904e-44f5-b22b-9c6bed4ce3ce",
      "houseNoName": "23",
      "street": "Willow gradens",
      "city": "Lockewell",
      "county": "Estone",
      "postCode": "ET12 5RM",
      "createddate": "2022-10-16T11:14:36.7777365+00:00",
      "isEnabled": true,
      "isDeleted": false,
      "companyId": 1,
      "company": {
        "id": 1,
        "guid": "4ad95916-904e-44f5-b22b-9c6bed4ce3ce",
        "companyName": "Company One",
        "createdDate": "2022-10-16T10:33:24.2222357+00:00",
        "isEnabled": true,
        "isDeleted": false
      },
      "addressTypeId": 1,
      "addressType": {
        "id": 1,
        "addressTypeName": "Office",
        "isEnabled": true,
        "isDeleted": false
      }
    }
  ],
  "success": true,
  "message": "ok",
  "error": null,
  "errorMessages": null
}

Part 7 API versioning Coming Soon
<<<Part 5 How to Web API .Net Core Controller And SwaggerUI
<<<Part 4 How to Web API Core set up Service Layer
<<<Part 3 How to Web API Core set up Data Access Layer
<<<Part 2 How to Web API Core set up Database Context
<<<Part 1 How to set up Web API core project

ICollection, IEnumerable, IList, IDictionary, Enumerator, Data Structures, Arrays, ArrayList, HashTable, Stack, Queue.

Manik — Thu, 12 May 2022 18:07:09 +0000

Data Structure
Data structure is a way to store data which makes it easier and efficient to retrieve data from persistent store in-memory and to perform additional functions on data. Simple Array is a linear data structure and so is:

Linked List
Stack
Queue

Collections
As the name suggests it is a collection of records related or unrelated data which is held in memory temporarily, some of the different types of collections are Queues, Stacks, Dictionaries, Lists and Hash Tables.

In C# System.Collections Namespace contains interfaces and classes that define various collections of objects mentioned above. What is more important when thinking about collections of records is to keep in mind what kind of collection we should use to store our records in memory.

Now the question is how do we decide what kind of collection to use? (list, queues, dictionaries) That depends on what we want to do with our collection of records, do we just want to read through those records in our collection or we may need to insert, update, remove or even filter them in future. It is always a good idea to take your time and think what kind of collection is best suited to retrieve and store data temporarily in memory.

To do that, I think first we should try to understand different kind of collections and what it means to iterate through a collection. We can basically divide collections in two sections one which only store a value for each element in a collection and second where every item stores both a Key and a Value.

Collections which store only Value.

Array
ArrayList
List<T>
Queue
ConcurrentQueue<T>
Stack
ConcurrentStack<T>
LinkedList<T>

Collection which store Key and Value.

Hashtable Recommended to use Generic Disctionary
SortedList<TKey,TValue>
Dictionary<TKey,TValue>
ConcurrentDictionary<TKey,TValue>

In C# we got different interfaces to handle collections for example IList<T>, ICollection<T>, IDictionary<TKey,TValue>, IEnumerable<T> etc. They all implement Iterator Pattern to iterate on a set of rows or collection of rows, so what is iteration and iterator.

Iterators
To understand iterators we need to understand what iteration means. In its most basic form, iteration means taking each element at a time in a collection of elements and going through them one after another. At any time we use a loop to go through a collection of rows it is called an iteration.



// Simple array is used to store city names
//which contain 3 element. We can iterate through 
//an array to get value of each item.

string[] citiesArray = new string[3]{ "Paris", "London", "Rome" };
//We going to loop through  an array 
for(int i = 0; i < citiesArray .Length; i++)
{
    Console.WriteLine(citiesArray[i]);  
}

Now what is an iterator? Simply put it is an object which defines how to iterate over a collection and what is the next element we can iterate to (Move Next). Iterator Design Pattern is used in every modern programming language to step through data structures or collections to provide some kind of iterator for example in C# foreach() that allows programmers or developers to iterate through its objects, without knowing underlying implementation.

In C# IEnumerable is the base interface for all collections that can be iterated on. To use generic version of IEnumerable we can use IEnumerable<T>. IEnumerable contains only one method, GetEnumerator, which returns an IEnumerator or IEnumerator<T> which supports a simple iteration over a non-generic and generic collection respectively. IEnumerator provides the ability to iterate through the collection by exposing.

Current (Property)
MoveNext and Reset (Methods)

Iterating over a collection is made simple in c# with the use of foreach keyword which enumerates a collection, executing the embedded statement once for each element in the collection:

Basic Differences Between IEnumerable and IEnumerator
IEnumerable has only one method (GetEnumerator), whereas IEnumerator has two methods (MoveNext and Reset). IEnumerable can only return IEnumerator, IEnumerable cannot retain the cursor's current state. But IEnumerator is a read-only, forward-only cursor over a collection of values and can retain the current cursor state.

IEnumerable
IEnumerable object is the logical representation of a collection of values, it is only suitable for iterating through collections because we cannot Add or Remove items which makes it read only. IEnumerable can not be instantiated from Enumerable, so it should be instantiated from other types of collection for example: List, Dictionary, stack etc.




//create IEnumerable of string (Give you error)
//IEnumerable<string>' does not contain a definition for 'Add'
IEnumerable<string> Weekdays = new List<string>();
Weekdays.Add("Monday");
Weekdays.Add("Tuesday");
Weekdays.Add("Wednesday");
Weekdays.Add("Thursday");
Weekdays.Add("Friday");
Weekdays.Add("Saturday");
Weekdays.Add("Sunday");

//create a list
IList<string> WeekdaysList = new List<string>();
WeekdaysList.Add("Monday");
WeekdaysList.Add("Tuesday");
WeekdaysList.Add("Wednesday");
WeekdaysList.Add("Thursday");
WeekdaysList.Add("Friday");
WeekdaysList.Add("Saturday");
WeekdaysList.Add("Sunday");

//create IEnumerable
//IEnumerable object WeekdaysList is 
//logical representation of a collection
IEnumerable<string> EnumerableOfWeekdaysList = 
(IEnumerable<string>)WeekdaysList;  

//OR 
//because List<T> is already an IEnumerable<T>
IEnumerable<string> EnumerableOfWeekdaysList = WeekdaysList;

//Retrieve all the items from this IEnumerable object
//WeekdaysList we are using foreach loop
foreach(string DaysOfWeek in EnumerableOfWeekdaysList)
{  
   Console.WriteLine(DaysOfWeek);  
}  


//create IEnumerator of string.
IEnumerator<string> EnumeratorOfWeekDays = 
WeekdaysList.GetEnumerator(); 

//Loop over the collection and display
//Monday
while (EnumeratorOfWeekDays.MoveNext())
{   
   if (EnumeratorOfWeekDays.Current == "Monday")
   {
      Console.WriteLine(EnumeratorOfWeekDays.Current);
   }

}

IEnumerable is used to hold data in memory from DB server or some other data source. Point to keep in mind when handling data in collections is not to have a lot of records in the memory as it will add a lot of overhead and reduce the amount of memory available for other tasks. Good practice is to only fetch records which are needed and hold them in memory for a short period of time.

ICollection
ICollection is the base interface for non-generic collections in system.collection namespace and to use generic interface for collections in C# we can use ICollection<T>, both ICollection and ICollection<T> extends or implements IEnumerable and IEnumerable<T> respectively but collections like IList, IDictionary, SortedList and others extends ICollection interface. Now the extra functions ICollection interface provide which are the ability to add, remove, update, delete and filter elements in memory. ICollection also holds the total number of elements and can be retrieved by using Count property.

Even though ICollection extend IEnumerable but one major difference between them other than extra functions exposed by ICollection interface is that we can get an index of an element in IEnumerable[i] but ICollection is not index based so we can't get ICollection[i].



//ICollection extends IDictionary<TKey,TValue> Explicitly

ICollection<KeyValuePair<int, int>> 
dict = new Dictionary<int, int>();

//Default implementations of collections in the 
//System.Collections.Generic namespace are not synchronized.

//Enumerating through a collection is intrinsically not a
//thread-safe procedure. Even when a collection is synchronized,

//other threads can still modify the collection, which can cause 
//the enumerator to throw an exception. To guarantee thread safety

//during enumeration, you can either lock the collection during 
//the entire enumeration or catch the exceptions resulting from 
//changes made by other threads.

bool sync = dict.IsSynchronized;





//Collection object can not be instantiated from ICollection, so
// it should be instantiated from List

System.Collections.Generic.ICollection<string> strICollection =
 new List<string>();

strICollection.Add("Madrid");
strICollection.Add("Spain");

//Countable***
int ICollectionCount=strICollection.Count;

//ICollection
ICollection<Company> listOfCompaniesCollection = new 
List<Company>();

listOfCompaniesCollection = 
(from cmp in _context.Companies
                  select cmp).ToList();

var companyObj = listOfCompaniesCollection.Where(i =>
 i.CompanyName == "Apple").FirstOrDefault();


//You can not get index of object, if you clear comment below 
//code it will give you an error.

//int indexofICollection = listOfCompaniesCollection.IndexOf();
int iCollectionCount = listOfCompaniesCollection.Count;

IList
IList extend ICollection

public interface IList : System.Collections.ICollection

and IList<T> extends

public interface IList<T> : System.Collections.Generic.ICollection<T>

Microsoft encourage the use of Generic collections and reason for example take an ArrayList which is similar to List but if we use a generic implementation List<T> one major difference is that List<T> is more efficient as compared to an ArrayList. Because List<T> is a collection of strongly typed objects which means compiler will know its Type at compile time instead of runtime which makes it run faster and as there is no need for boxing and unboxing which makes it more efficient.IList<T> extends ICollections<T> so it inherits all the functionality from ICollection and few more which are not implemented by ICollection for example: sorting, searching, Index[i] and modifying items in a the List<T>.

*Why do we need List? *
We may want to use IList<T> when we need to insert or remove an element in the middle of a list using an index[i] or if we need to order our list, because ICollection does not support indexing or sorting.



//IList***
System.Collections.Generic.IList<string> strIList = new List<string>();

//List of Company Object Type
System.Collections.Generic.IList<Company> listOfCompanies = 
new List<Company>();

listOfCompanies = (from cmp in _context.Companies
            select cmp).ToList();

company companyObj = listOfCompanies.Where(c => c.Name == 
"Microsoft").FirstOrDefault();

foreach (var item in listOfCompaniesCollection)
{
 int indexofICollection = listOfCompaniesCollection.IndexOf(item);
}

int contOfList = listOfCompaniesCollection.Count;

IDictionary
IDictionary
The IDictionary is base interface for generic collections which stores key/value pairs in no perticular order and it is also an interface for Dictionary same as ICollection or IList explained above. Dictionary Key must be unique and cannot be null but we can have Value as null or even duplicate and we can access the value by simply passing the key. Dictionary is generic version of [HashTable]. Dictionary is GENERIC but Hashtable is NON GENERIC. There is a tiny difference between them, dictionary will throw an exception if it cannot find specific key but HashTable will returns null instead of throwing an exception.



//Dictionary can create an object IDictionary<string, string> 
//countryCityNames = new Dictionary<string, string>();

//Create Dictionary
IDictionary<string, string> countryCityNames = new 
Dictionary<string, string>(); 

//adding a key/value using the Add() method
countryCityNames.Add("UK", "London");
countryCityNames.Add("Spain", "Madrid");
countryCityNames.Add("India", "Mumbai, New Delhi");

// update value of India key
cities["India"] = "Darjeeling, Asam"; 

//The code below throws run-time exception: key already added.
//numberNames.Add("UK", "London"); 

// removes UK key
cities.Remove("UK"); 

//prints values of India key.
Console.WriteLine(countryCityNames["India"]);

Array
Arrays remind me of days when I was studying computer science and my introduction to Single Dimension, Two Dimensional and Three Dimensional arrays. Just a quick and short example is below



//If we Add array elements at time of declaration then size is 
//optional because compiler will be able to decide its size based
//on the number of elements as in the case of "Single Dimensional
//Array" below.

//Single Dimensional Array c++
int Test1[]={5,4,8,10};

Two Dimensional Array



//Defining size C++
int twoDemnsionalArray[2][3] = {{1, 3, 0}}, {-1, 5, 9}};

Three Dimensional Array



//Three Dimensional Array c# 

int [, , ] threeDemnsionalArray = new int[3, 3, 3]{
                { { 1, 2, 3}, {4, 5, 6}, {4, 5, 6} },
                { { 7, 8, 9}, {10, 11, 12}, {4, 5, 6} },
                { { 7, 8, 9}, {10, 11, 12}, {4, 5, 6} }
            };

Arrays with predefined size and type will perform better as compared to when type and size is not defined for example. Let's assume we want an array of 3 elements of type Int. Because compiler already knows what is the type and exact size of an array it will perform better.



//Let us define string array and we can name it fruitArray
//which contain 3 element 

string[] fruitArray = new string[3]{ "Mango", "Apple", "Lemon" };

//loop through an array 
for(int i = 0; i < citiesArray .Length; i++)
{
    Console.WriteLine(citiesArray[i]);  
}

If you will like to read more about Arrays or Multidimensional Arrays

ArrayList
ArrayList is a non-generic collection of objects and it is the same as an Array except ArrayList size can increases or decrease dynamically. We should only use ArrayList when we encounter a situation where we are not sure about the size of our data and ArrayType (int, string, decimal etc). Now it is quite tempting to use ArrayList where it can increase and shrink in size dynamically at runtime. But But But it does come with some penalties, it will take longer as at runtime, compiler will determine size and Type of ArrayList.



//Belong to system.collection
using System.Collections; 

ArrayList citylist = new ArrayList(); 

//using ArrayList.Add() method
ArrayList dynamicObjectlist = new ArrayList();
dynamicObjectlist .Add("Madrid"); //string
dynamicObjectlist .Add(true);     //bool
dynamicObjectlist .Add("London"); //String
dynamicObjectlist .Add(2587);     //int
dynamicObjectlist .Add(4.5);      //double
dynamicObjectlist .Add(null);     //null

foreach (var item in dynamicObjectlist){
    Console.Write(item + "- "); 
}

//output 
Madrid- True- London- 2587- 4.5- -

//Insert in ArrayList
//1 is index position and we want to insert "New York" 
//we are pushing true bool to index position 2.  
dynamicObjectlist.Insert(1, "New York");

//output 
Madrid- New York- True- London- 2587- 4.5- -

//Let us remove first occurrence of null from ArrayList
dynamicObjectlist.Remove(null); 

//output
Madrid- New York- True- London- 2587- 4.5-

//Let us check if element exist in our ArrayList
dynamicObjectlist.Contains(Madrid)

//output
True Or False

Hash Table

The Hash Table is a non-generic type of collection which stores key-value pairs for each data block. It performs better when looking up data because rather than sorting the data according to a key, it computes the location of the data from the key. It implements a hashing function to improves data access times.

Hash Table can be created without setting its type or size which means it will be allocated memory at run time. We can say Hash Tables are kind of data structure which are non generic in nature and it allow us the freedom not to set the type and size.



//Lets create HasTable
Hashtable cityRanking= new Hashtable();

Add Key Value



cityRanking.Add(1,"London"); 
cityRanking.Add(2,"Paris");
cityRanking.Add(3,"Rome");

foreach(DictionaryEntry de in cityRanking){
    Console.WriteLine("Key: {0}, Value: {1}", de.Key, de.Value);
}

//out put       
//Key: 3, Value: Rome
//Key: 2, Value: Paris
//Key: 1, Value: London

//lets update a value in HashTable for key[2]

cityRanking[2]="Athens";

//out put
//Key: 3, Value: Rome
//Key: 2, Value: Athens
//Key: 1, Value: London

//Remove value from HashTable
if(cityRanking.ContainsKey("2")){ 
    cityRanking.Remove(2);
}

//out put
//Key: 3, Value: Rome
//Key: 1, Value: London

Stack
Stack is a kind of Data Structure which follows (Last In First Out) LIFO principal which means when we push new data it is inserted on top of the stack and when we remove a data item from the stack it will be the last one we inserted on top of the stack. So whatever we inserted last will be removed first. Stack is normally not strongly typed or either need fixed size but I always recommend if possible, to declare a Stack with a type (Stack<T>). By declaring Type of a Stack<T> it makes compile-time type checking possible and remove the need to perform boxing-unboxing because when we specify type for example (Stack numberStack = new Stack();) makes it non-generic.

Stack - Push
https://askanydifference.com/difference-between-stack-and-heap-with-table/



//Lets create a stack
Stack<int> numberStack = new Stack<int>();




//Lets push value in stack
numberStack.Push(110);
numberStack.Push(32);

foreach (var item in numberStack)
{
     Console.Write(item + ","); 
}
//out put
//32,110

Stack - Pop



//Remove the last element from stack
numberStack.Pop();
//out put 
//110

Stack - Peek



//Lets push value back on stack
numberStack.Push(32);

//Peek() returns the last value added
if(numberStack.Count > 0){
     Console.WriteLine(numberStack.Peek());      
}

//out put 
//32

Stack - Contains



numberStack.Contains(22); 
//out put 
//False

numberStack.Contains(32); 
//out put 
//true

Stack - Count



//Returns total number of items in stack
numberStack.Count
Console.Write("Count...." + numberStack.Count);
//out put
//Count....2

//Remove all items from stack
numberStack.Clear()

** Here is a more realife example**
It creates an empty list to hold the subfolder paths, and a stack to hold the subdirectories that need to be processed. It pushes the root folder path onto the stack.

It then enters a while loop that continues until the stack is empty. Inside the loop, it pops a folder path from the stack, adds it to the subfolders list, and gets the subdirectories of that folder using Directory.GetDirectories. It then pushes each subdirectory onto the stack.

After looping through subdirectories, it returns the subfolders list.



 public List<string> GetAllSubFoldersWithStack(string rootFolderPath)
        {
            var subFolders = new List<string>();
            var stack = new Stack<string>();
            stack.Push(rootFolderPath);

            while (stack.Count > 0)
            {
                var folderPath = stack.Pop();
                subFolders.Add(folderPath);
                var subDirectories = Directory.GetDirectories(folderPath);
                foreach (var subDirectory in subDirectories)
                {
                    stack.Push(subDirectory);
                }
            }

            return subFolders;
        }

Queue
Queue follows (First In First Out) FIFO principal which is opposite to Stack that is it :). In C# it can be generic Queue() and non-generic. It is not strongly typed and not of fixed size.

Queue



//Lets create a Queue
Queue<int> numberQueue = new Queue<int>();

Queue - Enqueue




//Lets push value in Queue
numberQueue .Enqueue(110);
numberQueue .Enqueue(32);

foreach (var item in numberQueue )
{
     Console.Write(item + ","); 
}
//out put
//32,110

Queue - Dequeue



//Remove the last element from Queue
numberQueue.Dequeue();
//out put 
//110

Queue - Peek



//Lets push value back on stack
numberQueue.Enqueue(32);

//Peek() returns the first item from a queue
if(numberQueue.Count > 0){
     Console.WriteLine(numberQueue.Peek());      
}

//out put 
//32

Queue - Contains



//Returns true if item is present
numberQueue.Contains(22); 
//out put 
//False

numberQueue.Contains(32); 
//out put 
//true

Queue - Count



//Returns total number of items in Queue 
numberQueue.Count
Console.Write("Count...." + numberQueue.Count);
//out put
//Count....2

//Remove all items from stack
numberQueue.Clear()

Data Access Layer

Manik — Sat, 30 Oct 2021 20:30:43 +0000

Data access layer helps us to isolate our code from presentation layer and business layer. We use data access layer to pull data from different data stores (database server, flat files, web services, whatever else). This way, if you have to bring any changes to your data layer for example we want to replace ORM, Database server or add web service repository to retrieve data. We wont end up rewriting the whole thing.

These days, various ORM frameworks blur the boundaries between different layers. This typically makes development easier and cuts development time, but it can cause a lot of problems as demand on application grows and we end up with spaghetti code. To be honest, changing database servers is very uncommon.

Basically there are two main reasons why we should use Data Access Layer.

It help us abstract the actual database or other data providers from our applications and that makes it easier to switch from using MySQL and moving to MS SQL server. On Business Layer side we can abstract the logical data model from our Business Layer making it loosely coupled and it also makes business layer agnostic about data access. Giving us the freedom to modify the data model without impacting the business layer.

Another reason our business layer should not be aware of the logical data model used by our application, is to allow changes in our business layer without having any effect on our physical data model. Lets take an example at some point in time in our applications life we need to retrieve data from third party web API and use it in our business logic, if our Business Layer is agnostic about data and how and from where it is retrieved, this allows us lot of freedom to improve or enhance our application. Modern tool sets like ORMs and Linq make life a lot easier which, in my opinion, encourages developers to cut corners under pressure to deliver applications quickly and tend to forget (or are not able to implement the separation between different layers that should exist).

Essentially, to get a better understanding the reasons and function of a Data Access Layer, you need to see things from Presentation and Business Layer's side, keeping in mind that presentation layer should be agnostic of business layer and business layer should be agnostic of the data access layer.

A data access layer follows the idea of "separation of concerns" whereby all of the logic required for your business layer to interact with your data layer is isolated to a single layer, as shown in the image below.

The reason behind me blabbering about Data Access Layer is because time and again colleagues and others were very adamant that data access frameworks, such as Entity Framework acts as Data access layer and (EF) which follows the repository pattern and it is acting as a data abstraction layer. But, I hold a different opinion and I think ORMs have its place but they can make your application very inefficient if we fail to use them effectively. Some of the performance related issues are well known, for example:

Majority of the time when I migrated a legacy application it was normally a big fat monolith and the most of the Linq statements were DataContext.TableName.where(Some Condition EqualTo) which basically translates to (select * from table where condition) In reality we may only need two fields from a table that has 100 fields.
In order to do a delete or update, (EF) first select the record and then fire a query to the delete or update.

3) ORMS tie your business layer very closely to the data model, defeating the whole concept of "Separation of concerns" and reason why we should have a data access layer.

I personally always implement a class library in my data access layer where I can write SQL queries which are a lot more efficient as compared to Linq, especially when we need to retrieve a large set of data from several tables. You can call it a hybrid application which make use of EF and SQL.

How to Web API .Net Core Basics to Advanced Part 5 Controller And SwaggerUI

Manik — Sat, 30 Oct 2021 12:45:01 +0000

What are Controllers?

Controllers are the first point of contact for an ASP.NET Web API Core 5 application. They process incoming requests and depending upon how the application is structured, it may pass the request to service layer as in our case to perform operations on Model data and return a response as JSON or SOAP but, we are going to work with JSON response in this post. Controllers are stored inside the Controllers folder, they are basically C# classes whose public methods are called Action Methods. These Action Methods handle the HTTP request and prepares the response to be sent to the client.

In the image below we have a Model which represents our data and controllers, which are responsible to process incoming requests and views can be any of the UI's ASP.Net MVC Web App, Angular, React or a mobile application which can consume our Web API.

Controllers are classes which are derived from ControllerBase class in ASP.Net Core 5 and onwards, one of the important points to remember while working with Controller class, is that it must have a “Controller” suffix. For example, if you want to add a controller with the name Company, then the name of the controller should be CompanyController. Similarly, if you want to add a controller for Address, then the name should be AddressController. Controller class must inherit from the ControllerBase class.

The ControllerBase class provides many properties and methods that are useful for handling HTTP requests. For more information click the link. To find more about Controllers click me

Here are some examples of methods that ControllerBase provides.

Method	Return
BadRequest	Returns 400 status code.
NotFound	Returns 404 status code.
PhysicalFile	Returns a file.
NoContent	Returns no content.

Enough of the theory let us create a controller.
To Add a controller right click the controller folder in solution explorer and select Add->Controller

Next we are going to name our controller, so our first controller is going to be company as in image below.

We will end up with the basic template of Web API controller



using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace WebApiSeriesCore5.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CompanyController : ControllerBase
    {
    }
}

How to Use Get Put Post Delete
To start with, I will like to get a list of companies and to do that we can use [HttpGet] in our controller as you can see in the example code below.



[HttpGet]
[ProducesResponseType(StatusCodes.Status200OK, Type = typeof(List<CompanyDto>))]
public async Task<IActionResult> GetAll()
{            
       return OK();
}

In the above code I have added two things first one is, ProducesResponseType An IActionResult method in a controller can return multiple response types and paths, using [ProducesResponseType] attribute is a good practice. It helps to produce more descriptive response for web API help pages generated by tools like Swagger. It also narrows down known response types and HTTP status codes to be returned by the action. To find more about ProducesResponseType click me

async which is out of scope of this project but I encourage you to go explore and experiment with async code and learn how to use it and how to implement it.

If you have read my previous article How to Web API .Net Core Basics to Advanced Part 4 Service Layer in which we implemented service layer. So lets inject our service object in our controller to interact with our data.



using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace WebApiSeriesCore5.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CompanyController : ControllerBase
    {
        private readonly ICompanyService _companyService;

        public CompanyController(ICompanyService companyService)
        {
            this._companyService = companyService;
        }

        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(List<CompanyDto>))]
        public async Task<IActionResult> GetAll()
        {
            var companies = await _companyService.GetCompaniesAsync();

            return Ok(companies);
        }

    }
}

Even though I have provided complete controller in the example below, including if you notice GetByGUID(Guid CompanyGUID) the method is commented and if you add, remove or edit any part of comments on top of methods it will reflect on swagger UI. I would suggest try and add HttpPost, HttPut, HttpPatch and HttpDelete yourself and have fun with them. Try parameter binding with primitive types and using complex types because that is the best way to learn when you are enjoying it.



using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WebApiSeriesCore5.Dtos.Company;
using WebApiSeriesCore5.Service.Contract;

namespace WebApiSeriesCore5.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CompanyController : ControllerBase
    {
        private readonly ICompanyService _companyService;

        public CompanyController(ICompanyService companyService)
        {
            this._companyService = companyService;
        }


        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(List<CompanyDto>))]
        public async Task<IActionResult> GetAll()
        {
            var companies = await _companyService.GetCompaniesAsync();

            return Ok(companies);
        }

        [HttpGet("{CompanyID:int}", Name = "GetByCompanyID")]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CompanyDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<CompanyDto>> GetCompanyID(int CompanyID)
        {
            if (CompanyID <=0)
            {
                return BadRequest(CompanyID);
            }
            var CompanyFound = await _companyService.GetByIdAsync(CompanyID);

            if (CompanyFound.Data == null)
            {
                return NotFound();
            }

            return Ok(CompanyFound);

        }



        /// <summary>
        /// Get Company by GUID.
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <returns></returns>
        //GET/companies/123
        [HttpGet("{CompanyGUID:Guid}", Name = "GetCompanyByGUID")]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CompanyDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesDefaultResponseType]
        public async Task<ActionResult<CompanyDto>> GetByGUID(Guid CompanyGUID)
        {

            if (CompanyGUID == Guid.Empty)
            {
                return BadRequest(CompanyGUID);
            }

            var company = await _companyService.GetByGUIDAsync(CompanyGUID);

            if (company.Data == null)
            {

                return NotFound();
            }

            return Ok(company);
        }

        /// <summary>
        /// Create a new company Record.
        /// </summary>
        /// <param name="createCompanyDto"></param>
        /// <returns></returns>
        //POST /Companies
        [HttpPost]
        [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CompanyDto))]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<ActionResult<CompanyDto>> CreateCompany([FromBody] CreateCompanyDto createCompanyDto)
        {
            if (createCompanyDto == null)
            {
                return BadRequest(ModelState);
            }

            if (!ModelState.IsValid) { return BadRequest(ModelState); }

            var _newCompany = await _companyService.AddCompanyAsync(createCompanyDto);

            if (_newCompany.Success == false && _newCompany.Message == "Exist")
            {
                return Ok(_newCompany);
            }


            if (_newCompany.Success == false && _newCompany.Message == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong in respository layer when adding company {createCompanyDto}");
                return StatusCode(500, ModelState);
            }

            if (_newCompany.Success == false && _newCompany.Message == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong in service layer when adding company {createCompanyDto}");
                return StatusCode(500, ModelState);
            }

            //Return new company created
            return CreatedAtRoute("GetCompanyByGUID", new { CompanyGUID = _newCompany.Data.GUID }, _newCompany);

        }

        /// <summary>
        /// Update existing company record.
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <param name="updateCompanyDto"></param>
        /// <returns></returns>
        //PUT/Companies/id
        [HttpPatch("{CompanyGUID:Guid}", Name = "UpdateCompany")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<IActionResult> UpdateCompany(Guid CompanyGUID, [FromBody] UpdateCompanyDto updateCompanyDto)
        {
            if (updateCompanyDto == null || updateCompanyDto.GUID != CompanyGUID)
            {
                return BadRequest(ModelState);
            }


            var _updateCompany = await _companyService.UpdateCompanyAsync(updateCompanyDto);

            if (_updateCompany.Success == false && _updateCompany.Message == "NotFound")
            {
                return Ok(_updateCompany);
            }

            if (_updateCompany.Success == false && _updateCompany.Message == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong in respository layer when updating company {updateCompanyDto}");
                return StatusCode(500, ModelState);
            }

            if (_updateCompany.Success == false && _updateCompany.Message == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong in service layer when updating company {updateCompanyDto}");
                return StatusCode(500, ModelState);
            }


            return Ok(_updateCompany);
        }

        /// <summary>
        /// Mark a record as deleted .
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <returns></returns>
        //DELETE /companies/{id}
        [HttpDelete("{CompanyGUID:Guid}")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)] //Not found
        [ProducesResponseType(StatusCodes.Status409Conflict)] //Can not be removed 
        [ProducesResponseType(StatusCodes.Status500InternalServerError)]
        public async Task<IActionResult> DeleteCompany(Guid CompanyGUID)
        {

            var _deleteCompany = await _companyService.SoftDeleteCompanyAsync(CompanyGUID);


            if (_deleteCompany.Success == false && _deleteCompany.Data == "NotFound")
            {
                ModelState.AddModelError("", "Company Not found");
                return StatusCode(404, ModelState);
            }

            if (_deleteCompany.Success == false && _deleteCompany.Data == "RepoError")
            {
                ModelState.AddModelError("", $"Some thing went wrong in Repository when deleting company");
                return StatusCode(500, ModelState);
            }

            if (_deleteCompany.Success == false && _deleteCompany.Data == "Error")
            {
                ModelState.AddModelError("", $"Some thing went wrong in service layer when deleting company");
                return StatusCode(500, ModelState);
            }

            return NoContent();

        }
    }
}

Before we run our API lets make sure we have registered our service and repository objects for DI in startup.cs



 // This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
    services.AddHealthChecks();
    services.AddDbContext<DataContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

   //Add Automapper
   services.AddAutoMapper(typeof(Startup));
   //inject Data Access Layer - Repository
   services.AddScoped<ICompanyRepository, CompanyRepository>();

   //inject Service layer
   services.AddScoped<ICompanyService, CompanyService>();           

   services.AddControllers();
   services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "WebApiSeriesCore5", Version = "v1" });
            });
 }

Now lets run our API

Response
Because we don't have any records in our table we get an empty json response.

Post Let us add one record.

Get Let us get that record we just added.

>>Part 6 Web API Core Controllers
<<<Part 4 How to Web API Core set up Service Layer
<<<Part 3 How to Web API Core set up Data Access Layer
<<<Part 2 How to Web API Core set up Database Context
<<<Part 1 How to set up Web API core project

How to Web API .Net Core Basics to Advanced Part 4 Service Layer

Manik — Mon, 12 Jul 2021 14:29:12 +0000

Service Layer
Welcome back!

In AspNet Core Web API Basics Part 3 Data Access Layer article we talked about separation of concern and how to isolate our application in different layers based on their domain and we implemented Data Access Layer by using Repository pattern. In this article we are going to Implement Business Layer.

To implement our Business/Service layer we will also make use of Dtos to pass data from our Entities/Models to our presentation layer (Controller) which further isolate our front end.

*Question is what is a service layer? *
Service layer is the middle layer between presentation layer and data layer (Repository). It abstracts business logic from data access.This provides easier management, better abstraction and scalability.

We can start with creating five folders in our project, first one Service to keep our CompanyService.cs class file, at the same time let us create Contract folder inside Service folder to keep our interface class file ICompanyService.cs next, we can create a folder Dtos and create another folder called Company to keep our Company Dtos and the last folder ServiceResponder to keep our ServiceResponse.cs file which we will use to wrap our API response to provide a more meaningful response when a request is sent to our API.

Let us start by creating our Dtos

CompanyDto.cs



public class CompanyDto
    {

        public int Id { get; set; }
        public Guid GUID { get; set; }
        [Required]
        [RegularExpression(@"[a-zA-Z0-9._@+-]{2,150}",
              ErrorMessage = "The {0} must be 1 to 150 valid characters which are any digit, any letter and -._@+.")]
        [StringLength(150, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 2)]
        [Display(Name = "CompanyName")]
        public string CompanyName { get; set; }
        public DateTimeOffset CreatedDate { get; set; }
        public bool IsEnabled { get; set; }
        public bool IsDeleted { get; set; }
    }

CreateCompanyDto.cs



public class CreateCompanyDto
    {
        [Required(ErrorMessage = "Company name is required")]
        [MinLength(2, ErrorMessage = "Company Name can not be less than two characters")]
        [MaxLength(150, ErrorMessage = "Company Name to long")]
        public string CompanyName { get; set; }

    }

UpdateCompanyDto.cs



public class UpdateCompanyDto
    {
        public Guid GUID { get; set; }
        [Required]
        public string CompanyName { get; set; }        
        public bool IsEnabled { get; set; }
        public bool IsDeleted { get; set; }
    }

Once we are happy with our Dtos we can create our generic API response wrapper.



public class ServiceResponse<T>
     /// <summary>
    /// Generic wrapper for web api response.       
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ServiceResponse<T>
    {

        public T Data { get; set; }
        public bool Success { get; set; } = true;
        public string Message { get; set; } = null;
        public string Error { get; set; } = null;
        public List<string> ErrorMessages { get; set; } = null;
    }

Now we can start writing code in our ICompanyService.cs and CompanyService.cs files.

ICompanyService.cs



    public interface ICompanyService
    {
        /// <summary>
        /// Return list of companies which are not marked as deleted.
        /// </summary>
        /// <returns>List Of CompanyDto</returns>
        Task<ServiceResponse<List<Dtos.Company.CompanyDto>>> GetCompaniesAsync();
        /// <summary>
        /// Return company record.
        /// </summary>
        /// <param name="Id"></param>
        /// <returns>CompanyDto</returns>
        Task<ServiceResponse<Dtos.Company.CompanyDto>> GetByIdAsync(int Id);
        /// <summary>
        /// Return company record.
        /// </summary>
        /// <param name="guid"></param>
        /// <returns>CompanyDto</returns>
        Task<ServiceResponse<Dtos.Company.CompanyDto>> GetByGUIDAsync(Guid guid);
        /// <summary>
        /// Add new company record in db
        /// </summary>
        /// <param name="createCompanyDto"></param>
        /// <returns>CompanyDto</returns>
        Task<ServiceResponse<Dtos.Company.CompanyDto>> AddCompanyAsync(Dtos.Company.CreateCompanyDto createCompanyDto);
        /// <summary>
        /// Update company record
        /// </summary>
        /// <param name="updateCompanyDto"></param>
        /// <returns>CompanyDto</returns>
        Task<ServiceResponse<Dtos.Company.CompanyDto>> UpdateCompanyAsync(Dtos.Company.UpdateCompanyDto updateCompanyDto);
        /// <summary>
        /// Mark the company record as deleted
        /// </summary>
        /// <param name="guid"></param>
        /// <returns>bool</returns>
        Task<ServiceResponse<string>> SoftDeleteCompanyAsync(Guid guid);

    }

And here is our ICompanyService.cs file. Before we start implementing our service class let us first install another package AutoMapper.Extensions.Microsoft.DependencyInjections after that we can create a new folder called mapper and add a class file .... I am going to call it DtoMapping.cs, you can name it what ever you think is best.

Basic example how to use AutoMapper

In Startup.cs file we need initialize AutoMapper.



public void ConfigureServices(IServiceCollection services)
{
    services.AddAutoMapper(typeof(Startup));    
}

Now in DtoMapping.cs file we can set up mapping.



 Public DtoMapping()
        {
            CreateMap<Company, CompanyDto>().ReverseMap();           
        }

Once we have set up mapping between our Dtos and Entities we can set up our service class.




public class CompanyService : ICompanyService
    {
        private readonly ICompanyRepository _compRepo;
        private readonly IMapper _mapper;

        public CompanyService(ICompanyRepository companyRepository, IMapper mapper)
        {
            this._compRepo = companyRepository;
            this._mapper = mapper;
        }
        public async Task<ServiceResponse<CompanyDto>> AddCompanyAsync(CreateCompanyDto createCompanyDto)
        {
            ServiceResponse<CompanyDto> _response = new();
            try
            {


                //Check If company exist
                if (await _compRepo.CompanyExistAsync(createCompanyDto.CompanyName))
                {
                    _response.Message = "Exist";
                    _response.Success = false;
                    _response.Data = null;
                    return _response;

                }

                Entities.Company _newCompany = new()
                {

                    CompanyName = createCompanyDto.CompanyName,
                    GUID = Guid.NewGuid(),
                    CreatedDate = DateTimeOffset.UtcNow,
                    IsEnabled = true,
                    IsDeleted = false
                };

                //Add new record
                if (!await _compRepo.CreateCompanyAsync(_newCompany))
                {
                    _response.Error = "RepoError";
                    _response.Success = false;
                    _response.Data = null;
                    return _response;
                }

                _response.Success = true;
                _response.Data = _mapper.Map<CompanyDto>(_newCompany);
                _response.Message = "Created";

            }
            catch (Exception ex)
            {
                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };

            }
            return _response;
        }

        public async Task<ServiceResponse<CompanyDto>> GetByGUIDAsync(Guid CompanyGUID)
        {
            ServiceResponse<CompanyDto> _response = new();

            try
            {

                var _Company = await _compRepo.GetCompanyByGUIDAsync(CompanyGUID);

                if (_Company == null)
                {
                    _response.Success = false;
                    _response.Message = "NotFound";
                    return _response;
                }

                var _CompanyDto = _mapper.Map<CompanyDto>(_Company);

                _response.Success = true;
                _response.Message = "ok";
                _response.Data = _CompanyDto;


            }
            catch (Exception ex)
            {
                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };
            }

            return _response;
        }

        public async Task<ServiceResponse<CompanyDto>> GetByIdAsync(int Id)
        {
            ServiceResponse<CompanyDto> _response = new();

            try
            {


                var _Company = await _compRepo.GetCompanyByIDAsync(Id);

                if (_Company == null)
                {

                    _response.Success = false;
                    _response.Message = "Not Found";
                    return _response;
                }

                var _CompanyDto = _mapper.Map<CompanyDto>(_Company);

                _response.Success = true;
                _response.Message = "ok";
                _response.Data = _CompanyDto;

            }
            catch (Exception ex)
            {
                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };
            }

            return _response;
        }

        public async Task<ServiceResponse<List<CompanyDto>>> GetCompaniesAsync()
        {
            ServiceResponse<List<CompanyDto>> _response = new();

            try
            {

                var CompaniesList = await _compRepo.GetCompaniesAsync();

                var CompanyListDto = new List<CompanyDto>();

                foreach (var item in CompaniesList)
                {
                    CompanyListDto.Add(_mapper.Map<CompanyDto>(item));
                }

                //OR 
                //CompanyListDto.AddRange(from item in CompaniesList select _mapper.Map<CompanyDto>(item));
                _response.Success = true;
                _response.Message = "ok";
                _response.Data = CompanyListDto;

            }
            catch (Exception ex)
            {
                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };
            }

            return _response;
        }

        public async Task<ServiceResponse<string>> SoftDeleteCompanyAsync(Guid CompanyGUID)
        {
            ServiceResponse<string> _response = new();

            try
            {
                //check if record exist
                var _existingCompany = await _compRepo.CompanyExistAsync(CompanyGUID);

                if (_existingCompany == false)
                {
                    _response.Success = false;
                    _response.Message = "NotFound";
                    _response.Data = null;
                    return _response;

                }

                if (!await _compRepo.SoftDeleteCompanyAsync(CompanyGUID))
                {
                    _response.Success = false;
                    _response.Message = "RepoError";
                    return _response;
                }



                _response.Success = true;
                _response.Message = "SoftDeleted";

            }
            catch (Exception ex)
            {

                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };
            }
            return _response;
        }

        public async Task<ServiceResponse<CompanyDto>> UpdateCompanyAsync(UpdateCompanyDto updateCompanyDto)
        {
            ServiceResponse<CompanyDto> _response = new();

            try
            {
                //check if record exist
                var _existingCompany = await _compRepo.GetCompanyByGUIDAsync(updateCompanyDto.GUID);

                if (_existingCompany == null)
                {
                    _response.Success = false;
                    _response.Message = "NotFound";
                    _response.Data = null;
                    return _response;

                }

                //Update
                _existingCompany.CompanyName = updateCompanyDto.CompanyName;
                _existingCompany.IsEnabled = updateCompanyDto.IsEnabled;
                _existingCompany.IsDeleted = updateCompanyDto.IsDeleted;

                if (!await _compRepo.UpdateCompanyAsync(_existingCompany))
                {
                    _response.Success = false;
                    _response.Message = "RepoError";
                    _response.Data = null;
                    return _response;
                }

                //Map updateCompanyDto To Company
                var _companyDto = _mapper.Map<CompanyDto>(_existingCompany);
                _response.Success = true;
                _response.Message = "Updated";
                _response.Data = _companyDto;

            }
            catch (Exception ex)
            {

                _response.Success = false;
                _response.Data = null;
                _response.Message = "Error";
                _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };
            }
            return _response;
        }
    }

Point To Note In my projects I never return exception in my service response because application exception should not be exposed to front-end, I am only using it here as an example. I prefer to log application exception.



 _response.ErrorMessages = new List<string> { Convert.ToString(ex.Message) };

Well done! We managed to get our service layer up and running, time to move on and set up our presentation layer which is controllers. In the next article we are going to set up our first controller.

>>>Part 5 How to Web API Core Controllers/Get/Put/Post/Delete

<<<Part 3 How to Web API Core set up Data Access Layer
<<<Part 2 How to Web API Core set up Database Context
<<<Part 1 How to set up Web API core project

How to Web API AspNet Core Basics Data Access Layer

Manik — Sat, 10 Jul 2021 10:35:20 +0000

Welcome back!

Now I wont be surprised if smart people like you have already figured out what a mess single tier application can be as the image below shows.

If you look at the image above, we have a presentation logic, business logic and data access problems rolled in one single tier. Imagine, we need to make changes to build new features as demand on our software increases. Now any changes we make will require major code change because it will affect all three layers.

To solve these problems we use "separation of concerns" as shown in the image below. We are isolating our presentation data (Controllers) from our business layer (Service Layer) and our data layer (Repository). This allows us to easily make changes to all three layers for example, business layer has no knowledge about data layer and how it handles data and so by introducing separation of concerns gives us a lot of flexibility. If you will like to read more about Importance Of Data Access Layer

Let us now get down to business and implement our Data Access Layer. We should create a folder called Repository and add a class file CompanyRepository.cs inside the folder. I am going to create another folder inside Repository folder and call it Contract, where we going to add my interface class file and I am going to name it ICompanyRepository.cs surprise surprise :). If you will like to read more about Repository Pattern.

We can now go head and add some code to our interface to define the methods we want in our Data layer.

ICompanyRepository.cs



public interface ICompanyRepository
    {

        /// <summary>
        /// Return all companies including records marked as deleted and disabled
        /// </summary>
        /// <returns>Entites.Company</returns>
        Task<ICollection<Entities.Company>> GetAllCompaniesAsync();
        /// <summary>
        /// Return list of companies which are not marked as deleted.
        /// </summary>
        /// <returns>Entites.Company</returns>
        Task<ICollection<Entities.Company>> GetCompaniesAsync();
        /// <summary>
        /// Return list of companies which are marked as deleted
        /// </summary>
        /// <returns>Entites.Company</returns>
        Task<ICollection<Entities.Company>> GetDeletedCompaniesAsync();
        /// <summary>
        /// Return list of companies which are marked as disabled
        /// </summary>
        /// <returns>Entites.Company</returns>
        Task<ICollection<Entities.Company>> GetDisabledCompaniesAsync();
        /// <summary>
        /// Return a company record
        /// </summary>
        /// <param name="CompanyId"></param>
        /// <returns>Entites.Company</returns>
        Task<Entities.Company> GetCompanyByIDAsync(int CompanyId);
        /// <summary>
        /// Return a company record
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <returns>Entites.Company</returns>
        Task<Entities.Company> GetCompanyByGUIDAsync(Guid CompanyGUID);
        /// <summary>
        /// Return True/False if record exist
        /// </summary>
        /// <param name="CompanyName"></param>
        /// <returns>bool</returns>
        Task<bool> CompanyExistAsync(string CompanyName);
        /// <summary>
        /// Return True/False if record exist
        /// </summary>
        /// <param name="Id"></param>
        /// <returns>bool</returns>
        Task<bool> CompanyExistAsync(int Id);
        /// <summary>
        /// Return bool if record exist
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <returns>bool</returns>
        Task<bool> CompanyExistAsync(Guid CompanyGUID);
        /// <summary>
        /// Add a new record for company
        /// </summary>
        /// <param name="company"></param>
        /// <returns>bool</returns>
        Task<bool> CreateCompanyAsync(Entities.Company company);
        /// <summary>
        /// Update a record in db
        /// </summary>
        /// <param name="company"></param>
        /// <returns>bool</returns>
        Task<bool> UpdateCompanyAsync(Entities.Company company);
        /// <summary>
        /// Update a record as Deleted=True
        /// </summary>
        /// <param name="CompanyGUID"></param>
        /// <returns>bool</returns>
        Task<bool> SoftDeleteCompanyAsync(Guid CompanyGUID);
        /// <summary>
        /// Permanently remove a record from db
        /// </summary>
        /// <param name="company"></param>
        /// <returns></returns>
        Task<bool> HardDeleteCompanyAsync(Entities.Company company);

    }

This is our CompanyRepository.cs which is interacting with our Database server and separating our Presentation and business logic.



public class CompanyRepository : ICompanyRepository
    {
        private readonly DataContext _dataContext;

        public CompanyRepository(DataContext dataContext)
        {
            this._dataContext = dataContext;
        }
        public async Task<bool> CompanyExistAsync(string CompanyName)
        {
            return await _dataContext.Companies.AnyAsync(Comp => Comp.CompanyName.Contains(CompanyName));
        }

        public async Task<bool> CompanyExistAsync(int Id)
        {
            return await _dataContext.Companies.AnyAsync(Comp => Comp.Id == Id);
        }

        public async Task<bool> CompanyExistAsync(Guid CompanyGUID)
        {
            return await _dataContext.Companies.AnyAsync(Comp => Comp.GUID == CompanyGUID);
        }

        public async Task<bool> CreateCompanyAsync(Company company)
        {
            await _dataContext.Companies.AddAsync(company);
            return await Save();
        }
        public async Task<bool> UpdateCompanyAsync(Company company)
        {
            _dataContext.Companies.Update(company);
            return await Save();
        }

        public async Task<ICollection<Company>> GetAllCompaniesAsync()
        {
            return await _dataContext.Companies.ToListAsync();
        }

        public async Task<ICollection<Company>> GetCompaniesAsync()
        {
            return await _dataContext.Companies.Where(Comp => Comp.IsDeleted == false).ToListAsync();
        }

        public async Task<Company> GetCompanyByGUIDAsync(Guid CompanyGUID)
        {
            return await _dataContext.Companies.FirstOrDefaultAsync(Comp => Comp.GUID == CompanyGUID);
        }

        public async Task<Company> GetCompanyByIDAsync(int CompanyId)
        {
            return await _dataContext.Companies.FirstOrDefaultAsync(Comp => Comp.Id == CompanyId);
        }

        public async Task<ICollection<Company>> GetDeletedCompaniesAsync()
        {
            return await _dataContext.Companies.Where(Comp => Comp.IsDeleted == true).ToListAsync();
        }

        public async Task<ICollection<Company>> GetDisabledCompaniesAsync()
        {
            return await _dataContext.Companies.Where(Comp => Comp.IsEnabled == false).ToListAsync();
        }

        public async Task<bool> HardDeleteCompanyAsync(Company company)
        {
            _dataContext.Remove(company);
            return await Save();
        }

        public async Task<bool> SoftDeleteCompanyAsync(Guid CompanyGUID)
        {
            var _exisitngCompany = await GetCompanyByGUIDAsync(CompanyGUID);

            if (_exisitngCompany != null)
            {
                _exisitngCompany.IsDeleted = true;
                return await Save();
            }
            return false;
        }

        private async Task<bool> Save()
        {
            return await _dataContext.SaveChangesAsync() >= 0 ? true : false;
        }

    }

Now that was not too bad was it?
See you next time :)

Part 4 How to Web API Core Service Layer>

<<<Part 2 How to Web API Core set up Database Context
<<<Part 1 How to set up Web API core project

AspNet Core Web API Part2 DB

Manik — Thu, 08 Jul 2021 15:16:06 +0000

Configuring Data
Welcome back!

Every application in the modern world needs to work with data. Why not? We first deal with big fat DATA problems. To do this we can start with code first approach by creating Entities or Models, so let us create a folder in our project called Entities and after that we can add a class file and name it Company.cs. I am hoping you have some experience with entities.

Code First
In code first we should think about all the columns we want in our tables. We will need to declare them in entities class. I have given very basic examples of DataAnnotations and you should do your own research and use them accordingly.

Adding our model to database
In order to add our models to database we need to first set up a few things such as DB connection string, installing few nuget packages and configuring our Datacontext.

To start with we are going to add Database connection string to appsettings.json file.

Once you are happy with your appsettings.json changes we want to create our database and company table. To do this we need to set up our Database context object. Go ahead and add another folder to your project which I am going to call Data, you can call it what ever you feel comfortable with. Inside Data folder we are going to add class file and I am going to name it DataContext.cs, some people like to name it AppDataContext so it is up to you what you want to name it.

Now before we configure our Database Context we need Microsoft.EntityFrameworkCore, Microsoft.EntityFrameworkCore.Tools and Microsoft.EntityFrameworkCore.SqlServer nuget packages. You can add them by using nuget package manager or simply adding it in your .csproj file. Either way, you will see it appear in your .csproj file.

After installing Microsoft.EntityFrameworkCore we can get on with setting up our DataBase context object. Notice that our DataContext class is inheriting from DbContext which is part of Microsoft.EntityFrameworkCore all the heavy lifting is done by Entity Framework we just need to provide it with enough information.

public class DataContext:DbContext
{

public DataContext(DbContextOptions<DataContext> options)
 : base(options)  { }

    public DbSet <Entities.Company>  Companies { get; set; }

 }

Now we need to make sure we add our DataContext.cs file in startup.cs file. DotNet core comes with inbuilt dependency injection which makes it a lot easier for us to impliment IoC by using inbuilt IoC container, if you want to know more about Dependency injection in ASP.NET Core. Next, we are going to set up DataContext object so it can be injected when it is needed. To do that first, we need Microsoft.EntityFrameworkCore.SqlServer. We added SqlServer package in the last step so we can get on with configuring startup.cs file.

public void ConfigureServices(IServiceCollection services)
{

services.AddDbContext<DataContext>
(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

   services.AddControllers();
   services.AddSwaggerGen(c =>
    {
     c.SwaggerDoc("v1", new OpenApiInfo { Title = "AspNetWebApiSeriesCore5", Version = "v1" });
     });
}

Look at that! we are now all set to push it to our Database :) this is easy as most of the work is done by EF core. Go to tools in your Visual Studio IDE and select.

To set up our first migration, we can run add-migration AddCompanyToDB once build succeeded, we can run update-database command and that is it. Easy peasy! ;)

AspNet Core Web API Part 3 Data Access Layer >

Part 1 AspNet Core Web API project_