using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.IO.Pipes;

[MemoryDiagnoser]
public class Program
{
    static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);

    private Stream _server;
    private Stream _client;
    private byte[] _buffer = new byte[1];
    private CancellationTokenSource _cts = new CancellationTokenSource();

    [Params(false, true)]
    public bool Cancelable { get; set; }

    [Params(false, true)]
    public bool Named { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        if (Named)
        {
            string name = Guid.NewGuid().ToString("N");
            var server = new NamedPipeServerStream(name, PipeDirection.Out);
            var client = new NamedPipeClientStream(".", name, PipeDirection.In);
            Task.WaitAll(server.WaitForConnectionAsync(), client.ConnectAsync());
            _server = server;
            _client = client;
        }
        else
        {
            var server = new AnonymousPipeServerStream(PipeDirection.Out);
            var client = new AnonymousPipeClientStream(PipeDirection.In, server.ClientSafePipeHandle);
            _server = server;
            _client = client;
        }
    }

    [GlobalCleanup]
    public void Cleanup()
    {
        _server.Dispose();
        _client.Dispose();
    }

    [Benchmark(OperationsPerInvoke = 1000)]
    public async Task ReadWriteAsync()
    {
        CancellationToken ct = Cancelable ? _cts.Token : default;
        for (int i = 0; i < 1000; i++)
        {
            ValueTask<int> read = _client.ReadAsync(_buffer, ct);
            await _server.WriteAsync(_buffer, ct);
            await read;
        }
    }
}