/// <inheritdoc /> public object Deserialize(Type expectedType, IDeserializationContext context) { var startOffset = context.CurrentObjectOffset; var token = (SerializerTypeToken)context.StreamReader.ReadByte(); if (token == SerializerTypeToken.Exception) { var typeName = SerializationManager.DeserializeInner <string>(context); if (!_typeResolver.TryResolveType(typeName, out var type)) { // Deserialize into a fallback type for unknown exceptions // This means that missing fields will not be represented. var result = (UnavailableExceptionFallbackException)_objectSerializer.Deserialize(typeof(UnavailableExceptionFallbackException), startOffset, context); result.ExceptionType = typeName; return(result); } return(_objectSerializer.Deserialize(type, startOffset, context)); } else { var type = SerializationManager.DeserializeInner <Type>(context); if (type.IsValueType) { var serializer = _valueTypeSerializerFactory.GetSerializer(type); return(serializer.Deserialize(type, startOffset, context)); } return(_objectSerializer.Deserialize(type, startOffset, context)); } }
internal static object Deserialize(Type t, BinaryTokenStreamReader stream) { var target = (ActorPath)SerializationManager.DeserializeInner(typeof(ActorPath), stream); var message = MessageEnvelope.Deserializer((byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream)); return(new RequestEnvelope(target, message)); }
/// <inheritdoc /> public object Deserialize(Type type, int startOffset, IDeserializationContext context) { var callbacks = _serializationCallbacks.GetReferenceTypeCallbacks(type); var result = FormatterServices.GetUninitializedObject(type); context.RecordObject(result, startOffset); var memberCount = SerializationManager.DeserializeInner <int>(context); var info = new SerializationInfo(type, _formatterConverter); var streamingContext = new StreamingContext(StreamingContextStates.All, context); callbacks.OnDeserializing?.Invoke(result, streamingContext); for (var i = 0; i < memberCount; i++) { var name = SerializationManager.DeserializeInner <string>(context); var fieldType = SerializationManager.DeserializeInner <Type>(context); var value = SerializationManager.DeserializeInner(fieldType, context); info.AddValue(name, value); } var constructor = _constructorFactory.GetSerializationConstructorDelegate(type); constructor(result, info, streamingContext); callbacks.OnDeserialized?.Invoke(result, streamingContext); if (result is IDeserializationCallback callback) { callback.OnDeserialization(context); } return(result); }
object IMessageSerializer.Deserialize(BinaryTokenStreamReader stream) { var bytes = (byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream); var json = Encoding.Default.GetString(bytes); return(JsonConvert.DeserializeObject(json, settings)); }
internal static object Deserialize(Type t, BinaryTokenStreamReader stream) { var sender = (ActorPath)SerializationManager.DeserializeInner(typeof(ActorPath), stream); var message = MessageEnvelope.Deserializer((byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream)); return(new NotificationEnvelope(sender, message)); }
public static object Deserializer(Type expected, IDeserializationContext context) { TestTypeA result = new TestTypeA(); context.RecordObject(result); result.Collection = (ICollection <TestTypeA>)SerializationManager.DeserializeInner(typeof(ICollection <TestTypeA>), context); return(result); }
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader)); var streamParameter = SF.IdentifierName("stream"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var boxedResultVariable = resultVariable; var body = new List <StatementSyntax> { resultDeclaration }; if (type.IsValueType) { // For value types, we need to box the result for reflection-based setters to work. body.Add(SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(object).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("boxedResult").WithInitializer(SF.EqualsValueClause(resultVariable))))); boxedResultVariable = SF.IdentifierName("boxedResult"); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(streamParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized), boxedResultVariable))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), boxedResultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("stream")).WithType(typeof(BinaryTokenStreamReader).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
internal static object Deserialize(Type expected, IDeserializationContext context) { int a = (int)SerializationManager.DeserializeInner <int>(context); int b = (int)SerializationManager.DeserializeInner <int>(context); return(new AdvancedPOCO { A = a, B = b }); }
internal static object Deserialize(Type expected, IDeserializationContext context) { string etag = SerializationManager.DeserializeInner <string>(context); TView state = SerializationManager.DeserializeInner <TView>(context); int globalVersion = SerializationManager.DeserializeInner <int>(context); string writeVector = SerializationManager.DeserializeInner <string>(context); return(new GrainStateWithMetaDataAndETag <TView>(etag, state, globalVersion, writeVector)); }
/// <summary> /// Returns syntax for the deserializer method. /// </summary> /// <param name="type">The type.</param> /// <param name="fields">The fields.</param> /// <returns>Syntax for the deserializer method.</returns> private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields) { Expression <Action> deserializeInner = () => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext)); var contextParameter = SF.IdentifierName("context"); var resultDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(type.GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("result") .WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))); var resultVariable = SF.IdentifierName("result"); var body = new List <StatementSyntax> { resultDeclaration }; // Value types cannot be referenced, only copied, so there is no need to box & record instances of value types. if (!type.GetTypeInfo().IsValueType) { // Record the result for cyclic deserialization. Expression <Action <IDeserializationContext> > recordObject = ctx => ctx.RecordObject(default(object)); var currentSerializationContext = contextParameter; body.Add( SF.ExpressionStatement( recordObject.Invoke(currentSerializationContext) .AddArgumentListArguments(SF.Argument(resultVariable)))); } // Deserialize all fields. foreach (var field in fields) { var deserialized = deserializeInner.Invoke() .AddArgumentListArguments( SF.Argument(SF.TypeOfExpression(field.Type)), SF.Argument(contextParameter)); body.Add( SF.ExpressionStatement( field.GetSetter( resultVariable, SF.CastExpression(field.Type, deserialized)))); } body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), resultVariable))); return (SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer") .AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword)) .AddParameterListParameters( SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()), SF.Parameter(SF.Identifier("context")).WithType(typeof(IDeserializationContext).GetTypeSyntax())) .AddBodyStatements(body.ToArray()) .AddAttributeLists( SF.AttributeList() .AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax())))); }
public override object Deserialize(BinaryTokenStreamReader stream) { var bytes = (byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream); using (var ms = new MemoryStream(bytes)) { var formatter = new BinaryFormatter(); return(formatter.Deserialize(ms)); } }
internal static object Deserialize(Type expected, IDeserializationContext context) { int a = SerializationManager.DeserializeInner <int>(context); int b = SerializationManager.DeserializeInner <int>(context); int copyCount = SerializationManager.DeserializeInner <int>(context); int serializeCount = SerializationManager.DeserializeInner <int>(context); int deserializeCount = SerializationManager.DeserializeInner <int>(context); return(new ReportingPOCO { A = a, B = b, CopyCount = copyCount, SerializeCount = serializeCount, DeserializeCount = deserializeCount + 1 }); }
public void Deserialize(ReadOnlySequence <byte> input, out T value) { reader.PartialReset(input); try { value = (T)SerializationManager.DeserializeInner(this.serializationManager, typeof(T), this.deserializationContext, this.reader); } finally { this.deserializationContext.Reset(); } }
public static object Deserializer(Type expected, IDeserializationContext context) { var source = SerializationManager.DeserializeInner <WorkflowActivity>(context); var target = SerializationManager.DeserializeInner <WorkflowActivity>(context); var predicate = (Expression <Func <ActivityContext, bool> >)ExpressionSerializer.DeserializeBinary(SerializationManager.DeserializeInner <byte[]>(context)); return(new EdgeWithPredicate { Source = source, Target = target, Predicate = predicate }); }
public virtual object Deserialize(Type expectedType, IDeserializationContext context) { var bytes = SerializationManager.DeserializeInner <byte[]>(context); using (var stream = new MemoryStream()) { stream.Write(bytes, 0, bytes.Length); var formatter = new BinaryFormatter(); stream.Position = 0; object obTarget = formatter.Deserialize(stream); stream.Close(); return(obTarget); } }
public static object Deserializer(Type expected, IDeserializationContext context) { var typeSourceCode = SerializationManager.DeserializeInner <string>(context); var workflowType = ActivityTypeCache.GetOrAdd(typeSourceCode, src => src.CompileFromSourceCode()); var objectBytes = SerializationManager.DeserializeInner <byte[]>(context); var workflowActivity = JsonSerializer.NonGeneric.Deserialize(workflowType, objectBytes); context.RecordObject(workflowActivity); return(workflowActivity); }
/// <summary> /// Deserializes the container from the data stream. /// </summary> /// <param name="expected">The expected type</param> /// <param name="reader">The stream reader</param> /// <returns>The deserialized value</returns> public static object Deserialize(Type expected, BinaryTokenStreamReader reader) { var deserialized = new AzureQueueBatchContainerV2(); DeserializationContext.Current.RecordObject(deserialized); var guid = reader.ReadGuid(); var ns = reader.ReadString(); var eventToken = SerializationManager.DeserializeInner <EventSequenceTokenV2>(reader); var events = SerializationManager.DeserializeInner <List <object> >(reader); var context = SerializationManager.DeserializeInner <Dictionary <string, object> >(reader); deserialized.SetValues(guid, ns, events, context, eventToken); return(deserialized); }
public static object Deserializer(Type expected, IDeserializationContext context) { var result = new User(); // Record 'result' immediately after constructing it. As with with the deep copier, this // allows for cyclic references and de-duplication. context.RecordObject(result); // Deserialize each field in the order that they were serialized. result.BestFriend = SerializationManager.DeserializeInner <User>(context); result.NickName = SerializationManager.DeserializeInner <string>(context); result.FavoriteNumber = SerializationManager.DeserializeInner <int>(context); result.BirthDate = SerializationManager.DeserializeInner <DateTimeOffset>(context); return(result); }
public static object Deserializer(Type expected, IDeserializationContext context) { var result = new ActivityContext(); // Record 'result' immediately after constructing it. As with with the deep copier, this // allows for cyclic references and de-duplication. context.RecordObject(result); var deserialized = SerializationManager.DeserializeInner <IDictionary <string, object> >(context); foreach (var kvp in deserialized) { result.Data.Add(kvp.Key, kvp.Value); } return(result); }
public ReflectedSerializationMethodInfo() { this.GetUninitializedObject = TypeUtils.Method(() => FormatterServices.GetUninitializedObject(typeof(int))); this.GetTypeFromHandle = TypeUtils.Method(() => Type.GetTypeFromHandle(typeof(Type).TypeHandle)); this.DeepCopyInner = TypeUtils.Method(() => SerializationManager.DeepCopyInner(default(Type), default(ICopyContext))); this.SerializeInner = TypeUtils.Method(() => SerializationManager.SerializeInner(default(object), default(ISerializationContext), default(Type))); this.DeserializeInner = TypeUtils.Method(() => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext))); this.RecordObjectWhileCopying = TypeUtils.Method((ICopyContext ctx) => ctx.RecordCopy(default(object), default(object))); this.GetStreamFromDeserializationContext = TypeUtils.Property((IDeserializationContext ctx) => ctx.StreamReader).GetMethod; this.GetStreamFromSerializationContext = TypeUtils.Property((ISerializationContext ctx) => ctx.StreamWriter).GetMethod; this.RecordObjectWhileDeserializing = TypeUtils.Method((IDeserializationContext ctx) => ctx.RecordObject(default(object))); this.SerializerDelegate = TypeUtils.Method((Serializer del) => del.Invoke(default(object), default(ISerializationContext), default(Type))); this.DeserializerDelegate = TypeUtils.Method((Deserializer del) => del.Invoke(default(Type), default(IDeserializationContext))); this.DeepCopierDelegate = TypeUtils.Method((DeepCopier del) => del.Invoke(default(object), default(ICopyContext))); }
public ReflectedSerializationMethodInfo() { #if NETSTANDARD this.GetUninitializedObject = TypeUtils.Method(() => SerializationManager.GetUninitializedObjectWithFormatterServices(typeof(int))); #else this.GetUninitializedObject = TypeUtils.Method(() => FormatterServices.GetUninitializedObject(typeof(int))); #endif this.GetTypeFromHandle = TypeUtils.Method(() => Type.GetTypeFromHandle(typeof(int).TypeHandle)); this.DeepCopyInner = TypeUtils.Method(() => SerializationManager.DeepCopyInner(typeof(int))); this.SerializeInner = TypeUtils.Method(() => SerializationManager.SerializeInner(default(object), default(BinaryTokenStreamWriter), default(Type))); this.DeserializeInner = TypeUtils.Method(() => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader))); this.GetCurrentSerializationContext = TypeUtils.Property((object _) => SerializationContext.Current).GetMethod; this.RecordObjectWhileCopying = TypeUtils.Method((SerializationContext ctx) => ctx.RecordObject(default(object), default(object))); this.GetCurrentDeserializationContext = TypeUtils.Property((object _) => DeserializationContext.Current).GetMethod; this.RecordObjectWhileDeserializing = TypeUtils.Method((DeserializationContext ctx) => ctx.RecordObject(default(object))); this.SerializerDelegate = TypeUtils.Method((SerializationManager.Serializer del) => del.Invoke(default(object), default(BinaryTokenStreamWriter), default(Type))); this.DeserializerDelegate = TypeUtils.Method((SerializationManager.Deserializer del) => del.Invoke(default(Type), default(BinaryTokenStreamReader))); this.DeepCopierDelegate = TypeUtils.Method((SerializationManager.DeepCopier del) => del.Invoke(default(object))); }
static private object Deserialize(Type expected, IDeserializationContext context) { return(SerializationManager.DeserializeInner(expected, context)); }
internal static object Deserialize(Type t, BinaryTokenStreamReader stream) { var message = MessageEnvelope.Deserializer((byte[])SerializationManager.DeserializeInner(typeof(byte[]), stream)); return(new ResponseEnvelope(message)); }
public static object Deserializer(Type expected, BinaryTokenStreamReader stream) { var str = (string)(SerializationManager.DeserializeInner(typeof(string), stream)); return(JObject.Parse(str)); }
/// <summary> /// Called from generated code. /// </summary> /// <param name="stream">Stream to recover / repopulate this grain state object from.</param> public void DeserializeFrom(BinaryTokenStreamReader stream) { var values = (Dictionary <string, object>)SerializationManager.DeserializeInner(wireFormatType, stream); this.SetAllInternal(values); }
public static object Deserializer(Type expected, IDeserializationContext context) { var result = new HeadersContainer(); var reader = context.StreamReader; context.RecordObject(result); var headers = (Headers)reader.ReadInt(); if ((headers & Headers.CACHE_INVALIDATION_HEADER) != Headers.NONE) { var n = reader.ReadInt(); if (n > 0) { var list = result.CacheInvalidationHeader = new List <ActivationAddress>(n); for (int i = 0; i < n; i++) { list.Add((ActivationAddress)ReadObj(typeof(ActivationAddress), context)); } } } if ((headers & Headers.CATEGORY) != Headers.NONE) { result.Category = (Categories)reader.ReadByte(); } if ((headers & Headers.DEBUG_CONTEXT) != Headers.NONE) { result.DebugContext = reader.ReadString(); } if ((headers & Headers.DIRECTION) != Headers.NONE) { result.Direction = (Message.Directions)reader.ReadByte(); } if ((headers & Headers.TIME_TO_LIVE) != Headers.NONE) { result.TimeToLive = reader.ReadTimeSpan(); } if ((headers & Headers.FORWARD_COUNT) != Headers.NONE) { result.ForwardCount = reader.ReadInt(); } if ((headers & Headers.GENERIC_GRAIN_TYPE) != Headers.NONE) { result.GenericGrainType = reader.ReadString(); } if ((headers & Headers.CORRELATION_ID) != Headers.NONE) { result.Id = (Orleans.Runtime.CorrelationId)ReadObj(typeof(Orleans.Runtime.CorrelationId), context); } if ((headers & Headers.ALWAYS_INTERLEAVE) != Headers.NONE) { result.IsAlwaysInterleave = ReadBool(reader); } if ((headers & Headers.IS_NEW_PLACEMENT) != Headers.NONE) { result.IsNewPlacement = ReadBool(reader); } if ((headers & Headers.IS_USING_INTERFACE_VERSION) != Headers.NONE) { result.IsUsingIfaceVersion = true; } if ((headers & Headers.READ_ONLY) != Headers.NONE) { result.IsReadOnly = ReadBool(reader); } if ((headers & Headers.IS_UNORDERED) != Headers.NONE) { result.IsUnordered = ReadBool(reader); } if ((headers & Headers.NEW_GRAIN_TYPE) != Headers.NONE) { result.NewGrainType = reader.ReadString(); } if ((headers & Headers.REJECTION_INFO) != Headers.NONE) { result.RejectionInfo = reader.ReadString(); } if ((headers & Headers.REJECTION_TYPE) != Headers.NONE) { result.RejectionType = (RejectionTypes)reader.ReadByte(); } if ((headers & Headers.REQUEST_CONTEXT) != Headers.NONE) { var c = reader.ReadInt(); var requestData = new Dictionary <string, object>(c); for (int i = 0; i < c; i++) { requestData[reader.ReadString()] = SerializationManager.DeserializeInner(null, context); } result.RequestContextData = requestData; } if ((headers & Headers.RESEND_COUNT) != Headers.NONE) { result.ResendCount = reader.ReadInt(); } if ((headers & Headers.RESULT) != Headers.NONE) { result.Result = (Orleans.Runtime.Message.ResponseTypes)reader.ReadByte(); } if ((headers & Headers.SENDING_ACTIVATION) != Headers.NONE) { result.SendingActivation = reader.ReadActivationId(); } if ((headers & Headers.SENDING_GRAIN) != Headers.NONE) { result.SendingGrain = reader.ReadGrainId(); } if ((headers & Headers.SENDING_SILO) != Headers.NONE) { result.SendingSilo = reader.ReadSiloAddress(); } if ((headers & Headers.TARGET_ACTIVATION) != Headers.NONE) { result.TargetActivation = reader.ReadActivationId(); } if ((headers & Headers.TARGET_GRAIN) != Headers.NONE) { result.TargetGrain = reader.ReadGrainId(); } if ((headers & Headers.TARGET_OBSERVER) != Headers.NONE) { result.TargetObserverId = (Orleans.Runtime.GuidId)ReadObj(typeof(Orleans.Runtime.GuidId), context); } if ((headers & Headers.TARGET_SILO) != Headers.NONE) { result.TargetSilo = reader.ReadSiloAddress(); } result.IsTransactionRequired = (headers & Headers.IS_TRANSACTION_REQUIRED) != Headers.NONE; if ((headers & Headers.TRANSACTION_INFO) != Headers.NONE) { result.TransactionInfo = SerializationManager.DeserializeInner <ITransactionInfo>(context); } return(result); }
public virtual object Deserialize(Type expectedType, IDeserializationContext context) { var str = SerializationManager.DeserializeInner <string>(context); return(JsonConvert.DeserializeObject(str, expectedType, JsonSettingsFunc())); }
public object DeserializeInner(Type expected) { return(SerializationManager.DeserializeInner(expected, this)); }
public override object Deserialize(BinaryTokenStreamReader stream) { return(SerializationManager.DeserializeInner(null, stream)); }
public object DeserializeInner(Type expected) => SerializationManager.DeserializeInner(expected, this);