public UserClaimsAdded <TKey> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var claimFormatter = formatterResolver.GetFormatter <Claim>();
var keyFormatter = formatterResolver.GetFormatter <TKey>();
var startOffset = offset;
var k = keyFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new Claim[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = claimFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return(new UserClaimsAdded <TKey>(k, array));
}
public ValueTuple <T1> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
throw new InvalidOperationException("Data is Nil, ValueTuple can not be null.");
}
else
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
if (count != 1)
{
throw new InvalidOperationException("Invalid ValueTuple count");
}
offset += readSize;
var item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new ValueTuple <T1>(item1));
}
}
public System.Numerics.Complex Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 2)
{
throw new InvalidOperationException("Invalid Complex format.");
}
var real = MessagePackBinary.ReadDouble(bytes, offset, out readSize);
offset += readSize;
var imaginary = MessagePackBinary.ReadDouble(bytes, offset, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new System.Numerics.Complex(real, imaginary));
}
public KeyValuePair <TKey, TValue> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 2)
{
throw new InvalidOperationException("Invalid KeyValuePair format.");
}
var key = formatterResolver.GetFormatterWithVerify <TKey>().Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
var value = formatterResolver.GetFormatterWithVerify <TValue>().Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new KeyValuePair <TKey, TValue>(key, value));
}
public OffsetDateTime Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 2)
{
throw new InvalidOperationException("Invalid array count");
}
var dt = LocalDateTimeAsDateTimeMessagePackFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
var off = OffsetMessagePackFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new OffsetDateTime(dt, off));
}
public UInt32[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new UInt32[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = MessagePackBinary.ReadUInt32(bytes, offset, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return(array);
}
}
public T[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return null;
}
else
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify<T>();
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new T[len];
for (int i = 0; i < array.Length; i++)
{
array[i] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return array;
}
}
public Tuple <T1> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
if (count != 1)
{
ThrowHelper.ThrowInvalidOperationException_Tuple_Count();
}
offset += readSize;
var item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new Tuple <T1>(item1));
}
}
public string[] Deserialize(byte[] bytes, int offset, IFormatterResolver typeResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
var startOffset = offset;
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new string[len];
for (var i = 0; i < array.Length; i++)
{
array[i] = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return(array);
}
public DateTime[] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new DateTime[len];
for (int i = 0; i < array.Length; i++)
{
var dateData = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
array[i] = DateTime.FromBinary(dateData);
offset += readSize;
}
readSize = offset - startOffset;
return(array);
}
}
public IList Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return default(IList);
}
var formatter = formatterResolver.GetFormatterWithVerify<object>();
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var list = new object[count];
for (int i = 0; i < count; i++)
{
list[i] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return list;
}
public List <T> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify <T>();
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var list = new List <T>(len);
for (int i = 0; i < len; i++)
{
list.Add(formatter.Deserialize(bytes, offset, formatterResolver, out readSize));
offset += readSize;
}
readSize = offset - startOffset;
return(list);
}
}
public DateTimeOffset Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 2)
{
throw new InvalidOperationException("Invalid DateTimeOffset format.");
}
var utc = MessagePackBinary.ReadDateTime(bytes, offset, out readSize);
offset += readSize;
var dtOffsetMinutes = MessagePackBinary.ReadInt16(bytes, offset, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new DateTimeOffset(utc.Ticks, TimeSpan.FromMinutes(dtOffsetMinutes)));
}
/// <inheritdoc />
public HttpRequestMessage Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
int startOffset = offset;
int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 5)
{
throw new InvalidOperationException("Request format invalid.");
}
// RequestPart.Version:
string versionStr = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
if (!Version.TryParse(versionStr, out Version version))
{
throw new InvalidOperationException($"Request version '{versionStr}' in invalid format!");
}
// RequestPart.UriScheme:
string uriStr = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
if (!Uri.TryCreate(uriStr, UriKind.Absolute, out Uri uri))
{
throw new InvalidOperationException($"Request Uri '{uri}' could not be parsed");
}
// RequestPart.Method:
HttpMethod method = HttpMethodFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
// Create request so we can add headers and content
HttpRequestMessage request = new HttpRequestMessage(method, uri)
{
Version = version
};
// RequestPart.Headers:
int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
offset += readSize;
if (headersCount > 0)
{
while (headersCount-- > 0)
{
string key = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
// Note, we can't have an empty array, and if we tried adding one it would be ignored anyway
// therefore it's safe to just start looping and call add for each entry.
while (valuesCount-- > 0)
{
string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
request.Headers.TryAddWithoutValidation(key, headerValue);
}
}
}
// RequestPart.Content:
#pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
request.Content = HttpContentFormatter.Deserialize(bytes, offset, out readSize);
#pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
offset += readSize;
readSize = offset - startOffset;
return(request);
}
public T[,,,] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify <T>();
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (len != ArrayLength)
{
throw new InvalidOperationException("Invalid T[,,,] format");
}
var iLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var jLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var kLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var lLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var maxLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new T[iLength, jLength, kLength, lLength];
var i = 0;
var j = 0;
var k = 0;
var l = -1;
using (MessagePackSecurity.DepthStep())
{
for (int loop = 0; loop < maxLen; loop++)
{
if (l < lLength - 1)
{
l++;
}
else if (k < kLength - 1)
{
l = 0;
k++;
}
else if (j < jLength - 1)
{
l = 0;
k = 0;
j++;
}
else
{
l = 0;
k = 0;
j = 0;
i++;
}
array[i, j, k, l] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
}
readSize = offset - startOffset;
return(array);
}
}
/// <summary>
/// Deserializes the content into the specified response.
/// </summary>
/// <param name="bytes">The bytes.</param>
/// <param name="offset">The offset.</param>
/// <param name="readSize">Size of the read.</param>
/// <returns></returns>
/// <exception cref="InvalidOperationException">Content format invalid.</exception>
public static HttpContent Deserialize(byte[] bytes, int offset, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
int startOffset = offset;
int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 3)
{
throw new InvalidOperationException("Content format invalid.");
}
// Type
byte typeByte = MessagePackBinary.ReadByte(bytes, offset, out readSize);
offset += readSize;
// Headers
Dictionary <string, string[]> headers = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase);
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize++;
}
else
{
int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
offset += readSize;
if (headersCount > 0)
{
while (headersCount-- > 0)
{
string key = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
string[] values = new string[valuesCount];
// Note, we can't have an empty array, and if we tried adding one it would be ignored anyway
// therefore it's safe to just start looping and call add for each entry.
for (int i = 0; i < valuesCount; i++)
{
string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
values[i] = headerValue;
}
headers[key] = values;
}
}
}
// Get data
byte[] data = MessagePackBinary.ReadBytes(bytes, offset, out readSize);
HttpContent content;
switch (typeByte)
{
// StreamContent
case 1:
#pragma warning disable DF0000 // Marks undisposed anonymous objects from object creations.
content = new StreamContent(new MemoryStream(data));
#pragma warning restore DF0000 // Marks undisposed anonymous objects from object creations.
break;
/*
* TODO
* case 2:
* // See https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/FormUrlEncodedContent.cs
* string encoded = Encoding.UTF8.GetString(data).Replace("+", "%20");
* List<KeyValuePair<string, string>> nvc = new List<KeyValuePair<string, string>>();
* int start = 0;
* do
* {
*
* } while ()
*
*
* break;
*/
case 3:
// See https://github.com/dotnet/corefx/blob/master/src/System.Net.Http/src/System/Net/Http/StringContent.cs
// Get encoding from headers if possible
Encoding encoding;
string charSet;
if (headers.TryGetValue("content-type", out string[] ctValues) &&
/// <inheritdoc />
public HttpResponseMessage Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
int startOffset = offset;
int count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 5)
{
throw new InvalidOperationException("Response format invalid.");
}
// Version
string versionStr = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
if (!Version.TryParse(versionStr, out Version version))
{
throw new InvalidOperationException($"Response version '{versionStr}' in invalid format!");
}
// Status Code
HttpStatusCode statusCode = (HttpStatusCode)MessagePackBinary.ReadUInt16(bytes, offset, out readSize);
offset += readSize;
// ReasonPhrase
string reasonPhrase = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
// Create response so we can start updating it's headers
HttpResponseMessage response = new HttpResponseMessage(statusCode)
{
Version = version,
ReasonPhrase = reasonPhrase
};
// Headers
int headersCount = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
offset += readSize;
if (headersCount > 0)
{
while (headersCount-- > 0)
{
string key = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
int valuesCount = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
// Note, we can't have an empty array, and if we tried adding one it would be ignored anyway
// therefore it's safe to just start looping and call add for each entry.
while (valuesCount-- > 0)
{
string headerValue = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
response.Headers.TryAddWithoutValidation(key, headerValue);
}
}
}
// Content
#pragma warning disable DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
response.Content = HttpContentFormatter.Deserialize(bytes, offset, out readSize);
#pragma warning restore DF0023 // Marks undisposed objects assinged to a property, originated from a method invocation.
readSize = offset - startOffset;
return(response);
}
public Period Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
var startOffset = offset;
var count = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (count != 10)
{
throw new InvalidOperationException("Invalid array count");
}
var years = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var months = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var weeks = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var days = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var hours = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
var minutes = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
var seconds = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
var milliseconds = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
var ticks = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
var nano = MessagePackBinary.ReadInt64(bytes, offset, out readSize);
offset += readSize;
readSize = offset - startOffset;
return(new PeriodBuilder()
{
Years = years,
Months = months,
Weeks = weeks,
Days = days,
Hours = hours,
Minutes = minutes,
Seconds = seconds,
Milliseconds = milliseconds,
Ticks = ticks,
Nanoseconds = nano,
}.Build());
}
async Task StartSubscribe()
{
var syncContext = SynchronizationContext.Current; // capture SynchronizationContext.
var reader = connection.RawStreamingCall.ResponseStream;
try
{
while (await reader.MoveNext(cts.Token).ConfigureAwait(false)) // avoid Post to SyncContext(it losts one-frame per operation)
{
try
{
var data = reader.Current;
// MessageFormat:
// broadcast: [methodId, [argument]]
// response: [messageId, methodId, response]
// error-response: [messageId, statusCode, detail, StringMessage]
var readSize = 0;
var offset = 0;
var arrayLength = MessagePackBinary.ReadArrayHeader(data, offset, out readSize);
offset += readSize;
if (arrayLength == 3)
{
var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
object future;
if (responseFutures.TryRemove(messageId, out future))
{
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
try
{
OnResponseEvent(methodId, future, new ArraySegment <byte>(data, offset, data.Length - offset));
}
catch (Exception ex)
{
if (!(future as ITaskCompletion).TrySetException(ex))
{
throw;
}
}
}
}
else if (arrayLength == 4)
{
var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
object future;
if (responseFutures.TryRemove(messageId, out future))
{
var statusCode = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
var detail = MessagePackBinary.ReadString(data, offset, out readSize);
offset += readSize;
var error = LZ4MessagePackSerializer.Deserialize <string>(new ArraySegment <byte>(data, offset, data.Length - offset));
(future as ITaskCompletion).TrySetException(new RpcException(new Status((StatusCode)statusCode, detail), error));
}
}
else
{
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
if (syncContext != null)
{
var tuple = Tuple.Create(methodId, data, offset, data.Length - offset);
syncContext.Post(state =>
{
var t = (Tuple <int, byte[], int, int>)state;
OnBroadcastEvent(t.Item1, new ArraySegment <byte>(t.Item2, t.Item3, t.Item4));
}, tuple);
}
else
{
OnBroadcastEvent(methodId, new ArraySegment <byte>(data, offset, data.Length - offset));
}
}
}
catch (Exception ex)
{
const string msg = "Error on consume received message, but keep subscribe.";
// log post on main thread.
if (syncContext != null)
{
syncContext.Post(state => logger.Error((Exception)state, msg), ex);
}
else
{
logger.Error(ex, msg);
}
}
}
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
{
return;
}
const string msg = "Error on subscribing message.";
// log post on main thread.
if (syncContext != null)
{
syncContext.Post(state => logger.Error((Exception)state, msg), ex);
}
else
{
logger.Error(ex, msg);
}
}
finally
{
try
{
// set syncContext before await
if (syncContext != null && SynchronizationContext.Current == null)
{
SynchronizationContext.SetSynchronizationContext(syncContext);
}
await DisposeAsyncCore(false);
}
finally
{
waitForDisconnect.TrySetResult(null);
}
}
}
async Task HandleMessageAsync()
{
var ct = Context.CallContext.CancellationToken;
var reader = Context.RequestStream;
var writer = Context.ResponseStream;
var handlers = StreamingHubHandlerRepository.GetHandlers(Context.MethodHandler);
// Main loop of StreamingHub.
// Be careful to allocation and performance.
while (await reader.MoveNext(ct))
{
var data = reader.Current;
var length = MessagePackBinary.ReadArrayHeader(data, 0, out var readSize);
var offset = readSize;
if (length == 2)
{
// void: [methodId, [argument]]
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
if (handlers.TryGetValue(methodId, out var handler))
{
var context = new StreamingHubContext() // create per invoke.
{
AsyncWriterLock = Context.AsyncWriterLock,
FormatterResolver = handler.resolver,
HubInstance = this,
ServiceContext = Context,
Request = new ArraySegment <byte>(data, offset, data.Length - offset),
Path = handler.ToString(),
MethodId = handler.MethodId,
MessageId = -1,
Timestamp = DateTime.UtcNow
};
var isErrorOrInterrupted = false;
Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType);
try
{
await handler.MethodBody.Invoke(context);
}
catch (Exception ex)
{
isErrorOrInterrupted = true;
LogError(ex, context);
}
finally
{
Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted);
}
}
else
{
throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId);
}
}
else if (length == 3)
{
// T: [messageId, methodId, [argument]]
var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
if (handlers.TryGetValue(methodId, out var handler))
{
var context = new StreamingHubContext() // create per invoke.
{
AsyncWriterLock = Context.AsyncWriterLock,
FormatterResolver = handler.resolver,
HubInstance = this,
ServiceContext = Context,
Request = new ArraySegment <byte>(data, offset, data.Length - offset),
Path = handler.ToString(),
MethodId = handler.MethodId,
MessageId = messageId,
Timestamp = DateTime.UtcNow
};
var isErrorOrInterrupted = false;
Context.MethodHandler.logger.BeginInvokeHubMethod(context, context.Request, handler.RequestType);
try
{
await handler.MethodBody.Invoke(context);
}
catch (ReturnStatusException ex)
{
await context.WriteErrorMessage((int)ex.StatusCode, ex.Detail, null, false);
}
catch (Exception ex)
{
LogError(ex, context);
await context.WriteErrorMessage((int)StatusCode.Internal, "Erorr on " + handler.ToString(), ex, Context.MethodHandler.isReturnExceptionStackTraceInErrorDetail);
}
finally
{
Context.MethodHandler.logger.EndInvokeHubMethod(context, context.responseSize, context.responseType, (DateTime.UtcNow - context.Timestamp).TotalMilliseconds, isErrorOrInterrupted);
}
}
else
{
throw new InvalidOperationException("Handler not found in received methodId, methodId:" + methodId);
}
}
else
{
throw new InvalidOperationException("Invalid data format.");
}
}
}
public UserCreated <TKey, TUser> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var keyFormatter = formatterResolver.GetFormatter <TKey>();
var claimFormatter = formatterResolver.GetFormatter <Claim>();
var startOffset = offset;
var key = keyFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
var usr = (TUser)Activator.CreateInstance(typeof(TUser), key);
offset += readSize;
usr.UserName = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.NormalizedUserName = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.Email = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.NormalizedEmail = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.EmailConfirmed = MessagePackBinary.ReadBoolean(bytes, offset, out readSize);
offset += readSize;
usr.PasswordHash = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.SecurityStamp = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.PhoneNumber = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.PhoneNumberConfirmed = MessagePackBinary.ReadBoolean(bytes, offset, out readSize);
offset += readSize;
usr.TwoFactorEnabled = MessagePackBinary.ReadBoolean(bytes, offset, out readSize);
offset += readSize;
usr.LockoutEnd = null;
if (MessagePackBinary.IsNil(bytes, offset))
{
offset++;
}
else
{
usr.LockoutEnd = MessagePackBinary.ReadDateTime(bytes, offset, out readSize);
offset += readSize;
}
usr.LockoutEnabled = MessagePackBinary.ReadBoolean(bytes, offset, out readSize);
offset += readSize;
usr.AccessFailedCount = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
usr.Claims = null;
if (MessagePackBinary.IsNil(bytes, offset))
{
offset++;
}
else
{
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
usr.Claims = new List <Claim>(len);
for (int i = 0; i < len; i++)
{
var claim = claimFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
usr.Claims.Add(claim);
}
}
usr.Logins = null;
if (MessagePackBinary.IsNil(bytes, offset))
{
offset++;
}
else
{
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
usr.Logins = new List <ImmutableUserLoginInfo>(len);
for (int i = 0; i < len; i++)
{
var loginProvider = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
var providerKey = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
var displayName = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.Logins.Add(new ImmutableUserLoginInfo(loginProvider, providerKey, displayName));
}
}
usr.Tokens = null;
if (MessagePackBinary.IsNil(bytes, offset))
{
offset++;
}
else
{
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
usr.Tokens = new List <ImmutableIdentityUserToken>(len);
for (int i = 0; i < len; i++)
{
var loginProvider = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
var name = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
var value = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
usr.Tokens.Add(new ImmutableIdentityUserToken(loginProvider, name, value));
}
}
readSize = offset - startOffset;
return(new UserCreated <TKey, TUser>(usr));
}
/// <summary>
/// Open the database.
/// </summary>
public static Database Open(byte[] bytes)
{
var offset = 0;
int readSize;
var memoryCount = MessagePackBinary.ReadArrayHeader(bytes, 0, out readSize);
offset += readSize;
var memories = new KeyValuePair <string, IInternalMemory> [memoryCount];
for (int i = 0; i < memoryCount; i++)
{
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (len != 2)
{
throw new InvalidOperationException("Invalid MsgPack Binary of Database.");
}
var keyName = MessagePackBinary.ReadString(bytes, offset, out readSize);
offset += readSize;
// is LZ4 or plain msgpack?
byte[] rawData;
var type = MessagePackBinary.GetMessagePackType(bytes, offset);
if (type == MessagePackType.Extension)
{
var extensionOffset = offset;
var ext = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize);
if (ext.TypeCode == LZ4MessagePackSerializer.ExtensionTypeCode)
{
offset += readSize;
offset += (int)ext.Length;
rawData = new byte[offset - extensionOffset];
Buffer.BlockCopy(bytes, extensionOffset, rawData, 0, rawData.Length);
goto END;
}
}
{
var beginOffset = offset;
var arrayLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
for (int j = 0; j < arrayLen; j++)
{
offset += MessagePackBinary.ReadNextBlock(bytes, offset);
}
readSize = offset - beginOffset;
rawData = new byte[readSize];
Buffer.BlockCopy(bytes, beginOffset, rawData, 0, readSize);
}
END:
var memory = new InternalRawMemory(rawData);
memories[i] = new KeyValuePair <string, IInternalMemory>(keyName, memory);
}
return(new Database(memories));
}
public JsonRpcRequest?Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
var startOffset = offset;
int singleReadSize;
if (MessagePackBinary.ReadArrayHeader(bytes, offset, out singleReadSize) != 4)
{
throw new InvalidOperationException("Invalid JsonRpcMessage format.");
}
offset += singleReadSize;
var version = MessagePackBinary.ReadString(bytes, offset, out singleReadSize);
offset += singleReadSize;
var id = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize);
offset += singleReadSize;
var method = MessagePackBinary.ReadString(bytes, offset, out singleReadSize);
offset += singleReadSize;
object?arguments;
switch (MessagePackBinary.GetMessagePackType(bytes, offset))
{
case MessagePackType.Nil:
{
arguments = null;
offset++;
break;
}
case MessagePackType.Array:
{
var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out singleReadSize);
offset += singleReadSize;
var array = new object[length];
for (var i = 0; i < length; i++)
{
array[i] = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize);
offset += singleReadSize;
}
arguments = array;
break;
}
case MessagePackType.Map:
{
var length = MessagePackBinary.ReadMapHeader(bytes, offset, out singleReadSize);
offset += singleReadSize;
var map = new Dictionary <string, object>(length);
for (var i = 0; i < length; i++)
{
var key = MessagePackBinary.ReadString(bytes, offset, out singleReadSize);
offset += singleReadSize;
var value = TypelessFormatter.Instance.Deserialize(bytes, offset, formatterResolver, out singleReadSize);
offset += singleReadSize;
map.Add(key, value);
}
arguments = map;
break;
}
default:
throw new InvalidOperationException(string.Format("Invalid code : {0}", bytes[offset]));
}
readSize = offset - startOffset;
return(new JsonRpcRequest()
{
Version = version,
Id = id,
Method = method,
Arguments = arguments,
});
}
public object Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var type = MessagePackBinary.GetMessagePackType(bytes, offset);
switch (type)
{
case MessagePackType.Integer:
var code = bytes[offset];
if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
{
return(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
}
else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
{
return(MessagePackBinary.ReadByte(bytes, offset, out readSize));
}
else if (code == MessagePackCode.Int8)
{
return(MessagePackBinary.ReadSByte(bytes, offset, out readSize));
}
else if (code == MessagePackCode.Int16)
{
return(MessagePackBinary.ReadInt16(bytes, offset, out readSize));
}
else if (code == MessagePackCode.Int32)
{
return(MessagePackBinary.ReadInt32(bytes, offset, out readSize));
}
else if (code == MessagePackCode.Int64)
{
return(MessagePackBinary.ReadInt64(bytes, offset, out readSize));
}
else if (code == MessagePackCode.UInt8)
{
return(MessagePackBinary.ReadByte(bytes, offset, out readSize));
}
else if (code == MessagePackCode.UInt16)
{
return(MessagePackBinary.ReadUInt16(bytes, offset, out readSize));
}
else if (code == MessagePackCode.UInt32)
{
return(MessagePackBinary.ReadUInt32(bytes, offset, out readSize));
}
else if (code == MessagePackCode.UInt64)
{
return(MessagePackBinary.ReadUInt64(bytes, offset, out readSize));
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Boolean:
return(MessagePackBinary.ReadBoolean(bytes, offset, out readSize));
case MessagePackType.Float:
if (MessagePackCode.Float32 == bytes[offset])
{
return(MessagePackBinary.ReadSingle(bytes, offset, out readSize));
}
else
{
return(MessagePackBinary.ReadDouble(bytes, offset, out readSize));
}
case MessagePackType.String:
return(MessagePackBinary.ReadString(bytes, offset, out readSize));
case MessagePackType.Binary:
return(MessagePackBinary.ReadBytes(bytes, offset, out readSize));
case MessagePackType.Extension:
var ext = MessagePackBinary.ReadExtensionFormatHeader(bytes, offset, out readSize);
if (ext.TypeCode == ReservedMessagePackExtensionTypeCode.DateTime)
{
return(MessagePackBinary.ReadDateTime(bytes, offset, out readSize));
}
throw new InvalidOperationException("Invalid primitive bytes.");
case MessagePackType.Array:
{
var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
var startOffset = offset;
offset += readSize;
var objectFormatter = formatterResolver.GetFormatter <object>();
var array = new object[length];
for (int i = 0; i < length; i++)
{
array[i] = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return(array);
}
case MessagePackType.Map:
{
var length = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
var startOffset = offset;
offset += readSize;
var objectFormatter = formatterResolver.GetFormatter <object>();
var hash = new Dictionary <object, object>(length);
for (int i = 0; i < length; i++)
{
var key = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
var value = objectFormatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
hash.Add(key, value);
}
readSize = offset - startOffset;
return(hash);
}
case MessagePackType.Nil:
readSize = 1;
return(null);
default:
throw new InvalidOperationException("Invalid primitive bytes.");
}
}
public T[,,] Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
if (MessagePackBinary.IsNil(bytes, offset))
{
readSize = 1;
return(null);
}
else
{
var startOffset = offset;
var formatter = formatterResolver.GetFormatterWithVerify <T>();
var len = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
if (len != ArrayLength)
{
ThrowHelper.ThrowInvalidOperationException_T_Format2();
}
var iLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var jLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var kLength = MessagePackBinary.ReadInt32(bytes, offset, out readSize);
offset += readSize;
var maxLen = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var array = new T[iLength, jLength, kLength];
var i = 0;
var j = 0;
var k = -1;
for (int loop = 0; loop < maxLen; loop++)
{
if (k < kLength - 1)
{
k++;
}
else if (j < jLength - 1)
{
k = 0;
j++;
}
else
{
k = 0;
j = 0;
i++;
}
array[i, j, k] = formatter.Deserialize(bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
readSize = offset - startOffset;
return(array);
}
}
public void Read()
{
void Check1 <T, T2>(T data, T2 result, Func <Stream, T2> streamRead)
{
const int CheckOffset = 10;
byte[] bytes = null;
var len = MessagePack.Resolvers.StandardResolver.Instance.GetFormatter <T>().Serialize(ref bytes, CheckOffset, data, MessagePack.Resolvers.StandardResolver.Instance);
MessagePackBinary.FastResize(ref bytes, CheckOffset + len);
var ms = new MemoryStream(bytes);
ms.Position = CheckOffset;
streamRead(ms).Is(result);
}
void Check2 <T>(T data, Func <Stream, T> streamRead)
{
const int CheckOffset = 10;
byte[] bytes = null;
var len = MessagePack.Resolvers.StandardResolver.Instance.GetFormatter <T>().Serialize(ref bytes, CheckOffset, data, MessagePack.Resolvers.StandardResolver.Instance);
MessagePackBinary.FastResize(ref bytes, CheckOffset + len);
var ms = new MemoryStream(bytes);
ms.Position = CheckOffset;
streamRead(ms).Is(data);
}
Check1(new[] { 1, 10, 100, 1000, 10000, short.MaxValue, int.MaxValue }, 7, x => MessagePackBinary.ReadArrayHeader(x));
Check1(new[] { 1, 10, 100, 1000, 10000, short.MaxValue, int.MaxValue }, (uint)7, x => MessagePackBinary.ReadArrayHeaderRaw(x));
Check1(Nil.Default, true, x => MessagePackBinary.IsNil((x)));
Check2(true, x => MessagePackBinary.ReadBoolean(x));
Check2((byte)100, x => MessagePackBinary.ReadByte(x));
Check2(new byte[] { 1, 10, 100, 245 }, x => MessagePackBinary.ReadBytes(x));
Check2('あ', x => MessagePackBinary.ReadChar(x));
Check2(DateTime.UtcNow, x => MessagePackBinary.ReadDateTime(x));
Check2(132, x => MessagePackBinary.ReadInt16(x));
Check2(423, x => MessagePackBinary.ReadInt32(x));
Check2(64332, x => MessagePackBinary.ReadInt64(x));
Check2(Nil.Default, x => MessagePackBinary.ReadNil(x));
Check2(11, x => MessagePackBinary.ReadSByte(x));
Check2(10.31231f, x => MessagePackBinary.ReadSingle(x));
Check2("foobar", x => MessagePackBinary.ReadString(x));
Check2(124, x => MessagePackBinary.ReadUInt16(x));
Check2((uint)432, x => MessagePackBinary.ReadUInt32(x));
Check2((ulong)432, x => MessagePackBinary.ReadUInt64(x));
Check1(new Dictionary <int, int>()
{
{ 1, 2 }
}, 1, x => MessagePackBinary.ReadMapHeader(x));
Check1(new Dictionary <int, int>()
{
{ 1, 2 }
}, (uint)1, x => MessagePackBinary.ReadMapHeaderRaw(x));
{
var block = new object[] { 1, new[] { 1, 10, 100 }, 100 };
var bytes = MessagePackSerializer.Serialize(block);
var stream = new MemoryStream(bytes);
MessagePackBinary.ReadNext(stream); // array(first)
MessagePackBinary.ReadNext(stream); // int
MessagePackBinary.ReadNextBlock(stream); // skip array
MessagePackBinary.ReadInt32(stream).Is(100);
}
{
var block = new object[] { 1, new Dictionary <int, int> {
{ 1, 10 }, { 111, 200 }
}, 100 };
var bytes = MessagePackSerializer.Serialize(block);
var stream = new MemoryStream(bytes);
MessagePackBinary.ReadNext(stream);
MessagePackBinary.ReadNext(stream);
MessagePackBinary.ReadNextBlock(stream);
MessagePackBinary.ReadInt32(stream).Is(100);
}
}
async Task StartSubscribe()
{
var reader = connection.RawStreamingCall.ResponseStream;
try
{
while (await reader.MoveNext(cts.Token))
{
try
{
var data = reader.Current;
// MessageFormat:
// broadcast: [methodId, [argument]]
// response: [messageId, methodId, response]
// error-response: [messageId, statusCode, detail, StringMessage]
var readSize = 0;
var offset = 0;
var arrayLength = MessagePackBinary.ReadArrayHeader(data, offset, out readSize);
offset += readSize;
if (arrayLength == 3)
{
var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
object future;
if (responseFutures.TryRemove(messageId, out future))
{
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
try
{
OnResponseEvent(methodId, future, new ArraySegment <byte>(data, offset, data.Length - offset));
}
catch (Exception ex)
{
if (!(future as ITaskCompletion).TrySetException(ex))
{
throw;
}
}
}
}
else if (arrayLength == 4)
{
var messageId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
object future;
if (responseFutures.TryRemove(messageId, out future))
{
var statusCode = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
var detail = MessagePackBinary.ReadString(data, offset, out readSize);
offset += readSize;
var error = LZ4MessagePackSerializer.Deserialize <string>(new ArraySegment <byte>(data, offset, data.Length - offset));
(future as ITaskCompletion).TrySetException(new RpcException(new Status((StatusCode)statusCode, detail), error));
}
}
else
{
var methodId = MessagePackBinary.ReadInt32(data, offset, out readSize);
offset += readSize;
await OnBroadcastEvent(methodId, new ArraySegment <byte>(data, offset, data.Length - offset));
}
}
catch (Exception ex)
{
logger?.Error(ex, "Error on consume received message, but keep subscribe.");
}
}
}
catch (Exception ex)
{
if (ex is OperationCanceledException)
{
return;
}
logger?.Error(ex, "Error on subscribing message.");
}
finally
{
try
{
await DisposeAsyncCore(false);
}
finally
{
waitForDisconnect.TrySetResult(null);
}
}
}
public DynamicArgumentTuple <T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialize(byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
var length = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
var item1 = default1;
var item2 = default2;
var item3 = default3;
var item4 = default4;
var item5 = default5;
var item6 = default6;
var item7 = default7;
var item8 = default8;
var item9 = default9;
for (var i = 0; i < length; i++)
{
switch (i)
{
case 0:
item1 = formatterResolver.GetFormatterWithVerify <T1>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 1:
item2 = formatterResolver.GetFormatterWithVerify <T2>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 2:
item3 = formatterResolver.GetFormatterWithVerify <T3>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 3:
item4 = formatterResolver.GetFormatterWithVerify <T4>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 4:
item5 = formatterResolver.GetFormatterWithVerify <T5>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 5:
item6 = formatterResolver.GetFormatterWithVerify <T6>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 6:
item7 = formatterResolver.GetFormatterWithVerify <T7>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 7:
item8 = formatterResolver.GetFormatterWithVerify <T8>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
case 8:
item9 = formatterResolver.GetFormatterWithVerify <T9>().Deserialize(bytes, offset, formatterResolver, out readSize);
break;
default:
readSize = MessagePackBinary.ReadNextBlock(bytes, offset);
break;
}
offset += readSize;
}
readSize = offset - startOffset;
return(new DynamicArgumentTuple <T1, T2, T3, T4, T5, T6, T7, T8, T9>(item1, item2, item3, item4, item5, item6, item7, item8, item9));
}
internal static object Deserialize(ObjectSerializationInfo metaInfo, ObjectSerializationInfo.EmittableMember[] readMembers, int[] constructorParameterIndexes, AutomataDictionary mapMemberDictionary, byte[] bytes, int offset, IFormatterResolver formatterResolver, out int readSize)
{
var startOffset = offset;
object[] parameters = null;
var headerType = MessagePackBinary.GetMessagePackType(bytes, offset);
if (headerType == MessagePackType.Nil)
{
readSize = 1;
return(null);
}
else if (headerType == MessagePackType.Array)
{
var arraySize = MessagePackBinary.ReadArrayHeader(bytes, offset, out readSize);
offset += readSize;
// ReadValues
parameters = new object[arraySize];
for (int i = 0; i < arraySize; i++)
{
var info = readMembers[i];
if (info != null)
{
parameters[i] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
else
{
offset += MessagePackBinary.ReadNextBlock(bytes, offset);
}
}
}
else if (headerType == MessagePackType.Map)
{
var mapSize = MessagePackBinary.ReadMapHeader(bytes, offset, out readSize);
offset += readSize;
// ReadValues
parameters = new object[mapSize];
for (int i = 0; i < mapSize; i++)
{
var rawPropName = MessagePackBinary.ReadStringSegment(bytes, offset, out readSize);
offset += readSize;
int index;
if (mapMemberDictionary.TryGetValue(rawPropName.Array, rawPropName.Offset, rawPropName.Count, out index))
{
var info = readMembers[index];
parameters[index] = MessagePackSerializer.NonGeneric.Deserialize(info.Type, bytes, offset, formatterResolver, out readSize);
offset += readSize;
}
else
{
offset += MessagePackBinary.ReadNextBlock(bytes, offset);
}
}
}
else
{
throw new InvalidOperationException("Invalid MessagePackType:" + MessagePackCode.ToFormatName(bytes[offset]));
}
// CreateObject
object result = null;
if (constructorParameterIndexes.Length == 0)
{
result = Activator.CreateInstance(metaInfo.Type);
}
else
{
var args = new object[constructorParameterIndexes.Length];
for (int i = 0; i < constructorParameterIndexes.Length; i++)
{
args[i] = parameters[constructorParameterIndexes[i]];
}
result = Activator.CreateInstance(metaInfo.Type, args);
}
// SetMembers
for (int i = 0; i < readMembers.Length; i++)
{
var info = readMembers[i];
if (info != null)
{
info.ReflectionStoreValue(result, parameters[i]);
}
}
readSize = offset - startOffset;
return(result);
}
