如果我的界面必须返回Task，那么执行无操作实现的最佳方法是什么？

在下面的代码中，由于接口的原因，该类LazyBar必须从其方法中返回一个任务（出于参数的考虑，不能更改）。如果LazyBars实现不寻常，因为它恰巧可以快速且同步地运行，那么从该方法返回No-Operation任务的最佳方法是什么？

我已经跟Task.Delay(0)下面，但是我想知道这是否有任何性能的副作用，如果该功能被称为很多（为了讨论各种情形，说上百次），：

• 这种语法糖是否会发展成大事？
• 它会开始阻塞我的应用程序的线程池吗？
• 编译器切割器是否足以应付Delay(0)不同要求？
• 请问return Task.Run(() => { });有什么不同？

有没有更好的办法？

using System.Threading.Tasks;

namespace MyAsyncTest
{
    internal interface IFooFace
    {
        Task WillBeLongRunningAsyncInTheMajorityOfImplementations();
    }

    /// <summary>
    /// An implementation, that unlike most cases, will not have a long-running
    /// operation in 'WillBeLongRunningAsyncInTheMajorityOfImplementations'
    /// </summary>
    internal class LazyBar : IFooFace
    {
        #region IFooFace Members

        public Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
        {
            // First, do something really quick
            var x = 1;

            // Can't return 'null' here! Does 'Task.Delay(0)' have any performance considerations?
            // Is it a real no-op, or if I call this a lot, will it adversely affect the
            // underlying thread-pool? Better way?
            return Task.Delay(0);

            // Any different?
            // return Task.Run(() => { });

            // If my task returned something, I would do:
            // return Task.FromResult<int>(12345);
        }

        #endregion
    }

    internal class Program
    {
        private static void Main(string[] args)
        {
            Test();
        }

        private static async void Test()
        {
            IFooFace foo = FactoryCreate();
            await foo.WillBeLongRunningAsyncInTheMajorityOfImplementations();
            return;
        }

        private static IFooFace FactoryCreate()
        {
            return new LazyBar();
        }
    }
}

与使用no-op表达式创建相比，使用Task.FromResult(0)或Task.FromResult<object>(null)将产生较少的开销Task。创建Task具有预定结果的时，不涉及调度开销。

今天，我建议使用Task.CompletedTask来完成此任务。

要添加到Reed Copsey关于using 的答案Task.FromResult，您可以缓存已完成的任务，从而进一步提高性能，因为所有已完成任务的实例都是相同的：

public static class TaskExtensions
{
    public static readonly Task CompletedTask = Task.FromResult(false);
}

有了TaskExtensions.CompletedTask您可以使用相同的实例在整个应用程序域。

.Net Framework（v4.6）的最新版本仅添加了带有Task.CompletedTaskstatic属性的内容。

Task completedTask = Task.CompletedTask;

Task.Delay(0)因为接受的答案是一种很好的方法，因为它是complete的缓存副本Task。

从4.6开始Task.CompletedTask，它的目的更加明确，但不仅Task.Delay(0)仍然返回单个缓存的实例，而且还返回相同的单个缓存的实例Task.CompletedTask。

既不缓存的本质是保证保持不变，但作为实现相关的优化技术是唯一实现相关的优化技术（也就是，他们还是会正确如果实现改变的东西，仍然是有效的工作）使用的Task.Delay(0)是比公认的答案更好。

最近遇到这种情况，并不断收到有关该方法无效的警告/错误。

我们负责编译器的工作，这可以清除它：

    public async Task MyVoidAsyncMethod()
    {
        await Task.CompletedTask;
    }

到目前为止，这里汇集了所有建议中最好的。除非您实际上在该方法中进行任何操作，否则不需要return语句。

return Task.CompletedTask; // this will make the compiler happy

当您必须返回指定的类型时：

Task.FromResult<MyClass>(null);

我更喜欢Task completedTask = Task.CompletedTask;.Net 4.6 的解决方案，但是另一种方法是将方法标记为异步并返回void：

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

您会收到警告（CS1998-不具有await表达式的Async函数），但是在这种情况下可以忽略。

如果您使用的是泛型，则所有答案都会给我们带来编译错误。您可以使用return default(T);。下面的示例进一步解释。

public async Task<T> GetItemAsync<T>(string id)
            {
                try
                {
                    var response = await this._container.ReadItemAsync<T>(id, new PartitionKey(id));
                    return response.Resource;
                }
                catch (CosmosException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
                {

                    return default(T);
                }

            }

return await Task.FromResult(new MyClass());