TypeSerializationInfo GetTypeSerializationInfo(string OrleansTypeString, Type Type)
{
if (!typeInfoCache.TryGetValue(Type, out var typeInfo))
{
foreach (var providerInfo in options.SerializationProviders.Values)
{
if (providerInfo.provider.IsSupportedType(Type))
{
typeInfo = new TypeSerializationInfo()
{
typeString = providerInfo.provider.GetTypeString(OrleansTypeString, Type),
providerInfo = providerInfo
};
if (typeInfo.typeString.Contains("!"))
{
throw new ArgumentException($"TypeString returned from storage serialization providers may not contain the special character '!', got {typeInfo.typeString}");
}
break;
}
}
typeInfoCache.TryAdd(Type, typeInfo);
}
return(typeInfo);
}
static TypeSerializationInfo DoTypeRemap(TypeSerializationInfo info, Dictionary <TypeSerializationInfo, TypeSerializationInfo> remapper)
{
if (remapper.TryGetValue(info, out var foundInfo))
{
return(foundInfo);
}
return(info);
}
private static Type GetTypeFromSerializedString(TypeSerializationInfo typeInfo)
{
if (!typeInfo.IsValid())
{
return(null);
}
return(Type.GetType(typeInfo.SearchString()));
}
private void WriteTypeInfo(TypeSerializationInfo typeInfo, string propName = "$type")
{
if (typeInfo == null)
{
return;
}
if (propName != null)
{
_jsonWriter.WritePropertyName(propName);
}
if (typeInfo == TypeSerializationInfo.Self)
{
_jsonWriter.WriteValue("$type");
}
else if (typeInfo.Assembly == null && typeInfo.GenericArgs == null)
{
_jsonWriter.WriteValue(typeInfo.Name);
}
else
{
_jsonWriter.WriteStartObject();
_jsonWriter.WritePropertyName(nameof(TypeSerializationInfo.Name));
_jsonWriter.WriteValue(typeInfo.Name);
if (typeInfo.GenericArgs != null)
{
_jsonWriter.WritePropertyName(nameof(TypeSerializationInfo.GenericArgs));
_jsonWriter.WriteStartArray();
foreach (var genericArgType in typeInfo.GenericArgs)
{
WriteTypeInfo(genericArgType, propName: null);
}
_jsonWriter.WriteEndArray();
}
if (typeInfo.Assembly != null)
{
_jsonWriter.WritePropertyName(nameof(TypeSerializationInfo.Assembly));
if (typeInfo.Assembly.Token == null && typeInfo.Assembly.Version == null)
{
_jsonWriter.WriteValue(typeInfo.Assembly.Name);
}
else
{
_jsonSerializer.Serialize(_jsonWriter, typeInfo.Assembly);
}
}
_jsonWriter.WriteEndObject();
}
}
private NamedEntityAttributes GetNamedEntityAttributesFrom(Type type)
{
AvroContractResolver resolver = this.settings.Resolver;
TypeSerializationInfo typeInfo = resolver.ResolveType(type);
var name = new SchemaName(typeInfo.Name, typeInfo.Namespace);
var aliases = typeInfo
.Aliases
.Select(alias => string.IsNullOrEmpty(name.Namespace) || alias.Contains(".") ? alias : name.Namespace + "." + alias)
.ToList();
return new NamedEntityAttributes(name, aliases, typeInfo.Doc);
}
public object Compose(IValueContainer container, Type valueType)
{
var c = (EntityProjectionContainer)container;
var projetionInterface = _typeSerializerHelper.ResolveType(TypeSerializationInfo.Parse(c.Type));
var result = EntityProjection.CreateInstance(projetionInterface);
if (c.Properties != null)
{
foreach (var pair in c.Properties)
{
// BAD CODE
// The problem is in JSON serialization, so we have to perform some extra type checks and conversion.
// I know, it's bad, just need to make it work as a quick-fix without going back to the drawing board.
var value = pair.Value;
if (value != null)
{
var expectedValueType = projetionInterface.GetProperty(pair.Key).PropertyType;
var actualValueType = value.GetType();
if (actualValueType != expectedValueType)
{
if ((expectedValueType == typeof(Guid) || expectedValueType == typeof(Guid?)) && actualValueType == typeof(string))
{
value = Guid.Parse((string)value);
}
else if (expectedValueType == typeof(Uri) && actualValueType == typeof(string))
{
value = new Uri((string)value);
}
else if (expectedValueType.IsEnum)
{
value = Enum.ToObject(expectedValueType, value);
}
else if (expectedValueType.IsGenericType && !expectedValueType.IsClass && expectedValueType.Name == "Nullable`1")
{
var nullableValueType = expectedValueType.GetGenericArguments()[0];
if (nullableValueType != actualValueType)
{
value = Convert.ChangeType(value, nullableValueType);
}
value = Activator.CreateInstance(expectedValueType, value);
}
else
{
value = Convert.ChangeType(value, expectedValueType);
}
}
}
// BAD CODE
EntityProjection.SetValue(result, pair.Key, value);
}
}
return(result);
}
public static T Deserialize <T>(JSONSerializedElement item, Dictionary <TypeSerializationInfo, TypeSerializationInfo> remapper, params object[] constructorArgs) where T : class
{
if (!item.typeInfo.IsValid() || string.IsNullOrEmpty(item.JSONnodeData))
{
throw new ArgumentException(string.Format("Can not deserialize {0}, it is invalid", item));
}
TypeSerializationInfo info = item.typeInfo;
info.fullName = info.fullName.Replace("UnityEngine.MaterialGraph", "UnityEditor.ShaderGraph");
info.fullName = info.fullName.Replace("UnityEngine.Graphing", "UnityEditor.Graphing");
if (remapper != null)
{
info = DoTypeRemap(info, remapper);
}
var type = GetTypeFromSerializedString(info);
if (type == null)
{
throw new ArgumentException(string.Format("Can not deserialize ({0}), type is invalid", info.fullName));
}
T instance;
try
{
var culture = CultureInfo.CurrentCulture;
var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
instance = Activator.CreateInstance(type, flags, null, constructorArgs, culture) as T;
}
catch (Exception e)
{
throw new Exception(string.Format("Could not construct instance of: {0}", type), e);
}
if (instance != null)
{
JsonUtility.FromJsonOverwrite(item.JSONnodeData, instance);
return(instance);
}
return(null);
}
static Type GetTypeFromSerializedString(TypeSerializationInfo typeInfo)
{
if (!typeInfo.IsValid())
{
return(null);
}
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
var type = assembly.GetType(typeInfo.fullName);
if (type != null)
{
return(type);
}
}
return(null);
}
public static T Deserialize <T>(string data, TypeSerializationInfo typeInfo, Dictionary <TypeSerializationInfo, TypeSerializationInfo> remapper, params object[] constructorArgs) where T : class
{
if (!typeInfo.IsValid() || string.IsNullOrEmpty(data))
{
throw new ArgumentException($"Can not deserialize {data} of type {typeInfo}, it is invalid");
}
typeInfo.fullName = typeInfo.fullName.Replace("UnityEngine.MaterialGraph", "UnityEditor.ShaderGraph");
typeInfo.fullName = typeInfo.fullName.Replace("UnityEngine.Graphing", "UnityEditor.Graphing");
if (remapper != null)
{
typeInfo = DoTypeRemap(typeInfo, remapper);
}
var type = GetTypeFromSerializedString(typeInfo);
if (type == null)
{
throw new ArgumentException($"Can not deserialize ({typeInfo.fullName}), type is invalid");
}
T instance;
try
{
instance = Activator.CreateInstance(type, constructorArgs) as T;
}
catch (Exception e)
{
throw new Exception($"Could not construct instance of: {type}", e);
}
if (instance != null)
{
JsonUtility.FromJsonOverwrite(data, instance);
return(instance);
}
return(null);
}
public static void Deserialize <T>(IDictionary <int, T> dictionary, IEnumerable <JSONSerializedIndexedElement> list, Dictionary <TypeSerializationInfo, TypeSerializationInfo> remapper, params object[] constructorArgs) where T : class
{
foreach (var element in list)
{
try
{
T existingElement;
if (dictionary.TryGetValue(element.index, out existingElement))
{
TypeSerializationInfo info = element.typeInfo;
var type = GetTypeFromSerializedString(info);
if (type == null)
{
throw new ArgumentException(string.Format("Can not deserialize ({0}), type is invalid", info.fullName));
}
if (!type.IsInstanceOfType(existingElement))
{
dictionary[element.index] = Deserialize <T>(element, remapper, constructorArgs);
}
else
{
JsonUtility.FromJsonOverwrite(element.JSONnodeData, existingElement);
}
}
else
{
dictionary.Add(element.index, Deserialize <T>(element, remapper));
}
}
catch (Exception e)
{
Debug.LogException(e);
Debug.LogError(element.JSONnodeData);
}
}
}
/// <summary>
/// Is known type.
/// </summary>
private static bool IsKnownType(Type type)
{
TypeSerializationInfo info = KnownTypes.GetTypeSerializationInfo(type);
return(info != null);
}
private TypeSerializationInfo ConvertToTypeSerializationInfo(JToken typeObject)
{
if (typeObject.Type == JTokenType.String)
{
var typeName = (string)typeObject;
if (typeName == "$type")
{
return(TypeSerializationInfo.Self);
}
return(new TypeSerializationInfo
{
Name = typeName
});
}
else if (typeObject.Type == JTokenType.Object)
{
var result = new TypeSerializationInfo
{
Name = typeObject.Value <string>(nameof(TypeSerializationInfo.Name))
};
var assemblyValue = typeObject[nameof(TypeSerializationInfo.Assembly)];
if (assemblyValue != null)
{
if (assemblyValue.Type == JTokenType.String)
{
result.Assembly = new AssemblySerializationInfo
{
Name = assemblyValue.Value <string>()
};
}
else if (assemblyValue.Type == JTokenType.Object)
{
result.Assembly = assemblyValue.ToObject <AssemblySerializationInfo>();
}
else
{
throw new Exception($"Invalid assembly token: '{assemblyValue.Type}'");
}
}
var genericArgsValues = typeObject[nameof(TypeSerializationInfo.GenericArgs)];
if (genericArgsValues != null)
{
if (genericArgsValues.Type == JTokenType.Array)
{
var genericArguments = new List <TypeSerializationInfo>();
foreach (var genericArgTypeValue in genericArgsValues)
{
var genericArgument = ConvertToTypeSerializationInfo(genericArgTypeValue);
genericArguments.Add(genericArgument);
}
result.GenericArgs = genericArguments.ToArray();
}
else
{
throw new Exception($"Invalid generic arguments token: '{genericArgsValues.Type}'");
}
}
return(result);
}
else
{
throw new Exception($"Invalid type info token: '{typeObject.Type}'");
}
}
