// Method that converts an IDictionary<string, object> to an object of the right type private static bool ConvertDictionaryToObject(IDictionary<string, object> dictionary, Type type, JSerializer 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(JSerializer.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(JSerializer.ServerTypeFieldName); } } JConverter 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); } // 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)); } var typeMapper = TypeMapper.Create(o.GetType()); foreach(string memberName in memberNames) { object propertyValue = dictionary[memberName]; // Assign the value into a property or field of the object if(!AssignToProperty(typeMapper, propertyValue, o, memberName, serializer, throwOnError)) { convertedObject = null; return false; } } convertedObject = o; return true; }
// Is this a type for which we want to instantiate based on the client stub internal static bool IsClientInstantiatableType(Type t, JSerializer serializer) { // Abstract classes and interfaces can't be instantiated // if(t == null || t.IsAbstract || t.IsInterface || t.IsArray) return false; // Even though 'object' is instantiatable, it is never useful to do this if(t == typeof(object)) return false; // Return true if a converter is registered for the given type, so the converter // can generate code on the client to instantiate it. JConverter converter = null; if(serializer.ConverterExistsForType(t, out converter)) { return true; } // Value types are okay (i.e. structs); if(t.IsValueType) { return true; } // Ignore types that don't have a public default ctor ConstructorInfo constructorInfo = t.GetConstructor(BindingFlags.Public | BindingFlags.Instance, null, s_emptyTypeArray, null); if(constructorInfo == null) return false; return true; }