自定义DeferredFirstOrDefault实现遇ToQueryString返回类型不匹配错误求助

错误原因 #

你遇到的ArgumentException是因为Queryable.FirstOrDefault<T>方法的返回类型是单个T实例（比如你的CompanyInfo），但IQueryProvider.CreateQuery<T>要求传入的表达式树返回类型必须是IEnumerable<T>——因为IQueryable<T>本质是对可枚举集合的查询描述，无法直接承载单个值的表达式。

方案1：生成带SELECT TOP(1)的SQL（无延迟批量需求） #

如果只是需要得到包含TOP(1)的SQL语句，无需延迟批量执行，直接使用Take(1)即可，它返回的IQueryable<T>符合类型要求：

IQueryable<T> query = queryable;
if (predicate != null)
    query = queryable.Where(predicate);

// 用Take(1)代替直接构造FirstOrDefault表达式
var top1Query = query.Take(1);
var stringQuery = top1Query.ToQueryString();

此时ToQueryString()会正确生成包含TOP(1)的SQL，且不会触发类型错误。

方案2：实现类似EF Plus的延迟批量执行功能 #

要实现延迟批量执行（多个查询一次性提交数据库），需要自定义包装类跟踪延迟查询，直到调用FutureValue()时统一执行。

步骤1：定义延迟值包装类 #

public class DeferredValue<T>
{
    private readonly IQueryable<T> _sourceQuery;

    public DeferredValue(IQueryable<T> sourceQuery)
    {
        _sourceQuery = sourceQuery;
    }

    // 存储执行后的结果
    public T Result { get; private set; }
    // 标记是否已执行
    public bool IsExecuted { get; private set; }

    // 执行当前查询并返回结果
    public T Execute()
    {
        if (IsExecuted) return Result;

        // 构造FirstOrDefault的调用表达式
        var firstOrDefaultCall = Expression.Call(
            typeof(Queryable),
            "FirstOrDefault",
            new[] { typeof(T) },
            _sourceQuery.Expression);
        
        Result = _sourceQuery.Provider.Execute<T>(firstOrDefaultCall);
        IsExecuted = true;
        return Result;
    }
}

步骤2：扩展DeferredFirstOrDefault方法 #

public static class QueryableDeferredExtensions
{
    public static DeferredValue<T> DeferredFirstOrDefault<T>(this IQueryable<T> queryable)
    {
        return new DeferredValue<T>(queryable);
    }

    public static DeferredValue<T> DeferredFirstOrDefault<T>(this IQueryable<T> queryable, Expression<Func<T, bool>> predicate)
    {
        var filteredQuery = predicate != null ? queryable.Where(predicate) : queryable;
        return new DeferredValue<T>(filteredQuery);
    }
}

步骤3：实现批量执行管理器 #

public static class FutureQueryExecutor
{
    // 用AsyncLocal跟踪当前上下文的延迟查询，支持多线程/异步场景
    private static readonly AsyncLocal<List<object>> _deferredQueries = new();

    public static T FutureValue<T>(this DeferredValue<T> deferredValue)
    {
        // 将当前延迟查询加入跟踪列表
        _deferredQueries.Value ??= new List<object>();
        if (!_deferredQueries.Value.Contains(deferredValue))
        {
            _deferredQueries.Value.Add(deferredValue);
        }

        // 如果还未执行所有延迟查询，统一执行
        if (_deferredQueries.Value.Any(d => d is DeferredValue<object> dv && !dv.IsExecuted))
        {
            ExecuteAllDeferred();
        }

        return deferredValue.Result;
    }

    private static void ExecuteAllDeferred()
    {
        if (_deferredQueries.Value == null) return;

        // 批量执行所有延迟查询（可根据ORM特性优化，比如EF Core可合并SQL）
        foreach (var query in _deferredQueries.Value)
        {
            if (query is DeferredValue<object> dv)
            {
                dv.Execute();
            }
        }

        _deferredQueries.Value.Clear();
    }
}

使用示例 #

// 创建多个延迟查询
var deferredCompany1 = dbContext.CompanyInfos.DeferredFirstOrDefault(c => c.Id == 1);
var deferredCompany2 = dbContext.CompanyInfos.DeferredFirstOrDefault(c => c.Name.Contains("HQ"));

// 调用FutureValue时，所有延迟查询会一次性提交到数据库执行
var company1 = deferredCompany1.FutureValue();
var company2 = deferredCompany2.FutureValue();

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