internal JsonSerializer(JSONParameters param, SerializationManager manager) { _manager = manager; _params = param; _useEscapedUnicode = _params.UseEscapedUnicode; _maxDepth = _params.SerializerMaxDepth; _naming = _params.NamingStrategy; if (_params.EnableAnonymousTypes) { _useExtensions = _useGlobalTypes = false; _showReadOnlyFields = _showReadOnlyProperties = true; } else { _useExtensions = _params.UseExtensions; _useGlobalTypes = _params.UsingGlobalTypes && _useExtensions; _showReadOnlyProperties = _params.ShowReadOnlyProperties; _showReadOnlyFields = _params.ShowReadOnlyFields; } }
static GreaterThanValueCondition() { SerializationManager.RegisterSerializable(nameof(GreaterThanValueCondition), x => new GreaterThanValueCondition(x)); }
public ReceiveCallbackContext(SaeaPoolWrapper poolWrapper, MessageFactory messageFactory, SerializationManager serializationManager, ILoggerFactory loggerFactory) { this.messageFactory = messageFactory; SaeaPoolWrapper = poolWrapper; _buffer = new IncomingMessageBuffer(loggerFactory, serializationManager); }
public void ProtoBufSerializerIsPresentByDefaultTest() { var serializationManager = new SerializationManager(_logFactory); Assert.NotNull(serializationManager.ExtractSerializer <int>(SerializationFormat.ProtoBuf)); }
public GrainCallFilterWithDependencies(SerializationManager serializationManager, Silo silo, IGrainFactory grainFactory) { this.serializationManager = serializationManager; this.silo = silo; this.grainFactory = grainFactory; }
/// <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 DataNode WriteSeedDataDefinition() { return(SerializationManager.WriteValue(Seed)); }
public DataNode WriteInteger() { return(SerializationManager.WriteValue(Integer)); }
public object GetItem(string key) { byte[] objectBytes = redisClient.Get(key); return(SerializationManager.DeserializeFromBinary(objectBytes)); }
public void AddItem(string key, object item, int expire) { byte[] objectBytes = SerializationManager.SerializeToBinary(item); redisClient.Set(key, objectBytes, new TimeSpan(expire)); }
/// <summary> /// Adds serialization type descriptions from <paramref name="types"/> to <paramref name="serializationTypes"/>. /// </summary> /// <param name="serializationTypes">The serialization type descriptions.</param> /// <param name="targetAssembly">The target assembly for generated code.</param> /// <param name="types">The types.</param> private void AddSerializationTypes(SerializationTypeDescriptions serializationTypes, Assembly targetAssembly) { // Only types which exist in assemblies referenced by the target assembly can be referenced. var references = new HashSet <string>(targetAssembly.GetReferencedAssemblies().Select(asm => asm.Name)); bool IsAssemblyReferenced(Type type) { // If the target doesn't reference this type's assembly, it cannot reference a type within that assembly. var asmName = type.Assembly.GetName().Name; if (type.Assembly != targetAssembly) { if (!references.Contains(asmName)) { return(false); } if (!type.IsSerializable) { return(false); } } return(true); } // Visit all types in other assemblies for serialization metadata. foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { if (!references.Contains(assembly.GetName().Name)) { continue; } foreach (var type in TypeUtils.GetDefinedTypes(assembly, this.Logger)) { this.typeCollector.RecordEncounteredType(type); } } // Returns true if a type can be accessed from source and false otherwise. bool IsAccessibleType(Type type) { var accessible = !type.IsGenericParameter; if (type.IsSpecialName) { accessible = false; } if (type.GetCustomAttribute <CompilerGeneratedAttribute>() != null) { accessible = false; } // Obsolete types can be accessed, however obsolete types which have IsError set cannot. var obsoleteAttr = type.GetCustomAttribute <ObsoleteAttribute>(); if (obsoleteAttr != null && obsoleteAttr.IsError) { accessible = false; } if (!TypeUtilities.IsAccessibleFromAssembly(type, targetAssembly)) { accessible = false; } return(accessible); } foreach (var type in this.typeCollector.EncounteredTypes) { if (!IsAssemblyReferenced(type)) { continue; } if (type.GetCustomAttribute <GeneratedCodeAttribute>() != null) { continue; } var qualifiedTypeName = RuntimeTypeNameFormatter.Format(type); if (this.knownTypes.Contains(qualifiedTypeName)) { continue; } serializationTypes.KnownTypes.Add(new KnownTypeDescription { Type = qualifiedTypeName, TypeKey = type.OrleansTypeKeyString() }); if (!IsAccessibleType(type)) { continue; } var typeSyntax = type.GetTypeSyntax(includeGenericParameters: false); var serializerAttributes = type.GetCustomAttributes <SerializerAttribute>().ToList(); if (serializerAttributes.Count > 0) { // Account for serializer types. foreach (var serializerAttribute in serializerAttributes) { if (!IsAccessibleType(serializerAttribute.TargetType)) { continue; } serializationTypes.SerializerTypes.Add( new SerializerTypeDescription { Serializer = typeSyntax, Target = serializerAttribute.TargetType.GetTypeSyntax(includeGenericParameters: false) }); } } else { // Account for self-serializing types. SerializationManager.GetSerializationMethods(type, out var copier, out var serializer, out var deserializer); if (copier != null || serializer != null || deserializer != null) { serializationTypes.SerializerTypes.Add( new SerializerTypeDescription { Serializer = typeSyntax, Target = typeSyntax }); } } } }
public static HeartbeatData Deserialize(byte [] data) { return(SerializationManager.DeserializeFromByteArray <HeartbeatData>(data)); }
public static byte[] Serialize(object o) { return(SerializationManager.SerializeToByteArray(o)); }
BeginPersistObjectData(SerializableObjectContext serializableObjectContext, out ReachTreeWalker treeWalker) { if (serializableObjectContext == null) { throw new ArgumentNullException("serializableObjectContext"); } _xpsOMSerializationManager.RegisterPageStart(); if (serializableObjectContext.IsComplexValue) { PrintTicket printTicket = _xpsOMSerializationManager.FixedPagePrintTicket; if (printTicket != null) { PrintTicketSerializer serializer = new PrintTicketSerializer(SerializationManager); serializer.SerializeObject(printTicket); _xpsOMSerializationManager.FixedPagePrintTicket = null; } } FixedPage fixedPage = serializableObjectContext.TargetObject as FixedPage; treeWalker = new ReachTreeWalker(this); treeWalker.SerializeLinksInFixedPage((FixedPage)serializableObjectContext.TargetObject); String xmlnsForType = SerializationManager.GetXmlNSForType(serializableObjectContext.TargetObject.GetType()); if (xmlnsForType == null) { XmlWriter.WriteStartElement(serializableObjectContext.Name); } else { XmlWriter.WriteStartElement(serializableObjectContext.Name); XmlWriter.WriteAttributeString(XpsS0Markup.Xmlns, xmlnsForType); XmlWriter.WriteAttributeString(XpsS0Markup.XmlnsX, XpsS0Markup.XmlnsXSchema); XmlLanguage language = fixedPage.Language; if (language == null) { //If the language property is null, assign the language to the default language = XmlLanguage.GetLanguage(XpsS0Markup.XmlLangValue); } SerializationManager.Language = language; XmlWriter.WriteAttributeString(XpsS0Markup.XmlLang, language.ToString()); } Size fixedPageSize = new Size(fixedPage.Width, fixedPage.Height); _xpsOMSerializationManager.FixedPageSize = fixedPageSize; // // Before we serialize any properties on the FixedPage, we need to // serialize the FixedPage as a Visual // Visual fixedPageAsVisual = serializableObjectContext.TargetObject as Visual; bool needEndVisual = false; if (fixedPageAsVisual != null) { needEndVisual = SerializePageAsVisual(fixedPageAsVisual); } return(needEndVisual); }
public bool CanSerialize(object data, SerializationManager manager) => data is Envelope env && manager.CanSerialize(env.Data);
public void SaveChanges() { SerializationManager.Serialize(Transform(_personsList), FileHelper.StorageFilePath); }
public DataNode WriteString() { return(SerializationManager.WriteValue(String)); }
internal OutgoingMessageSender(string nameSuffix, IMessagingConfiguration config, SerializationManager serializationManager, ILoggerFactory loggerFactory) : base(nameSuffix, config, loggerFactory) { this.serializationManager = serializationManager; }
public DataNode WriteDataDefinitionWithString() { return(SerializationManager.WriteValue(DataDefinitionWithString)); }
protected override void OnClosing(CancelEventArgs e) { SerializationManager.Serialise("..\\..\\SerializedData\\users.bin", _data.Users); base.OnClosing(e); }
/// <summary> /// Called from generated code. /// </summary> /// <param name="stream">Stream to serialize this grain state object to.</param> public void SerializeTo(BinaryTokenStreamWriter stream) { var values = this.AsDictionaryInternal(); SerializationManager.SerializeInner(values, stream, wireFormatType); }
/// <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)))); } // If the type implements the internal IOnDeserialized lifecycle method, invoke it's method now. if (typeof(IOnDeserialized).IsAssignableFrom(type)) { Expression <Action <IOnDeserialized> > onDeserializedMethod = _ => _.OnDeserialized(default(ISerializerContext)); // C#: ((IOnDeserialized)result).OnDeserialized(context); var typedResult = SF.ParenthesizedExpression(SF.CastExpression(typeof(IOnDeserialized).GetTypeSyntax(), resultVariable)); var invokeOnDeserialized = onDeserializedMethod.Invoke(typedResult).AddArgumentListArguments(SF.Argument(contextParameter)); body.Add(SF.ExpressionStatement(invokeOnDeserialized)); } 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())))); }
/// <summary> /// Cache data adapter that adapts EventHub's EventData to CachedEventHubMessage used in cache /// </summary> /// <param name="serializationManager"></param> public EventHubDataAdapter(SerializationManager serializationManager) { this.serializationManager = serializationManager; }
/// <summary> /// Returns syntax for the static fields of the serializer class. /// </summary> /// <param name="fields">The fields.</param> /// <returns>Syntax for the static fields of the serializer class.</returns> private static MemberDeclarationSyntax[] GenerateStaticFields(List <FieldInfoMember> fields) { var result = new List <MemberDeclarationSyntax>(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Expression <Action <TypeInfo> > getField = _ => _.GetField(string.Empty, BindingFlags.Default); Expression <Action <Type> > getTypeInfo = _ => _.GetTypeInfo(); Expression <Action> getGetter = () => SerializationManager.GetGetter(default(FieldInfo)); Expression <Action> getReferenceSetter = () => SerializationManager.GetReferenceSetter(default(FieldInfo)); Expression <Action> getValueSetter = () => SerializationManager.GetValueSetter(default(FieldInfo)); // Expressions for specifying binding flags. var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax( SyntaxKind.BitwiseOrExpression, BindingFlags.Instance, BindingFlags.NonPublic, BindingFlags.Public); // Add each field and initialize it. foreach (var field in fields) { var fieldInfo = getField.Invoke(getTypeInfo.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax()))) .AddArgumentListArguments( SF.Argument(field.FieldInfo.Name.GetLiteralExpression()), SF.Argument(bindingFlags)); var fieldInfoVariable = SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo)); var fieldInfoField = SF.IdentifierName(field.InfoFieldName); if (!field.IsGettableProperty || !field.IsSettableProperty) { result.Add( SF.FieldDeclaration( SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } // Declare the getter for this field. if (!field.IsGettableProperty) { var getterType = typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType) .GetTypeSyntax(); var fieldGetterVariable = SF.VariableDeclarator(field.GetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( getterType, getGetter.Invoke().AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(getterType).AddVariables(fieldGetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } if (!field.IsSettableProperty) { if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.GetTypeInfo().IsValueType) { var setterType = typeof(SerializationManager.ValueTypeSetter <,>).MakeGenericType( field.FieldInfo.DeclaringType, field.FieldInfo.FieldType).GetTypeSyntax(); var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( setterType, getValueSetter.Invoke() .AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } else { var setterType = typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType) .GetTypeSyntax(); var fieldSetterVariable = SF.VariableDeclarator(field.SetterFieldName) .WithInitializer( SF.EqualsValueClause( SF.CastExpression( setterType, getReferenceSetter.Invoke() .AddArgumentListArguments(SF.Argument(fieldInfoField))))); result.Add( SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } } } return(result.ToArray()); }
internal SimpleMessageStreamProducer(StreamImpl <T> stream, string streamProviderName, IStreamProviderRuntime providerUtilities, bool fireAndForgetDelivery, bool optimizeForImmutableData, IStreamPubSub pubSub, bool isRewindable, SerializationManager serializationManager, ILoggerFactory loggerFactory) { this.stream = stream; this.streamProviderName = streamProviderName; providerRuntime = providerUtilities; this.pubSub = pubSub; this.serializationManager = serializationManager; connectedToRendezvous = false; this.fireAndForgetDelivery = fireAndForgetDelivery; this.optimizeForImmutableData = optimizeForImmutableData; IsRewindable = isRewindable; isDisposed = false; initLock = new AsyncLock(); this.loggerFactory = loggerFactory; this.logger = loggerFactory.CreateLogger(this.GetType().FullName); ConnectToRendezvous().Ignore(); }
public static void Serializer(object untypedInput, ISerializationContext context, Type expected) { HeadersContainer input = (HeadersContainer)untypedInput; var headers = input.GetHeadersMask(); var writer = context.StreamWriter; writer.Write((int)headers); if ((headers & Headers.CACHE_INVALIDATION_HEADER) != Headers.NONE) { var count = input.CacheInvalidationHeader.Count; writer.Write(input.CacheInvalidationHeader.Count); for (int i = 0; i < count; i++) { WriteObj(context, typeof(ActivationAddress), input.CacheInvalidationHeader[i]); } } if ((headers & Headers.CATEGORY) != Headers.NONE) { writer.Write((byte)input.Category); } if ((headers & Headers.DEBUG_CONTEXT) != Headers.NONE) { writer.Write(input.DebugContext); } if ((headers & Headers.DIRECTION) != Headers.NONE) { writer.Write((byte)input.Direction.Value); } if ((headers & Headers.TIME_TO_LIVE) != Headers.NONE) { writer.Write(input.TimeToLive.Value); } if ((headers & Headers.FORWARD_COUNT) != Headers.NONE) { writer.Write(input.ForwardCount); } if ((headers & Headers.GENERIC_GRAIN_TYPE) != Headers.NONE) { writer.Write(input.GenericGrainType); } if ((headers & Headers.CORRELATION_ID) != Headers.NONE) { writer.Write(input.Id); } if ((headers & Headers.ALWAYS_INTERLEAVE) != Headers.NONE) { writer.Write(input.IsAlwaysInterleave); } if ((headers & Headers.IS_NEW_PLACEMENT) != Headers.NONE) { writer.Write(input.IsNewPlacement); } // Nothing to do with Headers.IS_USING_INTERFACE_VERSION since the value in // the header is sufficient if ((headers & Headers.READ_ONLY) != Headers.NONE) { writer.Write(input.IsReadOnly); } if ((headers & Headers.IS_UNORDERED) != Headers.NONE) { writer.Write(input.IsUnordered); } if ((headers & Headers.NEW_GRAIN_TYPE) != Headers.NONE) { writer.Write(input.NewGrainType); } if ((headers & Headers.REJECTION_INFO) != Headers.NONE) { writer.Write(input.RejectionInfo); } if ((headers & Headers.REJECTION_TYPE) != Headers.NONE) { writer.Write((byte)input.RejectionType); } if ((headers & Headers.REQUEST_CONTEXT) != Headers.NONE) { var requestData = input.RequestContextData; var count = requestData.Count; writer.Write(count); foreach (var d in requestData) { writer.Write(d.Key); SerializationManager.SerializeInner(d.Value, context, typeof(object)); } } if ((headers & Headers.RESEND_COUNT) != Headers.NONE) { writer.Write(input.ResendCount); } if ((headers & Headers.RESULT) != Headers.NONE) { writer.Write((byte)input.Result); } if ((headers & Headers.SENDING_ACTIVATION) != Headers.NONE) { writer.Write(input.SendingActivation); } if ((headers & Headers.SENDING_GRAIN) != Headers.NONE) { writer.Write(input.SendingGrain); } if ((headers & Headers.SENDING_SILO) != Headers.NONE) { writer.Write(input.SendingSilo); } if ((headers & Headers.TARGET_ACTIVATION) != Headers.NONE) { writer.Write(input.TargetActivation); } if ((headers & Headers.TARGET_GRAIN) != Headers.NONE) { writer.Write(input.TargetGrain); } if ((headers & Headers.TARGET_OBSERVER) != Headers.NONE) { WriteObj(context, typeof(GuidId), input.TargetObserverId); } if ((headers & Headers.TARGET_SILO) != Headers.NONE) { writer.Write(input.TargetSilo); } if ((headers & Headers.TRANSACTION_INFO) != Headers.NONE) { SerializationManager.SerializeInner(input.TransactionInfo, context, typeof(ITransactionInfo)); } }
// Used for holding enough info to handle receive completion internal IncomingMessageAcceptor(MessageCenter msgCtr, IPEndPoint here, SocketDirection socketDirection, MessageFactory messageFactory, SerializationManager serializationManager, ExecutorService executorService, ILoggerFactory loggerFactory) :base(executorService, loggerFactory) { this.loggerFactory = loggerFactory; Log = new LoggerWrapper<IncomingMessageAcceptor>(loggerFactory); MessageCenter = msgCtr; listenAddress = here; this.MessageFactory = messageFactory; this.receiveEventArgsPool = new ConcurrentObjectPool<SaeaPoolWrapper>(() => this.CreateSocketReceiveAsyncEventArgsPoolWrapper()); this.serializationManager = serializationManager; if (here == null) listenAddress = MessageCenter.MyAddress.Endpoint; AcceptingSocket = MessageCenter.SocketManager.GetAcceptingSocketForEndpoint(listenAddress); Log.Info(ErrorCode.Messaging_IMA_OpenedListeningSocket, "Opened a listening socket at address " + AcceptingSocket.LocalEndPoint); OpenReceiveSockets = new HashSet<Socket>(); OnFault = FaultBehavior.CrashOnFault; SocketDirection = socketDirection; checkedOutSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_OUT_SOCKET_EVENT_ARGS, false); checkedInSocketEventArgsCounter = CounterStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_CHECKED_IN_SOCKET_EVENT_ARGS, false); IntValueStatistic.FindOrCreate(StatisticNames.MESSAGE_ACCEPTOR_IN_USE_SOCKET_EVENT_ARGS, () => checkedOutSocketEventArgsCounter.GetCurrentValue() - checkedInSocketEventArgsCounter.GetCurrentValue()); }
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); }
internal static void RecordTypeToGenerate(Type t) { if (t.IsGenericParameter || processedTypes.Contains(t) || typesToProcess.Contains(t) || typeof(Exception).IsAssignableFrom(t)) { return; } if (t.IsArray) { RecordTypeToGenerate(t.GetElementType()); return; } if (t.IsNestedPublic || t.IsNestedFamily || t.IsNestedPrivate) { Console.WriteLine("Skipping serializer generation for nested type {0}. If this type is used frequently, you may wish to consider making it non-nested.", t.Name); } if (t.IsGenericType) { var args = t.GetGenericArguments(); foreach (var arg in args) { if (!arg.IsGenericParameter) { RecordTypeToGenerate(arg); } } } if (t.IsInterface || t.IsAbstract || t.IsEnum || t == typeof(object) || t == typeof(void) || GrainInterfaceData.IsTaskType(t)) { return; } if (t.IsGenericType) { var def = t.GetGenericTypeDefinition(); if (def == typeof(Task <>) || (SerializationManager.GetSerializer(def) != null) || processedTypes.Contains(def) || typeof(IAddressable).IsAssignableFrom(def)) { return; } if (def.Namespace.Equals("System") || def.Namespace.StartsWith("System.")) { ConsoleText.WriteWarning("System type " + def.Name + " requires a serializer."); } else { typesToProcess.Add(def); } return; } if (t.IsOrleansPrimitive() || (SerializationManager.GetSerializer(t) != null) || typeof(IAddressable).IsAssignableFrom(t)) { return; } if (t.Namespace.Equals("System") || t.Namespace.StartsWith("System.")) { ConsoleText.WriteWarning("System type " + t.Name + " may require a custom serializer for optimal performance. " + "If you use arguments of this type a lot, consider asking the Orleans team to build a custom serializer for it."); return; } if (t.IsArray) { RecordTypeToGenerate(t.GetElementType()); return; } bool hasCopier = false; bool hasSerializer = false; bool hasDeserializer = false; foreach (var method in t.GetMethods(BindingFlags.Static | BindingFlags.Public)) { if (method.GetCustomAttributes(typeof(SerializerMethodAttribute), false).Length > 0) { hasSerializer = true; } else if (method.GetCustomAttributes(typeof(DeserializerMethodAttribute), false).Length > 0) { hasDeserializer = true; } if (method.GetCustomAttributes(typeof(CopierMethodAttribute), false).Length > 0) { hasCopier = true; } } if (hasCopier && hasSerializer && hasDeserializer) { return; } typesToProcess.Add(t); }
/// <summary> /// Deserializes the provided value into this instance's <see cref="BodyObject"/>. /// </summary> /// <param name="serializationManager">The serialization manager.</param> /// <param name="body">The serialized body contents.</param> public void DeserializeBodyObject(SerializationManager serializationManager, List <ArraySegment <byte> > body) { this.BodyObject = DeserializeBody(serializationManager, body); }
private void SaveChanges() { SerializationManager.Serialize(_persons, FileFolderHelper.StorageFilePath); }
internal ReflectionCache(Type type, SerializationManager manager) { Type = type; TypeName = type.FullName; AssemblyName = type.AssemblyQualifiedName; JsonDataType = Reflection.GetJsonDataType (type); SerializeMethod = JsonSerializer.GetWriteJsonMethod (type); DeserializeMethod = JsonDeserializer.GetReadJsonMethod (type); if (JsonDataType == JsonDataType.Enum) { IsFlaggedEnum = AttributeHelper.HasAttribute<FlagsAttribute> (type, false); return; } if (type.IsGenericType) { ArgumentTypes = type.GetGenericArguments (); var gt = type.GetGenericTypeDefinition (); if (gt.Equals (typeof (Dictionary<,>))) { CommonType = ComplexType.Dictionary; } else if (gt.Equals (typeof (List<>))) { CommonType = ComplexType.List; } else if (gt.Equals (typeof (Nullable<>))) { CommonType = ComplexType.Nullable; SerializeMethod = JsonSerializer.GetWriteJsonMethod (ArgumentTypes[0]); } } else if (type.IsArray) { ArgumentTypes = new Type[] { type.GetElementType () }; CommonType = type.GetArrayRank () == 1 ? ComplexType.Array : ComplexType.MultiDimensionalArray; } if (typeof(IEnumerable).IsAssignableFrom (type)) { if (typeof(Array).IsAssignableFrom (type) == false) { AppendItem = Reflection.CreateWrapperMethod<AddCollectionItem> (Reflection.FindMethod (type, "Add", new Type[1] { null })); } if (ArgumentTypes != null && ArgumentTypes.Length == 1) { ItemSerializer = JsonSerializer.GetWriteJsonMethod (ArgumentTypes[0]); ItemDeserializer = JsonDeserializer.GetReadJsonMethod (ArgumentTypes[0]); } } if (ArgumentTypes != null) { ArgumentReflections = Array.ConvertAll (ArgumentTypes, manager.GetReflectionCache); } if (CommonType != ComplexType.Array && CommonType != ComplexType.MultiDimensionalArray && CommonType != ComplexType.Nullable) { var t = type; if (type.IsNested == false && type.IsPublic == false) { ConstructorInfo |= ConstructorTypes.NonPublic; } else { while (t != null && t.IsNested) { if (t.IsNestedPublic == false) { ConstructorInfo |= ConstructorTypes.NonPublic; } t = t.DeclaringType; } } if (type.IsClass || type.IsValueType) { Constructor = Reflection.CreateConstructorMethod (type, type.IsVisible == false || typeof (DatasetSchema).Equals (type)); if (Constructor != null && Constructor.Method.IsPublic == false) { ConstructorInfo |= ConstructorTypes.NonPublic; } if (Constructor == null) { var c = type.GetConstructors (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); if (c != null && c.Length > 0) { ConstructorInfo |= ConstructorTypes.Parametric; } } Members = Reflection.GetMembers (type); } } //if (typeof (IEnumerable).IsAssignableFrom (type)) { // return; //} //if (JsonDataType != JsonDataType.Undefined) { // return; //} }