Kapan TaskCompletionSource <T> harus digunakan?

AFAIK, yang diketahuinya adalah bahwa pada titik tertentu, metode SetResultatau SetExceptiondipanggil untuk menyelesaikan Task<T>eksposur melalui Taskpropertinya.

Dengan kata lain, ia bertindak sebagai produsen untuk Task<TResult>dan penyelesaiannya.

Saya melihat contohnya di sini :

Jika saya memerlukan cara untuk menjalankan Func asynchronous dan memiliki Tugas untuk mewakili operasi itu.

public static Task<T> RunAsync<T>(Func<T> function) 
{ 
    if (function == null) throw new ArgumentNullException(“function”); 
    var tcs = new TaskCompletionSource<T>(); 
    ThreadPool.QueueUserWorkItem(_ => 
    { 
        try 
        {  
            T result = function(); 
            tcs.SetResult(result);  
        } 
        catch(Exception exc) { tcs.SetException(exc); } 
    }); 
    return tcs.Task; 
}

Yang dapat digunakan * jika saya tidak memiliki Task.Factory.StartNew- Tapi aku tidak memiliki Task.Factory.StartNew.

Pertanyaan:

Dapatkah seseorang tolong jelaskan dengan contoh skenario yang berhubungan langsung dengan TaskCompletionSource dan bukan dengan situasi hipotetis di mana saya tidak punya Task.Factory.StartNew?

Saya kebanyakan menggunakannya ketika hanya API berbasis acara yang tersedia ( misalnya soket Windows Phone 8 ):

public Task<Args> SomeApiWrapper()
{
    TaskCompletionSource<Args> tcs = new TaskCompletionSource<Args>(); 

    var obj = new SomeApi();

    // will get raised, when the work is done
    obj.Done += (args) => 
    {
        // this will notify the caller 
        // of the SomeApiWrapper that 
        // the task just completed
        tcs.SetResult(args);
    }

    // start the work
    obj.Do();

    return tcs.Task;
}

Jadi ini sangat berguna ketika digunakan bersama dengan asynckata kunci C # 5 .

Dalam pengalaman saya, TaskCompletionSourcesangat bagus untuk membungkus pola asinkron lama dengan pola modern async/await.

Contoh paling bermanfaat yang bisa saya pikirkan adalah ketika bekerja dengannya Socket. Ini memiliki pola APM dan EAP lama, tetapi bukan awaitable Taskmetode itu TcpListenerdan TcpClientmiliki.

Saya pribadi punya beberapa masalah dengan NetworkStreamkelas dan lebih suka yang mentah Socket. Karena saya juga menyukai async/awaitpolanya, saya membuat kelas ekstensi SocketExtenderyang menciptakan beberapa metode ekstensi untuk Socket.

Semua metode ini digunakan TaskCompletionSource<T>untuk membungkus panggilan asinkron seperti:

    public static Task<Socket> AcceptAsync(this Socket socket)
    {
        if (socket == null)
            throw new ArgumentNullException("socket");

        var tcs = new TaskCompletionSource<Socket>();

        socket.BeginAccept(asyncResult =>
        {
            try
            {
                var s = asyncResult.AsyncState as Socket;
                var client = s.EndAccept(asyncResult);

                tcs.SetResult(client);
            }
            catch (Exception ex)
            {
                tcs.SetException(ex);
            }

        }, socket);

        return tcs.Task;
    }

Saya meneruskan socketke BeginAcceptmetode sehingga saya mendapatkan sedikit peningkatan kinerja dari kompiler tidak harus mengerek parameter lokal.

Maka keindahan dari semuanya:

 var listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 listener.Bind(new IPEndPoint(IPAddress.Loopback, 2610));
 listener.Listen(10);

 var client = await listener.AcceptAsync();

Bagi saya, skenario klasik untuk digunakan TaskCompletionSourceadalah ketika mungkin bahwa metode saya tidak perlu harus melakukan operasi yang memakan waktu. Apa yang memungkinkan kami lakukan adalah memilih kasus tertentu di mana kami ingin menggunakan utas baru.

Contoh yang baik untuk ini adalah ketika Anda menggunakan cache. Anda dapat memiliki GetResourceAsyncmetode, yang terlihat di cache untuk sumber daya yang diminta dan kembali sekaligus (tanpa menggunakan utas baru, dengan menggunakan TaskCompletionSource) jika sumber itu ditemukan. Hanya jika sumber daya tidak ditemukan, kami ingin menggunakan utas baru dan mengambilnya menggunakan Task.Run().

Contoh kode dapat dilihat di sini: Cara menjalankan kode secara kondisional menggunakan tugas

Dalam posting blog ini , Levi Botelho menjelaskan cara menggunakan TaskCompletionSourceuntuk menulis bungkus asinkron untuk Proses sehingga Anda dapat meluncurkannya dan menunggu penghentiannya.

public static Task RunProcessAsync(string processPath)
{
    var tcs = new TaskCompletionSource<object>();
    var process = new Process
    {
        EnableRaisingEvents = true,
        StartInfo = new ProcessStartInfo(processPath)
        {
            RedirectStandardError = true,
            UseShellExecute = false
        }
    };
    process.Exited += (sender, args) =>
    {
        if (process.ExitCode != 0)
        {
            var errorMessage = process.StandardError.ReadToEnd();
            tcs.SetException(new InvalidOperationException("The process did not exit correctly. " +
                "The corresponding error message was: " + errorMessage));
        }
        else
        {
            tcs.SetResult(null);
        }
        process.Dispose();
    };
    process.Start();
    return tcs.Task;
}

dan penggunaannya

await RunProcessAsync("myexecutable.exe");

Sepertinya tidak ada yang disebutkan, tapi saya kira tes unit juga dapat dianggap cukup nyata .

Saya menemukan TaskCompletionSourceberguna ketika mengejek ketergantungan dengan metode async.

Dalam program aktual yang sedang diuji:

public interface IEntityFacade
{
  Task<Entity> GetByIdAsync(string id);
}

Dalam tes unit:

// set up mock dependency (here with NSubstitute)

TaskCompletionSource<Entity> queryTaskDriver = new TaskCompletionSource<Entity>();

IEntityFacade entityFacade = Substitute.For<IEntityFacade>();

entityFacade.GetByIdAsync(Arg.Any<string>()).Returns(queryTaskDriver.Task);

// later on, in the "Act" phase

private void When_Task_Completes_Successfully()
{
  queryTaskDriver.SetResult(someExpectedEntity);
  // ...
}

private void When_Task_Gives_Error()
{
  queryTaskDriver.SetException(someExpectedException);
  // ...
}

Lagi pula, penggunaan TaskCompletionSource ini tampaknya merupakan kasus lain dari "objek Tugas yang tidak mengeksekusi kode".

TaskCompletionSource digunakan untuk membuat objek Tugas yang tidak mengeksekusi kode. Dalam skenario dunia nyata, TaskCompletionSource sangat ideal untuk operasi terikat I / O. Dengan cara ini, Anda mendapatkan semua manfaat tugas (misalnya nilai pengembalian, kelanjutan, dll) tanpa memblokir utas selama operasi. Jika "fungsi" Anda adalah operasi terikat I / O, tidak disarankan untuk memblokir utas menggunakan Tugas baru . Alih-alih, menggunakan TaskCompletionSource , Anda dapat membuat tugas budak untuk menunjukkan kapan operasi terikat I / O Anda selesai atau ada kesalahan.

Ada contoh dunia nyata dengan penjelasan yang layak dalam posting ini dari blog "Pemrograman Paralel dengan .NET" . Anda benar-benar harus membacanya, tetapi inilah ringkasannya.

Posting blog menunjukkan dua implementasi untuk:

"metode pabrik untuk membuat tugas" tertunda ", tugas yang tidak benar-benar dijadwalkan sampai beberapa waktu habis yang disediakan pengguna terjadi."

Implementasi pertama yang ditunjukkan didasarkan pada Task<>dan memiliki dua kelemahan utama. Pos implementasi kedua berlanjut untuk mengurangi ini dengan menggunakan TaskCompletionSource<>.

Inilah implementasi kedua:

public static Task StartNewDelayed(int millisecondsDelay, Action action)
{
    // Validate arguments
    if (millisecondsDelay < 0)
        throw new ArgumentOutOfRangeException("millisecondsDelay");
    if (action == null) throw new ArgumentNullException("action");

    // Create a trigger used to start the task
    var tcs = new TaskCompletionSource<object>();

    // Start a timer that will trigger it
    var timer = new Timer(
        _ => tcs.SetResult(null), null, millisecondsDelay, Timeout.Infinite);

    // Create and return a task that will be scheduled when the trigger fires.
    return tcs.Task.ContinueWith(_ =>
    {
        timer.Dispose();
        action();
    });
}

Ini mungkin terlalu menyederhanakan hal-hal tetapi sumber TaskCompletion memungkinkan seseorang untuk menunggu acara. Karena tcs.SetResult hanya diatur setelah peristiwa terjadi, pemanggil dapat menunggu tugas.

Tonton video ini untuk wawasan lebih lanjut:

http://channel9.msdn.com/Series/Three-Essential-Tips-for-Async/Lucian03-TipsForAsyncThreadsAndDatabinding

Skenario dunia nyata yang pernah saya gunakan TaskCompletionSourceadalah ketika mengimplementasikan antrian unduhan. Dalam kasus saya jika pengguna memulai 100 unduhan, saya tidak ingin memadamkan semuanya sekaligus dan alih-alih mengembalikan tugas yang sudah ditentukan, saya mengembalikan tugas yang dilampirkan TaskCompletionSource. Setelah unduhan selesai, utas yang berfungsi, antrian menyelesaikan tugas.

Konsep kuncinya di sini adalah bahwa saya melakukan decoupling ketika seorang klien meminta sebuah tugas dimulai dari saat ia benar-benar dimulai. Dalam hal ini karena saya tidak ingin klien harus berurusan dengan manajemen sumber daya.

perhatikan bahwa Anda dapat menggunakan async / menunggu di .net 4 selama Anda menggunakan kompiler C # 5 (VS 2012+) lihat di sini untuk lebih jelasnya.

Saya sudah terbiasa TaskCompletionSourcemenjalankan Tugas sampai dibatalkan. Dalam hal ini adalah pelanggan ServiceBus yang biasanya ingin saya jalankan selama aplikasi berjalan.

public async Task RunUntilCancellation(
    CancellationToken cancellationToken,
    Func<Task> onCancel)
{
    var doneReceiving = new TaskCompletionSource<bool>();

    cancellationToken.Register(
        async () =>
        {
            await onCancel();
            doneReceiving.SetResult(true); // Signal to quit message listener
        });

    await doneReceiving.Task.ConfigureAwait(false); // Listen until quit signal is received.
}

TaskCompletionSourceadalah untuk Tugas seperti WaitHandleuntuk Thread. Jadi kita dapat menggunakan TaskCompletionSource untuk melakukan pensinyalan yang tepat .

Contohnya adalah jawaban saya untuk pertanyaan ini: Penundaan ContentDialog setelah OK diklik