private static object ConvertDictionaryToObject(IDictionary <string, object> dictionary, Type type, JsonSerializer serializer)
{
Type targetType = type;
object s;
string serverTypeName = null;
object o = dictionary;
if (dictionary.TryGetValue(JsonSerializer.ServerTypeFieldName, out s))
{
serverTypeName = ConvertObjectToType(s, typeof(String), serializer) as String;
if (serverTypeName != null)
{
if (serializer.TypeResolver != null)
{
targetType = serializer.TypeResolver.ResolveType(serverTypeName);
if (targetType == null)
{
throw new InvalidOperationException();
}
}
dictionary.Remove(JsonSerializer.ServerTypeFieldName);
}
}
JsonConverter converter = null;
if (targetType != null && serializer.ConverterExistsForType(targetType, out converter))
{
return(converter.Deserialize(dictionary, targetType, serializer));
}
if (serverTypeName != null ||
(targetType != null && IsClientInstantiatableType(targetType, serializer)))
{
o = Activator.CreateInstance(targetType);
}
#if INDIGO
StructuralContract contract = null;
if (suggestedType != null &&
suggestedType.GetCustomAttributes(typeof(DataContractAttribute), false).Length > 0)
{
contract = StructuralContract.Create(suggestedType);
}
#endif
List <String> memberNames = new List <String>(dictionary.Keys);
if (type != null && type.IsGenericType && (typeof(IDictionary).IsAssignableFrom(type) || type.GetGenericTypeDefinition() == _idictionaryGenericType) &&
type.GetGenericArguments().Length == 2)
{
Type keyType = type.GetGenericArguments()[0];
if (keyType != typeof(string) && keyType != typeof(object))
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, Resources.JSON_DictionaryTypeNotSupported, type.FullName));
}
Type valueType = type.GetGenericArguments()[1];
IDictionary dict = null;
if (IsClientInstantiatableType(type, serializer))
{
dict = (IDictionary)Activator.CreateInstance(type);
}
else
{
Type t = _dictionaryGenericType.MakeGenericType(keyType, valueType);
dict = (IDictionary)Activator.CreateInstance(t);
}
if (dict != null)
{
foreach (string memberName in memberNames)
{
dict[memberName] = ConvertObjectToType(dictionary[memberName], valueType, serializer);
}
return(dict);
}
}
if (type != null && !type.IsAssignableFrom(o.GetType()))
{
ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, s_emptyTypeArray, null);
if (constructorInfo == null)
{
throw new MissingMethodException(String.Format(CultureInfo.InvariantCulture, Resources.JSON_NoConstructor, type.FullName));
}
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, Resources.JSON_DeserializerTypeMismatch, type.FullName));
}
foreach (string memberName in memberNames)
{
object propertyValue = dictionary[memberName];
#if INDIGO
if (contract != null)
{
Member member = contract.FindMember(memberName);
if (member == null)
{
throw new InvalidOperationException();
}
if (member.MemberType == MemberTypes.Field)
{
member.SetValue(o, propertyValue);
}
else
{
member.SetValue(o, propertyValue);
}
continue;
}
#endif
AssignToPropertyOrField(propertyValue, o, memberName, serializer);
}
return(o);
}
// Method that converts an IDictionary<string, object> to an object of the right type
private static bool ConvertDictionaryToObject(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject)
{
// The target type to instantiate.
Type targetType = type;
object s;
string serverTypeName = null;
object o = dictionary;
// Check if __serverType exists in the dictionary, use it as the type.
if (dictionary.TryGetValue(JavaScriptSerializer.ServerTypeFieldName, out s))
{
// Convert the __serverType value to a string.
if (!ConvertObjectToTypeMain(s, typeof(String), serializer, throwOnError, out s))
{
convertedObject = false;
return(false);
}
serverTypeName = (string)s;
if (serverTypeName != null)
{
// If we don't have the JavaScriptTypeResolver, we can't use it
if (serializer.TypeResolver != null)
{
// Get the actual type from the resolver.
targetType = serializer.TypeResolver.ResolveType(serverTypeName);
// In theory, we should always find the type. If not, it may be some kind of attack.
if (targetType == null)
{
if (throwOnError)
{
throw new InvalidOperationException();
}
convertedObject = null;
return(false);
}
}
// Remove the serverType from the dictionary, even if the resolver was null
dictionary.Remove(JavaScriptSerializer.ServerTypeFieldName);
}
}
JavaScriptConverter converter = null;
if (targetType != null && serializer.ConverterExistsForType(targetType, out converter))
{
try {
convertedObject = converter.Deserialize(dictionary, targetType, serializer);
return(true);
}
catch {
if (throwOnError)
{
throw;
}
convertedObject = null;
return(false);
}
}
// Instantiate the type if it's coming from the __serverType argument.
if (serverTypeName != null || IsClientInstantiatableType(targetType, serializer))
{
// First instantiate the object based on the type.
o = Activator.CreateInstance(targetType);
}
#if INDIGO
StructuralContract contract = null;
if (suggestedType != null &&
suggestedType.GetCustomAttributes(typeof(DataContractAttribute), false).Length > 0)
{
contract = StructuralContract.Create(suggestedType);
}
#endif
// Use a different collection to avoid modifying the original during keys enumeration.
List <String> memberNames = new List <String>(dictionary.Keys);
// Try to handle the IDictionary<K, V> case
if (IsGenericDictionary(type))
{
Type keyType = type.GetGenericArguments()[0];
if (keyType != typeof(string) && keyType != typeof(object))
{
if (throwOnError)
{
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DictionaryTypeNotSupported, type.FullName));
}
convertedObject = null;
return(false);
}
Type valueType = type.GetGenericArguments()[1];
IDictionary dict = null;
if (IsClientInstantiatableType(type, serializer))
{
dict = (IDictionary)Activator.CreateInstance(type);
}
else
{
// Get the strongly typed Dictionary<K, V>
Type t = _dictionaryGenericType.MakeGenericType(keyType, valueType);
dict = (IDictionary)Activator.CreateInstance(t);
}
if (dict != null)
{
foreach (string memberName in memberNames)
{
object memberObject;
if (!ConvertObjectToTypeMain(dictionary[memberName], valueType, serializer, throwOnError, out memberObject))
{
convertedObject = null;
return(false);
}
dict[memberName] = memberObject;
}
convertedObject = dict;
return(true);
}
}
// Fail if we know we cannot possibly return the required type.
if (type != null && !type.IsAssignableFrom(o.GetType()))
{
if (!throwOnError)
{
convertedObject = null;
return(false);
}
ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, s_emptyTypeArray, null);
if (constructorInfo == null)
{
throw new MissingMethodException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_NoConstructor, type.FullName));
}
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_DeserializerTypeMismatch, type.FullName));
}
foreach (string memberName in memberNames)
{
object propertyValue = dictionary[memberName];
#if INDIGO
if (contract != null)
{
Member member = contract.FindMember(memberName);
//
if (member == null)
{
throw new InvalidOperationException();
}
if (member.MemberType == MemberTypes.Field)
{
member.SetValue(o, propertyValue);
}
else
{
member.SetValue(o, propertyValue);
}
continue;
}
#endif
// Assign the value into a property or field of the object
if (!AssignToPropertyOrField(propertyValue, o, memberName, serializer, throwOnError))
{
convertedObject = null;
return(false);
}
}
convertedObject = o;
return(true);
}
