เมื่อใดที่ควรใช้ TaskCompletionSource <T>

AFAIK ทั้งหมดก็รู้ก็คือว่าในบางจุดของมันSetResultหรือSetExceptionวิธีการที่จะถูกเรียกตัวไปดำเนินการTask<T>สัมผัสผ่านTaskคุณสมบัติ

กล่าวอีกนัยหนึ่งมันทำหน้าที่เป็นผู้อำนวยการสร้างTask<TResult>และเสร็จสมบูรณ์

ฉันเห็นตัวอย่างที่นี่ :

หากฉันต้องการวิธีในการรัน Func แบบอะซิงโครนัสและมีภารกิจเพื่อแสดงการดำเนินการนั้น

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

ซึ่งสามารถนำมาใช้ * ถ้าฉันไม่ได้มีTask.Factory.StartNew- แต่ผมไม่Task.Factory.StartNewได้

คำถาม:

ใครจะกรุณาอธิบายโดยยกตัวอย่างเช่นสถานการณ์ที่เกี่ยวข้องโดยตรงจะTaskCompletionSource ไม่ไปสมมุติสถานการณ์ที่ผมไม่ได้ Task.Factory.StartNew?

ฉันใช้เป็นส่วนใหญ่เมื่อมีเพียง API ที่ใช้เหตุการณ์เท่านั้น ( เช่นซ็อกเก็ต 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;
}

ดังนั้นจึงมีประโยชน์อย่างยิ่งเมื่อใช้ร่วมกับasyncคำหลักC # 5

ในประสบการณ์ของฉันTaskCompletionSourceเป็นที่ดีสำหรับการตัดรูปแบบไม่ตรงกันเก่าไปทันสมัยasync/awaitรูปแบบ

Socketตัวอย่างที่เป็นประโยชน์มากที่สุดที่ฉันสามารถคิดคือเมื่อทำงานร่วมกับ มันมีรูปแบบ APM และ EAP แบบเก่า แต่ไม่ใช่awaitable TaskวิธีการTcpListenerและTcpClientมี

ผมเองมีหลายประเด็นที่มีการเรียนและต้องการดิบNetworkStream Socketเป็นที่ฉันยังรักasync/awaitรูปแบบที่ผมทำชั้นนามสกุลซึ่งจะสร้างวิธีการขยายหลายSocketExtenderSocket

วิธีการทั้งหมดเหล่านี้ใช้ประโยชน์จากTaskCompletionSource<T>การตัดการโทรแบบอะซิงโครนัสดังนี้:

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

ผมผ่านsocketเข้าไปในBeginAcceptวิธีการเพื่อที่ฉันได้รับการเพิ่มประสิทธิภาพการทำงานเล็กน้อยจากคอมไพเลอร์ไม่ต้องยกพารามิเตอร์ท้องถิ่น

จากนั้นความงามของมันทั้งหมด:

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

สำหรับฉันแล้วสถานการณ์คลาสสิกสำหรับใช้TaskCompletionSourceคือเมื่อเป็นไปได้ว่าวิธีการของฉันไม่จำเป็นต้องใช้เวลานานในการดำเนินการ สิ่งที่ทำให้เราสามารถทำได้คือเลือกกรณีเฉพาะที่เราต้องการใช้เธรดใหม่

ตัวอย่างที่ดีสำหรับสิ่งนี้คือเมื่อคุณใช้แคช คุณสามารถมีGetResourceAsyncวิธีการซึ่งดูในแคชสำหรับทรัพยากรที่ร้องขอและส่งคืนทันที (โดยไม่ต้องใช้เธรดใหม่โดยใช้TaskCompletionSource) หากพบทรัพยากร Task.Run()เฉพาะในกรณีที่ทรัพยากรไม่พบเราต้องการใช้หัวข้อใหม่และเรียกดูได้โดยใช้

ตัวอย่างรหัสสามารถเห็นได้ที่นี่: วิธีการเรียกใช้โค้ดแบบอะซิงโคนัลโดยใช้งาน

ในโพสต์บล็อกนี้ Levi Botelho อธิบายถึงวิธีการใช้TaskCompletionSourceเพื่อเขียน wrapper แบบอะซิงโครนัสสำหรับกระบวนการเพื่อให้คุณสามารถเปิดใช้งานและรอการยกเลิก

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

และการใช้งาน

await RunProcessAsync("myexecutable.exe");

ดูเหมือนว่าไม่มีใครพูดถึง แต่ฉันเดาว่าการทดสอบหน่วยก็อาจถือว่าเป็นชีวิตจริงได้เช่นกัน

ฉันพบว่าTaskCompletionSourceมีประโยชน์เมื่อเยาะเย้ยการพึ่งพาด้วยวิธีการ async

ในโปรแกรมจริงภายใต้การทดสอบ:

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

ในการทดสอบหน่วย:

// 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);
  // ...
}

ท้ายที่สุดการใช้งานของ TaskCompletionSource นี้ดูเหมือนจะเป็นอีกกรณีหนึ่งของ "วัตถุภารกิจที่ไม่ได้ใช้รหัส"

TaskCompletionSourceใช้เพื่อสร้างภารกิจของวัตถุที่ไม่ได้ใช้รหัส ในสถานการณ์โลกแห่งความเป็นจริงTaskCompletionSourceเหมาะอย่างยิ่งสำหรับการดำเนินการที่ถูกผูกไว้กับ I / O ด้วยวิธีนี้คุณจะได้รับประโยชน์ทั้งหมดของงาน (เช่นค่าส่งคืนความต่อเนื่อง ฯลฯ ) โดยไม่ปิดกั้นเธรดในช่วงระยะเวลาของการดำเนินการ หาก "ฟังก์ชั่น" ของคุณเป็น I / O การดำเนินงานที่ถูกผูกไว้จะไม่แนะนำเพื่อป้องกันด้ายใช้ใหม่งาน แต่ใช้TaskCompletionSource แทนคุณสามารถสร้างภารกิจทาสเพื่อระบุเมื่อการดำเนินการ I / O ของคุณเสร็จสิ้นหรือเกิดข้อผิดพลาด

มีตัวอย่างที่เป็นโลกแห่งความจริงกับคำอธิบายที่ดีในเรื่องนี้โพสต์จาก "การเขียนโปรแกรมแบบขนานกับ .NET" บล็อก คุณควรอ่านมันจริงๆ แต่นี่เป็นบทสรุป

โพสต์บล็อกแสดงสองการใช้งานสำหรับ:

"วิธีการจากโรงงานสำหรับการสร้างงาน" ล่าช้า "งานที่ไม่ได้ถูกกำหนดเวลาไว้จริงจนกว่าจะถึงเวลาที่ผู้ใช้กำหนด

การใช้งานครั้งแรกที่แสดงขึ้นอยู่กับTask<>และมีข้อบกพร่องหลักสองประการ TaskCompletionSource<>โพสต์การดำเนินงานที่สองไปในการบรรเทาเหล่านี้โดยใช้

นี่คือการใช้งานครั้งที่สอง:

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

สิ่งนี้อาจทำให้สิ่งต่าง ๆ มีขนาดใหญ่เกินไป แต่แหล่ง TaskCompletion อนุญาตให้ใครรอเหตุการณ์ เนื่องจากมีการตั้งค่า tcs.SetResult เมื่อเหตุการณ์เกิดขึ้นผู้เรียกจึงสามารถรองานได้

ชมวิดีโอนี้เพื่อรับข้อมูลเชิงลึกเพิ่มเติม:

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

ฉันสถานการณ์โลกแห่งความจริงที่ฉันได้ใช้TaskCompletionSourceคือเมื่อใช้คิวการดาวน์โหลด ในกรณีของฉันถ้าผู้ใช้เริ่มต้น 100 ดาวน์โหลดฉันไม่ต้องการที่จะยิงพวกเขาออกทั้งหมดในครั้งเดียวและอื่นแทนที่จะกลับเป็นงานที่เราจะกลับมา strated TaskCompletionSourceงานที่แนบมากับ เมื่อการดาวน์โหลดเสร็จสมบูรณ์เธรดที่ใช้งานคิวจะทำงานเสร็จสมบูรณ์

แนวคิดหลักที่นี่คือฉัน decoupling เมื่อลูกค้าขอให้งานที่จะเริ่มต้นเมื่อมันเริ่มจริง ในกรณีนี้เพราะฉันไม่ต้องการให้ลูกค้าต้องจัดการกับการจัดการทรัพยากร

โปรดทราบว่าคุณสามารถใช้ async / คอยใน. net 4 ตราบใดที่คุณใช้คอมไพเลอร์ C # 5 (VS 2012+) ดูที่นี่สำหรับรายละเอียดเพิ่มเติม

ฉันเคยTaskCompletionSourceเรียกใช้งานจนกว่าจะถูกยกเลิก ในกรณีนี้มันเป็นสมาชิก ServiceBus ซึ่งโดยปกติฉันต้องการเรียกใช้ตราบเท่าที่แอปพลิเคชันทำงาน

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.
}

TaskCompletionSourceคือ Tasks เช่นเดียวWaitHandleกับเธรด และเพื่อให้เราสามารถใช้ในการดำเนินการส่งสัญญาณได้อย่างแม่นยำTaskCompletionSource

ตัวอย่างคือคำตอบของฉันสำหรับคำถามนี้: ความล่าช้าของ ContentDialog หลังจากคลิกตกลง