Jika antarmuka saya harus mengembalikan Tugas, apa cara terbaik untuk mengimplementasikan implementasi tanpa operasi?

Dalam kode di bawah ini, karena antarmuka, kelas LazyBarharus mengembalikan tugas dari metode itu (dan demi argumen tidak dapat diubah). Jika LazyBarimplementasi tidak biasa terjadi karena berjalan dengan cepat dan serempak - apa cara terbaik untuk mengembalikan tugas Tanpa Operasi dari metode ini?

Saya telah membahas di Task.Delay(0)bawah ini, namun saya ingin tahu apakah ini memiliki efek samping kinerja jika fungsinya disebut banyak (demi argumen, katakan ratusan kali per detik):

• Apakah gula sintaksis ini melepaskan angin ke sesuatu yang besar?
• Apakah itu mulai menyumbat kumpulan utas aplikasi saya?
• Apakah golok compiler cukup untuk menangani secara Delay(0)berbeda?
• Apakah return Task.Run(() => { });akan berbeda?

Apakah ada cara yang lebih baik?

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

Menggunakan Task.FromResult(0)atau Task.FromResult<object>(null)akan dikenakan biaya lebih sedikit daripada membuat Taskdengan tanpa-op ekspresi. Saat membuat Taskdengan hasil yang ditentukan sebelumnya, tidak ada overhead penjadwalan yang terlibat.

Hari ini, saya akan merekomendasikan menggunakan Task.CompletedTask untuk mencapai ini.

Untuk menambahkan jawaban Reed Copsey tentang penggunaan Task.FromResult, Anda dapat meningkatkan kinerja lebih banyak lagi jika Anda men-cache tugas yang sudah selesai karena semua contoh tugas yang diselesaikan adalah sama:

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

Dengan TaskExtensions.CompletedTaskAnda dapat menggunakan contoh yang sama di seluruh domain aplikasi.

Versi terbaru dari .Net Framework (v4.6) menambahkan hanya itu dengan Task.CompletedTaskproperti statis

Task completedTask = Task.CompletedTask;

Task.Delay(0)seperti dalam jawaban yang diterima adalah pendekatan yang baik, karena merupakan salinan cache yang sudah diisi Task.

Pada 4.6 ada sekarang Task.CompletedTaskyang lebih eksplisit dalam tujuannya, tetapi tidak hanya Task.Delay(0)masih kembali contoh cache tunggal, itu mengembalikan contoh cache tunggal yang sama seperti halnya Task.CompletedTask.

Sifat cache dari tidak dijamin untuk tetap konstan, tetapi sebagai optimisations tergantung dari implementasi yang hanya tergantung dari implementasi sebagai optimisations (yaitu, mereka masih akan bekerja dengan benar jika pelaksanaan berubah menjadi sesuatu yang masih berlaku) penggunaan Task.Delay(0)adalah lebih baik dari jawaban yang diterima.

Baru-baru ini menjumpai ini dan terus mendapatkan peringatan / kesalahan tentang metode yang batal.

Kami berada dalam bisnis menempatkan kompiler dan ini akan membersihkannya:

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

Sejauh ini, ini menyatukan semua saran terbaik di sini. Pernyataan pengembalian tidak diperlukan kecuali Anda benar-benar melakukan sesuatu dalam metode ini.

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

Ketika Anda harus mengembalikan jenis yang ditentukan:

Task.FromResult<MyClass>(null);

Saya lebih suka Task completedTask = Task.CompletedTask;solusi. Net 4.6, tetapi pendekatan lain adalah menandai metode async dan mengembalikan void:

    public async Task WillBeLongRunningAsyncInTheMajorityOfImplementations()
    {
    }

Anda akan mendapatkan peringatan (CS1998 - Async berfungsi tanpa menunggu ekspresi), tetapi ini aman untuk diabaikan dalam konteks ini.

Jika Anda menggunakan obat generik, semua jawaban akan memberi kami kesalahan kompilasi. Anda bisa menggunakannya return default(T);. Contoh di bawah ini untuk menjelaskan lebih lanjut.

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