Question

我正在研究一系列使用实体框架执行许多不同数据库调用的方法。其中许多方法都可以异步运行，因为我真的不关心它们的输出，也不依赖它们。

然而，当我尝试实现某些方法时，我收到编译器的警告：“因为没有等待此调用，所以当前方法在调用完成之前继续运行”

但对我来说，这似乎是我理想的行为，因为我不关心这些方法的作用。

以下是方法的示例

public async Task SetupAccessControl(int objectTypeId, int objectId, int? organizationId)
{
    using (var context = new SupportContext(CustomerId))
    {
        ... // omitted for brevity
        if (objectTypeId == (int) ObjectType.User)
        {
            AddToUserRoleBridge("Everyone", objectId);//Warning on this line
            AddToUserRoleBridge("Default", objectId); //Warning on this line
        }
        ... // omitted for brevity
    }
}

public async Task AddToUserRoleBridge(string role, int userId)
{
    using (var context = new SupportContext(CustomerId))
    {
        var defaultRole = context.Roles.FirstOrDefault(n => n.Name == role);
        if (defaultRole != null)
        {
            var urb = new UserRoleBridge
            {
                RoleId = defaultRole.Id,
                UserId = userId
            };

            context.UserRoleBridges.Add(urb);
            await context.SaveChangesAsync();
        }
    }
}

修改

基本上，当我运行main函数时，我想要一些方法调用同时触发所有并在自己的线程中处理所有内容，以便我不必担心它。这是一个伪代码示例。

public async void RunAllAsync() {
    taskA(*some value*);
    taskA(*some value*);
    taskB(*some value*);
    taskB(*some value*);

    await AllTasksCompleted
}

public async Task taskA(int item){
     //do something with item
}


public async Task taskB(int item) {
    subTaskB(*some value*)
    subTaskB(*some value*)
}

public async Task subTaskB(int item) {
    // do something
}

在上面的例子中，当调用#RunAllAsync时，它所做的每个函数调用（以及它们所做的函数调用）都会被同时触发。当所有这些调用完成后，任何名为#RunAllAsync的方法都将继续执行。

Answer 1

如果您没有使用await，async关键字实际上没有做任何有用的事情，您可以将其关闭。您可以等待返回Task的方法，无论它是否标记为异步。

public Task DoSomethingAsync()
{
    Task someTaskJustLikeANormalReturnValue = Task.Delay(1000);
    return someTaskJustLikeANormalReturnValue;
}

// later...
public async Task SomeOtherFunction()
{
    // You can await DoSomethingAsync just like any async method, because
    // you're really awaiting the Task which got returned.
    await DoSomethingAsync();
}

在你的情况下，我可能会收集任务并一起等待它们：

    public async Task SetupAccessControl(int objectTypeId, int objectId, int? organizationId)
    {
        var tasks = new List<Task>();
        using (var context = new SupportContext(CustomerId))
        {
            ... // omitted for brevity
            if (objectTypeId == (int) ObjectType.User)
            {
                tasks.Add(AddToUserRoleBridge("Everyone", objectId));
                tasks.Add(AddToUserRoleBridge("Default", objectId));
            }
            ... // omitted for brevity
        }

        await Task.WhenAll(tasks.ToArray());
    }

这允许您将决定传递给是否等待子任务的调用者。这也将允许任何调用者在AddToUserRoleBridge中发生任何异常时解包。

Answer 2

你可以用两种方式做到：

更改AddToUserRoleBridge的签名以返回void will 删除警告（但没有任何东西可以等待它）。
存储通话结果。 var ignoreme=AddToUserRoleBridge(...)也会删除警告。

没有等待的异步编程？

2 个答案: