public static async Task CopyToAsync_AllDataCopied(int byteCount, bool useAsync) { using StreamPair streams = await CreateConnectedStreamsAsync(); (Stream writeable, Stream readable) = GetReadWritePair(streams); var results = new MemoryStream(); byte[] dataToCopy = RandomNumberGenerator.GetBytes(byteCount); Task copyTask; if (useAsync) { copyTask = readable.CopyToAsync(results); await writeable.WriteAsync(dataToCopy); } else { copyTask = Task.Run(() => readable.CopyTo(results)); writeable.Write(new ReadOnlySpan <byte>(dataToCopy)); } writeable.Dispose(); await copyTask; }
internal static async Task ReadWrite_Success(ReadWriteMode mode, int writeSize, bool startWithFlush) { foreach (CancellationToken nonCanceledToken in new[] { CancellationToken.None, new CancellationTokenSource().Token }) { using StreamPair streams = await CreateConnectedStreamsAsync(); foreach ((Stream writeable, Stream readable) in GetReadWritePairs(streams)) { if (startWithFlush) { await FlushAsync(mode, writeable, nonCanceledToken); } byte[] writerBytes = RandomNumberGenerator.GetBytes(writeSize); var readerBytes = new byte[writerBytes.Length]; Task writes = Task.Run(async() => { await WriteAsync(mode, writeable, writerBytes, 0, writerBytes.Length, nonCanceledToken); if (FlushRequiredToWriteData) { if (FlushGuaranteesAllDataWritten) { await writeable.FlushAsync(); } else { await writeable.DisposeAsync(); } } }); int n = 0; while (n < readerBytes.Length) { int r = await ReadAsync(mode, readable, readerBytes, n, readerBytes.Length - n); n += r; } await writes; if (!FlushGuaranteesAllDataWritten) { break; } } } }
protected static (Stream writeable, Stream readable) GetReadWritePair(StreamPair streams) =>
protected static IEnumerable <(Stream writeable, Stream readable)> GetReadWritePairs(StreamPair streams) { var pairs = new List <(Stream, Stream)>(2); if (streams.Stream1.CanWrite) { pairs.Add((streams.Stream1, streams.Stream2)); } if (streams.Stream2.CanWrite) { pairs.Add((streams.Stream2, streams.Stream1)); } return(pairs); }
protected static async Task <StreamPair> CreateConnectedStreamsAsync() { QuicImplementationProvider provider = ImplementationProvider; var protocol = new SslApplicationProtocol("quictest"); QuicListener listener = new QuicListener(provider, new QuicListenerOptions() { ListenEndPoint = new IPEndPoint(IPAddress.Loopback, 0), ServerAuthenticationOptions = new SslServerAuthenticationOptions { ApplicationProtocols = new List <SslApplicationProtocol> { protocol } }, CertificateFilePath = "Certs/cert.crt", PrivateKeyFilePath = "Certs/cert.key" }); listener.Start(); QuicConnection connection1 = null, connection2 = null; QuicStream stream1 = null, stream2 = null; await Task.WhenAll( Task.Run(async() => { connection1 = await listener.AcceptConnectionAsync(); stream1 = await connection1.AcceptStreamAsync(); // Hack to force stream creation byte[] buffer = new byte[1]; await stream1.ReadAsync(buffer); }), Task.Run(async() => { connection2 = new QuicConnection( provider, listener.ListenEndPoint, new SslClientAuthenticationOptions() { ApplicationProtocols = new List <SslApplicationProtocol>() { protocol } }); await connection2.ConnectAsync(); stream2 = connection2.OpenBidirectionalStream(); // Hack to force stream creation byte[] buffer = new byte[1]; await stream2.WriteAsync(buffer); await stream2.FlushAsync(); })); var result = new StreamPair(stream1, stream2); result.Disposables.Add(connection1); result.Disposables.Add(connection2); result.Disposables.Add(listener); return(result); }