如何定位Entity Framework Core中并行执行的首个查询？

我知道Entity Framework不支持并行查询执行，但目前遇到EF检测到并行调用的问题。已经查看了异常提示的文档，但还是找不到发起第一个请求的代码位置。

我已尝试以下排查方法：

• 检查是否存在异步调用相关警告
• 使用DbCommandInterceptor拦截查询，尝试记录未完成查询或在已有未完成查询的上下文实例执行查询时触发断点，但异常发生时所有查询均已完成
• 校验所有名称包含Async的上下文函数调用是否都直接使用了await
• 在并行堆栈窗口中查找上下文的引用

请问是否有可行的方案来定位执行第一个查询的代码？

技术环境：EF Core 7.0.0 + SQL Server、.NET 6.0 Web API（MVC），服务配置代码如下：

services.AddDbContext<MyContext>(c =>
        {
            var connection = Configuration.GetSection("Database").GetSection("ConnectionString").Get<string>();
            c.UseSqlServer(connection, opt =>
            {
                opt.EnableRetryOnFailure(3);
            });
            c.EnableSensitiveDataLogging();
            if (Environment.IsDevelopment())
                c.EnableDetailedErrors();
        });

可行定位方案 #

1. 自定义DbContext生命周期追踪 #

在MyContext中添加状态追踪逻辑，记录每个上下文实例的第一个查询调用栈：

public class MyContext : DbContext
{
    private readonly ILogger<MyContext> _logger;
    private bool _hasActiveQuery;
    private string? _firstQueryStackTrace;

    public MyContext(DbContextOptions<MyContext> options, ILogger<MyContext> logger) 
        : base(options)
    {
        _logger = logger;
    }

    public override int SaveChanges(bool acceptAllChangesOnSuccess)
    {
        TrackQueryStart();
        return base.SaveChanges(acceptAllChangesOnSuccess);
    }

    public override Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
    {
        TrackQueryStart();
        return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
    }

    public override DbSet<TEntity> Set<TEntity>()
    {
        TrackQueryStart();
        return base.Set<TEntity>();
    }

    private void TrackQueryStart()
    {
        if (!_hasActiveQuery)
        {
            _firstQueryStackTrace = Environment.StackTrace;
            _logger.LogInformation("[上下文ID:{Id}] 第一个查询执行栈:\n{StackTrace}", this.GetHashCode(), _firstQueryStackTrace);
            _hasActiveQuery = true;
        }
    }

    protected override void Dispose(bool disposing)
    {
        _hasActiveQuery = false;
        base.Dispose(disposing);
    }

    public override ValueTask DisposeAsync()
    {
        _hasActiveQuery = false;
        return base.DisposeAsync();
    }
}

每次上下文实例触发第一个查询时，会将完整调用栈写入日志，直接定位请求源头。

2. 利用DiagnosticListener监听查询生命周期 #

注册EF Core的诊断监听器，捕获所有查询的开始/结束事件，关联上下文实例和调用栈：

public class QueryTracker : IObserver<DiagnosticListener>
{
    private readonly ILogger<QueryTracker> _logger;
    private readonly Dictionary<string, string> _activeQueries = new();

    public QueryTracker(ILogger<QueryTracker> logger)
    {
        _logger = logger;
    }

    public void OnCompleted() { }
    public void OnError(Exception error) { }

    public void OnNext(DiagnosticListener listener)
    {
        if (listener.Name == "Microsoft.EntityFrameworkCore")
        {
            listener.Subscribe(new QueryObserver(_logger, _activeQueries));
        }
    }

    private class QueryObserver : IObserver<KeyValuePair<string, object>>
    {
        private readonly ILogger<QueryTracker> _logger;
        private readonly Dictionary<string, string> _activeQueries;

        public QueryObserver(ILogger<QueryTracker> logger, Dictionary<string, string> activeQueries)
        {
            _logger = logger;
            _activeQueries = activeQueries;
        }

        public void OnCompleted() { }
        public void OnError(Exception error) { }

        public void OnNext(KeyValuePair<string, object> evt)
        {
            if (evt.Key == "Microsoft.EntityFrameworkCore.Query.QueryExecuting")
            {
                var context = evt.Value.GetType().GetProperty("Context")?.GetValue(evt.Value) as DbContext;
                if (context != null)
                {
                    var contextId = context.GetHashCode().ToString();
                    var stackTrace = Environment.StackTrace;
                    _activeQueries[contextId] = stackTrace;
                    _logger.LogInformation("[查询开始] 上下文ID:{Id}\n调用栈:\n{StackTrace}", contextId, stackTrace);
                }
            }
            else if (evt.Key == "Microsoft.EntityFrameworkCore.Query.QueryExecuted")
            {
                var context = evt.Value.GetType().GetProperty("Context")?.GetValue(evt.Value) as DbContext;
                if (context != null)
                {
                    var contextId = context.GetHashCode().ToString();
                    _activeQueries.Remove(contextId);
                }
            }
        }
    }
}

在Program.cs中注册监听器：

services.AddSingleton<IObserver<DiagnosticListener>, QueryTracker>();

当并行异常触发时，_activeQueries中残留的记录对应的调用栈就是未完成的第一个请求。

3. 强化日志过滤 #

调整日志配置，聚焦EF查询相关的详细日志：

builder.Logging.AddFilter("Microsoft.EntityFrameworkCore.Query", LogLevel.Information);
builder.Logging.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Information);

结合已启用的EnableSensitiveDataLogging和EnableDetailedErrors，日志会包含每个查询的执行上下文，辅助定位冲突源头。

4. 检查上下文注入合法性 #

当前配置使用默认的Scoped生命周期，需排查：

• 是否存在手动new MyContext()创建实例的场景
• 是否在Singleton服务中注入了Scoped的MyContext
• 是否有跨线程共享上下文实例的代码

这类场景会直接导致并行调用冲突，需确保每个请求只使用独立的上下文实例。

内容的提问来源于stack exchange，提问作者greg-e