能否为Entity Framework构建首次编译复用的内联查询容器？

这个需求完全可行，EF（尤其是EF Core）本身提供了查询预编译的原生API，我们可以封装轻量级容器自动完成「首次调用编译、复用已编译查询」的逻辑，同时通过泛型和委托设计，让查询编写体验和原生写法几乎一致。

核心实现思路 #

• 用泛型容器类内部缓存已编译的查询委托
• 通过Lazy<T>实现延迟编译（仅首次访问时执行编译逻辑）
• 分别支持同步、异步，以及带参数的查询场景

通用容器代码实现 #

基础同步查询容器 #

using System;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;

public class CompiledQueryContainer<TContext, TResult> where TContext : DbContext
{
    private readonly Func<TContext, TResult> _compiledQuery;

    public CompiledQueryContainer(Expression<Func<TContext, TResult>> queryExpression)
    {
        // Lazy<T>确保仅首次访问时编译查询
        _compiledQuery = new Lazy<Func<TContext, TResult>>(() =>
            EF.CompileQuery(queryExpression)).Value;
    }

    public TResult Execute(TContext context)
    {
        return _compiledQuery(context);
    }
}

带参数的同步查询容器 #

public class CompiledQueryContainer<TContext, TParam, TResult> where TContext : DbContext
{
    private readonly Func<TContext, TParam, TResult> _compiledQuery;

    public CompiledQueryContainer(Expression<Func<TContext, TParam, TResult>> queryExpression)
    {
        _compiledQuery = new Lazy<Func<TContext, TParam, TResult>>(() =>
            EF.CompileQuery(queryExpression)).Value;
    }

    public TResult Execute(TContext context, TParam param)
    {
        return _compiledQuery(context, param);
    }
}

异步查询容器 #

public class AsyncCompiledQueryContainer<TContext, TResult> where TContext : DbContext
{
    private readonly Func<TContext, TResult> _compiledQuery;

    public AsyncCompiledQueryContainer(Expression<Func<TContext, TResult>> queryExpression)
    {
        _compiledQuery = new Lazy<Func<TContext, TResult>>(() =>
            EF.CompileAsyncQuery(queryExpression)).Value;
    }

    public TResult ExecuteAsync(TContext context)
    {
        return _compiledQuery(context);
    }
}

// 带参数的异步版本
public class AsyncCompiledQueryContainer<TContext, TParam, TResult> where TContext : DbContext
{
    private readonly Func<TContext, TParam, TResult> _compiledQuery;

    public AsyncCompiledQueryContainer(Expression<Func<TContext, TParam, TResult>> queryExpression)
    {
        _compiledQuery = new Lazy<Func<TContext, TParam, TResult>>(() =>
            EF.CompileAsyncQuery(queryExpression)).Value;
    }

    public TResult ExecuteAsync(TContext context, TParam param)
    {
        return _compiledQuery(context, param);
    }
}

实际业务场景用法 #

以用户查询为例，写法和原生EF查询几乎一致，仅需将表达式传入容器：

// 示例DbContext
public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

public class UserService
{
    // 静态声明容器，确保全局唯一，避免重复编译
    private static readonly CompiledQueryContainer<AppDbContext, int, User> _getUserByIdQuery =
        new CompiledQueryContainer<AppDbContext, int, User>((context, id) => 
            context.Users.FirstOrDefault(u => u.Id == id));

    private static readonly AsyncCompiledQueryContainer<AppDbContext, string, Task<User>> _getUserByNameAsyncQuery =
        new AsyncCompiledQueryContainer<AppDbContext, string, Task<User>>((context, name) => 
            context.Users.FirstOrDefaultAsync(u => u.Name == name));

    public User GetUserById(AppDbContext context, int id)
    {
        return _getUserByIdQuery.Execute(context, id);
    }

    public async Task<User> GetUserByNameAsync(AppDbContext context, string name)
    {
        return await _getUserByNameAsyncQuery.ExecuteAsync(context, name);
    }
}

关键注意事项 #

1. 容器必须全局唯一：将容器声明为静态字段（或注入单例），否则每次创建容器都会重新编译查询，失去复用价值。
2. 参数兼容性：预编译查询支持动态参数，只需在表达式中添加参数即可，无需修改容器核心逻辑。
3. 性能收益：预编译查询适合频繁执行的固定逻辑查询，能避免EF每次解析表达式树的开销，提升高并发场景下的性能。

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