public static void EncodeAsString(string encodingName)
{
var encoding = Encoding.GetEncoding(encodingName);
using var stream = new MemoryStream();
var g = Guid.NewGuid();
var dt = DateTime.Now;
var dto = DateTimeOffset.Now;
var t = TimeSpan.FromMilliseconds(1096);
stream.WriteInt64(42L, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteUInt64(12UL, StringLengthEncoding.PlainLittleEndian, encoding, provider: InvariantCulture);
stream.WriteInt32(34, StringLengthEncoding.PlainBigEndian, encoding, provider: InvariantCulture);
stream.WriteUInt32(78, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteInt16(90, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteUInt16(12, StringLengthEncoding.Plain, encoding, format: "X", provider: InvariantCulture);
stream.WriteUInt16(12, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteByte(10, StringLengthEncoding.Plain, encoding, format: "X", provider: InvariantCulture);
stream.WriteSByte(11, StringLengthEncoding.Plain, encoding, format: "X", provider: InvariantCulture);
stream.WriteByte(10, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteSByte(11, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteGuid(g, StringLengthEncoding.Plain, encoding);
stream.WriteGuid(g, StringLengthEncoding.Plain, encoding, format: "X");
stream.WriteDateTime(dt, StringLengthEncoding.Plain, encoding, format: "O", provider: InvariantCulture);
stream.WriteDateTimeOffset(dto, StringLengthEncoding.Plain, encoding, format: "O", provider: InvariantCulture);
stream.WriteDateTime(dt, StringLengthEncoding.Plain, encoding, format: "O", provider: InvariantCulture);
stream.WriteDateTimeOffset(dto, StringLengthEncoding.Plain, encoding, format: "O", provider: InvariantCulture);
stream.WriteDecimal(42.5M, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteSingle(32.2F, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteDouble(56.6D, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteTimeSpan(t, StringLengthEncoding.Plain, encoding, provider: InvariantCulture);
stream.WriteTimeSpan(t, StringLengthEncoding.Plain, encoding, "G", provider: InvariantCulture);
stream.Position = 0;
var decodingContext = new DecodingContext(encoding);
Span <byte> buffer = stackalloc byte[256];
Equal(42L, stream.ReadInt64(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(12UL, stream.ReadUInt64(StringLengthEncoding.PlainLittleEndian, in decodingContext, buffer, provider: InvariantCulture));
Equal(34, stream.ReadInt32(StringLengthEncoding.PlainBigEndian, in decodingContext, buffer, provider: InvariantCulture));
Equal(78U, stream.ReadUInt32(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(90, stream.ReadInt16(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal("C", stream.ReadString(StringLengthEncoding.Plain, in decodingContext, buffer));
Equal(12, stream.ReadUInt16(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal("A", stream.ReadString(StringLengthEncoding.Plain, in decodingContext, buffer));
Equal("B", stream.ReadString(StringLengthEncoding.Plain, in decodingContext, buffer));
Equal(10, stream.ReadByte(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(11, stream.ReadSByte(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(g, stream.ReadGuid(StringLengthEncoding.Plain, in decodingContext, buffer));
Equal(g, stream.ReadGuid(StringLengthEncoding.Plain, in decodingContext, buffer, "X"));
Equal(dt, stream.ReadDateTime(StringLengthEncoding.Plain, in decodingContext, buffer, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, stream.ReadDateTimeOffset(StringLengthEncoding.Plain, in decodingContext, buffer, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dt, stream.ReadDateTime(StringLengthEncoding.Plain, in decodingContext, buffer, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, stream.ReadDateTimeOffset(StringLengthEncoding.Plain, in decodingContext, buffer, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(42.5M, stream.ReadDecimal(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(32.2F, stream.ReadSingle(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(56.6D, stream.ReadDouble(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(t, stream.ReadTimeSpan(StringLengthEncoding.Plain, in decodingContext, buffer, provider: InvariantCulture));
Equal(t, stream.ReadTimeSpan(StringLengthEncoding.Plain, in decodingContext, buffer, formats: new[] { "G" }, provider: InvariantCulture));
}
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
JsonToken token = context.Input.Peek();
if (context.KnownType == null || context.KnownType == typeof(object))
{
if (token == JsonToken.BeginArray)
{
yield return new ProvideNextNode(new ListNode());
}
else if (token == JsonToken.BeginObject)
{
yield return new ProvideNextNode(new DictNode());
}
else
{
yield return new ProvideNextNode(new ValudeNode());
}
}
else if (token == JsonToken.Null)
{
yield return new ProvideNextNode(new ValudeNode());
}
yield break;
}
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
if (_action != null)
context.Value = _action(context.Value);
yield break;
}
public static void EncodeAsString(BufferWriter <byte> writer, Encoding encoding)
{
var encodingContext = new EncodingContext(encoding, true);
using (writer)
{
var g = Guid.NewGuid();
var bi = new BigInteger(RandomBytes(64));
var dt = DateTime.Now;
var dto = DateTimeOffset.Now;
writer.WriteInt64(42L, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteUInt64(12UL, LengthFormat.PlainLittleEndian, in encodingContext, provider: InvariantCulture);
writer.WriteInt32(34, LengthFormat.PlainBigEndian, in encodingContext, provider: InvariantCulture);
writer.WriteUInt32(78, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteInt16(90, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteUInt16(12, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture);
writer.WriteUInt16(12, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteByte(10, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture);
writer.WriteSByte(11, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture);
writer.WriteByte(10, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteSByte(11, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteGuid(g, LengthFormat.Plain, in encodingContext);
writer.WriteGuid(g, LengthFormat.Plain, in encodingContext, format: "X");
writer.WriteDateTime(dt, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture);
writer.WriteDateTimeOffset(dto, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture);
writer.WriteDateTime(dt, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture);
writer.WriteDateTimeOffset(dto, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture);
writer.WriteDecimal(42.5M, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteSingle(32.2F, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteDouble(56.6D, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
writer.WriteBigInteger(bi, LengthFormat.Plain, in encodingContext, provider: InvariantCulture);
var decodingContext = new DecodingContext(encoding, true);
var reader = IAsyncBinaryReader.Create(writer.WrittenMemory);
Equal(42L, reader.ReadInt64(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(12UL, reader.ReadUInt64(LengthFormat.PlainLittleEndian, in decodingContext, provider: InvariantCulture));
Equal(34, reader.ReadInt32(LengthFormat.PlainBigEndian, in decodingContext, provider: InvariantCulture));
Equal(78U, reader.ReadUInt32(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(90, reader.ReadInt16(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal("C", reader.ReadString(LengthFormat.Plain, in decodingContext));
Equal(12, reader.ReadUInt16(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal("A", reader.ReadString(LengthFormat.Plain, in decodingContext));
Equal("B", reader.ReadString(LengthFormat.Plain, in decodingContext));
Equal(10, reader.ReadByte(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(11, reader.ReadSByte(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(g, reader.ReadGuid(LengthFormat.Plain, in decodingContext));
Equal(g, reader.ReadGuid(LengthFormat.Plain, in decodingContext, "X"));
Equal(dt, reader.ReadDateTime(LengthFormat.Plain, in decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, reader.ReadDateTimeOffset(LengthFormat.Plain, in decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dt, reader.ReadDateTime(LengthFormat.Plain, in decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, reader.ReadDateTimeOffset(LengthFormat.Plain, in decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(42.5M, reader.ReadDecimal(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(32.2F, reader.ReadSingle(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(56.6D, reader.ReadDouble(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
Equal(bi, reader.ReadBigInteger(LengthFormat.Plain, in decodingContext, provider: InvariantCulture));
}
}
public override Result <ProcessedPayload> Decode(IPayload payload, DecodingContext context)
{
if (CurrentEncodingIs(payload, EncodingName) && payload.Data is string data)
{
return(Result.Ok(new ProcessedPayload(
data.FromBase64(),
RemoveCurrentEncodingPart(payload))));
}
return(Result.Ok(new ProcessedPayload(payload)));
}
public override Result <ProcessedPayload> Decode(IPayload payload, DecodingContext context)
{
// Assume all the other steps will always work with Utf8
if (CurrentEncodingIs(payload, EncodingName))
{
return(Result.Ok(new ProcessedPayload(
(payload.Data as byte[]).GetText(),
RemoveCurrentEncodingPart(payload))));
}
return(Result.Ok(new ProcessedPayload(payload)));
}
public void WithBase64EncodingBeforeOtherEncodings_SavesDecodedDataToTheContext()
{
var payload = new Message {
Data = _base64Data, Encoding = "utf-8/base64"
};
var context = new DecodingContext();
MessageHandler.DecodePayload(payload, context);
context.PreviousPayload.GetBytes().Should().BeEquivalentTo(_binaryData);
context.PreviousPayload.Encoding.Should().BeEquivalentTo("utf-8");
}
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
context.Input -= JsonToken.BeginArray;
IList list;
if (_listType == null || _listType.IsInterface || _listType.IsArray)
{
if (_genericArgument == null)
{
list = new List<object>();
}
else
{
list = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(_genericArgument));
}
}
else
{
// Create the desired instance directly
list = (IList)Activator.CreateInstance(_listType);
}
for (int index = 0; context.Input.Peek() != JsonToken.EndArray; index++)
{
if (index > 0)
{
context.Input -= JsonToken.ValueSeperator;
}
DoDecode instruction = new DoDecode(context.Input, _genericArgument);
yield return instruction;
list.Add(instruction.Value);
}
context.Input -= JsonToken.EndArray;
if (_listType == null || !_listType.IsArray)
{
context.Value = list;
}
else
{
Array array = Array.CreateInstance(_listType.GetElementType(), list.Count);
list.CopyTo(array, 0);
context.Value = array;
}
}
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
if (_mapping.UsesReferencing && context.Input.Peek().Type == JsonTokenType.Number)
{
double reference = context.Input.Pop().Value<double>();
context.Value = context.Process.References.FollowReference(reference);
yield break;
}
context.Input -= JsonToken.BeginObject;
object reflected = Activator.CreateInstance(context.KnownType);
if (_mapping.UsesReferencing)
{
context.Process.References.Reference(reflected);
}
for (int index = 0; context.Input.Peek() != JsonToken.EndObject; index++)
{
if (index > 0)
{
context.Input -= JsonToken.ValueSeperator;
}
string key = context.Input.Pop().Value<string>();
if (key!=null && _mapping.FieldMappings.ContainsKey(key))
{
JsonFieldMappingBase fieldMapping = _mapping.FieldMappings[key];
context.Input -= JsonToken.NameSeperator;
DoDecode instruction = new DoDecode(context.Input, fieldMapping.DesiredType);
yield return instruction;
object value = fieldMapping.Decode(instruction.Value);
fieldMapping.Set(reflected, value);
}
else
{
//yield return null;
}
}
context.Input -= JsonToken.EndObject;
context.Value = reflected;
}
public void WhenBase64IsNotTheFirstEncoding_ShouldSaveTheOriginalPayloadInContext()
{
var message = new Message {
Data = new { Text = "Hello" }
};
MessageHandler.EncodePayload(message, new DecodingContext());
var payloadData = message.Data as string;
var payloadEncoding = message.Encoding;
var context = new DecodingContext();
MessageHandler.DecodePayload(message, context);
context.PreviousPayload.GetBytes().Should().BeEquivalentTo(payloadData.GetBytes());
context.PreviousPayload.Encoding.Should().Be(payloadEncoding);
}
public async Task ActAsServerAsync(Socket clientSocket)
{
var channel = new SocketChannel();
channel.Assign(clientSocket);
_encodingContext = new EncodingContext(channel);
_decodingContext = new DecodingContext(_channel);
_encoder = new FrameEncoder(_encodingContext);
_decoder = new FrameDecoder();
await channel.ReceiveAsync(_decodingContext.Buffer, _decodingContext.Offset, _decodingContext.Capacity);
if (_decodingContext.BytesLeftToProcess < ClientPreface.Length)
{
//TODO: Invalid protocol
}
// ReSharper disable once LoopCanBeConvertedToQuery
for (var i = 0; i < ClientPreface.Length; i++)
{
if (ClientPreface[i] != _decodingContext.Buffer[_decodingContext.Offset + i])
{
throw new Http2Exception(Http2ErrorCode.ProtocolError, "ClientPreface was not valid.");
}
}
_decodingContext.Offset += ClientPreface.Length;
_decodingContext.BytesLeftToProcess -= ClientPreface.Length;
// didn't get the settings frame directly
if (_decodingContext.BytesLeftToProcess == 0)
{
await _decodingContext.ReceiveMoreAsync();
}
var frame = await _decoder.DecodeAsync(_decodingContext) as SettingsFrame;
if (frame == null)
{
throw new Http2Exception(Http2ErrorCode.ProtocolError, "Expected SETTINGS frame after client preface.");
}
//ack on client frame
await _encoder.EncodeAsync(new SettingsFrame { IsAcknowledgment = true });
// our own settings.
await _encoder.EncodeAsync(new SettingsFrame());
}
/// <summary>
/// Reads the string using the specified encoding.
/// </summary>
/// <param name="stream">The stream to read from.</param>
/// <param name="length">The length of the string, in bytes.</param>
/// <param name="context">The text decoding context.</param>
/// <param name="buffer">The buffer that is allocated by the caller.</param>
/// <returns>The string decoded from the log entry content stream.</returns>
public static string ReadString(this Stream stream, int length, DecodingContext context, byte[] buffer)
{
//TODO: Should be rewritten for .NET Standard 2.1
var maxChars = context.Encoding.GetMaxCharCount(buffer.Length);
if (maxChars == 0)
{
throw new ArgumentException(ExceptionMessages.BufferTooSmall, nameof(buffer));
}
var decoder = context.GetDecoder();
var charBuffer = new ArrayRental <char>(maxChars);
var result = default(ArrayRental <char>);
int currentPos = 0, resultOffset = 0;
try
{
do
{
var readLength = Math.Min(length - currentPos, buffer.Length);
var n = stream.Read(buffer, 0, readLength);
if (n == 0)
{
throw new EndOfStreamException();
}
var charsRead = decoder.GetChars(buffer, 0, n, (char[])charBuffer, 0);
if (currentPos == 0 && n == length)
{
return(new string((char[])charBuffer, 0, charsRead));
}
if (result.IsEmpty)
{
result = new ArrayRental <char>(length);
}
Memory.Copy(ref charBuffer[0], ref result[resultOffset], (uint)charsRead);
resultOffset += charsRead;
currentPos += n;
}while (currentPos < length);
return(new string((char[])result, 0, resultOffset));
}
finally
{
charBuffer.Dispose();
result.Dispose();
}
}
public override Result <ProcessedPayload> Encode(IPayload payload, DecodingContext context)
{
var data = payload.Data;
if (IsEmpty(data))
{
return(Result.Ok(new ProcessedPayload(payload)));
}
if (data is byte[] bytes)
{
return(Result.Ok(new ProcessedPayload(
bytes.ToBase64(),
AddEncoding(payload, EncodingName))));
}
return(Result.Ok(new ProcessedPayload(payload)));
}
ValueTask <TimeSpan> IAsyncBinaryReader.ReadTimeSpanAsync(StringLengthEncoding lengthFormat, DecodingContext context, string[] formats, TimeSpanStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadTimeSpanAsync(input, lengthFormat, context, buffer, formats, style, provider, token);
ValueTask <DateTimeOffset> IAsyncBinaryReader.ReadDateTimeOffsetAsync(StringLengthEncoding lengthFormat, DecodingContext context, DateTimeStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadDateTimeOffsetAsync(input, lengthFormat, context, buffer, style, provider, token);
ValueTask <Guid> IAsyncBinaryReader.ReadGuidAsync(StringLengthEncoding lengthFormat, DecodingContext context, string format, CancellationToken token) => StreamExtensions.ReadGuidAsync(input, lengthFormat, context, buffer, format, token);
ValueTask <double> IAsyncBinaryReader.ReadDoubleAsync(StringLengthEncoding lengthFormat, DecodingContext context, NumberStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadDoubleAsync(input, lengthFormat, context, buffer, style, provider, token);
ValueTask <BigInteger> IAsyncBinaryReader.ReadBigIntegerAsync(LengthFormat lengthFormat, DecodingContext context, NumberStyles style, IFormatProvider?provider, CancellationToken token) => EndOfStream <BigInteger>();
ValueTask <string> IAsyncBinaryReader.ReadStringAsync(int length, DecodingContext context, CancellationToken token) => reader.ReadStringAsync(length, context, token);
public override Result <ProcessedPayload> Encode(IPayload payload, DecodingContext context)
{
return(Result.Ok(new ProcessedPayload(payload)));
}
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
context.Input -= JsonToken.BeginObject;
IDictionary dict;
#if NET40
IDictionary<string, object> expando = null;
#endif
if (_dictType == null)
{
#if NET40
dict = null;
expando = new ExpandoObject();
#else
dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(typeof(string), _genericArgument));
#endif
}
else if(_dictType.IsInterface)
{
if (_genericArgument != null)
dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<,>).MakeGenericType(typeof(string), _genericArgument));
else
dict = (IDictionary)Activator.CreateInstance(typeof(Dictionary<string, object>));
}
else
{
// Create the desired instance directly
dict = (IDictionary)Activator.CreateInstance(_dictType);
}
for (int index = 0; context.Input.Peek() != JsonToken.EndObject; index++)
{
if (index > 0)
{
context.Input -= JsonToken.ValueSeperator;
}
string key = context.Input.Pop().Value<string>();
context.Input -= JsonToken.NameSeperator;
DoDecode instruction = new DoDecode(context.Input, _genericArgument);
yield return instruction;
#if NET40
if (dict == null)
{
expando.Add(key, instruction.Value);
}
else
{
dict.Add(key, instruction.Value);
}
#else
dict.Add(key, instruction.Value);
#endif
}
context.Input -= JsonToken.EndObject;
#if NET40
if (dict == null)
{
context.Value = expando;
}
else
{
context.Value = dict;
}
#else
context.Value = dict;
#endif
}
public ValueTask <string> ReadStringAsync(int length, DecodingContext context, CancellationToken token) => EndOfStream <string>();
ValueTask <Guid> IAsyncBinaryReader.ReadGuidAsync(LengthFormat lengthFormat, DecodingContext context, CancellationToken token) => StreamExtensions.ReadGuidAsync(stream, lengthFormat, context, buffer, token);
public IEnumerable<DecodingInstruction> ExecuteDecode(DecodingContext context)
{
context.Value = context.Input.Pop().Value(context.KnownType == null ? typeof(object) : context.KnownType);
yield break;
}
/// <summary>
/// Decodes string asynchronously from pipe.
/// </summary>
/// <param name="reader">The pipe reader.</param>
/// <param name="length">The length of the string, in bytes.</param>
/// <param name="context">The text decoding context.</param>
/// <param name="token">The token that can be used to cancel the operation.</param>
/// <returns>The decoded string.</returns>
/// <exception cref="EndOfStreamException"><paramref name="reader"/> doesn't contain the necessary number of bytes to restore string.</exception>
/// <exception cref="OperationCanceledException">The operation has been canceled.</exception>
public static async ValueTask <string> ReadStringAsync(this PipeReader reader, int length, DecodingContext context, CancellationToken token = default)
{
if (length == 0)
{
return(string.Empty);
}
using var resultBuffer = new ArrayBuffer <char>(length);
return(await ReadAsync <string, StringReader <ArrayBuffer <char> > >(reader, new StringReader <ArrayBuffer <char> >(context, resultBuffer), token).ConfigureAwait(false));
}
/// <summary> /// Decodes string asynchronously from pipe. /// </summary> /// <param name="reader">The pipe reader.</param> /// <param name="lengthFormat">Represents string length encoding format.</param> /// <param name="context">The text decoding context.</param> /// <param name="token">The token that can be used to cancel the operation.</param> /// <returns>The decoded string.</returns> /// <exception cref="EndOfStreamException"><paramref name="reader"/> doesn't contain the necessary number of bytes to restore string.</exception> /// <exception cref="OperationCanceledException">The operation has been canceled.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="lengthFormat"/> is invalid.</exception> public static async ValueTask <string> ReadStringAsync(this PipeReader reader, StringLengthEncoding lengthFormat, DecodingContext context, CancellationToken token = default) => await ReadStringAsync(reader, await reader.ReadLengthAsync(lengthFormat, token).ConfigureAwait(false), context, token).ConfigureAwait(false);
public static async Task WriteReadPrimitivesAsync(IAsyncBinaryReaderWriterSource source, bool littleEndian, Encoding encoding)
{
await using (source)
{
const byte value8 = 254;
const short value16 = 42;
const int value32 = int.MaxValue;
const long value64 = long.MaxValue;
const decimal valueM = 42M;
const float valueF = 56.6F;
const double valueD = 67.7D;
var valueG = Guid.NewGuid();
var valueDT = DateTime.Now;
var valueDTO = DateTimeOffset.Now;
var valueT = TimeSpan.FromMilliseconds(1024);
var writer = source.CreateWriter();
await writer.WriteInt16Async(value16, littleEndian);
await writer.WriteInt32Async(value32, littleEndian);
await writer.WriteInt64Async(value64, littleEndian);
await writer.WriteAsync(valueM);
var encodingContext = new EncodingContext(encoding, true);
await writer.WriteByteAsync(value8, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture);
await writer.WriteInt16Async(value16, StringLengthEncoding.Compressed, encodingContext, provider : InvariantCulture);
await writer.WriteInt32Async(value32, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture);
await writer.WriteInt64Async(value64, StringLengthEncoding.PlainBigEndian, encodingContext, provider : InvariantCulture);
await writer.WriteDecimalAsync(valueM, StringLengthEncoding.PlainLittleEndian, encodingContext, provider : InvariantCulture);
await writer.WriteSingleAsync(valueF, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture);
await writer.WriteDoubleAsync(valueD, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture);
await writer.WriteGuidAsync(valueG, StringLengthEncoding.Plain, encodingContext);
await writer.WriteGuidAsync(valueG, StringLengthEncoding.Plain, encodingContext, "X");
await writer.WriteDateTimeAsync(valueDT, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture);
await writer.WriteDateTimeOffsetAsync(valueDTO, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture);
await writer.WriteDateTimeAsync(valueDT, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture);
await writer.WriteDateTimeOffsetAsync(valueDTO, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture);
await writer.WriteTimeSpanAsync(valueT, StringLengthEncoding.Plain, encodingContext);
await writer.WriteTimeSpanAsync(valueT, StringLengthEncoding.Plain, encodingContext, "G", InvariantCulture);
var reader = source.CreateReader();
Equal(value16, await reader.ReadInt16Async(littleEndian));
Equal(value32, await reader.ReadInt32Async(littleEndian));
Equal(value64, await reader.ReadInt64Async(littleEndian));
Equal(valueM, await reader.ReadAsync <decimal>());
var decodingContext = new DecodingContext(encoding, true);
Equal(value8, await reader.ReadByteAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(value16, await reader.ReadInt16Async(StringLengthEncoding.Compressed, decodingContext, provider: InvariantCulture));
Equal(value32, await reader.ReadInt32Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(value64, await reader.ReadInt64Async(StringLengthEncoding.PlainBigEndian, decodingContext, provider: InvariantCulture));
Equal(valueM, await reader.ReadDecimalAsync(StringLengthEncoding.PlainLittleEndian, decodingContext, provider: InvariantCulture));
Equal(valueF, await reader.ReadSingleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(valueD, await reader.ReadDoubleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(valueG, await reader.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext));
Equal(valueG, await reader.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext, "X"));
Equal(valueDT, await reader.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(valueDTO, await reader.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(valueDT, await reader.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(valueDTO, await reader.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(valueT, await reader.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, InvariantCulture));
Equal(valueT, await reader.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, new[] { "G" }, TimeSpanStyles.None, InvariantCulture));
}
}
public ValueTask <string> ReadStringAsync(StringLengthEncoding lengthFormat, DecodingContext context, CancellationToken token = default) => StreamExtensions.ReadStringAsync(input, lengthFormat, context, buffer, token);
ValueTask <string> IAsyncBinaryReader.ReadStringAsync(StringLengthEncoding lengthFormat, DecodingContext context, CancellationToken token) => reader.ReadStringAsync(lengthFormat, context, token);
ValueTask <Guid> IAsyncBinaryReader.ReadGuidAsync(LengthFormat lengthFormat, DecodingContext context, string format, CancellationToken token) => EndOfStream <Guid>();
ValueTask <DateTime> IAsyncBinaryReader.ReadDateTimeAsync(LengthFormat lengthFormat, DecodingContext context, string[] formats, DateTimeStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadDateTimeAsync(stream, lengthFormat, context, buffer, style, provider, token);
ValueTask <byte> IAsyncBinaryReader.ReadByteAsync(LengthFormat lengthFormat, DecodingContext context, NumberStyles style, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadByteAsync(stream, lengthFormat, context, buffer, style, provider, token);
public ValueTask <string> ReadStringAsync(StringLengthEncoding lengthFormat, DecodingContext context, CancellationToken token) => EndOfStream <string>();
ValueTask <TimeSpan> IAsyncBinaryReader.ReadTimeSpanAsync(LengthFormat lengthFormat, DecodingContext context, IFormatProvider?provider, CancellationToken token) => StreamExtensions.ReadTimeSpanAsync(stream, lengthFormat, context, buffer, provider, token);
public static async Task EncodeAsStringAsync(string encodingName)
{
var encoding = Encoding.GetEncoding(encodingName);
using var stream = new MemoryStream();
var g = Guid.NewGuid();
var dt = DateTime.Now;
var dto = DateTimeOffset.Now;
var t = TimeSpan.FromMilliseconds(1096);
await stream.WriteInt64Async(42L, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteUInt64Async(12UL, StringLengthEncoding.PlainLittleEndian, encoding, provider : InvariantCulture);
await stream.WriteInt32Async(34, StringLengthEncoding.PlainBigEndian, encoding, provider : InvariantCulture);
await stream.WriteUInt32Async(78, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteInt16Async(90, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteUInt16Async(12, StringLengthEncoding.Plain, encoding, format : "X", provider : InvariantCulture);
await stream.WriteUInt16Async(12, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteByteAsync(10, StringLengthEncoding.Plain, encoding, format : "X", provider : InvariantCulture);
await stream.WriteSByteAsync(11, StringLengthEncoding.Plain, encoding, format : "X", provider : InvariantCulture);
await stream.WriteByteAsync(10, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteSByteAsync(11, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteGuidAsync(g, StringLengthEncoding.Plain, encoding);
await stream.WriteGuidAsync(g, StringLengthEncoding.Plain, encoding, format : "X");
await stream.WriteDateTimeAsync(dt, StringLengthEncoding.Plain, encoding, format : "O", provider : InvariantCulture);
await stream.WriteDateTimeOffsetAsync(dto, StringLengthEncoding.Plain, encoding, format : "O", provider : InvariantCulture);
await stream.WriteDateTimeAsync(dt, StringLengthEncoding.Plain, encoding, format : "O", provider : InvariantCulture);
await stream.WriteDateTimeOffsetAsync(dto, StringLengthEncoding.Plain, encoding, format : "O", provider : InvariantCulture);
await stream.WriteDecimalAsync(42.5M, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteSingleAsync(32.2F, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteDoubleAsync(56.6D, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteTimeSpanAsync(t, StringLengthEncoding.Plain, encoding, provider : InvariantCulture);
await stream.WriteTimeSpanAsync(t, StringLengthEncoding.Plain, encoding, "G", provider : InvariantCulture);
stream.Position = 0;
var decodingContext = new DecodingContext(encoding);
Equal(42L, await stream.ReadInt64Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(12UL, await stream.ReadUInt64Async(StringLengthEncoding.PlainLittleEndian, decodingContext, provider: InvariantCulture));
Equal(34, await stream.ReadInt32Async(StringLengthEncoding.PlainBigEndian, decodingContext, provider: InvariantCulture));
Equal(78U, await stream.ReadUInt32Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(90, await stream.ReadInt16Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal("C", await stream.ReadStringAsync(StringLengthEncoding.Plain, decodingContext.Encoding));
Equal(12, await stream.ReadUInt16Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal("A", await stream.ReadStringAsync(StringLengthEncoding.Plain, decodingContext.Encoding));
Equal("B", await stream.ReadStringAsync(StringLengthEncoding.Plain, decodingContext.Encoding));
Equal(10, await stream.ReadByteAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(11, await stream.ReadSByteAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(g, await stream.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext));
Equal(g, await stream.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext, "X"));
Equal(dt, await stream.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, await stream.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dt, await stream.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(dto, await stream.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture));
Equal(42.5M, await stream.ReadDecimalAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(32.2F, await stream.ReadSingleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(56.6D, await stream.ReadDoubleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(t, await stream.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture));
Equal(t, await stream.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, formats: new[] { "G" }, provider: InvariantCulture));
}
public ValueTask <string> ReadStringAsync(int length, DecodingContext context, CancellationToken token = default) => StreamExtensions.ReadStringAsync(stream, length, context, buffer, token);
