Implement Unit Of Work And Generic Repository pattern in a Web API .NET Core Project Using EF

public class Person {
    public int PersonId {
        get;
        set;
    }
    public string Name {
        get;
        set;
    }
    public int Age {
        get;
        set;
    }
    public Address Address {
        get;
        set;
    }
    public List < Email > Emails {
        get;
        set;
    }
}

public class Address {
    public int AddressId {
        get;
        set;
    }
    public string StreetAdress {
        get;
        set;
    }
    public string City {
        get;
        set;
    }
    public string State {
        get;
        set;
    }
    public string ZipCode {
        get;
        set;
    }
}

public class Email {
    public int EmailId {
        get;
        set;
    }
    public string EmailAdress {
        get;
        set;
    }
}

public class PeopleContext: DbContext {
    public PeopleContext(DbContextOptions options): base(options) {}
    public DbSet < Person > Person {
        get;
        set;
    }
    public DbSet < Address > Address {
        get;
        set;
    }
    public DbSet < Email > Email {
        get;
        set;
    }
}

public void ConfigureServices(IServiceCollection services) {
        services.AddDbContext < PeopleContext > (options => options.UseSqlServer(Configuration.GetConnectionString("Default")));

To create a database using Entity Framework is easy, we need to add a migration and send the create command to our local server. Let's create the database.

Open Package Manager Console, select DataAccesEF project as default project and type add-migration CreateInitialDB and press enter.

If everything was ok, you should see a Build succeeded message. Now let’s create the database by using another command, update-database and press enter.

Now we have a database created.

Creating Interfaces

In order to have a decupled environment we need to use as much as possible interfaces and these interfaces needs to be declared on Domain project, because we can replace Entity Framework

with another technology, but the application layer will still use the same interfaces.

Let’s create a Folder Interfaces and start creating them.

First, we need to create a Generic Repository interface for the Generic Repository Pattern which will be used by all repositories.

public interface IGenericRepository < T > where T: class {
    T GetById(int id);
    IEnumerable < T > GetAll();
    IEnumerable < T > Find(Expression < Func < T, bool >> expression);
    void Add(T entity);
    void AddRange(IEnumerable < T > entities);
    void Remove(T entity);
    void RemoveRange(IEnumerable < T > entities);
}

And now an interface for each model class. We keep them empty, for now

public interface IPersonRepository: IGenericRepository < Person > {}

public interface IAdressRepository: IGenericRepository < Address > {}

public interface IEmailRepository: IGenericRepository < Email > {}

And Unit of Work interface, which will be the connection layer between the WebAPI project and the repositories.

ublic interface IUnitOfWork: IDisposable {
    IAdressRepository Address {
        get;
    }
    IEmailRepository Email {
        get;
    }
    IPersonRepository Person {
        get;
    }
    int Save();
}

Save method was included here because we need to save changes to the database regardless of which repository have been changed.

After we added all the interfaces this how the project will look

Implement Repository’s and Unit of Work

Let’s go to DataAccessEF project to implement the repositories. We will start with the Generic Repository. We will create a class GenericRepository which will implement IGenericRepository.

This class will contain the implementation for all generic usages.

public class GenericRepository < T > : IGenericRepository < T > where T: class {
    protected readonly PeopleContext context;
    public GenericRepository(PeopleContext context) {
        this.context = context;
    }
    public void Add(T entity) {
        context.Set < T > ().Add(entity);
    }
    public void AddRange(IEnumerable < T > entities) {
        context.Set < T > ().AddRange(entities);
    }
    public IEnumerable < T > Find(Expression < Func < T, bool >> expression) {
        return context.Set < T > ().Where(expression);
    }
    public IEnumerable < T > GetAll() {
        return context.Set < T > ().ToList();
    }
    public T GetById(int id) {
        return context.Set < T > ().Find(id);
    }
    public void Remove(T entity) {
        context.Set < T > ().Remove(entity);
    }
    public void RemoveRange(IEnumerable < T > entities) {
        context.Set < T > ().RemoveRange(entities);
    }
}

As you can see here are all the implementation for basic CRUD operations which are used by all repositories. DRY 😊

Now let’s create a folder named TypeRepository and add the implementation for Address, Email and Person repositories.

class PersonRepository: GenericRepository < Person > , IPersonRepository {
    public PersonRepository(PeopleContext context): base(context) {}
}

class AddressRepository: GenericRepository < Address > , IAdressRepository {
    public AddressRepository(PeopleContext context): base(context) {}
}

class EmailRepository: GenericRepository < Email > , IEmailRepository {
    public EmailRepository(PeopleContext context): base(context) {}
}

All 3 classes are similar, only the types have changed, for now we will keep these classes as they are.

Now Unit of Work. We will create a folder named UnitOfWork and add the implementation class here.

public class UnitOfWork: IUnitOfWork {
    private PeopleContext context;
    public UnitOfWork(PeopleContext context) {
        this.context = context;
        Address = new AddressRepository(this.context);
        Email = new EmailRepository(this.context);
        Person = new PersonRepository(this.context);
    }
    public IAdressRepository Address {
        get;
        private set;
    }
    public IEmailRepository Email {
        get;
        private set;
    }
    public IPersonRepository Person {
        get;
        private set;
    }
    public void Dispose() {
        context.Dispose();
    }
    public int Save() {
        return context.SaveChanges();
    }
}

If all the was ok you should have something similar like this

Usage

Let's go to WebAPI project and start to implement the usage.

Add an injectable instance of UnitOfWork class in ConfigureServices () method from Startup.cs class.

public void ConfigureServices(IServiceCollection services) {
        services.AddDbContext < PeopleContext > (options => options.UseSqlServer(Configuration.GetConnectionString("Default")));
        services.AddTransient < IUnitOfWork, UnitOfWork > ();

Now let’s modify default WeatherForecast controller to a Person controller and inject UnitOfWork instance

[ApiController]
[Route("[controller]")]
public class PersonController: ControllerBase {
    private readonly IUnitOfWork unitOfWork;
    public PersonController(IUnitOfWork unitOfWork) {
            this.unitOfWork = unitOfWork;
        }
        [HttpGet]
    public IEnumerable < Person > GetAllPersons() {
        return unitOfWork.Person.GetAll();
    }
}

I have created a Get method which is returning all the person from the database. The controller knows only unit of work object and that’s it.

The person repository is inheriting Generic Repository which have implemented GetAll() method. This is an example of the usage Unit of Work with a Generic Repository

Extension to Repository

Let's go to Domain project, and edit IPersonRepository interface to add a method which returns all adult persons.

public interface IPersonRepository: IGenericRepository < Person > {
    IEnumerable < Person > GetAdultPersons();
}

Now let's go to DataAccessEF project and add the implementation for the method

class PersonRepository: GenericRepository < Person > , IPersonRepository {
    public PersonRepository(PeopleContext context): base(context) {}
    IEnumerable < Person > IPersonRepository.GetAdultPersons() {
        return context.Person.Where(pers => pers.Age >= 18).ToList();
    }
}

Finally lest use our new method in PersonController class, by adding a new GET method

public class PersonController: ControllerBase {
    private readonly IUnitOfWork unitOfWork;
    public PersonController(IUnitOfWork unitOfWork) {
            this.unitOfWork = unitOfWork;
        }
        [HttpGet]
    public IEnumerable < Person > GetAllPersons() {
            return unitOfWork.Person.GetAll();
        }
        [Route("[action]")]
        [HttpGet]
    public IEnumerable < Person > GetAdultPersons() {
        return unitOfWork.Person.GetAdultPersons();
    }
}

This is it. 😊

Conclusion

I strongly recommend to use this type of approach when you have more than 3 tables in your project because sooner than later it will become a headache to keep track with all the repository’s and don’t forget, DRY principle.