NamedPipeServerStream.ReadAsync() не завершается при отмене запросов CancellationToken

У .NET-программистов возникают ужасные проблемы с async/await, когда они пишут такие маленькие тестовые программы. Он плохо сочиняет, это черепахи на всем протяжении. В этой программе отсутствует финальная черепаха, задачи зашли в тупик. Никто не заботится о выполнении продолжений задач, как это обычно происходит (скажем) в приложении с графическим интерфейсом. Чрезвычайно сложно отлаживать.

Сначала внесите небольшое изменение, чтобы тупик был полностью виден:

   int bytes = await server.ReadPipeAsync(buffer, 0, 4, cancellationTokenSource.Token);

Это устраняет неприятный маленький краеугольный случай, метод сервера, который полностью приводит к сообщению «Сервер вышел». Хроническая проблема с классом Task заключается в том, что когда задача завершается или ожидаемый метод завершается синхронно, он пытается запустить продолжение напрямую. Это работает в этой программе. Заставив его получить асинхронный результат, тупик теперь очевиден.

Следующим шагом будет исправление функции Main(), чтобы эти задачи больше не блокировались. Это может выглядеть так:

static void Main(string[] args) {
    try {
        var tasks = new Task[3];
        tasks[0] = Server();
        tasks[1] = tasks[0].ContinueWith(c => {
            Console.WriteLine($"Server exited, cancelled={c.IsCanceled}");
        });
        tasks[2] = Clinet();
        Task.WhenAll(tasks).Wait();
    }
    catch (Exception ex) {
        Console.WriteLine(ex);
    }
    Console.WriteLine("press [enter] to exit");
    Console.ReadLine();
}

Теперь у нас есть шанс продвинуться вперед и решить проблему отмены. Класс NamedPipeServerStream не реализует сам ReadAsync, он наследует метод от одного из своих базовых классов, Stream. У него есть маленькая крысиная деталь, которая полностью задокументирована. Вы можете увидеть это, только если посмотрите на исходный код фреймворка. Он может обнаружить отмену только тогда, когда отмена произошла до вызова ReadAsync(). Как только чтение началось, оно больше не может видеть отмену. Конечная проблема, которую вы пытаетесь решить.

Это поправимая проблема, но у меня есть смутное представление, почему Microsoft не сделала этого для PipeStreams. Обычный способ принудительного завершения метода BeginRead() — это метод Dispose() объекта, а также единственный способ, которым можно прервать Stream.ReadAsync(). Но есть и другой способ: в Windows можно прервать операцию ввода-вывода с помощью Отмена(). Давайте сделаем это методом расширения:

using System;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.IO.Pipes;
using Microsoft.Win32.SafeHandles;

public static class AsyncPipeFixer {

    public static Task<int> ReadPipeAsync(this PipeStream pipe, byte[] buffer, int offset, int count, CancellationToken cancellationToken) {
        if (cancellationToken.IsCancellationRequested) return Task.FromCanceled<int>(cancellationToken);
        var registration = cancellationToken.Register(() => CancelPipeIo(pipe));
        var async = pipe.BeginRead(buffer, offset, count, null, null);
        return new Task<int>(() => {
            try { return pipe.EndRead(async); }
            finally { registration.Dispose(); }
        }, cancellationToken);
    }

    private static void CancelPipeIo(PipeStream pipe) {
        // Note: no PipeStream.IsDisposed, we'll have to swallow
        try {
            CancelIo(pipe.SafePipeHandle);
        }
        catch (ObjectDisposedException) { }
    }
    [DllImport("kernel32.dll")]
    private static extern bool CancelIo(SafePipeHandle handle);

}

И, наконец, настройте сервер, чтобы использовать его:

    int bytes = await server.ReadPipeAsync(buffer, 0, 4, cancellationTokenSource.Token);

Имейте в виду, что этот обходной путь специфичен для Windows, поэтому он не может работать в программе .NETCore, предназначенной для разновидности Unix. Затем рассмотрим более тяжелый молот, вызовите pipe.Close() в методе CancelPipeIo().

ReadAsync Сначала проверьте отмену, затем начните чтение, если токен отменен, он не действует.

добавить следующую строку

отменаToken.Register(server.Disconnect);

using (var cancellationTokenSource = new CancellationTokenSource(1000))
using (var server = new NamedPipeServerStream("test",
    PipeDirection.InOut,
    1,
    PipeTransmissionMode.Byte,
    PipeOptions.Asynchronous))
{
    var cancellationToken = cancellationTokenSource.Token;
    cancellationToken.Register(server.Disconnect);
    await server.WaitForConnectionAsync(cancellationToken);
    await server.WriteAsync(new byte[]{1,2,3,4}, 0, 4, cancellationToken);
    var buffer = new byte[4];
    await server.ReadAsync(buffer, 0, 4, cancellationToken);
    Console.WriteLine("exit server");
}

Я просто смотрю на ваш код и, возможно, смотрю на него свежим взглядом...

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

Используйте свойство IsCancellationRequested, чтобы проверить, отменен ли токен, и не передавать отмененные токены.

Вот пример добавления этого в ваш код из исходного вопроса (вы можете сделать то же самое для своего более позднего метода ReadPipeAsync.

var cancellationToken = cancellationTokenSource.Token;
await server.WaitForConnectionAsync(cancellationToken);

if(!cancellationToken.IsCancellationRequested)
{
    await server.WriteAsync(new byte[] { 1, 2, 3, 4 }, 0, 4, cancellationToken);
}

if(!cancellationToken.IsCancellationRequested)
{
    var buffer = new byte[4];
    await server.ReadAsync(buffer, 0, 4, cancellationToken);
}

Console.WriteLine("exit server");

приведенный выше код приведет к

exit server
client exit

который, я думаю, был и вашим очень оригинальным вопросом...

Ответ Ханса Пассана идеален... почти. Единственная проблема заключается в том, что CancelIo() отменяет запрос, сделанный из того же потока. Это не сработает, если задача будет возобновлена ​​в другом потоке. К сожалению, у меня недостаточно очков репутации, чтобы напрямую прокомментировать его ответ, поэтому я отвечаю отдельно.

Поэтому последнюю часть его примера кода следует переписать следующим образом:

    private static void CancelPipeIo(PipeStream pipe) {
        // Note: no PipeStream.IsDisposed, we'll have to swallow
        try {
            CancelIoEx(pipe.SafePipeHandle);
        }
        catch (ObjectDisposedException) { }
    }
    [DllImport("kernel32.dll")]
    private static extern bool CancelIoEx(SafePipeHandle handle, IntPtr _ = default);

Обратите внимание, что CancelIoEx() доступен в Vista/Server 2008 и более поздних версиях, а CancelIo() также доступен в Windows XP.