diff --git a/src/EFCore/Extensions/EntityFrameworkQueryableExtensions.cs b/src/EFCore/Extensions/EntityFrameworkQueryableExtensions.cs
index 5745e5ae638..21915af068a 100644
--- a/src/EFCore/Extensions/EntityFrameworkQueryableExtensions.cs
+++ b/src/EFCore/Extensions/EntityFrameworkQueryableExtensions.cs
@@ -2710,9 +2710,7 @@ public static IQueryable<TEntity> IgnoreQueryFilters<TEntity>(
                 Expression.Call(
                     instance: null,
                     method: IgnoreNamedQueryFiltersMethodInfo.MakeGenericMethod(typeof(TEntity)),
-                    // converting the collection to an array if it isn't already one to ensure consistent caching. Fixes #37112.
-                    // #37212 may be a possible future solution providing broader capabilities around parameterizing collections.
-                    arguments: [source.Expression, Expression.Constant(filterKeys is string[] ? filterKeys : filterKeys.ToArray())]))
+                    arguments: [source.Expression, Expression.Constant(filterKeys)]))
             : source;
 
     #endregion
diff --git a/src/EFCore/Query/ExpressionEqualityComparer.cs b/src/EFCore/Query/ExpressionEqualityComparer.cs
index 3f2875f866f..6e3d0b55740 100644
--- a/src/EFCore/Query/ExpressionEqualityComparer.cs
+++ b/src/EFCore/Query/ExpressionEqualityComparer.cs
@@ -76,6 +76,13 @@ public int GetHashCode(Expression obj)
                             hash.Add(structuralEquatable.GetHashCode(StructuralComparisons.StructuralEqualityComparer));
                             break;
 
+                        case IEnumerable enumerable:
+                            foreach (var item in enumerable)
+                            {
+                                hash.Add(item?.GetHashCode() ?? 0);
+                            }
+                            break;
+
                         default:
                             hash.Add(constantExpression.Value);
                             break;
@@ -368,8 +375,25 @@ private static bool CompareConstant(ConstantExpression a, ConstantExpression b)
         {
             var (v1, v2) = (a.Value, b.Value);
 
-            return Equals(v1, v2)
-                || (v1 is IStructuralEquatable array1 && array1.Equals(v2, StructuralComparisons.StructuralEqualityComparer));
+            if (Equals(v1, v2))
+            {
+                return true;
+            }
+
+            if (v1 is IStructuralEquatable structuralEquatable1)
+            {
+                if (structuralEquatable1.Equals(v2, StructuralComparisons.StructuralEqualityComparer))
+                {
+                    return true;
+                }
+            }
+
+            if (v1 is IEnumerable enumerable1 && v2 is IEnumerable enumerable2)
+            {
+                return enumerable1.Cast<object?>().SequenceEqual(enumerable2.Cast<object?>());
+            }
+
+            return false;
         }
 
         private bool CompareGoto(GotoExpression a, GotoExpression b)