Union查询中选择子集合时Entity Framework异常问题咨询

这个问题我之前也碰到过，核心原因其实很明确：EF在处理Union操作时，默认会自动添加Distinct来去除重复结果，但匿名类型里如果包含集合属性（比如你的ItemType集合），EF没办法在数据库层面判断两个集合是否相等，自然就抛出那个ArgumentException了。再加上你用了TPT继承（每个派生类单独一张表），Union多个表的查询时这个矛盾就更突出了。

下面给你几个实用的解决方案，你可以根据自己的业务场景选：

方案一：先查基础数据，内存中加载子集合（最推荐） #

思路是把数据库层面的查询和子集合加载分开，先Union出所有基础字段（不含集合）并加载到内存，再批量查询关联的子集合，最后在内存中组合。这样EF不需要在数据库里处理集合的Distinct，完美避开问题。

示例代码：

// 第一步：Union查询基础属性，先加载到内存
var baseRecords = context.TypeA
    .Select(a => new 
    {
        Id = a.Id,
        Name = a.Name,
        RefTypeId = a.RefType.Id,
        // 可选：加个类型标识，方便后续区分原类型
        SourceType = "TypeA"
    })
    .Union(context.TypeB
        .Select(b => new 
        {
            Id = b.Id,
            Name = b.Name,
            RefTypeId = b.RefType.Id,
            SourceType = "TypeB"
        }))
    .ToList(); // 关键：先把基础数据拉到内存

// 第二步：批量查询所有关联的RefType及其Item集合
var refTypeIds = baseRecords.Select(r => r.RefTypeId).Distinct();
var refTypeDict = context.RefType
    .Where(r => refTypeIds.Contains(r.Id))
    .Include(r => r.Items) // 预加载Item集合
    .ToDictionary(r => r.Id);

// 第三步：组合成包含子集合的最终结果
var finalResult = baseRecords.Select(r => new 
{
    r.Id,
    r.Name,
    r.SourceType,
    Items = refTypeDict[r.RefTypeId].Items
}).ToList();

方案二：用Concat代替Union（如果不需要去重） #

如果你的两个派生类查询结果不会有重复数据（比如每个记录的Id都是唯一的），那直接用Concat代替Union就行——Concat只是单纯合并两个结果集，不会自动执行Distinct，自然也就不会触发集合比较的问题。

示例代码：

var result = context.TypeA
    .Select(a => new 
    {
        a.Id,
        a.Name,
        Items = a.RefType.Items
    })
    .Concat(context.TypeB
        .Select(b => new 
        {
            b.Id,
            b.Name,
            Items = b.RefType.Items
        }))
    .ToList();

⚠️ 注意：这个方案只适用于你确定两个结果集没有重复的情况，如果有重复数据，最终结果会保留重复项，要根据业务需求判断。

方案三：用DTO类代替匿名类型，内存中Union（适合小数据量） #

如果必须保留Union的去重功能，且要包含子集合，那只能把所有数据先加载到内存，再在内存中做Union。但匿名类型不好自定义比较逻辑，所以建议先定义一个DTO类，重写相等判断方法。

示例代码：

// 先定义DTO类，实现相等比较
public class EntityDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<ItemType> Items { get; set; }

    // 重写Equals和GetHashCode，这里假设Id是唯一标识，或者根据实际需求调整
    public override bool Equals(object obj)
    {
        if (obj is not EntityDto other) return false;
        // 如果需要严格比较集合内容，要确保ItemType也重写了Equals
        return Id == other.Id && Name == other.Name && Items.SequenceEqual(other.Items);
    }

    public override int GetHashCode()
    {
        // 这里可以只根据Id（因为Id唯一），或者包含Name和Items的哈希
        return HashCode.Combine(Id);
    }
}

// 然后查询并在内存中Union
var typeAData = context.TypeA
    .Include(a => a.RefType.Items)
    .Select(a => new EntityDto
    {
        Id = a.Id,
        Name = a.Name,
        Items = a.RefType.Items.ToList()
    })
    .ToList();

var typeBData = context.TypeB
    .Include(b => b.RefType.Items)
    .Select(b => new EntityDto
    {
        Id = b.Id,
        Name = b.Name,
        Items = b.RefType.Items.ToList()
    })
    .ToList();

var finalResult = typeAData.Union(typeBData).ToList();

⚠️ 注意：这个方案会把所有数据加载到内存，数据量大的时候性能会受影响，只适合小数据集的场景。

内容的提问来源于stack exchange，提问作者givemelight