diff --git a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/ContextFactoryRepositoryBaseOfT.cs b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/ContextFactoryRepositoryBaseOfT.cs
index 0c49360..a7d3ee7 100644
--- a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/ContextFactoryRepositoryBaseOfT.cs
+++ b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/ContextFactoryRepositoryBaseOfT.cs
@@ -2,25 +2,19 @@
 
 namespace Ardalis.Specification.EntityFrameworkCore;
 
-public abstract class ContextFactoryRepositoryBaseOfT<TEntity, TContext> : IRepositoryBase<TEntity>
+public abstract class ContextFactoryRepositoryBaseOfT<TEntity, TContext>(IDbContextFactory<TContext> dbContextFactory,
+  ISpecificationEvaluator specificationEvaluator) : IRepositoryBase<TEntity>
   where TEntity : class
   where TContext : DbContext
 {
-    private readonly IDbContextFactory<TContext> _dbContextFactory;
-    private readonly ISpecificationEvaluator _specificationEvaluator;
+    private readonly IDbContextFactory<TContext> _dbContextFactory = dbContextFactory;
+    private readonly ISpecificationEvaluator _specificationEvaluator = specificationEvaluator;
 
     public ContextFactoryRepositoryBaseOfT(IDbContextFactory<TContext> dbContextFactory)
       : this(dbContextFactory, SpecificationEvaluator.Default)
     {
-    }
-
-    public ContextFactoryRepositoryBaseOfT(IDbContextFactory<TContext> dbContextFactory,
-      ISpecificationEvaluator specificationEvaluator)
-    {
-        _dbContextFactory = dbContextFactory;
-        _specificationEvaluator = specificationEvaluator;
-    }
-
+    }
+
     /// <inheritdoc/>
     public async Task<TEntity?> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default) where TId : notnull
     {
@@ -205,10 +199,8 @@ public Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
         throw new InvalidOperationException();
     }
 
-    public async Task<int> SaveChangesAsync(TContext dbContext, CancellationToken cancellationToken = default)
-    {
-        return await dbContext.SaveChangesAsync(cancellationToken);
-    }
+    public async Task<int> SaveChangesAsync(TContext dbContext, CancellationToken cancellationToken = default) 
+        => await dbContext.SaveChangesAsync(cancellationToken);
 
     /// <summary>
     /// Filters the entities  of <typeparamref name="TEntity"/>, to those that match the encapsulated query logic of the
@@ -216,10 +208,8 @@ public async Task<int> SaveChangesAsync(TContext dbContext, CancellationToken ca
     /// </summary>
     /// <param name="specification">The encapsulated query logic.</param>
     /// <returns>The filtered entities as an <see cref="IQueryable{T}"/>.</returns>
-    protected virtual IQueryable<TEntity> ApplySpecification(ISpecification<TEntity> specification, TContext dbContext, bool evaluateCriteriaOnly = false)
-    {
-        return _specificationEvaluator.GetQuery(dbContext.Set<TEntity>().AsQueryable(), specification, evaluateCriteriaOnly);
-    }
+    protected virtual IQueryable<TEntity> ApplySpecification(ISpecification<TEntity> specification, TContext dbContext, bool evaluateCriteriaOnly = false) 
+        => _specificationEvaluator.GetQuery(dbContext.Set<TEntity>().AsQueryable(), specification, evaluateCriteriaOnly);
 
     /// <summary>
     /// Filters all entities of <typeparamref name="TEntity" />, that matches the encapsulated query logic of the
@@ -231,8 +221,6 @@ protected virtual IQueryable<TEntity> ApplySpecification(ISpecification<TEntity>
     /// <typeparam name="TResult">The type of the value returned by the projection.</typeparam>
     /// <param name="specification">The encapsulated query logic.</param>
     /// <returns>The filtered projected entities as an <see cref="IQueryable{T}"/>.</returns>
-    protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<TEntity, TResult> specification, TContext dbContext)
-    {
-        return _specificationEvaluator.GetQuery(dbContext.Set<TEntity>().AsQueryable(), specification);
-    }
+    protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<TEntity, TResult> specification, TContext dbContext)
+        => _specificationEvaluator.GetQuery(dbContext.Set<TEntity>().AsQueryable(), specification);
 }
diff --git a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/EFRepositoryFactory.cs b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/EFRepositoryFactory.cs
index 3e21e64..4b0c15e 100644
--- a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/EFRepositoryFactory.cs
+++ b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/EFRepositoryFactory.cs
@@ -10,20 +10,16 @@ namespace Ardalis.Specification.EntityFrameworkCore;
 /// The Concrete implementation of the repository interface to create
 /// </typeparam>
 /// <typeparam name="TContext">The DbContext derived class to support the concrete repository</typeparam>
-public class EFRepositoryFactory<TRepository, TConcreteRepository, TContext> : IRepositoryFactory<TRepository>
+/// <remarks>
+/// Initialises a new instance of the EFRepositoryFactory
+/// </remarks>
+/// <param name="dbContextFactory">The IDbContextFactory to use to generate the TContext</param>
+public class EFRepositoryFactory<TRepository, TConcreteRepository, TContext>(
+    IDbContextFactory<TContext> dbContextFactory) : IRepositoryFactory<TRepository>
   where TConcreteRepository : TRepository
   where TContext : DbContext
 {
-    private readonly IDbContextFactory<TContext> _dbContextFactory;
-
-    /// <summary>
-    /// Initialises a new instance of the EFRepositoryFactory
-    /// </summary>
-    /// <param name="dbContextFactory">The IDbContextFactory to use to generate the TContext</param>
-    public EFRepositoryFactory(IDbContextFactory<TContext> dbContextFactory)
-    {
-        _dbContextFactory = dbContextFactory;
-    }
+    private readonly IDbContextFactory<TContext> _dbContextFactory = dbContextFactory;
 
     /// <inheritdoc />
     public TRepository CreateRepository()
diff --git a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs
index e9118d4..7a63093 100644
--- a/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs
+++ b/Specification.EntityFrameworkCore/src/Ardalis.Specification.EntityFrameworkCore/RepositoryBaseOfT.cs
@@ -3,23 +3,19 @@
 namespace Ardalis.Specification.EntityFrameworkCore;
 
 /// <inheritdoc/>
-public abstract class RepositoryBase<T> : IRepositoryBase<T> where T : class
+/// <inheritdoc/>
+public abstract class RepositoryBase<T>(
+    DbContext dbContext, 
+    ISpecificationEvaluator specificationEvaluator) : IRepositoryBase<T> where T : class
 {
-    protected DbContext DbContext { get; set; }
-    protected ISpecificationEvaluator SpecificationEvaluator { get; set; }
+    protected DbContext DbContext { get; set; } = dbContext;
+    protected ISpecificationEvaluator SpecificationEvaluator { get; set; } = specificationEvaluator;
 
     public RepositoryBase(DbContext dbContext)
         : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)
     {
     }
 
-    /// <inheritdoc/>
-    public RepositoryBase(DbContext dbContext, ISpecificationEvaluator specificationEvaluator)
-    {
-        DbContext = dbContext;
-        SpecificationEvaluator = specificationEvaluator;
-    }
-
     /// <inheritdoc/>
     public virtual async Task<T> AddAsync(T entity, CancellationToken cancellationToken = default)
     {
@@ -82,60 +78,42 @@ public virtual async Task DeleteRangeAsync(ISpecification<T> specification, Canc
     }
 
     /// <inheritdoc/>
-    public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
-    {
-        return await DbContext.SaveChangesAsync(cancellationToken);
-    }
+    public virtual async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) 
+        => 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);
-    }
+    public virtual async Task<T?> GetByIdAsync<TId>(TId id, CancellationToken cancellationToken = default) where TId : notnull 
+        => await DbContext.Set<T>().FindAsync(new object[] { id }, cancellationToken: cancellationToken);
 
     /// <inheritdoc/>
     [Obsolete("Use FirstOrDefaultAsync<T> or SingleOrDefaultAsync<T> instead. The SingleOrDefaultAsync<T> can be applied only to SingleResultSpecification<T> specifications.")]
-    public virtual async Task<T?> GetBySpecAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
-    }
+    public virtual async Task<T?> GetBySpecAsync(ISpecification<T> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
     [Obsolete("Use FirstOrDefaultAsync<T> or SingleOrDefaultAsync<T> instead. The SingleOrDefaultAsync<T> can be applied only to SingleResultSpecification<T> specifications.")]
-    public virtual async Task<TResult?> GetBySpecAsync<TResult>(ISpecification<T, TResult> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
-    }
+    public virtual async Task<TResult?> GetBySpecAsync<TResult>(ISpecification<T, TResult> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
     public virtual async Task<T?> FirstOrDefaultAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
-    }
+        => await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
-    public virtual async Task<TResult?> FirstOrDefaultAsync<TResult>(ISpecification<T, TResult> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
-    }
+    public virtual async Task<TResult?> FirstOrDefaultAsync<TResult>(ISpecification<T, TResult> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification).FirstOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
-    public virtual async Task<T?> SingleOrDefaultAsync(ISingleResultSpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).SingleOrDefaultAsync(cancellationToken);
-    }
+    public virtual async Task<T?> SingleOrDefaultAsync(ISingleResultSpecification<T> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification).SingleOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
-    public virtual async Task<TResult?> SingleOrDefaultAsync<TResult>(ISingleResultSpecification<T, TResult> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification).SingleOrDefaultAsync(cancellationToken);
-    }
+    public virtual async Task<TResult?> SingleOrDefaultAsync<TResult>(ISingleResultSpecification<T, TResult> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification).SingleOrDefaultAsync(cancellationToken);
 
     /// <inheritdoc/>
     public virtual async Task<List<T>> ListAsync(CancellationToken cancellationToken = default)
-    {
-        return await DbContext.Set<T>().ToListAsync(cancellationToken);
-    }
+        => await DbContext.Set<T>().ToListAsync(cancellationToken);
 
     /// <inheritdoc/>
     public virtual async Task<List<T>> ListAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
@@ -154,34 +132,24 @@ public virtual async Task<List<TResult>> ListAsync<TResult>(ISpecification<T, TR
     }
 
     /// <inheritdoc/>
-    public virtual async Task<int> CountAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification, true).CountAsync(cancellationToken);
-    }
+    public virtual async Task<int> CountAsync(ISpecification<T> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification, true).CountAsync(cancellationToken);
 
     /// <inheritdoc/>
-    public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default)
-    {
-        return await DbContext.Set<T>().CountAsync(cancellationToken);
-    }
+    public virtual async Task<int> CountAsync(CancellationToken cancellationToken = default) 
+        => await DbContext.Set<T>().CountAsync(cancellationToken);
 
     /// <inheritdoc/>
-    public virtual async Task<bool> AnyAsync(ISpecification<T> specification, CancellationToken cancellationToken = default)
-    {
-        return await ApplySpecification(specification, true).AnyAsync(cancellationToken);
-    }
+    public virtual async Task<bool> AnyAsync(ISpecification<T> specification, CancellationToken cancellationToken = default) 
+        => await ApplySpecification(specification, true).AnyAsync(cancellationToken);
 
     /// <inheritdoc/>
     public virtual async Task<bool> AnyAsync(CancellationToken cancellationToken = default)
-    {
-        return await DbContext.Set<T>().AnyAsync(cancellationToken);
-    }
+        => await DbContext.Set<T>().AnyAsync(cancellationToken);
 
     /// <inheritdoc/>
     public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specification)
-    {
-        return ApplySpecification(specification).AsAsyncEnumerable();
-    }
+        => ApplySpecification(specification).AsAsyncEnumerable();
 
     /// <summary>
     /// Filters the entities  of <typeparamref name="T"/>, to those that match the encapsulated query logic of the
@@ -189,10 +157,8 @@ public virtual IAsyncEnumerable<T> AsAsyncEnumerable(ISpecification<T> specifica
     /// </summary>
     /// <param name="specification">The encapsulated query logic.</param>
     /// <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);
-    }
+    protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specification, bool evaluateCriteriaOnly = false) 
+        => SpecificationEvaluator.GetQuery(DbContext.Set<T>().AsQueryable(), specification, evaluateCriteriaOnly);
 
     /// <summary>
     /// Filters all entities of <typeparamref name="T" />, that matches the encapsulated query logic of the
@@ -204,8 +170,6 @@ protected virtual IQueryable<T> ApplySpecification(ISpecification<T> specificati
     /// <typeparam name="TResult">The type of the value returned by the projection.</typeparam>
     /// <param name="specification">The encapsulated query logic.</param>
     /// <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);
-    }
+    protected virtual IQueryable<TResult> ApplySpecification<TResult>(ISpecification<T, TResult> specification) 
+        => 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
index 6c81b2a..1080499 100644
--- a/Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/Fixture/RepositoryOfT.cs
+++ b/Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/Fixture/RepositoryOfT.cs
@@ -1,16 +1,12 @@
 namespace Ardalis.Specification.EntityFrameworkCore.IntegrationTests.Fixture;
 
 /// <inheritdoc/>
-public class Repository<T> : RepositoryBase<T> where T : class
+public class Repository<T>(TestDbContext dbContext,
+    ISpecificationEvaluator specificationEvaluator) : RepositoryBase<T>(dbContext, specificationEvaluator), RepositoryBase<T> where T : class
 {
-    protected readonly TestDbContext dbContext;
+    protected readonly TestDbContext dbContext = dbContext;
 
     public Repository(TestDbContext dbContext) : this(dbContext, EntityFrameworkCore.SpecificationEvaluator.Default)
     {
     }
-
-    public Repository(TestDbContext dbContext, ISpecificationEvaluator specificationEvaluator) : base(dbContext, specificationEvaluator)
-    {
-        this.dbContext = dbContext;
-    }
 }
diff --git a/Specification/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs b/Specification/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs
index c5691ec..278cb91 100644
--- a/Specification/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs
+++ b/Specification/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs
@@ -1,18 +1,14 @@
 namespace Ardalis.Specification;
 
-public class CacheSpecificationBuilder<T> : ICacheSpecificationBuilder<T> where T : class
+public class CacheSpecificationBuilder<T>(
+    Specification<T> specification, 
+    bool isChainDiscarded) : ICacheSpecificationBuilder<T> where T : class
 {
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
+    public Specification<T> Specification { get; } = specification;
+    public bool IsChainDiscarded { get; set; } = isChainDiscarded;
 
     public CacheSpecificationBuilder(Specification<T> specification)
         : this(specification, false)
     {
     }
-
-    public CacheSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
 }
diff --git a/Specification/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs b/Specification/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs
index f1686f5..1fdf6cc 100644
--- a/Specification/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs
+++ b/Specification/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs
@@ -1,18 +1,14 @@
 namespace Ardalis.Specification;
 
-public class IncludableSpecificationBuilder<T, TProperty> : IIncludableSpecificationBuilder<T, TProperty> where T : class
+public class IncludableSpecificationBuilder<T, TProperty>(
+    Specification<T> specification,
+    bool isChainDiscarded) : IIncludableSpecificationBuilder<T, TProperty> where T : class
 {
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
+    public Specification<T> Specification { get; } = specification;
+    public bool IsChainDiscarded { get; set; } = isChainDiscarded;
 
     public IncludableSpecificationBuilder(Specification<T> specification)
         : this(specification, false)
     {
     }
-
-    public IncludableSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
 }
diff --git a/Specification/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs b/Specification/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs
index 7a31903..2ceea20 100644
--- a/Specification/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs
+++ b/Specification/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs
@@ -1,18 +1,14 @@
 namespace Ardalis.Specification;
 
-public class OrderedSpecificationBuilder<T> : IOrderedSpecificationBuilder<T>
+public class OrderedSpecificationBuilder<T>(
+    Specification<T> specification,
+    bool isChainDiscarded) : IOrderedSpecificationBuilder<T>
 {
-    public Specification<T> Specification { get; }
-    public bool IsChainDiscarded { get; set; }
+    public Specification<T> Specification { get; } = specification;
+    public bool IsChainDiscarded { get; set; } = isChainDiscarded;
 
     public OrderedSpecificationBuilder(Specification<T> specification)
         : this(specification, false)
     {
     }
-
-    public OrderedSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
-    {
-        Specification = specification;
-        IsChainDiscarded = isChainDiscarded;
-    }
 }
diff --git a/Specification/src/Ardalis.Specification/Builder/SpecificationBuilder.cs b/Specification/src/Ardalis.Specification/Builder/SpecificationBuilder.cs
index b23eed0..d460de0 100644
--- a/Specification/src/Ardalis.Specification/Builder/SpecificationBuilder.cs
+++ b/Specification/src/Ardalis.Specification/Builder/SpecificationBuilder.cs
@@ -1,22 +1,11 @@
 namespace Ardalis.Specification;
 
-public class SpecificationBuilder<T, TResult> : SpecificationBuilder<T>, ISpecificationBuilder<T, TResult>
+public class SpecificationBuilder<T, TResult>(Specification<T, TResult> specification) : SpecificationBuilder<T>(specification), ISpecificationBuilder<T, TResult>
 {
-    public new Specification<T, TResult> Specification { get; }
-
-    public SpecificationBuilder(Specification<T, TResult> specification)
-        : base(specification)
-    {
-        Specification = specification;
-    }
+    public new Specification<T, TResult> Specification { get; } = specification;
 }
 
-public class SpecificationBuilder<T> : ISpecificationBuilder<T>
+public class SpecificationBuilder<T>(Specification<T> specification) : ISpecificationBuilder<T>
 {
-    public Specification<T> Specification { get; }
-
-    public SpecificationBuilder(Specification<T> specification)
-    {
-        Specification = specification;
-    }
+    public Specification<T> Specification { get; } = specification;
 }
diff --git a/Specification/src/Ardalis.Specification/IncludeTypeEnum.cs b/Specification/src/Ardalis.Specification/IncludeTypeEnum.cs
index 83176da..54bd40b 100644
--- a/Specification/src/Ardalis.Specification/IncludeTypeEnum.cs
+++ b/Specification/src/Ardalis.Specification/IncludeTypeEnum.cs
@@ -3,5 +3,5 @@
 public enum IncludeTypeEnum
 {
     Include = 1,
-    ThenInclude = 2
+    ThenInclude 
 }
diff --git a/Specification/src/Ardalis.Specification/OrderTypeEnum.cs b/Specification/src/Ardalis.Specification/OrderTypeEnum.cs
index 0291805..85f781b 100644
--- a/Specification/src/Ardalis.Specification/OrderTypeEnum.cs
+++ b/Specification/src/Ardalis.Specification/OrderTypeEnum.cs
@@ -6,7 +6,7 @@
 public enum OrderTypeEnum
 {
     OrderBy = 1,
-    OrderByDescending = 2,
-    ThenBy = 3,
-    ThenByDescending = 4
+    OrderByDescending ,
+    ThenBy ,
+    ThenByDescending 
 }
diff --git a/Specification/src/Ardalis.Specification/Specification.cs b/Specification/src/Ardalis.Specification/Specification.cs
index 7f0c42e..527e032 100644
--- a/Specification/src/Ardalis.Specification/Specification.cs
+++ b/Specification/src/Ardalis.Specification/Specification.cs
@@ -15,15 +15,9 @@ protected Specification()
     }
 
     protected Specification(IInMemorySpecificationEvaluator inMemorySpecificationEvaluator)
-        : base(inMemorySpecificationEvaluator)
-    {
-        Query = new SpecificationBuilder<T, TResult>(this);
-    }
+        : base(inMemorySpecificationEvaluator) => Query = new SpecificationBuilder<T, TResult>(this);
 
-    public new virtual IEnumerable<TResult> Evaluate(IEnumerable<T> entities)
-    {
-        return Evaluator.Evaluate(entities, this);
-    }
+    public new virtual IEnumerable<TResult> Evaluate(IEnumerable<T> entities) => Evaluator.Evaluate(entities, this);
 
     /// <inheritdoc/>
     public Expression<Func<T, TResult>>? Selector { get; internal set; }
@@ -65,16 +59,10 @@ protected Specification(IInMemorySpecificationEvaluator inMemorySpecificationEva
     }
 
     /// <inheritdoc/>
-    public virtual IEnumerable<T> Evaluate(IEnumerable<T> entities)
-    {
-        return Evaluator.Evaluate(entities, this);
-    }
+    public virtual IEnumerable<T> Evaluate(IEnumerable<T> entities) => Evaluator.Evaluate(entities, this);
 
     /// <inheritdoc/>
-    public virtual bool IsSatisfiedBy(T entity)
-    {
-        return Validator.IsValid(entity, this);
-    }
+    public virtual bool IsSatisfiedBy(T entity) => Validator.IsValid(entity, this);
 
     /// <inheritdoc/>
     public IDictionary<string, object> Items { get; set; } = new Dictionary<string, object>();
diff --git a/Specification/src/Ardalis.Specification/Validators/SpecificationValidator.cs b/Specification/src/Ardalis.Specification/Validators/SpecificationValidator.cs
index b2ff6a2..cf24120 100644
--- a/Specification/src/Ardalis.Specification/Validators/SpecificationValidator.cs
+++ b/Specification/src/Ardalis.Specification/Validators/SpecificationValidator.cs
@@ -17,10 +17,7 @@ public SpecificationValidator()
             SearchValidator.Instance
         });
     }
-    public SpecificationValidator(IEnumerable<IValidator> validators)
-    {
-        _validators.AddRange(validators);
-    }
+    public SpecificationValidator(IEnumerable<IValidator> validators) => _validators.AddRange(validators);
 
     public virtual bool IsValid<T>(T entity, ISpecification<T> specification)
     {