Dependency Injection Issue with Generic Repository and Specific Service in ASP.NET Core

Question

I am working on an ASP.NET Core project where I am using a generic repository pattern alongside specific services. I have implemented the following interfaces and classes:

Shared Interfaces:

namespace OPEG.Shared.Contracts
{
    public interface IEntity
    {
        int Id { get; set; }
    }

    public interface IEntityBaseRepository<T> where T : class, IEntity
    {
        Task<List<T>> GetAllAsync();
        Task<List<T>> GetAllAsync(params Expression<Func<T, object>>[] includeProperties);
        Task<T> GetByIdAsync(int id);
        Task AddAsync(T entity);
        Task AddRangeAsync(List<T> entities);
        Task UpdateAsync(int id, T entity);
        Task DeleteAsync(int id);
        Task DeleteRangeAsync(List<T> entities);
    }

    public interface IGradeService : IEntityBaseRepository<Grade>
    {
        Task<List<Subject>> GetAllSubjectsById(int id);
    }
}

API Project implementation

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.ChangeTracking;
using OPEG.Shared.Contracts;
using System.Linq.Expressions;

namespace OPEG.Api.Services
{
    public class EntityBaseRepository<T> : IEntityBaseRepository<T> where T : class, IEntity
    {
        private readonly OPEGContext _context;

        public EntityBaseRepository(OPEGContext context)
        {
            _context = context;
        }

        public async Task AddAsync(T entity)
        {
            await _context.Set<T>().AddAsync(entity);
            await _context.SaveChangesAsync();
        }

        public async Task<List<T>> GetAllAsync()
        {
            return await _context.Set<T>().ToListAsync();
        }

        public async Task<List<T>> GetAllAsync(params Expression<Func<T, object>>[] includeProperties)
        {
            IQueryable<T> query = _context.Set<T>();
            query = includeProperties.Aggregate(query, (current, includeProp) => current.Include(includeProp));
            return await query.ToListAsync();
        }

        public async Task<T> GetByIdAsync(int id)
        {
            return await _context.Set<T>().FirstOrDefaultAsync(e => e.Id == id);
        }

        public async Task UpdateAsync(int id, T entity)
        {
            EntityEntry entityEntry = _context.Entry(entity);
            entityEntry.State = EntityState.Modified;
            await _context.SaveChangesAsync();
        }

        public async Task DeleteAsync(int id)
        {
            var entity = await _context.Set<T>().FirstOrDefaultAsync(e => e.Id == id);
            if (entity != null)
            {
                EntityEntry entityEntry = _context.Entry(entity);
                entityEntry.State = EntityState.Deleted;
                await _context.SaveChangesAsync();
            }
        }

        public async Task AddRangeAsync(List<T> entities)
        {
            await _context.Set<T>().AddRangeAsync(entities);
            await _context.SaveChangesAsync();
        }

        public async Task DeleteRangeAsync(List<T> entities)
        {
            _context.Set<T>().RemoveRange(entities);
            await _context.SaveChangesAsync();
        }
    }

    public class GradeService : EntityBaseRepository<Grade>, IGradeService
    {
        private readonly OPEGContext _context;

        public GradeService(OPEGContext context) : base(context)
        {
            _context = context;
        }

        public async Task<List<Subject>> GetAllSubjectsById(int id)
        {
            return await _context.Subjects.Where(s => s.GradeId == id).ToListAsync();
        }
    }
}

DI Registration in Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<OPEGContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

// Generic repository registration
builder.Services.AddScoped(typeof(IEntityBaseRepository<>), typeof(EntityBaseRepository<>));

// Specific service registration
builder.Services.AddScoped<IGradeService, GradeService>();

var app = builder.Build();
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

I am using dotnet 8 framework and entityframeworkcore.sqlserver and entityframeworkcore.design with version 9.0.0 (latest) for my projects

The Problem: When I run the project, I encounter the following error during the DI registration:

errors:

1.CS0738'GradeService' does not implement interface member 'IGradeService.GetAllSubjectsById(int)'. 'GradeService.GetAllSubjectsById(int)' cannot implement 'IGradeService.GetAllSubjectsById(int)' because it does not have the matching return type of 'Task<List>'.

2.CS0535 'GradeService' does not implement interface member 'IEntityBaseRepository.GetAllAsync(params Expression<Func<Grade, object>>[])'

What I Tried: Verified that IGradeService is implemented correctly in GradeService. Ensured proper namespaces are being used. Rebuilt the solution multiple times. Registered both the generic repository and specific service in the DI container. What I Need Help With: Why am I getting this CS0535 and CS0738 error when registering the GradeService with the DI container? Is my inheritance and interface implementation approach correct for IEntityBaseRepository and IGradeService? How can I fix this DI issue while maintaining the generic repository pattern?

Answer 1

Modify the IGradeService.cs GetAllSubjectsById to be inherited by IEntityBaseRepository<Grade>

public interface IGradeService : IEntityBaseRepository<Grade>
{
    Task<List<Subject>> GetAllSubjectsById(int id);
}

And in the GradeService.cs Implementation :

public class GradeService : EntityBaseRepository<Grade>, IGradeService
{
    private readonly OPEGContext _context;

    public GradeService(OPEGContext context) : base(context)
    {
        _context = context;
    }

    public async Task<List<Subject>> GetAllSubjectsById(int id)
    {
        return await _context.Subjects.Where(s => s.GradeId == id).ToListAsync();
    }

}

Ensure the EntityBaseRepository uses the correct constraints that suits its interface.

public class EntityBaseRepository<T> : IEntityBaseRepository<T> where T : class, IEntity
{
    private readonly OPEGContext _context;

    public EntityBaseRepository(OPEGContext context)
    {
        _context = context;
    }

    public async Task AddAsync(T entity)
    {
        await _context.Set<T>().AddAsync(entity);
        await _context.SaveChangesAsync();
    }

    public async Task<List<T>> GetAllAsync()
    {
        return await _context.Set<T>().ToListAsync();
    }

    public async Task<List<T>> GetAllAsync(params Expression<Func<T, object>>[] includeProperties)
    {
        IQueryable<T> query = _context.Set<T>();
        query = includeProperties.Aggregate(query, (current, includeProp) => current.Include(includeProp));
        return await query.ToListAsync();
    }

    public async Task<T> GetByIdAsync(int id)
    {
        return await _context.Set<T>().FirstOrDefaultAsync(e => e.Id == id);
    }

    public async Task UpdateAsync(int id, T entity)
    {
        EntityEntry entityEntry = _context.Entry(entity);
        entityEntry.State = EntityState.Modified;
        await _context.SaveChangesAsync();
    }

    public async Task DeleteAsync(int id)
    {
        var entity = await _context.Set<T>().FirstOrDefaultAsync(e => e.Id == id);
        if (entity != null)
        {
            EntityEntry entityEntry = _context.Entry(entity);
            entityEntry.State = EntityState.Deleted;
            await _context.SaveChangesAsync();
        }
    }

    public async Task AddRangeAsync(List<T> entities)
    {
        await _context.Set<T>().AddRangeAsync(entities);
        await _context.SaveChangesAsync();
    }

    public async Task DeleteRangeAsync(List<T> entities)
    {
        _context.Set<T>().RemoveRange(entities);
        await _context.SaveChangesAsync();
    }
}

Finally in the Program.cs register the dependency like below:

builder.Services.AddScoped(typeof(IEntityBaseRepository<>), typeof(EntityBaseRepository<>));
builder.Services.AddScoped<IGradeService, GradeService>();

The above will help you resolve the issues mentioned in the error CS0738 and CS0535 errors and have a clean generic repository pattern.