Когда следует использовать TaskCompletionSource?

по моему опыту,TaskCompletionSource отлично подходит для обертывания старых асинхронных шаблонов в современный async/await узор.

самый полезный пример, который я могу придумать, это при работе с Socket. Он имеет старые шаблоны APM и EAP, но не awaitable Task методы TcpListener и TcpClient есть.

у меня лично есть некоторые проблемы с NetworkStream класс и предпочитают raw Socket. Будучи тем, что я также люблю async/await шаблон, я сделал расширение класса SocketExtender что создает несколько методов расширения для Socket.

все эти методы использовать 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 чтобы написать асинхронную оболочку для процесса, чтобы вы могли запустить его и дождаться его завершения.

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 используется для создания задание объекты, которые не выполнить код. В Реальных Сценариях TaskCompletionSource идеально подходит для операций ввода-вывода. Таким образом, вы получаете все преимущества задач (например, возвращаемые значения, продолжения и т. д.), не блокируя поток на время операции. Если ваша "функция" является операцией привязки ввода-вывода, не рекомендуется блокировать поток с помощью нового задание. Вместо использования TaskCompletionSource вы можете создать подчиненную задачу, чтобы просто указать, когда ваша операция ввода-вывода заканчивается или неисправна.

похоже, никто не упомянул, но я думаю, что модульные тесты тоже можно считать реальная жизнь

есть реальный пример с достойным объяснением в этом сообщение из блога "параллельное программирование с .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();
    });
}

Я реальный сценарий мира, где я использовал TaskCompletionSource при реализации очереди загрузки. В моем случае, если пользователь запускает 100 загрузок, я не хочу запускать их все сразу, и поэтому вместо возврата стратифицированной задачи я возвращаю задачу, прикрепленную к TaskCompletionSource. После завершения загрузки поток, который работает очередь завершает задачу.

ключевая концепция здесь заключается в том, что я отделяю, когда клиент запрашивает задачу, которая должна быть запущена, когда она фактически получает начатый. В этом случае, потому что я не хочу, чтобы клиент имел дело с управлением ресурсами.

обратите внимание, что вы можете использовать async / await в .net 4, Если вы используете компилятор C# 5 (VS 2012+) см. здесь для более подробной информации.

Это может быть чрезмерно упрощая вещи, но источник TaskCompletion позволяет ждать на событие. Начиная с ТКС.SetResult устанавливается только после того, как событие происходит, вызывающий может ожидать на задаче.

смотрите это видео для получения дополнительной информации:

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