Post History

Are any downsides of hiding the actual Entity Framework Core DbSets and exposing only some generic methods?

I have recently started a project based on the clean architecture principle and noticed that it did not rely on generic repositories since Entity Framework's DbSets are doing the job just fine. In the referenced project the database context class implements an interface that exposes all the DbSets, but I am wondering if exposing only some generic methods is enough.


    public class ApplicationDbContext : DbContext, IApplicationDbContext
    {
        public ApplicationDbContext(
            DbContextOptions options) : base(options)
        {
        }
			
        public virtual DbSet<RefDepartment> RefDepartment { get; set; }
        public virtual DbSet<RefCurrency> RefCurrency { get; set; }
		
        // other DbSets come here	
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        { 
            modelBuilder.ApplyConfigurationsFromAssembly(
                   Assembly.GetExecutingAssembly());
            SeedData(modelBuilder);

            base.OnModelCreating(modelBuilder);
        }

        private void SeedData(ModelBuilder modelBuilder)
        {
		// seed come here	
        }
		
        public IQueryable<TEnt> ReadSet<TEnt>() where TEnt : class
        {
            return Set<TEnt>().AsNoTracking();
        }
    }

In this case, the interface will expose only the minimum required methods from DbContext and none of the actual DbSets:

    /// <summary>
    /// DB context interface
    /// </summary>
    public interface IApplicationDbContext
    {
        /// <summary>
        /// db set 
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <returns></returns>
        DbSet<TEntity> Set<TEntity>() where TEntity : class;

        /// <summary>
        /// a read-only reference to a dbset
        /// </summary>
        /// <typeparam name="TEnt"></typeparam>
        /// <returns></returns>
        IQueryable<TEnt> ReadSet<TEnt>() where TEnt : class;

        /// <summary>
        /// save changes
        /// </summary>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        Task<int> SaveChangesAsync(CancellationToken cancellationToken);
    }

The immediate advantage is that any new DbSet is specified in the class, but not in the interface. I am wondering if there are any side effects for such an approach since I do not remember being used in any other project.