c# - 没有等待的异步方法与 Task.FromResult

Question

考虑以下接口(interface):

public interface IProvider
{
    Task<bool> Contains(string key);
}

这是满足 Visual Studio 的实现

public Task<bool> Contains(string key)
{
    return Task.FromResult(false);
}

这个实现写起来很方便并且似乎可以达到同样的效果:

public async Task<bool> Contains(string key)
{
    return false;
}

但是，Visual Studio 发出嘶嘶声并坚持:

This async method lacks 'await' operators and will run synchronously. Consider using the 'await' operator to await non-blocking API calls, or 'await TaskEx.Run(...)' to do CPU-bound work on a background thread.

我很乐意忽略该警告并避免使用 Task.FromResult(...)。

使用后一种选择是否有任何负面影响？

Answer 1

“嘶嘶作响”的原因是编译器需要做很多的工作来呈现一个以所有预期的正确方式工作的任务，你可以看到by compiling and decompiling it

Task.FromResult更干净，但可能仍有开销 - IIRC 在某些情况下 Task.FromResult在这里可能会高效工作(每次返回相同的对象)，但我不会依赖它。

有两种实用可靠的方法:

• 返回一个重复使用的静态 Task<bool>每次结果
• 使用ValueTask<bool> - 如果您经常同步返回，这在这里似乎很理想

即

private readonly static Task<bool> s_False = Task.FromResult(false);
public Task<bool> Contains(string key, string scope)
{
    return s_False ;
}

或

public ValueTask<bool> Contains(string key, string scope)
{
    return new ValueTask<bool>(false);
}

注意:在这种情况下，第二个可能是不可能的，因为您没有定义接口(interface)。但是:如果您正在设计一个需要允许异步使用但实际上可能是同步的界面:考虑使用 ValueTask<T>作为交换类型，而不是 Task<T> .

生成的 C#:

public async System.Threading.Tasks.Task<bool> Contains(string key, string scope)
{
    return false;
}

是这样的:

[StructLayout(LayoutKind.Auto)]
[CompilerGenerated]
private struct <Contains>d__0 : IAsyncStateMachine
{
    public int <>1__state;

    public AsyncTaskMethodBuilder<bool> <>t__builder;

    private void MoveNext()
    {
        bool result;
        try
        {
            result = false;
        }
        catch (Exception exception)
        {
            <>1__state = -2;
            <>t__builder.SetException(exception);
            return;
        }
        <>1__state = -2;
        <>t__builder.SetResult(result);
    }

    void IAsyncStateMachine.MoveNext()
    {
        //ILSpy generated this explicit interface implementation from .override directive in MoveNext
        this.MoveNext();
    }

    [DebuggerHidden]
    private void SetStateMachine(IAsyncStateMachine stateMachine)
    {
        <>t__builder.SetStateMachine(stateMachine);
    }

    void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
    {
        //ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
        this.SetStateMachine(stateMachine);
    }
}

[AsyncStateMachine(typeof(<Contains>d__0))]
public Task<bool> Contains(string key, string scope)
{
    <Contains>d__0 stateMachine = default(<Contains>d__0);
    stateMachine.<>t__builder = AsyncTaskMethodBuilder<bool>.Create();
    stateMachine.<>1__state = -1;
    AsyncTaskMethodBuilder<bool> <>t__builder = stateMachine.<>t__builder;
    <>t__builder.Start(ref stateMachine);
    return stateMachine.<>t__builder.Task;
}