Arayüzümün Görev'e dönmesi gerekiyorsa, işlem yapmama uygulamasının en iyi yolu nedir?

Aşağıdaki kodda, arabirim nedeniyle, sınıfın LazyBaryönteminden bir görev döndürmesi gerekir (ve sake argümanları değiştirilemez). Eğer LazyBaryönteminden bir No-Operasyon görevi döndürmek için en iyi yolu nedir - s uygulaması hızla ve eşzamanlı çalışmasına olur sıradışı mı?

Birlikte gitmiş Task.Delay(0)ancak işlevi denir, bu herhangi bir performans yan etkileri varsa bilmek istiyorum, aşağıda çok (kez ikinci yüzlerce argümanlar uğruna, derler):

• Bu sözdizimsel şeker büyük bir şeye yöneliyor mu?
• Uygulamamın iş parçacığı havuzunu tıkamaya mı başlıyor?
• Derleyici Delay(0)farklı şekilde başa çıkmak için yeterli mi?
• Misiniz return Task.Run(() => { });farklı olsun?

Daha iyi bir yol var mı?

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();
        }
    }
}

Kullanılması Task.FromResult(0)veya Task.FromResult<object>(null)bir oluşturma daha az yük tabidir Taskno-op ifadesi ile. TaskÖnceden belirlenmiş bir sonuç ile bir oluştururken , herhangi bir zamanlama yükü söz konusu değildir.

Bugün, bunu yapmak için Task.CompletedTask kullanmanızı tavsiye ederim .

Eklemek için Reed Copsey cevabı kullanma hakkında Task.FromResulttamamlanan görevlerin tüm örnekleri aynı olduğundan zaten tamamlanmış bir görevi önbelleğe eğer daha performansını artırabilir,:

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

İle TaskExtensions.CompletedTaskaynı uygulamayı tüm uygulama etki alanında kullanabilirsiniz.

.Net Framework (v4.6) en son sürümünü ekler sadece bununla ilgili Task.CompletedTaskstatik özelliği

Task completedTask = Task.CompletedTask;

Task.Delay(0)Kabul edilen cevapta olduğu gibi tamamlanmış bir önbelleğe alınmış kopya olduğu için iyi bir yaklaşımdı Task.

4.6 itibariyle artık Task.CompletedTaskamacı daha açıktır, ancak Task.Delay(0)yine de yalnızca tek bir önbelleğe alınmış örnek döndürmekle kalmaz , aynı önbelleğe alınmış tek örneği de döndürür Task.CompletedTask.

Kullanımını ne önbelleğe alınmış doğa sabiti kalması garanti edilir, ancak yalnızca uygulama bağımlı optimizasyonlar gibidir uygulama bağımlı optimizasyonlar olarak (uygulama hala geçerli olduğu bir şey değişirse olduğunu, hala düzgün çalışması ediyorum) Task.Delay(0)idi kabul edilen cevaptan daha iyi.

Son zamanlarda bu karşılaştım ve geçersiz yöntem hakkında uyarı / hata almaya devam etti.

Derleyiciyi yerleştirme işindeyiz ve bu temizler:

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

Bu, şimdiye kadarki tüm tavsiyelerin en iyisini bir araya getiriyor. Aslında yöntemde bir şey yapmadıkça bir iade ifadesi gerekli değildir.

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

Belirtilen türü döndürmeniz gerektiğinde:

Task.FromResult<MyClass>(null);

Task completedTask = Task.CompletedTask;Net 4.6 çözümünü tercih ederim , ancak başka bir yaklaşım yöntemi zaman uyumsuz olarak işaretlemek ve void döndürmektir:

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

Bir uyarı alırsınız (ifadeyi beklemeden CS1998 - Async işlevi), ancak bu bağlamda yoksaymak güvenlidir.

Jenerikler kullanıyorsanız, tüm cevaplar bize derleme hatası verecektir. Kullanabilirsiniz return default(T);. Daha fazla açıklamak için aşağıdaki örnek.

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());