同步异步EF任务

本文关键字：任务 EF 异步 同步 | 更新日期: 2023-09-27 18:05:36

我正在处理一个处理公司资源的应用程序。我们有一个MS SQL数据库，正在使用EntityFramework 6.1.3和。net 4.5。DbContext有async方法，例如

protected Task<int> SaveChangesAsync();

我知道DbContext不是线程安全的，我不想实际上调用异步操作，因为它们将并行执行。但是我需要在轮询数据库时释放我的GUI线程。

通常情况下，你会用await关键字编程，"只是要小心"不要同时调用2个异步操作，但应用程序应该总是最新的。因此，我们有一个服务器连接。现在，每当其他用户更新数据库时，就会向当前正在处理该数据库的所有应用程序发送一个轮询命令。这个轮询命令可以在任何时间执行，因此对于任何用户发起的数据库异步轮询都是一个竞争条件。

我想做的是将每个任务排在前一个任务之后。但我真的不知道怎么做，或者这是不是一个好主意。到目前为止，我尝试使用Task.ContinueWith()，但注意到我的任务永远不会启动，因此我永远等待。

这是目前为止的代码
_lastRunningTask在我的DbContext继承类中声明，并在构造函数中初始化:

_lastRunningTask = Task.Run(() => { Thread.Sleep(1); });

)

private Task _lastRunningTask;
private Task<int> SaveChangesAsyncImpl(CancellationToken cancellationToken)
    {
        return ValidateEntitiesAsyncImpl().ContinueWith(p => SaveChangesAsync(cancellationToken)).Unwrap();
    }
    public override int SaveChanges()
    {
        Task<int> t = _lastRunningTask.ContinueWith(p => SaveChangesAsyncImpl(CancellationToken.None)).Unwrap();
        _lastRunningTask = t;
        return t.Result;
    }
    public override Task<int> SaveChangesAsync()
    {
        return SaveChangesAsync(CancellationToken.None);
    }
    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken)
    {
        Task<int> t = _lastRunningTask.ContinueWith(p => SaveChangesAsyncImpl(cancellationToken)).Unwrap();
        _lastRunningTask = t;
        return t;
    }


    public Task ValidateEntitiesAsync()
    {
        return _lastRunningTask = _lastRunningTask.ContinueWith(p => ValidateEntitiesAsyncImpl()).Unwrap();
    }
    private Task ValidateEntitiesAsyncImpl()
    {
        return Task.Run(() =>
        {
            ChangeTracker.DetectChanges();
            List<DbEntityEntry> AllEntites = new List<DbEntityEntry>(ChangeTracker.Entries());
            try
            {
                foreach (DbEntityEntry entity in AllEntites)
                {
                    if (entity.State == EntityState.Deleted)
                        ((EntityBase)entity.Entity).readyToDelete();
                }
            }
            catch (ErrorException e)
            {
                fireError(e);
                throw e;
            }
            catch (Exception e)
            {
                return;
            }
            return;
        });
    }
    public Task RevertChangesAsync<TEntity>(CancellationToken token) 
        where TEntity : EntityBase
    {
        return _lastRunningTask = _lastRunningTask.ContinueWith(p => RevertChangesAsync<TEntity>(token)).Unwrap();
    }
    private Task RevertChangesAsyncImpl<TEntity>(CancellationToken token) where TEntity : EntityBase
    {
        return Task.Run(() => revertDummy<TEntity>(token));
    }
    private async void revertDummy<TEntity>(CancellationToken token) where TEntity : EntityBase
    {
        ChangeTracker.DetectChanges();
        List<DbEntityEntry<TEntity>> revertEntries = new List<DbEntityEntry<TEntity>>(ChangeTracker.Entries<TEntity>());
        foreach (DbEntityEntry entity in revertEntries)
        {
            await entity.ReloadAsync(token);
        }
    }

同步异步EF任务

我知道DbContext不是线程安全的，我不想实际上调用异步操作，并希望它们被执行平行。

DbContext确实不是线程安全的。但是，这并不意味着你要并发地查询它。对于async，没有线程。您不需要使用Task.Run为您想要做的任何工作。充分利用实体框架提供的自然异步API。

只要为每个查询启动DbContext的新实例，就可以了。

例如:

private async Task RevertDummyAsync<TEntity>(
    Entity entity, CancellationToken token) where TEntity : EntityBase
{
    using (var context = new SomeDbContext())
    {
        ChangeTracker.DetectChanges();
        List<DbEntityEntry<TEntity>> revertEntries = 
            new List<DbEntityEntry<TEntity>>(ChangeTracker.Entries<TEntity>());
        foreach (DbEntityEntry entity in revertEntries)
        {
            await entity.ReloadAsync(token);
        }
    }
}

然后你可以在一个实体集合上调用它:

var collections = new List<Entity>();
var tasks = collections.Select(x => RevertDummyAsync<Entity>(x));
await Task.WhenAll(tasks);
相关文章：