Question

我有一个项目，它有一个Sql-Server数据库后端，Dapper是一个ORM。我试图使用Dapper的QueryAsync()方法来获取一些数据。不仅如此，而且对我的仓库的调用来自于使用Task.WhenAll调用的几个任务（也就是说，每个任务都涉及从该仓库获取数据，因此每个任务都等待我的回购＆＃39;包装QueryAsync()调用的方法。

问题是我的SqlConnections永远不会关闭，即使我使用using块。结果，我有100多个与我的数据库的开放连接，并最终开始获得＆＃34;达到最大池大小＆＃34;例外。问题是，当我切换到Query()而不是QueryAsync()时，它运行正常，但我希望能够异步执行此操作。

这是一个代码示例。我试图尽可能地模仿实际应用程序的结构，这就是为什么它看起来比它必须更复杂。

接口：

public interface IFooRepository<T> where T: FooBase
{
    Task<IEnumerable<T>> Select(string account, DateTime? effectiveDate = null);
}

实现：

public class FooRepository : RepositoryBase, IFooRepository<SpecialFoo>
{
    private readonly IWebApiClientRepository _accountRepository;

    public FooRepository(IWebApiClientRepository repo)
    {
        _accountRepository = repo;
    }
    public async Task<IEnumerable<FuturePosition>> Select(string code, DateTime? effectiveDate = null)
    {
        effectiveDate = effectiveDate ?? DateTime.Today.Date;
        var referenceData =  await _accountRepository.GetCrossRefferenceData(code, effectiveDate.Value);
        using (var connection = new SqlConnection("iamaconnectionstring")
        {
            connection.Open();
            try
            {
                var res = await connection.QueryAsync<FuturePosition>(SqlQueryVariable + "AND t.code = @code;",
                    new
                    {
                        effectiveDate = effectiveDate.Value,
                        code = referenceData.Code
                    });

                foreach (var item in res)
                {
                    item.PropFromReference = referenceData.PropFromReference;
                }
                return res;
            }
            catch (Exception e)
            {
                //log 
                throw;
            }
            finally
            {
                connection.Close();
            }
        }
    }
}

现在使用调用代码，有2层。我将从外部开始。我认为这就是问题所在。以下是评论。

填充器：

public class Populator : PopulatorBase
{
    private IAccountRepository _acctRepository;
    public override async Task<IEnumerable<PopulationResult>> ProcessAccount(DateTime? popDate = null)
    {
        //My attempt at throttling the async calls
        //I was hoping this would force a max of 10 simultaneous connections.
        //It did not work.
        SemaphoreSlim ss = new SemaphoreSlim(10,10);
        var accountsToProcess = _acctRepository.GetAllAccountsToProcess();
        var accountNumbers = accountsToProcess.SelectMany(a => a.accountNumbers).ToList();

        List<Task<ProcessResult>> trackedTasks = new List<Task<ProcessResult>>();
        foreach (var item in accountNumbers)
        {
            await ss.WaitAsync();
            trackedTasks.Add(ProcessAccount(item.AccountCode, popDate ?? DateTime.Today));
            ss.Release();
        }
        //my gut tells me the issue is because of these tasks
        var results = await Task.WhenAll(trackedTasks);
        return results;
    }

    private async Task<ProcessResult>ProcessAccount(string accountCode, DateTime? popDate)
    {
        var createdItems = await _itemCreator.MakeExceptions(popDate, accountCode);
        return Populate(accountCode, createdItems);
    }
}

ItemCreator：

public class ItemCreator : ItemCreatorBase
{
    private readonly IFooRepository<FuturePosition> _fooRepository;
    private readonly IBarRepository<FuturePosition> _barRepository;

    public RussellGlobeOpFutureExceptionCreator() )
    {
        //standard constructor stuff
    }
    public async Task<ItemCreationResult> MakeItems(DateTime? effectiveDate, string account)
    {
        DateTime reconDate = effectiveDate ?? DateTime.Today.Date;

        //this uses the repository I outlined above
        var foos = await _fooRepository.Select(account, effectiveDate);

        //this repository uses a rest client, I doubt it's the problem
        var bars = await _barRepository.Select(account, effectiveDate);

        //just trying to make this example less lengthy
        var foobars = MakeFoobars(foos, bars);
        var result = new ItemCreationResult { EffectiveDate = effectiveDate, Items = foobars };
        return result;
    }
}

就我所尝试的而言：

使用SemaphoreSlim进行节流
没有节流
在repo中使用connection.OpenAnync()
包括/排除finally块（应该与using无关）

值得知道，populator中的foreach循环运行大约500次。基本上，有500个帐户的列表。对于每一个，它需要执行一个长期运行的populate任务，该任务涉及从我的Foo仓库中提取数据。

老实说，我不知道。我认为这可能与等待来自populator中该任务列表中的每个任务的异步数据库调用有关。对这个问题的任何见解都会非常有用。

Answer 1

经过一番挖掘，我想我已经设法解决了这个问题。我不认为我实际上正在经历像我原先假设的连接泄漏。从我现在的理解，通过连接池，当SQL连接从代码关闭时，它实际上并没有消失 - 它只是作为空闲连接进入连接池。在SQL中查看打开的连接仍然会显示它。

由于我的数据访问是异步的，所有连接在任何＆＃34;关闭＆＃34;之前打开。连接被返回到池，这意味着为每个请求打开了一个新连接。这导致了我看到的令人吃惊的打开连接数，让我觉得我有连接泄漏。

使用SemaphoreSlim实际上解决了这个问题 - 我只是错误地实现了它。它应该像这样工作：

public override async Task<IEnumerable<ProcessResult>> ProcessAccount(DateTime? popDate = null)
{
      foreach (item in accountNumbers)
      {

      trackedTasks.Add(new Func<Task<ProcessResult>>(async () =>
            {
                await ss.WaitAsync().ConfigureAwait(false);
                try
                {
                    return await ProcessAccount(item.AccountCode, popDate ?? DateTime.Today).ConfigureAwait(false);
                }
                catch (Exception e)
                {
                    //log, etc.
                }
                finally
                {
                    ss.Release();
                }
            })());
      }
}

执行此操作会限制一次打开的连接数量，并等待它们关闭，因此池中的相同较小的连接组将被重新使用。

使用异步时不处理SqlConnection

1 个答案: