Если мой интерфейс должен вернуть Task, каков наилучший способ реализации без операции?

В приведенном ниже коде из-за интерфейса класс LazyBarдолжен возвращать задачу из своего метода (и ради аргументов не может быть изменен). Если LazyBarреализация s необычна в том смысле, что она выполняется быстро и синхронно - каков наилучший способ вернуть задачу 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();
        }
    }
}

Использование Task.FromResult(0)или Task.FromResult<object>(null)приведет к меньшим накладным расходам, чем создание Taskс выражением no-op. При создании Taskс заранее определенным результатом не требуются затраты на планирование.

Сегодня я бы рекомендовал использовать Task.CompletedTask для достижения этой цели.

Чтобы добавить к ответу Рида Копси об использовании Task.FromResult, вы можете еще больше повысить производительность, если кешируете уже выполненную задачу, поскольку все экземпляры выполненных задач одинаковы:

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

С помощью TaskExtensions.CompletedTaskвы можете использовать один и тот же экземпляр во всем домене приложения.

В последней версии .Net Framework (v4.6) добавлено только это со Task.CompletedTaskстатическим свойством

Task completedTask = Task.CompletedTask;

Task.Delay(0)как в принятом ответе был хороший подход, так как это кэшированная копия готового 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, но другой подход - пометить метод async и вернуть void:

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

Вы получите предупреждение (CS1998 - Асинхронная функция без выражения await), но это безопасно игнорировать в этом контексте.

Если вы используете дженерики, все ответы приведут к ошибке компиляции. Вы можете использовать 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());