为什么我看到 between.Cast<int>() 和 .Select(a => (int)a) 不同？

Question

我正在尝试找出以下内容之间的区别：

someListOfEnums.Cast<int>()

和

someListOfEnums.Select(a => (int)a)?

我发现前者在 Entity Framework Core 3.1 的 Where 子句中使用时会导致异常，但后者不会。我本以为他们会采取类似的行动。

举个例子： ~~public 枚举水果 { 苹果，香蕉，橙子 }~~

public class FruitTable { public int Id { get; set; } public Fruit Value { get; set; } } public class FruitContext : DbContext { public DbSet<FruitTable> Fruit { get; set; } } public void TestMethod(FruitContext context) { var list = new List<Fruit>{Fruit.Apple, Fruit.Orange}; var breaks = list.Cast<int>(); var works = list.Select(a => (int)a); var fruits1 = context.Fruit.Where(a => works.Contains(a.Value)).ToList(); //This works var fruits2 = context.Fruit.Where(a => breaks.Contains(a.Value)).ToList(); //This breaks }

似乎使用 .Cast<int>() 会导致包含枚举名称（Apple、Orange 等）的 where 子句，而使用 .Select(a => (int)a) 则不会。

更新

我已经意识到我上面的例子不会导致同样的问题（抱歉）。我已经完成并创建了一个程序，它肯定会重现该问题。

使用以下数据库：

CREATE DATABASE Fruit

USE Fruit

CREATE TABLE Fruit
(
Id INT NOT NULL PRIMARY KEY,
Value INT NOT NULL,
)

INSERT INTO Fruit VALUES (1, 0)
INSERT INTO Fruit VALUES (3, 2)

以下程序：

using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
namespace ConsoleApp
{
    public class Program
    {
        static void Main(string[] args)
        {
            FruitTable.TestMethod(new FruitContext());
        }

        public enum Fruit
        {
            Apple,
            Banana,
            Orange
        }

        public class FruitTable
        {
            public int Id { get; set; }
            public int Value { get; set; }

            public static void TestMethod(FruitContext context)
            {
                IEnumerable<Fruit> list = new Fruit[] {Fruit.Apple, Fruit.Orange};

                var breaks = list.Cast<int>();
                var works = list.Select(a => (int) a);

                var fruits1 = context.Fruit.Where(a => works.Contains(a.Value)).ToList(); //This works
                var fruits2 = context.Fruit.Where(a => breaks.Contains(a.Value)).ToList(); //This breaks
            }
        }

        public class FruitContext : DbContext
        {
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlServer("Server=.;Database=fruit;Trusted_Connection=True;ConnectRetryCount=0");
            }

            public DbSet<FruitTable> Fruit { get; set; }
        }
    }
}

导致以下错误：

'Invalid column name 'Orange'. Invalid column name 'Apple'.'

编辑

补充一下，问题在 .Net Core 2.2 中不存在，当我们迁移到 3.1 时出现了。仔细想想——可能是因为这个：https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-3.0/breaking-changes#linq-queries-are-no-longer-evaluated-on-the-client

Answer 1

其实从.net的角度来看Cast<int>和Select(a => (int)a是不一样的。 Cast 会将值装箱到 object，然后将其拆箱回到 int。

static IEnumerable<TResult> CastIterator<TResult>(IEnumerable source) {
            foreach (object obj in source) yield return (TResult)obj;
        }

并且作为一项规则，对象只能拆箱到它从装箱的类型。否则会抛出异常。

但是，由于您的 Enum 的基础价值也是 Int，Cast<int> 将按预期工作。

更新：

如评论所述，要解决此问题，您可以将 ToList() 附加到查询末尾。现在该查询将以适当的方式在 .net 端进行评估。否则，EF Core 3.0 将尝试生成 Sql，如果失败，它将抛出异常。

 var breaks = list.Cast<int>().ToList();

关于您的编辑：

Just to add the problem was not present in .Net Core 2.2, it appeared when we migrated to 3.1. Thinking about it - it may be due to this:

在 link 中确实很好地解释了为什么它在 .net core 2.2 中工作。好像在以前的版本中当 EF Core 无法将作为查询一部分的表达式转换为 SQL 或参数时，它会自动在客户端上计算表达式。

而且真的很糟糕。因为，如前所述：

For example, a condition in a Where() call which can't be translated can cause all rows from the table to be transferred from the database server, and the filter to be applied on the client.

因此，之前您似乎只是将所有数据加载到客户端，然后在客户端应用过滤器。

为什么我看到 between.Cast<int>() 和 .Select(a => (int)a) 不同？

Why am I seeing a difference between.Cast<int>() and .Select(a => (int)a)?

c#

linq

casting

.net-core

ef-core-3.1