397 make fields and methods protected (#398)

eldamir · web-flow · commit 4e54413fdb1c · 2024-05-21T12:08:42.000-04:00
* Make repository fields protected rather than private

* Make repository fields protected in sample apps too

* Turn protected fields into protected properties instead

* Make the setters protected rather than private.

This affords maximum extensibility, while still encapsulating
the values within a property
diff --git a/Specification.EntityFramework6/src/Ardalis.Specification.EntityFramework6/RepositoryBaseOfT.cs b/Specification.EntityFramework6/src/Ardalis.Specification.EntityFramework6/RepositoryBaseOfT.cs
@@ -10,25 +10,25 @@ namespace Ardalis.Specification.EntityFramework6;
 /// <inheritdoc/>
 public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class
 {
-    private readonly DbContext _dbContext;
-    private readonly ISpecificationEvaluator _specificationEvaluator;
+    protected DbContext DbContext { get; set; }
+    protected ISpecificationEvaluator SpecificationEvaluator { get; set; }
 
     public RepositoryBase(DbContext dbContext)
-        : this(dbContext, SpecificationEvaluator.Default)
+        : this(dbContext, EntityFramework6.SpecificationEvaluator.Default)
     {
     }
 
     /// <inheritdoc/>
     public RepositoryBase(DbContext dbContext, ISpecificationEvaluator specificationEvaluator)
     {
-        _dbContext = dbContext;
-        _specificationEvaluator = specificationEvaluator;
+        DbContext = dbContext;
+        SpecificationEvaluator = specificationEvaluator;
     }
 
     /// <inheritdoc/>
     public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().Add(entity);
+        DbContext.Set<T>().Add(entity);
 
         await SaveChangesAsync(cancellationToken);
 
@@ -38,7 +38,7 @@ public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationTo
     /// <inheritdoc/>
     public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().AddRange(entities);
+        DbContext.Set<T>().AddRange(entities);
 
         await SaveChangesAsync(cancellationToken);
 
@@ -48,7 +48,7 @@ public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities,
     /// <inheritdoc/>
     public virtual async Task UpdateAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Entry(entity).State = EntityState.Modified;
+        DbContext.Entry(entity).State = EntityState.Modified;
 
         await SaveChangesAsync(cancellationToken);
     }
@@ -58,7 +58,7 @@ public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, Cancellation
     {
         foreach (var entity in entities)
         {
-            _dbContext.Entry(entity).State = EntityState.Modified;
+            DbContext.Entry(entity).State = EntityState.Modified;
         }
 
         await SaveChangesAsync(cancellationToken);
@@ -67,38 +67,38 @@ public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, Cancellation
     /// <inheritdoc/>
     public virtual async Task DeleteAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().Remove(entity);
+        DbContext.Set<T>().Remove(entity);
 
         await SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task DeleteRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().RemoveRange(entities);
+        DbContext.Set<T>().RemoveRange(entities);
 
         await SaveChangesAsync(cancellationToken);
-    }
-
+    }
+
     /// <inheritdoc/>
     public virtual async Task DeleteRangeAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        var query = ApplySpecification(specification);
-        _dbContext.Set<T>().RemoveRange(query);
-
+    {
+        var query = ApplySpecification(specification);
+        DbContext.Set<T>().RemoveRange(query);
+
         await SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.SaveChangesAsync(cancellationToken);
+        return await DbContext.SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task<T> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().FindAsync(cancellationToken: cancellationToken, new object[] { id });
+        return await DbContext.Set<T>().FindAsync(cancellationToken: cancellationToken, new object[] { id });
     }
 
     /// <inheritdoc/>
@@ -142,7 +142,7 @@ public virtual async Task<TResult> SingleOrDefaultAsync<TResult>(ISingleResultSp
     /// <inheritdoc/>
     public virtual async Task<List<T>> ListAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().ToListAsync(cancellationToken);
+        return await DbContext.Set<T>().ToListAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -170,7 +170,7 @@ public virtual async Task<int> CountAsync(ISpecification<T> specification, Cance
     /// <inheritdoc/>
     public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().CountAsync(cancellationToken);
+        return await DbContext.Set<T>().CountAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -182,7 +182,7 @@ public virtual async Task<bool> AnyAsync(ISpecification<T> specification, Cancel
     /// <inheritdoc/>
     public virtual async Task<bool> AnyAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().AnyAsync(cancellationToken);
+        return await DbContext.Set<T>().AnyAsync(cancellationToken);
     }
 
 #if NET6_0_OR_GREATER
@@ -201,7 +201,7 @@ public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specifica
     /// <returns>The filtered entities as an <see cref="IQueryable{T}"/>.</returns>
     protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specification, bool evaluateCriteriaOnly = false)
     {
-        return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);
+        return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);
     }
 
     /// <summary>
@@ -216,6 +216,6 @@ protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specificati
     /// <returns>The filtered projected entities as an <see cref="IQueryable{T}"/>.</returns>
     protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<T, TResult> specification)
     {
-        return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification);
+        return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification);
     }
 }
diff --git a/Specification.EntityFramework6/tests/Ardalis.Specification.EntityFramework6.IntegrationTests/Fixture/RepositoryOfT.cs b/Specification.EntityFramework6/tests/Ardalis.Specification.EntityFramework6.IntegrationTests/Fixture/RepositoryOfT.cs
@@ -5,12 +5,12 @@ public class Repository<T> : RepositoryBase<T> where T : class
 {
     protected readonly TestDbContext dbContext;
 
-    public Repository(TestDbContext dbContext) : this(dbContext, SpecificationEvaluator.Default)
+    public Repository(TestDbContext dbContext) : this(dbContext, EntityFramework6.SpecificationEvaluator.Default)
     {
     }
 
     public Repository(TestDbContext dbContext, ISpecificationEvaluator specificationEvaluator) : base(dbContext, specificationEvaluator)
     {
         this.dbContext = dbContext;
     }
-}
+}
diff --git a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs
@@ -5,25 +5,25 @@ namespace Ardalis.Specification.EntityFrameworkCore;
 /// <inheritdoc/>
 public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class
 {
-    private readonly DbContext _dbContext;
-    private readonly ISpecificationEvaluator _specificationEvaluator;
+    protected DbContext DbContext { get; set; }
+    protected ISpecificationEvaluator SpecificationEvaluator { get; set; }
 
     public RepositoryBase(DbContext dbContext)
-        : this(dbContext, SpecificationEvaluator.Default)
+        : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)
     {
     }
 
     /// <inheritdoc/>
     public RepositoryBase(DbContext dbContext, ISpecificationEvaluator specificationEvaluator)
     {
-        _dbContext = dbContext;
-        _specificationEvaluator = specificationEvaluator;
+        DbContext = dbContext;
+        SpecificationEvaluator = specificationEvaluator;
     }
 
     /// <inheritdoc/>
     public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().Add(entity);
+        DbContext.Set<T>().Add(entity);
 
         await SaveChangesAsync(cancellationToken);
 
@@ -33,7 +33,7 @@ public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationTo
     /// <inheritdoc/>
     public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().AddRange(entities);
+        DbContext.Set<T>().AddRange(entities);
 
         await SaveChangesAsync(cancellationToken);
 
@@ -43,54 +43,54 @@ public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities,
     /// <inheritdoc/>
     public virtual async Task UpdateAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().Update(entity);
+        DbContext.Set<T>().Update(entity);
 
         await SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().UpdateRange(entities);
+        DbContext.Set<T>().UpdateRange(entities);
 
         await SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task DeleteAsync(T entity, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().Remove(entity);
+        DbContext.Set<T>().Remove(entity);
 
         await SaveChangesAsync(cancellationToken);
-    }
-
+    }
+
     /// <inheritdoc/>
     public virtual async Task DeleteRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)
     {
-        _dbContext.Set<T>().RemoveRange(entities);
+        DbContext.Set<T>().RemoveRange(entities);
 
         await SaveChangesAsync(cancellationToken);
-    }
-
+    }
+
     /// <inheritdoc/>
     public virtual async Task DeleteRangeAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        var query = ApplySpecification(specification);
-        _dbContext.Set<T>().RemoveRange(query);
-
+    {
+        var query = ApplySpecification(specification);
+        DbContext.Set<T>().RemoveRange(query);
+
         await SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.SaveChangesAsync(cancellationToken);
+        return await DbContext.SaveChangesAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
     public virtual async Task<T?> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default) where TId : notnull
     {
-        return await _dbContext.Set<T>().FindAsync(new object[] { id }, cancellationToken: cancellationToken);
+        return await DbContext.Set<T>().FindAsync(new object[] { id }, cancellationToken: cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -134,7 +134,7 @@ public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationTo
     /// <inheritdoc/>
     public virtual async Task<List<T>> ListAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().ToListAsync(cancellationToken);
+        return await DbContext.Set<T>().ToListAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -162,7 +162,7 @@ public virtual async Task<int> CountAsync(ISpecification<T> specification, Cance
     /// <inheritdoc/>
     public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().CountAsync(cancellationToken);
+        return await DbContext.Set<T>().CountAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -174,7 +174,7 @@ public virtual async Task<bool> AnyAsync(ISpecification<T> specification, Cancel
     /// <inheritdoc/>
     public virtual async Task<bool> AnyAsync(CancellationToken cancellationToken = default)
     {
-        return await _dbContext.Set<T>().AnyAsync(cancellationToken);
+        return await DbContext.Set<T>().AnyAsync(cancellationToken);
     }
 
     /// <inheritdoc/>
@@ -191,7 +191,7 @@ public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specifica
     /// <returns>The filtered entities as an <see cref="IQueryable{T}"/>.</returns>
     protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specification, bool evaluateCriteriaOnly = false)
     {
-        return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);
+        return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);
     }
 
     /// <summary>
@@ -206,6 +206,6 @@ protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specificati
     /// <returns>The filtered projected entities as an <see cref="IQueryable{T}"/>.</returns>
     protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<T, TResult> specification)
     {
-        return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification);
+        return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification);
     }
 }
diff --git a/Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/Fixture/RepositoryOfT.cs b/Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/Fixture/RepositoryOfT.cs
@@ -5,7 +5,7 @@ public class Repository<T> : RepositoryBase<T> where T : class
 {
     protected readonly TestDbContext dbContext;
 
-    public Repository(TestDbContext dbContext) : this(dbContext, SpecificationEvaluator.Default)
+    public Repository(TestDbContext dbContext) : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)
     {
     }
 
diff --git a/sample/Ardalis.Sample.App3/RepositoryBase.cs b/sample/Ardalis.Sample.App3/RepositoryBase.cs

Original file line number	Diff line number	Diff line change
`@@ -10,25 +10,25 @@ namespace Ardalis.Specification.EntityFramework6;`
`10`	`10`	`/// <inheritdoc/>`
`11`	`11`	`public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class`
`12`	`12`	`{`
`13`		`- private readonly DbContext _dbContext;`
`14`		`- private readonly ISpecificationEvaluator _specificationEvaluator;`
	`13`	`+ protected DbContext DbContext { get; set; }`
	`14`	`+ protected ISpecificationEvaluator SpecificationEvaluator { get; set; }`
`15`	`15`
`16`	`16`	`public RepositoryBase(DbContext dbContext)`
`17`		`- : this(dbContext, SpecificationEvaluator.Default)`
	`17`	`+ : this(dbContext, EntityFramework6.SpecificationEvaluator.Default)`
`18`	`18`	`{`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`/// <inheritdoc/>`
`22`	`22`	`public RepositoryBase(DbContext dbContext, ISpecificationEvaluator specificationEvaluator)`
`23`	`23`	`{`
`24`		`- _dbContext = dbContext;`
`25`		`- _specificationEvaluator = specificationEvaluator;`
	`24`	`+ DbContext = dbContext;`
	`25`	`+ SpecificationEvaluator = specificationEvaluator;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`/// <inheritdoc/>`
`29`	`29`	`public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)`
`30`	`30`	`{`
`31`		`- _dbContext.Set<T>().Add(entity);`
	`31`	`+ DbContext.Set<T>().Add(entity);`
`32`	`32`
`33`	`33`	`await SaveChangesAsync(cancellationToken);`
`34`	`34`
`@@ -38,7 +38,7 @@ public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationTo`
`38`	`38`	`/// <inheritdoc/>`
`39`	`39`	`public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)`
`40`	`40`	`{`
`41`		`- _dbContext.Set<T>().AddRange(entities);`
	`41`	`+ DbContext.Set<T>().AddRange(entities);`
`42`	`42`
`43`	`43`	`await SaveChangesAsync(cancellationToken);`
`44`	`44`
`@@ -48,7 +48,7 @@ public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities,`
`48`	`48`	`/// <inheritdoc/>`
`49`	`49`	`public virtual async Task UpdateAsync(T entity, CancellationToken cancellationToken = default)`
`50`	`50`	`{`
`51`		`- _dbContext.Entry(entity).State = EntityState.Modified;`
	`51`	`+ DbContext.Entry(entity).State = EntityState.Modified;`
`52`	`52`
`53`	`53`	`await SaveChangesAsync(cancellationToken);`
`54`	`54`	`}`
`@@ -58,7 +58,7 @@ public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, Cancellation`
`58`	`58`	`{`
`59`	`59`	`foreach (var entity in entities)`
`60`	`60`	`{`
`61`		`- _dbContext.Entry(entity).State = EntityState.Modified;`
	`61`	`+ DbContext.Entry(entity).State = EntityState.Modified;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`await SaveChangesAsync(cancellationToken);`
`@@ -67,38 +67,38 @@ public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, Cancellation`
`67`	`67`	`/// <inheritdoc/>`
`68`	`68`	`public virtual async Task DeleteAsync(T entity, CancellationToken cancellationToken = default)`
`69`	`69`	`{`
`70`		`- _dbContext.Set<T>().Remove(entity);`
	`70`	`+ DbContext.Set<T>().Remove(entity);`
`71`	`71`
`72`	`72`	`await SaveChangesAsync(cancellationToken);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`/// <inheritdoc/>`
`76`	`76`	`public virtual async Task DeleteRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)`
`77`	`77`	`{`
`78`		`- _dbContext.Set<T>().RemoveRange(entities);`
	`78`	`+ DbContext.Set<T>().RemoveRange(entities);`
`79`	`79`
`80`	`80`	`await SaveChangesAsync(cancellationToken);`
`81`		`- }`
`82`		`-`
	`81`	`+ }`
	`82`	`+`
`83`	`83`	`/// <inheritdoc/>`
`84`	`84`	`public virtual async Task DeleteRangeAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)`
`85`		`- {`
`86`		`- var query = ApplySpecification(specification);`
`87`		`- _dbContext.Set<T>().RemoveRange(query);`
`88`		`-`
	`85`	`+ {`
	`86`	`+ var query = ApplySpecification(specification);`
	`87`	`+ DbContext.Set<T>().RemoveRange(query);`
	`88`	`+`
`89`	`89`	`await SaveChangesAsync(cancellationToken);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`/// <inheritdoc/>`
`93`	`93`	`public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)`
`94`	`94`	`{`
`95`		`- return await _dbContext.SaveChangesAsync(cancellationToken);`
	`95`	`+ return await DbContext.SaveChangesAsync(cancellationToken);`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`/// <inheritdoc/>`
`99`	`99`	`public virtual async Task<T> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default)`
`100`	`100`	`{`
`101`		`- return await _dbContext.Set<T>().FindAsync(cancellationToken: cancellationToken, new object[] { id });`
	`101`	`+ return await DbContext.Set<T>().FindAsync(cancellationToken: cancellationToken, new object[] { id });`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`/// <inheritdoc/>`
`@@ -142,7 +142,7 @@ public virtual async Task<TResult> SingleOrDefaultAsync<TResult>(ISingleResultSp`
`142`	`142`	`/// <inheritdoc/>`
`143`	`143`	`public virtual async Task<List<T>> ListAsync(CancellationToken cancellationToken = default)`
`144`	`144`	`{`
`145`		`- return await _dbContext.Set<T>().ToListAsync(cancellationToken);`
	`145`	`+ return await DbContext.Set<T>().ToListAsync(cancellationToken);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`/// <inheritdoc/>`
`@@ -170,7 +170,7 @@ public virtual async Task<int> CountAsync(ISpecification<T> specification, Cance`
`170`	`170`	`/// <inheritdoc/>`
`171`	`171`	`public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default)`
`172`	`172`	`{`
`173`		`- return await _dbContext.Set<T>().CountAsync(cancellationToken);`
	`173`	`+ return await DbContext.Set<T>().CountAsync(cancellationToken);`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`/// <inheritdoc/>`
`@@ -182,7 +182,7 @@ public virtual async Task<bool> AnyAsync(ISpecification<T> specification, Cancel`
`182`	`182`	`/// <inheritdoc/>`
`183`	`183`	`public virtual async Task<bool> AnyAsync(CancellationToken cancellationToken = default)`
`184`	`184`	`{`
`185`		`- return await _dbContext.Set<T>().AnyAsync(cancellationToken);`
	`185`	`+ return await DbContext.Set<T>().AnyAsync(cancellationToken);`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`#if NET6_0_OR_GREATER`
`@@ -201,7 +201,7 @@ public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specifica`
`201`	`201`	`/// <returns>The filtered entities as an <see cref="IQueryable{T}"/>.</returns>`
`202`	`202`	`protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specification, bool evaluateCriteriaOnly = false)`
`203`	`203`	`{`
`204`		`- return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);`
	`204`	`+ return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);`
`205`	`205`	`}`
`206`	`206`
`207`	`207`	`/// <summary>`
`@@ -216,6 +216,6 @@ protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specificati`
`216`	`216`	`/// <returns>The filtered projected entities as an <see cref="IQueryable{T}"/>.</returns>`
`217`	`217`	`protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<T, TResult> specification)`
`218`	`218`	`{`
`219`		`- return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification);`
	`219`	`+ return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification);`
`220`	`220`	`}`
`221`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,12 +5,12 @@ public class Repository<T> : RepositoryBase<T> where T : class`
`5`	`5`	`{`
`6`	`6`	`protected readonly TestDbContext dbContext;`
`7`	`7`
`8`		`- public Repository(TestDbContext dbContext) : this(dbContext, SpecificationEvaluator.Default)`
	`8`	`+ public Repository(TestDbContext dbContext) : this(dbContext, EntityFramework6.SpecificationEvaluator.Default)`
`9`	`9`	`{`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`public Repository(TestDbContext dbContext, ISpecificationEvaluator specificationEvaluator) : base(dbContext, specificationEvaluator)`
`13`	`13`	`{`
`14`	`14`	`this.dbContext = dbContext;`
`15`	`15`	`}`
`16`		`-}`
	`16`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -5,25 +5,25 @@ namespace Ardalis.Specification.EntityFrameworkCore;`
`5`	`5`	`/// <inheritdoc/>`
`6`	`6`	`public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class`
`7`	`7`	`{`
`8`		`- private readonly DbContext _dbContext;`
`9`		`- private readonly ISpecificationEvaluator _specificationEvaluator;`
	`8`	`+ protected DbContext DbContext { get; set; }`
	`9`	`+ protected ISpecificationEvaluator SpecificationEvaluator { get; set; }`
`10`	`10`
`11`	`11`	`public RepositoryBase(DbContext dbContext)`
`12`		`- : this(dbContext, SpecificationEvaluator.Default)`
	`12`	`+ : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)`
`13`	`13`	`{`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`/// <inheritdoc/>`
`17`	`17`	`public RepositoryBase(DbContext dbContext, ISpecificationEvaluator specificationEvaluator)`
`18`	`18`	`{`
`19`		`- _dbContext = dbContext;`
`20`		`- _specificationEvaluator = specificationEvaluator;`
	`19`	`+ DbContext = dbContext;`
	`20`	`+ SpecificationEvaluator = specificationEvaluator;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`/// <inheritdoc/>`
`24`	`24`	`public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)`
`25`	`25`	`{`
`26`		`- _dbContext.Set<T>().Add(entity);`
	`26`	`+ DbContext.Set<T>().Add(entity);`
`27`	`27`
`28`	`28`	`await SaveChangesAsync(cancellationToken);`
`29`	`29`
`@@ -33,7 +33,7 @@ public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationTo`
`33`	`33`	`/// <inheritdoc/>`
`34`	`34`	`public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)`
`35`	`35`	`{`
`36`		`- _dbContext.Set<T>().AddRange(entities);`
	`36`	`+ DbContext.Set<T>().AddRange(entities);`
`37`	`37`
`38`	`38`	`await SaveChangesAsync(cancellationToken);`
`39`	`39`
`@@ -43,54 +43,54 @@ public virtual async Task<IEnumerable<T>> AddRangeAsync(IEnumerable<T> entities,`
`43`	`43`	`/// <inheritdoc/>`
`44`	`44`	`public virtual async Task UpdateAsync(T entity, CancellationToken cancellationToken = default)`
`45`	`45`	`{`
`46`		`- _dbContext.Set<T>().Update(entity);`
	`46`	`+ DbContext.Set<T>().Update(entity);`
`47`	`47`
`48`	`48`	`await SaveChangesAsync(cancellationToken);`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`/// <inheritdoc/>`
`52`	`52`	`public virtual async Task UpdateRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)`
`53`	`53`	`{`
`54`		`- _dbContext.Set<T>().UpdateRange(entities);`
	`54`	`+ DbContext.Set<T>().UpdateRange(entities);`
`55`	`55`
`56`	`56`	`await SaveChangesAsync(cancellationToken);`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/// <inheritdoc/>`
`60`	`60`	`public virtual async Task DeleteAsync(T entity, CancellationToken cancellationToken = default)`
`61`	`61`	`{`
`62`		`- _dbContext.Set<T>().Remove(entity);`
	`62`	`+ DbContext.Set<T>().Remove(entity);`
`63`	`63`
`64`	`64`	`await SaveChangesAsync(cancellationToken);`
`65`		`- }`
`66`		`-`
	`65`	`+ }`
	`66`	`+`
`67`	`67`	`/// <inheritdoc/>`
`68`	`68`	`public virtual async Task DeleteRangeAsync(IEnumerable<T> entities, CancellationToken cancellationToken = default)`
`69`	`69`	`{`
`70`		`- _dbContext.Set<T>().RemoveRange(entities);`
	`70`	`+ DbContext.Set<T>().RemoveRange(entities);`
`71`	`71`
`72`	`72`	`await SaveChangesAsync(cancellationToken);`
`73`		`- }`
`74`		`-`
	`73`	`+ }`
	`74`	`+`
`75`	`75`	`/// <inheritdoc/>`
`76`	`76`	`public virtual async Task DeleteRangeAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)`
`77`		`- {`
`78`		`- var query = ApplySpecification(specification);`
`79`		`- _dbContext.Set<T>().RemoveRange(query);`
`80`		`-`
	`77`	`+ {`
	`78`	`+ var query = ApplySpecification(specification);`
	`79`	`+ DbContext.Set<T>().RemoveRange(query);`
	`80`	`+`
`81`	`81`	`await SaveChangesAsync(cancellationToken);`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`/// <inheritdoc/>`
`85`	`85`	`public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)`
`86`	`86`	`{`
`87`		`- return await _dbContext.SaveChangesAsync(cancellationToken);`
	`87`	`+ return await DbContext.SaveChangesAsync(cancellationToken);`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`/// <inheritdoc/>`
`91`	`91`	`public virtual async Task<T?> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default) where TId : notnull`
`92`	`92`	`{`
`93`		`- return await _dbContext.Set<T>().FindAsync(new object[] { id }, cancellationToken: cancellationToken);`
	`93`	`+ return await DbContext.Set<T>().FindAsync(new object[] { id }, cancellationToken: cancellationToken);`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`/// <inheritdoc/>`
`@@ -134,7 +134,7 @@ public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationTo`
`134`	`134`	`/// <inheritdoc/>`
`135`	`135`	`public virtual async Task<List<T>> ListAsync(CancellationToken cancellationToken = default)`
`136`	`136`	`{`
`137`		`- return await _dbContext.Set<T>().ToListAsync(cancellationToken);`
	`137`	`+ return await DbContext.Set<T>().ToListAsync(cancellationToken);`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`/// <inheritdoc/>`
`@@ -162,7 +162,7 @@ public virtual async Task<int> CountAsync(ISpecification<T> specification, Cance`
`162`	`162`	`/// <inheritdoc/>`
`163`	`163`	`public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default)`
`164`	`164`	`{`
`165`		`- return await _dbContext.Set<T>().CountAsync(cancellationToken);`
	`165`	`+ return await DbContext.Set<T>().CountAsync(cancellationToken);`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`/// <inheritdoc/>`
`@@ -174,7 +174,7 @@ public virtual async Task<bool> AnyAsync(ISpecification<T> specification, Cancel`
`174`	`174`	`/// <inheritdoc/>`
`175`	`175`	`public virtual async Task<bool> AnyAsync(CancellationToken cancellationToken = default)`
`176`	`176`	`{`
`177`		`- return await _dbContext.Set<T>().AnyAsync(cancellationToken);`
	`177`	`+ return await DbContext.Set<T>().AnyAsync(cancellationToken);`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`/// <inheritdoc/>`
`@@ -191,7 +191,7 @@ public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specifica`
`191`	`191`	`/// <returns>The filtered entities as an <see cref="IQueryable{T}"/>.</returns>`
`192`	`192`	`protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specification, bool evaluateCriteriaOnly = false)`
`193`	`193`	`{`
`194`		`- return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);`
	`194`	`+ return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);`
`195`	`195`	`}`
`196`	`196`
`197`	`197`	`/// <summary>`
`@@ -206,6 +206,6 @@ protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specificati`
`206`	`206`	`/// <returns>The filtered projected entities as an <see cref="IQueryable{T}"/>.</returns>`
`207`	`207`	`protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<T, TResult> specification)`
`208`	`208`	`{`
`209`		`- return _specificationEvaluator.GetQuery(_dbContext.Set<T>().AsQueryable(), specification);`
	`209`	`+ return SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification);`
`210`	`210`	`}`
`211`	`211`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ public class Repository<T> : RepositoryBase<T> where T : class`
`5`	`5`	`{`
`6`	`6`	`protected readonly TestDbContext dbContext;`
`7`	`7`
`8`		`- public Repository(TestDbContext dbContext) : this(dbContext, SpecificationEvaluator.Default)`
	`8`	`+ public Repository(TestDbContext dbContext) : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)`
`9`	`9`	`{`
`10`	`10`	`}`
`11`	`11`