Fix allocations produced by unreachable fallback code

src/Ardalis.Specification.EntityFrameworkCore/Evaluators/IncludeStringEvaluator.cs

@@ -13,17 +13,22 @@ public IQueryable<T> GetQuery<T>(IQueryable<T> query, ISpecification<T> specific
         if (specification is Specification<T> spec)
         {
             if (spec.OneOrManyIncludeStrings.IsEmpty) return query;
-            if (spec.OneOrManyIncludeStrings.SingleOrDefault is { } includeString)
+            if (spec.OneOrManyIncludeStrings.SingleOrDefault is { } includeStr)
             {
-                return query.Include(includeString);
+                return query.Include(includeStr);
             }
+
+            foreach (var includeString in spec.OneOrManyIncludeStrings.List)
+            {
+                query = query.Include(includeString);
+            }
+            return query;
         }
 
         foreach (var includeString in specification.IncludeStrings)
         {
             query = query.Include(includeString);
         }
-
         return query;
     }
 }

src/Ardalis.Specification.EntityFrameworkCore/Evaluators/QueryTagEvaluator.cs

@@ -17,13 +17,18 @@ public IQueryable<T> GetQuery<T>(IQueryable<T> query, ISpecification<T> specific
             {
                 return query.TagWith(spec.OneOrManyQueryTags.Single);
             }
+
+            foreach (var tag in spec.OneOrManyQueryTags.List)
+            {
+                query = query.TagWith(tag);
+            }
+            return query;
         }
 
         foreach (var tag in specification.QueryTags)
         {
             query = query.TagWith(tag);
         }
-
         return query;
     }
 }

src/Ardalis.Specification/Evaluators/SearchMemoryEvaluator.cs

@@ -33,14 +33,19 @@ public IEnumerable<T> Evaluate<T>(IEnumerable<T> query, ISpecification<T> specif
         // This is just to cover the case where users have custom ISpecification<T> implementation but use our evaluator.
         // We'll fall back to LINQ for this case.
 
-        foreach (var searchGroup in specification.SearchCriterias.GroupBy(x => x.SearchGroup))
+        return Fallback(query, specification);
+
+        static IEnumerable<T> Fallback(IEnumerable<T> query, ISpecification<T> specification)
         {
-            query = query.Where(x => searchGroup.Any(c => c.SelectorFunc(x)?.Like(c.SearchTerm) ?? false));
+            foreach (var searchGroup in specification.SearchCriterias.GroupBy(x => x.SearchGroup))
+            {
+                query = query.Where(x => searchGroup.Any(c => c.SelectorFunc(x)?.Like(c.SearchTerm) ?? false));
+            }
+            return query;
         }
-
-        return query;
     }
 
+
     private sealed class SpecSingleLikeIterator<TSource> : Iterator<TSource>
     {
         private readonly IEnumerable<TSource> _source;

src/Ardalis.Specification/Evaluators/WhereEvaluator.cs

@@ -24,13 +24,18 @@ public IQueryable<T> GetQuery<T>(IQueryable<T> query, ISpecification<T> specific
             {
                 return query.Where(whereExpression.Filter);
             }
+
+            foreach (var whereExpr in spec.OneOrManyWhereExpressions.List)
+            {
+                query = query.Where(whereExpr.Filter);
+            }
+            return query;
         }
 
         foreach (var whereExpression in specification.WhereExpressions)
         {
             query = query.Where(whereExpression.Filter);
         }
-
         return query;
     }
 
@@ -44,13 +49,18 @@ public IEnumerable<T> Evaluate<T>(IEnumerable<T> query, ISpecification<T> specif
             {
                 return query.Where(whereExpression.FilterFunc);
             }
+
+            foreach (var whereExpr in spec.OneOrManyWhereExpressions.List)
+            {
+                query = query.Where(whereExpr.FilterFunc);
+            }
+            return query;
         }
 
         foreach (var whereExpression in specification.WhereExpressions)
         {
             query = query.Where(whereExpression.FilterFunc);
         }
-
         return query;
     }
 }

src/Ardalis.Specification/Validators/SearchValidator.cs

@@ -24,13 +24,18 @@ public bool IsValid<T>(T entity, ISpecification<T> specification)
         // This is just to cover the case where users have custom ISpecification<T> implementation but use our validator.
         // We'll fall back to LINQ for this case.
 
-        foreach (var searchGroup in specification.SearchCriterias.GroupBy(x => x.SearchGroup))
+        return Fallback(entity, specification);
+
+        static bool Fallback(T entity, ISpecification<T> specification)
         {
-            if (!searchGroup.Any(c => c.SelectorFunc(entity)?.Like(c.SearchTerm) ?? false))
-                return false;
-        }
+            foreach (var searchGroup in specification.SearchCriterias.GroupBy(x => x.SearchGroup))
+            {
+                if (!searchGroup.Any(c => c.SelectorFunc(entity)?.Like(c.SearchTerm) ?? false))
+                    return false;
+            }
 
-        return true;
+            return true;
+        }
     }
 
     // This would be simpler using Span<SearchExpressionInfo<T>>

src/Ardalis.Specification/Validators/WhereValidator.cs

@@ -14,13 +14,18 @@ public bool IsValid<T>(T entity, ISpecification<T> specification)
             {
                 return whereExpression.FilterFunc(entity);
             }
+
+            foreach (var whereExpr in spec.OneOrManyWhereExpressions.List)
+            {
+                if (whereExpr.FilterFunc(entity) == false) return false;
+            }
+            return true;
         }
 
-        foreach (var whereExpression in specification.WhereExpressions)
+        foreach (var whereExpr in specification.WhereExpressions)
         {
-            if (whereExpression.FilterFunc(entity) == false) return false;
+            if (whereExpr.FilterFunc(entity) == false) return false;
         }
-
         return true;
     }
 }