[release/10.0] Fix InvalidCastException when query parameter is IEnumerable with mismatched enum types (#38021)

* Fix InvalidCastException when query parameter is IEnumerable with mismatched enum types

ValueConverter.Sanitize<T> used Convert.ChangeType for type mismatches, which
cannot convert between different enum types. Use Enum.ToObject instead when the
target type is an enum, which handles conversion from different enum types with
the same underlying type.

Fixes #38008

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Fix tests.

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Jiri Cincura <jiri@cincura.net>

Author: 3 people

src/EFCore/Storage/ValueConversion/ValueConverter`.cs

@@ -77,13 +77,26 @@ public ValueConverter(
                 ? null
                 : convertFunc(Sanitize<TIn>(v));
 
+    private static readonly bool UseOldBehavior38008 =
+        AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue38008", out var enabled) && enabled;
+
     private static T Sanitize<T>(object value)
     {
         var unwrappedType = typeof(T).UnwrapNullableType();
 
-        return (T)(!unwrappedType.IsInstanceOfType(value)
-            ? Convert.ChangeType(value, unwrappedType)
-            : value);
+        if (unwrappedType.IsInstanceOfType(value))
+        {
+            return (T)value;
+        }
+
+        // Convert.ChangeType cannot convert to enum types; use Enum.ToObject instead, which handles
+        // conversion from different enum types (with the same underlying type) or from integral types.
+        if (!UseOldBehavior38008 && unwrappedType.IsEnum)
+        {
+            return (T)Enum.ToObject(unwrappedType, value);
+        }
+
+        return (T)Convert.ChangeType(value, unwrappedType);
     }
 
     /// <summary>

test/EFCore.Relational.Specification.Tests/Query/NonSharedPrimitiveCollectionsQueryRelationalTestBase.cs

@@ -250,4 +250,56 @@ protected void ClearLog()
 
     protected void AssertSql(params string[] expected)
         => TestSqlLoggerFactory.AssertBaseline(expected);
+
+    // #38008
+    [ConditionalTheory, MemberData(nameof(ParameterTranslationModeValues))]
+    public virtual async Task Parameter_collection_of_enum_Cast_from_different_enum_type(ParameterTranslationMode mode)
+    {
+        var contextFactory = await InitializeAsync<Context38008>(
+            onConfiguring: b => SetParameterizedCollectionMode(b, mode),
+            seed: context =>
+            {
+                context.AddRange(
+                    new Context38008.TestEntity38008 { Id = 1, Status = Context38008.EntityEnum.Clean },
+                    new Context38008.TestEntity38008 { Id = 2, Status = Context38008.EntityEnum.Malware });
+                return context.SaveChangesAsync();
+            });
+
+        await using var context = contextFactory.CreateContext();
+
+        // Cast<EntityEnum>() returns a lazy IEnumerable whose boxed values retain the ViewModelEnum runtime type.
+        var filter = new[] { Context38008.ViewModelEnum.Malware }.Cast<Context38008.EntityEnum>();
+        var result = await context.Set<Context38008.TestEntity38008>()
+            .Where(a => filter.Any(f => f == a.Status))
+            .Select(a => a.Id)
+            .ToListAsync();
+
+        Assert.Equivalent(new[] { 2 }, result);
+    }
+
+    protected class Context38008(DbContextOptions options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+            => modelBuilder.Entity<TestEntity38008>().Property(e => e.Id).ValueGeneratedNever();
+
+        public class TestEntity38008
+        {
+            public int Id { get; set; }
+            public EntityEnum Status { get; set; }
+        }
+
+        [Flags]
+        public enum EntityEnum
+        {
+            Clean = 1,
+            Malware = 2
+        }
+
+        [Flags]
+        public enum ViewModelEnum
+        {
+            Clean = 1,
+            Malware = 2
+        }
+    }
 }

test/EFCore.SqlServer.FunctionalTests/Query/NonSharedPrimitiveCollectionsQuerySqlServerTest.cs

@@ -1201,6 +1201,63 @@ public class Dependent
         }
     }
 
+    public override async Task Parameter_collection_of_enum_Cast_from_different_enum_type(ParameterTranslationMode mode)
+    {
+        await base.Parameter_collection_of_enum_Cast_from_different_enum_type(mode);
+
+        switch (mode)
+        {
+            case ParameterTranslationMode.Constant:
+            {
+                AssertSql(
+                    """
+SELECT [t].[Id]
+FROM [TestEntity38008] AS [t]
+WHERE EXISTS (
+    SELECT 1
+    FROM (VALUES (CAST(2 AS int))) AS [f]([Value])
+    WHERE [f].[Value] = [t].[Status])
+""");
+                break;
+            }
+
+            case ParameterTranslationMode.Parameter:
+            {
+                AssertSql(
+                    """
+@filter='[2]' (Size = 4000)
+
+SELECT [t].[Id]
+FROM [TestEntity38008] AS [t]
+WHERE EXISTS (
+    SELECT 1
+    FROM OPENJSON(@filter) WITH ([value] int '$') AS [f]
+    WHERE [f].[value] = [t].[Status])
+""");
+                break;
+            }
+
+            case ParameterTranslationMode.MultipleParameters:
+            {
+                AssertSql(
+                    """
+@filter1='2'
+
+SELECT [t].[Id]
+FROM [TestEntity38008] AS [t]
+WHERE EXISTS (
+    SELECT 1
+    FROM (VALUES (@filter1)) AS [f]([Value])
+    WHERE [f].[Value] = [t].[Status])
+""");
+                break;
+            }
+
+            default:
+                throw new NotImplementedException();
+        }
+    }
+
     [ConditionalFact]
     public virtual void Check_all_tests_overridden()
         => TestHelpers.AssertAllMethodsOverridden(GetType());