没有等待的异步编程？

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(...) 也会删除警告。