如何让EF Core正确将复杂值对象查询转换为SQL？

问题背景 #

我在.NET 9项目里用EF Core 8连接PostgreSQL数据库，实体里有个DateRange值对象类型的属性，配置了复杂属性映射，但查询时EF Core无法把值对象的条件翻译成SQL，报错提示LINQ表达式无法转换。

相关代码 #

值对象定义：

public record DateRange
{
    private DateRange()
    {
    }

    public DateOnly Start { get; init; }
    public DateOnly? End { get; init; }

    public int LengthInDays => End.HasValue ? End.Value.DayNumber - Start.DayNumber : int.MaxValue;

    public static DateRange Create(DateOnly start, DateOnly? end)
    {
        if (start == default) 
            throw new ArgumentException("Start date cannot be empty.", nameof(start));

        if (end.HasValue && start > end.Value) 
            throw new ApplicationException("End date precedes start date");

        return new DateRange
                   {
                       Start = start,
                       End = end
                   };
    }

    public bool IsWithinRange(DateOnly date)
    {
        return date >= Start && (!End.HasValue || date <= End);
    }
}

实体属性：

public DateRange ValidityDateRange { get; private set; }

实体配置：

builder.ComplexProperty(x => x.ValidityDateRange);

报错的查询代码：

var campaigns = await campaignRepository.Query()
        .Where(c => c.ValidityDateRange.Start <= currentDate && c.ValidityDateRange.End >= currentDate)
        .WhereIf(request.Title is not null, c => c.Title.Value == request.Title)
        .WhereIf(request.Code is not null, c => c.Code.Value == request.Code)
        .WhereIf(request.CategoryName is not null, c => c.CampaignCategory.Name.Value == request.CategoryName)
        .WhereIf(request.TypeName is not null, c => c.CampaignType.Name.Value == request.TypeName)
        .Include(c => c.CampaignCategory)
        .Include(c => c.CampaignType)
        .Include(c => c.Conditions)
        .ThenInclude(cond => cond.ProductCategory)
        .Include(c => c.Rewards)
        .ThenInclude(reward => reward.ProductCategory)
        .Include(c => c.Coupons)
        .AsSplitQuery()
        .ToListAsync(cancellationToken);

错误信息：

The LINQ expression 'DbSet()
.Where(c => !(c.IsDeleted))
.Where(c => c.ValidityDateRange.Start <= __currentDate_0 && c.ValidityDateRange.End >= __currentDate_1)
.Where(c => c.Title.Value == __request_Title_2)' could not be translated. Either rewrite the query in a form that can be translated, or switch to client evaluation explicitly by inserting a call to 'AsEnumerable', 'AsAsyncEnumerable', 'ToList', or 'ToListAsync'.

解决办法 #

1. 显式指定复杂属性的数据库列名 #

EF Core自动生成的复杂属性列名可能存在识别问题，手动指定每个子属性对应的列名，让EF Core明确映射关系：

修改实体配置：

builder.ComplexProperty(x => x.ValidityDateRange, cp =>
{
    cp.Property(dr => dr.Start).HasColumnName("ValidityStart");
    cp.Property(dr => dr.End).HasColumnName("ValidityEnd");
});

这样查询时EF Core能准确识别到对应的数据库列，顺利翻译条件。

2. 注册值对象方法的SQL翻译 #

利用EF Core的自定义函数翻译功能，把IsWithinRange方法翻译成对应的SQL逻辑，既保持DDD值对象的封装性，又能让EF Core正确翻译：

首先修改查询，直接调用值对象的方法：

.Where(c => c.ValidityDateRange.IsWithinRange(currentDate))

然后在DbContext的OnModelCreating中注册方法翻译：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // 其他配置代码...

    // 注册IsWithinRange方法的SQL翻译
    modelBuilder.Entity<YourCampaignEntity>()
        .HasDbFunction(typeof(DateRange).GetMethod(nameof(DateRange.IsWithinRange))!)
        .HasTranslation(args =>
        {
            // args[0]是DateRange实例，args[1]是传入的date参数
            var dateRange = args[0];
            var date = args[1];

            return Expression.AndAlso(
                Expression.GreaterThanOrEqual(date, dateRange.Property(nameof(DateRange.Start))),
                Expression.OrElse(
                    Expression.Equal(dateRange.Property(nameof(DateRange.End)), Expression.Constant(null, typeof(DateOnly?))),
                    Expression.LessThanOrEqual(date, dateRange.Property(nameof(DateRange.End)))
                )
            );
        });
}

注意替换YourCampaignEntity为你的实体类型，这样EF Core就能把方法调用转换成对应的WHERE条件。

3. 利用PostgreSQL原生daterange类型 #

PostgreSQL支持原生的daterange类型，直接映射这个类型比拆分成两个字段更高效，也更符合值对象的设计：

首先安装Npgsql.EntityFrameworkCore.PostgreSQL包（如果没装的话），然后创建一个转换器：

public class DateRangeConverter : ValueConverter<DateRange, NpgsqlRange<DateOnly>>
{
    public DateRangeConverter()
        : base(
            dateRange => new NpgsqlRange<DateOnly>(dateRange.Start, dateRange.End, dateRange.End.HasValue ? RangeBoundType.Inclusive : RangeBoundType.Unbounded),
            npgsqlRange => DateRange.Create(npgsqlRange.LowerBound.Value, npgsqlRange.UpperBound.HasValue ? npgsqlRange.UpperBound.Value : null)
        )
    {
    }
}

然后修改实体配置，直接映射到daterange类型：

builder.Property(x => x.ValidityDateRange)
    .HasColumnType("daterange")
    .HasConversion<DateRangeConverter>();

查询时可以直接用PostgreSQL的范围包含操作，EF Core能自动翻译：

.Where(c => EF.Functions.Contains(c.ValidityDateRange, currentDate))

这个方式性能最优，因为直接利用了数据库的原生范围类型支持。

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