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;
//}
}
