Implement specification validators.

Specification.EntityFramework6/tests/Ardalis.Specification.EntityFramework6.IntegrationTests/RepositoryOfT_ListAsync.cs

@@ -167,7 +167,7 @@ public async Task ReturnsStoreContainingCity1_GivenStoreIncludeProductsSpec()
 
             result.Should().NotBeNull();
             result.Should().ContainSingle();
-            result[0].Id.Should().Be(StoreSeed.VALID_Search_City_ID);
+            result[0].Id.Should().Be(StoreSeed.VALID_Search_ID);
             result[0].City.Should().Contain(StoreSeed.VALID_Search_City_Key);
         }
     }

Specification.EntityFrameworkCore/tests/Ardalis.Specification.EntityFrameworkCore.IntegrationTests/RepositoryOfT_ListAsync.cs

@@ -193,7 +193,7 @@ public virtual async Task ReturnsStoreContainingCity1_GivenStoreIncludeProductsS
 
             result.Should().NotBeNull();
             result.Should().ContainSingle();
-            result[0].Id.Should().Be(StoreSeed.VALID_Search_City_ID);
+            result[0].Id.Should().Be(StoreSeed.VALID_Search_ID);
             result[0].City.Should().Contain(StoreSeed.VALID_Search_City_Key);
         }
     }

Specification/src/Ardalis.Specification/Builder/CacheSpecificationBuilder.cs

@@ -3,10 +3,17 @@
     public class CacheSpecificationBuilder<T> : ICacheSpecificationBuilder<T> where T : class
     {
         public Specification<T> Specification { get; }
+        public bool IsChainDiscarded { get; set; }
 
         public CacheSpecificationBuilder(Specification<T> specification)
+            :this(specification, false)
         {
-            Specification = specification;
+        }
+
+        public CacheSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
+        {
+            this.Specification = specification;
+            this.IsChainDiscarded = isChainDiscarded;
         }
     }
 }

Specification/src/Ardalis.Specification/Builder/ICacheSpecificationBuilder.cs

@@ -2,5 +2,6 @@
 {
     public interface ICacheSpecificationBuilder<T> : ISpecificationBuilder<T> where T : class
     {
+        bool IsChainDiscarded { get; set; }
     }
 }

Specification/src/Ardalis.Specification/Builder/IIncludableSpecificationBuilder.cs

@@ -6,5 +6,6 @@ namespace Ardalis.Specification
 {
     public interface IIncludableSpecificationBuilder<T, out TProperty> : ISpecificationBuilder<T> where T : class
     {
+        bool IsChainDiscarded { get; set; }
     }
 }

Specification/src/Ardalis.Specification/Builder/IOrderedSpecificationBuilder.cs

@@ -7,5 +7,6 @@ namespace Ardalis.Specification
 {
     public interface IOrderedSpecificationBuilder<T> : ISpecificationBuilder<T>
     {
+        bool IsChainDiscarded { get; set; }
     }
 }

Specification/src/Ardalis.Specification/Builder/IncludableBuilderExtensions.cs

@@ -10,12 +10,22 @@ public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TE
             this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> previousBuilder,
             Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression)
             where TEntity : class
+            => ThenInclude(previousBuilder, thenIncludeExpression, true);
+
+        public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+            this IIncludableSpecificationBuilder<TEntity, TPreviousProperty> previousBuilder,
+            Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression,
+            bool condition)
+            where TEntity : class
         {
-            var info = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(TPreviousProperty));
+            if (condition && !previousBuilder.IsChainDiscarded)
+            {
+                var info = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(TPreviousProperty));
 
-            ((List<IncludeExpressionInfo>)previousBuilder.Specification.IncludeExpressions).Add(info);
+                ((List<IncludeExpressionInfo>)previousBuilder.Specification.IncludeExpressions).Add(info);
+            }
 
-            var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification);
+            var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification, !condition || previousBuilder.IsChainDiscarded);
 
             return includeBuilder;
         }
@@ -24,12 +34,22 @@ public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TE
             this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> previousBuilder,
             Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression)
             where TEntity : class
+            => ThenInclude(previousBuilder, thenIncludeExpression, true);
+
+        public static IIncludableSpecificationBuilder<TEntity, TProperty> ThenInclude<TEntity, TPreviousProperty, TProperty>(
+            this IIncludableSpecificationBuilder<TEntity, IEnumerable<TPreviousProperty>> previousBuilder,
+            Expression<Func<TPreviousProperty, TProperty>> thenIncludeExpression,
+            bool condition)
+            where TEntity : class
         {
-            var info = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(IEnumerable<TPreviousProperty>));
+            if (condition && !previousBuilder.IsChainDiscarded)
+            {
+                var info = new IncludeExpressionInfo(thenIncludeExpression, typeof(TEntity), typeof(TProperty), typeof(IEnumerable<TPreviousProperty>));
 
-            ((List<IncludeExpressionInfo>)previousBuilder.Specification.IncludeExpressions).Add(info);
+                ((List<IncludeExpressionInfo>)previousBuilder.Specification.IncludeExpressions).Add(info);
+            }
 
-            var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification);
+            var includeBuilder = new IncludableSpecificationBuilder<TEntity, TProperty>(previousBuilder.Specification, !condition || previousBuilder.IsChainDiscarded);
 
             return includeBuilder;
         }

Specification/src/Ardalis.Specification/Builder/IncludableSpecificationBuilder.cs

@@ -7,10 +7,17 @@ namespace Ardalis.Specification
     public class IncludableSpecificationBuilder<T, TProperty> : IIncludableSpecificationBuilder<T, TProperty> where T : class
     {
         public Specification<T> Specification { get; }
+        public bool IsChainDiscarded { get; set; }
 
         public IncludableSpecificationBuilder(Specification<T> specification)
+            :this(specification, false)
         {
-            Specification = specification;
+        }
+
+        public IncludableSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
+        {
+            this.Specification = specification;
+            this.IsChainDiscarded = isChainDiscarded;
         }
     }
 }

Specification/src/Ardalis.Specification/Builder/OrderedBuilderExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 
 namespace Ardalis.Specification
@@ -9,17 +10,43 @@ public static class OrderedBuilderExtensions
         public static IOrderedSpecificationBuilder<T> ThenBy<T>(
             this IOrderedSpecificationBuilder<T> orderedBuilder,
             Expression<Func<T, object?>> orderExpression)
+            => ThenBy(orderedBuilder, orderExpression, true);
+
+        public static IOrderedSpecificationBuilder<T> ThenBy<T>(
+            this IOrderedSpecificationBuilder<T> orderedBuilder,
+            Expression<Func<T, object?>> orderExpression,
+            bool condition)
         {
-            ((List<OrderExpressionInfo<T>>)orderedBuilder.Specification.OrderExpressions).Add(new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenBy));
+            if (condition && !orderedBuilder.IsChainDiscarded)
+            {
+                ((List<OrderExpressionInfo<T>>)orderedBuilder.Specification.OrderExpressions).Add(new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenBy));
+            }
+            else
+            {
+                orderedBuilder.IsChainDiscarded = true;
+            }
 
             return orderedBuilder;
         }
 
         public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
             this IOrderedSpecificationBuilder<T> orderedBuilder,
             Expression<Func<T, object?>> orderExpression)
+            => ThenByDescending(orderedBuilder, orderExpression, true);
+
+        public static IOrderedSpecificationBuilder<T> ThenByDescending<T>(
+            this IOrderedSpecificationBuilder<T> orderedBuilder,
+            Expression<Func<T, object?>> orderExpression,
+            bool condition)
         {
-            ((List<OrderExpressionInfo<T>>)orderedBuilder.Specification.OrderExpressions).Add(new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenByDescending));
+            if (condition && !orderedBuilder.IsChainDiscarded)
+            {
+                ((List<OrderExpressionInfo<T>>)orderedBuilder.Specification.OrderExpressions).Add(new OrderExpressionInfo<T>(orderExpression, OrderTypeEnum.ThenByDescending));
+            }
+            else
+            {
+                orderedBuilder.IsChainDiscarded = true;
+            }
 
             return orderedBuilder;
         }

Specification/src/Ardalis.Specification/Builder/OrderedSpecificationBuilder.cs

@@ -8,12 +8,17 @@ namespace Ardalis.Specification
     public class OrderedSpecificationBuilder<T> : IOrderedSpecificationBuilder<T>
     {
         public Specification<T> Specification { get; }
+        public bool IsChainDiscarded { get; set; }
 
         public OrderedSpecificationBuilder(Specification<T> specification)
+            :this(specification, false)
         {
-            this.Specification = specification;
         }
 
-
+        public OrderedSpecificationBuilder(Specification<T> specification, bool isChainDiscarded)
+        {
+            this.Specification = specification;
+            this.IsChainDiscarded = isChainDiscarded;
+        }
     }
 }