/// <exception cref="InvalidDataException"></exception>
private static async Task <int> ReadAssertAsync(this AsyncBinaryReader br, int expected)
{
int x = await br.ReadInt32Async();
if (x != expected)
{
throw new InvalidDataException("The remote sent an unexpected result.");
}
return(x);
}
async Task <TResponse> AsyncCallAsync <TRequest, TResponse>(
Method <TRequest, TResponse> method, TRequest request)
{
await pipeLock.WaitAsync();
PipePair pipePair;
availablePipePairs.TryTake(out pipePair);
Debug.Assert(pipePair != null);
try
{
var writer = new AsyncBinaryWriter(pipePair.OutPipe);
var reader = new AsyncBinaryReader(pipePair.InPipe);
// Send the RPC name.
await writer.WriteAsync(method.FullName.Length);
await writer.WriteAsync(Encoding.ASCII.GetBytes(method.FullName));
// Send the request.
using (var serializationContext = new SimpleSerializationContext())
{
method.RequestMarshaller.ContextualSerializer(request, serializationContext);
byte[] requestBytes = serializationContext.GetPayload();
await writer.WriteAsync(requestBytes.Length);
await writer.WriteAsync(requestBytes);
}
// Read the response.
int size = await reader.ReadInt32Async();
byte[] responseBytes = await reader.ReadBytesAsync(size);
var deserializationContext = new SimpleDeserializationContext(responseBytes);
return(method.ResponseMarshaller.ContextualDeserializer(deserializationContext));
}
// Unfortunately, RpcExceptions can't be nested with InnerException.
catch (EndOfStreamException e)
{
throw new RpcException(new Status(StatusCode.Unknown, e.ToString()),
"Connection to server lost. Did it shut down?");
}
catch (Exception e) when(!(e is RpcException))
{
throw new RpcException(new Status(StatusCode.Unknown, e.ToString()),
"Unknown failure: " + e);
}
finally
{
availablePipePairs.Add(pipePair);
pipeLock.Release();
}
}
public async Task ValidateReadWriteStatistics()
{
InterceptData clientData = null, serverData = null;
var server = new WsServer();
await server.StartAsync(new IPEndPoint(IPAddress.Loopback, 0), async stream =>
{
await stream.WrapSocketAsync(x =>
Task.FromResult <WStreamSocket>(new Interceptor(x, out serverData))
);
var abr = new AsyncBinaryReader(stream);
for (int i = 0; i < 100000; i++)
{
Assert.Equal(i, await abr.ReadInt32Async());
}
await stream.CloseAsync();
});
var client = new WsClient();
var connection = await client.ConnectAsync(new Uri("ws://" + server.ListeningAddresses[0].Substring(7)));
await connection.WrapSocketAsync(x =>
Task.FromResult <WStreamSocket>(new Interceptor(x, out clientData))
);
var abw = new AsyncBinaryWriter(connection);
for (int i = 0; i < 100000; i++)
{
await abw.WriteAsync(i);
}
await abw.FlushAsync();
await Task.Delay(1000);
Assert.Equal(4 * 100000, clientData.BytesWritten);
Assert.Equal(4 * 100000, serverData.BytesRead);
client.Dispose();
server.Dispose();
}
public static async Task DecompressL33TZipAsync(
Stream inputStream,
Stream outputStream,
IProgress <double> progress = null,
CancellationToken ct = default)
{
//Get extracted content length
long fileLength;
using (var reader = new AsyncBinaryReader(inputStream, new UTF8Encoding(), true))
{
var fileHeader = new string(await reader.ReadCharsAsync(4, ct));
switch (fileHeader.ToLower())
{
case L33THeader:
fileLength = await reader.ReadInt32Async(ct);
break;
case L66THeader:
fileLength = await reader.ReadInt64Async(ct);
break;
default:
throw new InvalidOperationException($"Header '{fileHeader}' is not recognized as a valid type");
}
//Skip deflate specification (2 Byte)
reader.BaseStream.Position += 2;
}
//Extract content
var buffer = new byte[BufferSize];
int bytesRead;
var totalBytesRead = 0L;
var lastProgress = 0d;
using var compressedStream = new DeflateStream(inputStream, CompressionMode.Decompress);
while ((bytesRead = await compressedStream.ReadAsync(buffer, 0, buffer.Length, ct)) > 0)
{
ct.ThrowIfCancellationRequested();
if (bytesRead > fileLength)
{
totalBytesRead += fileLength;
await outputStream.WriteAsync(buffer, 0, (int)fileLength, ct);
}
else if (totalBytesRead + bytesRead <= fileLength)
{
totalBytesRead += bytesRead;
await outputStream.WriteAsync(buffer, 0, bytesRead, ct);
}
else if (totalBytesRead + bytesRead > fileLength)
{
var leftToRead = fileLength - totalBytesRead;
totalBytesRead += leftToRead;
await outputStream.WriteAsync(buffer, 0, (int)leftToRead, ct);
}
var newProgress = (double)totalBytesRead / fileLength * 100;
if (newProgress - lastProgress > 1)
{
progress?.Report(newProgress);
lastProgress = newProgress;
}
if (totalBytesRead >= fileLength)
{
break;
}
}
}
/// <summary>
/// Asynchronously reads a bit set from the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A <see cref="Task{Pdb20BitSet}"/> that represents the asynchronous read operation.
/// </returns>
public static async Task<Pdb70BitSet> ReadAsync(AsyncBinaryReader reader, CancellationToken cancellationToken)
{
var result = new Pdb70BitSet(await reader.ReadInt32Async(cancellationToken));
if (result.Words.Length != 0)
{
var bytes = await reader.ReadBytesAsync(result.Words.Length * sizeof(int), cancellationToken);
Buffer.BlockCopy(bytes, 0, result.Words, 0, bytes.Length);
}
return result;
}
public async Task TestAsyncBinaryReader()
{
byte customByte = 39;
bool customBool = Unsafe.As <byte, bool>(ref customByte);
object[] expectedResults =
{
true,
false,
customBool,
(byte)42,
(sbyte)-28,
(short)-279,
(ushort)64221,
(int)-288888,
(uint)3310229011,
(float)3811.55f,
(long)-19195205991011,
(ulong)11223372036854775807,
(double)Math.PI,
(decimal)295222.2811m
};
using (var ms = new MemoryStream())
{
using (var wr = new BinaryWriter(ms, Encoding.Default, leaveOpen: true))
{
foreach (dynamic obj in expectedResults)
{
wr.Write(obj);
}
}
ms.Position = 0;
using (var rd = new AsyncBinaryReader(ms, Encoding.Default, leaveOpen: true))
{
foreach (var obj in expectedResults)
{
switch (obj)
{
case bool b8:
////Assert.Equal(b8, await rd.ReadBooleanAsync());
if (b8)
{
Assert.True(await rd.ReadBooleanAsync());
}
else
{
Assert.False(await rd.ReadBooleanAsync());
}
break;
case byte u8:
Assert.Equal(u8, await rd.ReadByteAsync());
break;
case sbyte s8:
Assert.Equal(s8, await rd.ReadSByteAsync());
break;
case short s16:
Assert.Equal(s16, await rd.ReadInt16Async());
break;
case ushort u16:
Assert.Equal(u16, await rd.ReadUInt16Async());
break;
case int s32:
Assert.Equal(s32, await rd.ReadInt32Async());
break;
case uint u32:
Assert.Equal(u32, await rd.ReadUInt32Async());
break;
case long s64:
Assert.Equal(s64, await rd.ReadInt64Async());
break;
case ulong u64:
Assert.Equal(u64, await rd.ReadUInt64Async());
break;
case float f32:
Assert.Equal(f32, await rd.ReadSingleAsync());
break;
case double f64:
Assert.Equal(f64, await rd.ReadDoubleAsync());
break;
case decimal d128:
Assert.Equal(d128, await rd.ReadDecimalAsync());
break;
}
}
}
}
}
public async Task When_reading_an_Int32()
{
var sut = new AsyncBinaryReader(new TestStream(
1, 0, 0, 0
));
var i = await sut.ReadInt32Async(CancellationToken.None);
Assert.Equal(1, i);
}
public async Task When_reading_an_Int32_from_a_stream_that_is_too_short()
{
var sut = new AsyncBinaryReader(new TestStream(
1, 0, 0
));
await Assert.ThrowsAsync<EndOfStreamException>(async () =>
{
await sut.ReadInt32Async(CancellationToken.None);
});
}
