Why don't have a generic method instead of DbSets ?

[komdil]

In my project, I have more than 20 tables, Does it mean that I need to create 20 DbSets in my IApplicationDbContext?
Currently, I am using the generic method and didn't create DbSet for each table:

I created the IDbEntity interface in Domain/Common folder. The purpose of this interface is: if an entity implements this interface it means it is db entity. It will not allow using any kind of class in my generic method (see below)

My IApplicationDbContext will have only GetDbSet generic method:

public interface IApplicationDbContext
{
    DbSet<T> GetDbSet<T>() where T : class, IDbEntity;

    Task<int> SaveChangesAsync(CancellationToken cancellationToken);
}

Implementation in ApplicationDbContext:

    public DbSet<T> GetDbSet<T>() where T : class, IDbEntity
    {
        return Set<T>();
    }

Why do I need this?
There will not be a lot of DbSets
If I need to add or remove a table in the future, I don't need to change my Application layer.

So, why do not make this change? Is there any design pattern/rule to separate DbSet for each table?

[komdil]

@jasontaylordev any comments?

[jasontaylordev]

In my project, I have more than 20 tables, Does it mean that I need to create 20 DbSets in my IApplicationDbContext?

Yes.

A lot of the time it comes down to personal preference. Do you prefer the convenience of specific properties or are you happy to code against Set<TEntity>. I prefer specific properties.

If you want to use Set<TEntity>, then you could simplify your implementation as follows:

public interface IApplicationDbContext
{
    DbSet<TEntity> Set<TEntity>() where TEntity : class;

    Task<int> SaveChangesAsync(CancellationToken cancellationToken);
}

You don't need to do anything else, that will just expose the existing Set<TEntity> implementation from the DbContext.

If I need to add or remove a table in the future, I don't need to change my Application layer.

This would only be true if the entity was never used. More likely you will have significant changes across the Application and Domain layer. In comparison, the changes to the IAppDbContext / DbContext will be relatively insignificant.

Happy Coding! 💙