Якщо мій інтерфейс повинен повернути Завдання, який найкращий спосіб не виконати операцію?

У наведеному нижче коді, завдяки інтерфейсу, клас LazyBarповинен повернути завдання зі свого методу (а для аргументів змінити не можна). Якщо LazyBarреалізація s незвична тим, що вона запускається швидко і синхронно - який найкращий спосіб повернути завдання без операції з методу?

Я пішов з 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вираз без відключення. При створенні 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 Task.CompletedTask; // this will make the compiler happy

Коли потрібно повернути вказаний тип:

Task.FromResult<MyClass>(null);

Я віддаю перевагу Task completedTask = Task.CompletedTask;рішенню .Net 4.6, але інший підхід полягає в позначенні методу асинхронізацією та поверненням недійсним:

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

Ви отримаєте попередження (CS1998 - функція 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());