Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / ndp / fx / src / xsp / System / Web / Extensions / Script / Serialization / ObjectConverter.cs / 1 / ObjectConverter.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Reflection;
using System.Web.Resources;
namespace System.Web.Script.Serialization {
internal static class ObjectConverter {
private static readonly Type[] s_emptyTypeArray = new Type[] { };
private static Type _listGenericType = typeof(List<>);
private static Type _enumerableGenericType = typeof(IEnumerable<>);
private static Type _dictionaryGenericType = typeof(Dictionary<,>);
private static Type _idictionaryGenericType = typeof(IDictionary<,>);
// Helper method that recursively convert individual items in the old array
private static bool AddItemToList(IList oldList, IList newList, Type elementType, JavaScriptSerializer serializer, bool throwOnError) {
object convertedObject;
foreach (Object propertyValue in oldList) {
if (!ConvertObjectToTypeMain(propertyValue, elementType, serializer, throwOnError, out convertedObject)) {
return false;
}
newList.Add(convertedObject);
}
return true;
}
// Helper method that assigns the propertyValue to object o's member (memberName)
private static bool AssignToPropertyOrField(object propertyValue, object o, string memberName, JavaScriptSerializer serializer, bool throwOnError) {
IDictionary dictionary = o as IDictionary;
// if o is already an idictionary, assign the value to the dictionary
if (dictionary != null) {
if (!ConvertObjectToTypeMain(propertyValue, null, serializer, throwOnError, out propertyValue)) {
return false;
}
dictionary[memberName] = propertyValue;
return true;
}
Type serverType = o.GetType();
// First, look for a property
PropertyInfo propInfo = serverType.GetProperty(memberName,
BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (propInfo != null) {
// Ignore it if the property has no setter
MethodInfo setter = propInfo.GetSetMethod();
if (setter != null) {
// Deserialize the property value, with knownledge of the property type
if (!ConvertObjectToTypeMain(propertyValue, propInfo.PropertyType, serializer, throwOnError, out propertyValue)) {
return false;
}
// Set the property in the object
try {
setter.Invoke(o, new Object[] { propertyValue });
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
return false;
}
}
}
}
// We couldn't find a property, so try a field
FieldInfo fieldInfo = serverType.GetField(memberName,
BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (fieldInfo != null) {
// Deserialize the field value, with knownledge of the field type
if (!ConvertObjectToTypeMain(propertyValue, fieldInfo.FieldType, serializer, throwOnError, out propertyValue)) {
return false;
}
// Set the field in the object
try {
fieldInfo.SetValue(o, propertyValue);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
return false;
}
}
}
// not a property or field, so it is ignored
return true;
}
// Method that converts an IDictionary to an object of the right type
private static bool ConvertDictionaryToObject(IDictionary 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 memberNames = new List(dictionary.Keys);
// Try to handle the IDictionary 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
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;
}
internal static object ConvertObjectToType(object o, Type type, JavaScriptSerializer serializer) {
object convertedObject;
ConvertObjectToTypeMain(o, type, serializer, true, out convertedObject);
return convertedObject;
}
private static bool ConvertObjectToTypeMain(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) {
// If it's null, there is nothing to convert
if (o == null) {
// need to special case Char, as we convert \0 to null
if (type == typeof(char)) {
convertedObject = '\0';
return true;
}
// Throw if its a value type and not a nullable
if (IsNonNullableValueType(type)) {
if (throwOnError) {
throw new InvalidOperationException(AtlasWeb.JSON_ValueTypeCannotBeNull);
}
else {
convertedObject = null;
return false;
}
}
convertedObject = null;
return true;
}
// simply return the current object if the current type is same as return type.
if (o.GetType() == type) {
convertedObject = o;
return true;
}
// otherwise use the converters to convert object into target type.
return ConvertObjectToTypeInternal(o, type, serializer, throwOnError, out convertedObject);
}
// Helper method that converts the object to the corresponding type using converters.
// Items in IDictionary and ArrayList needs to be converted as well.
// Note this method does not invoke the custom converter for deserialization.
private static bool ConvertObjectToTypeInternal(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) {
// First checks if the object is an IDictionary
IDictionary dictionary = o as IDictionary;
if (dictionary != null) {
return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject);
}
// If it is an IList try to convert it to the requested type.
IList list = o as IList;
if (list != null) {
IList convertedList;
if (ConvertListToObject(list, type, serializer, throwOnError, out convertedList)) {
convertedObject = convertedList;
return true;
}
else {
convertedObject = null;
return false;
}
}
// simply return the current object if
// 1) the caller does not specify the return type.
// 2) if the current type is same as return type.
if (type == null || o.GetType() == type) {
convertedObject = o;
return true;
}
// Otherwise use the type converter to convert the string to the target type.
TypeConverter converter = TypeDescriptor.GetConverter(type);
// Use the memberType's converter to directly conver if supported.
if (converter.CanConvertFrom(o.GetType())) {
try {
convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
convertedObject = null;
return false;
}
}
}
// Otherwise if the target type can be converted from a string
// 1. first use the propertyValue's converter to convert object to string,
// 2. then use the target converter to convert the string to target type.
if (converter.CanConvertFrom(typeof(String))) {
TypeConverter propertyConverter = TypeDescriptor.GetConverter(o);
try {
string s = propertyConverter.ConvertToInvariantString(o);
convertedObject = converter.ConvertFromInvariantString(s);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
convertedObject = null;
return false;
}
}
}
// We can't convert object o to the target type, but perhaps o can be
// assigned directly to type?
if (type.IsAssignableFrom(o.GetType())) {
convertedObject = o;
return true;
}
// Nothing works
if (throwOnError) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, o.GetType(), type));
}
else {
convertedObject = null;
return false;
}
}
// Method that converts client array to the request type. It handles the following cases:
// 1. type is not passed in - An ArrayList will be returned.
// 2. type is an array - An array of the right type will be returned.
// 3. type is an abstract collection interface, e.g. IEnumerable, ICollection -
// An ArrayList will be returned.
// 4. type is an generic abstract collection interface, e.g. IEnumerable -
// An List will be returned.
// 5. type is a concrete type that implements IList -
// The type will be instantiated and returned.
// Otherwise we throw InvalidOperationException.
private static bool ConvertListToObject(IList list, Type type, JavaScriptSerializer serializer, bool throwOnError, out IList convertedList) {
// Add the items into an ArrayList then convert to custom type when
// 1. Type is null or typeof(Object)
// 2. Type is an Array, in which case we call ArrayList.ToArray(type) or
// 3. Type is already an ArrayList
if (type == null || type == typeof(Object) || IsArrayListCompatible(type)) {
Type elementType = typeof(Object);
if (type != null && type != typeof(Object)) {
elementType = type.GetElementType();
}
ArrayList newList = new ArrayList();
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, elementType, serializer, throwOnError)) {
convertedList = null;
return false;
}
if (type == typeof(ArrayList) || type == typeof(IEnumerable) || type == typeof(IList) || type == typeof(ICollection)) {
convertedList = newList;
return true;
}
convertedList = newList.ToArray(elementType);
return true;
}
// Add the items into an List then convert to the custom generic type when
// 1. Type is a generic collection type
// 2. Type only has one generic parameter, eg. List vs MyCustom
// 3. Type implements IEnumerable
else if (type.IsGenericType &&
type.GetGenericArguments().Length == 1) {
// gets the T of List as the elementType
Type elementType = type.GetGenericArguments()[0];
// Get the strongly typed IEnumerable
Type strongTypedEnumerable = _enumerableGenericType.MakeGenericType(elementType);
// Make sure the custom type can be assigned to IEnumerable
if (strongTypedEnumerable.IsAssignableFrom(type)) {
// Get the strongly typed List
Type t = _listGenericType.MakeGenericType(elementType);
// Create the List instance or a MyList
IList newList = null;
if (IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type)) {
newList = (IList)Activator.CreateInstance(type);
}
else {
// If this is MyList and we can't assign to it, throw
if (t.IsAssignableFrom(type)) {
if (throwOnError) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_CannotCreateListType, type.FullName));
}
else {
convertedList = null;
return false;
}
}
newList = (IList)Activator.CreateInstance(t);
}
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, elementType, serializer, throwOnError)) {
convertedList = null;
return false;
}
convertedList = newList;
return true;
}
}
// If the custom type implements IList and it's instantiable. Use that type.
else if (IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type)) {
IList newList = (IList)Activator.CreateInstance(type);
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, null, serializer, throwOnError)) {
convertedList = null;
return false;
}
convertedList = newList;
return true;
}
if (throwOnError) {
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture, AtlasWeb.JSON_ArrayTypeNotSupported, type.FullName));
}
else {
convertedList = null;
return false;
}
}
private static bool IsArrayListCompatible(Type type) {
return type.IsArray || type == typeof(ArrayList) || type == typeof(IEnumerable) || type == typeof(IList) || type == typeof(ICollection);
}
// Is this a type for which we want to instantiate based on the client stub
internal static bool IsClientInstantiatableType(Type t, JavaScriptSerializer 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.
JavaScriptConverter 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;
}
// these helper methods replace inline code.
// they simplify the code and reduce our cyclomatic complexity
private static bool IsGenericDictionary(Type type) {
return type != null &&
type.IsGenericType &&
(typeof(IDictionary).IsAssignableFrom(type) || type.GetGenericTypeDefinition() == _idictionaryGenericType) &&
type.GetGenericArguments().Length == 2;
}
private static bool IsNonNullableValueType(Type type) {
// the the type a value type, and if it is, is it not the nullable variety
return type != null && type.IsValueType &&
!(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
}
internal static bool TryConvertObjectToType(object o, Type type, JavaScriptSerializer serializer, out object convertedObject) {
return ConvertObjectToTypeMain(o, type, serializer, false, out convertedObject);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Reflection;
using System.Web.Resources;
namespace System.Web.Script.Serialization {
internal static class ObjectConverter {
private static readonly Type[] s_emptyTypeArray = new Type[] { };
private static Type _listGenericType = typeof(List<>);
private static Type _enumerableGenericType = typeof(IEnumerable<>);
private static Type _dictionaryGenericType = typeof(Dictionary<,>);
private static Type _idictionaryGenericType = typeof(IDictionary<,>);
// Helper method that recursively convert individual items in the old array
private static bool AddItemToList(IList oldList, IList newList, Type elementType, JavaScriptSerializer serializer, bool throwOnError) {
object convertedObject;
foreach (Object propertyValue in oldList) {
if (!ConvertObjectToTypeMain(propertyValue, elementType, serializer, throwOnError, out convertedObject)) {
return false;
}
newList.Add(convertedObject);
}
return true;
}
// Helper method that assigns the propertyValue to object o's member (memberName)
private static bool AssignToPropertyOrField(object propertyValue, object o, string memberName, JavaScriptSerializer serializer, bool throwOnError) {
IDictionary dictionary = o as IDictionary;
// if o is already an idictionary, assign the value to the dictionary
if (dictionary != null) {
if (!ConvertObjectToTypeMain(propertyValue, null, serializer, throwOnError, out propertyValue)) {
return false;
}
dictionary[memberName] = propertyValue;
return true;
}
Type serverType = o.GetType();
// First, look for a property
PropertyInfo propInfo = serverType.GetProperty(memberName,
BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (propInfo != null) {
// Ignore it if the property has no setter
MethodInfo setter = propInfo.GetSetMethod();
if (setter != null) {
// Deserialize the property value, with knownledge of the property type
if (!ConvertObjectToTypeMain(propertyValue, propInfo.PropertyType, serializer, throwOnError, out propertyValue)) {
return false;
}
// Set the property in the object
try {
setter.Invoke(o, new Object[] { propertyValue });
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
return false;
}
}
}
}
// We couldn't find a property, so try a field
FieldInfo fieldInfo = serverType.GetField(memberName,
BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.Public);
if (fieldInfo != null) {
// Deserialize the field value, with knownledge of the field type
if (!ConvertObjectToTypeMain(propertyValue, fieldInfo.FieldType, serializer, throwOnError, out propertyValue)) {
return false;
}
// Set the field in the object
try {
fieldInfo.SetValue(o, propertyValue);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
return false;
}
}
}
// not a property or field, so it is ignored
return true;
}
// Method that converts an IDictionary to an object of the right type
private static bool ConvertDictionaryToObject(IDictionary 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 memberNames = new List(dictionary.Keys);
// Try to handle the IDictionary 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
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;
}
internal static object ConvertObjectToType(object o, Type type, JavaScriptSerializer serializer) {
object convertedObject;
ConvertObjectToTypeMain(o, type, serializer, true, out convertedObject);
return convertedObject;
}
private static bool ConvertObjectToTypeMain(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) {
// If it's null, there is nothing to convert
if (o == null) {
// need to special case Char, as we convert \0 to null
if (type == typeof(char)) {
convertedObject = '\0';
return true;
}
// Throw if its a value type and not a nullable
if (IsNonNullableValueType(type)) {
if (throwOnError) {
throw new InvalidOperationException(AtlasWeb.JSON_ValueTypeCannotBeNull);
}
else {
convertedObject = null;
return false;
}
}
convertedObject = null;
return true;
}
// simply return the current object if the current type is same as return type.
if (o.GetType() == type) {
convertedObject = o;
return true;
}
// otherwise use the converters to convert object into target type.
return ConvertObjectToTypeInternal(o, type, serializer, throwOnError, out convertedObject);
}
// Helper method that converts the object to the corresponding type using converters.
// Items in IDictionary and ArrayList needs to be converted as well.
// Note this method does not invoke the custom converter for deserialization.
private static bool ConvertObjectToTypeInternal(object o, Type type, JavaScriptSerializer serializer, bool throwOnError, out object convertedObject) {
// First checks if the object is an IDictionary
IDictionary dictionary = o as IDictionary;
if (dictionary != null) {
return ConvertDictionaryToObject(dictionary, type, serializer, throwOnError, out convertedObject);
}
// If it is an IList try to convert it to the requested type.
IList list = o as IList;
if (list != null) {
IList convertedList;
if (ConvertListToObject(list, type, serializer, throwOnError, out convertedList)) {
convertedObject = convertedList;
return true;
}
else {
convertedObject = null;
return false;
}
}
// simply return the current object if
// 1) the caller does not specify the return type.
// 2) if the current type is same as return type.
if (type == null || o.GetType() == type) {
convertedObject = o;
return true;
}
// Otherwise use the type converter to convert the string to the target type.
TypeConverter converter = TypeDescriptor.GetConverter(type);
// Use the memberType's converter to directly conver if supported.
if (converter.CanConvertFrom(o.GetType())) {
try {
convertedObject = converter.ConvertFrom(null, CultureInfo.InvariantCulture, o);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
convertedObject = null;
return false;
}
}
}
// Otherwise if the target type can be converted from a string
// 1. first use the propertyValue's converter to convert object to string,
// 2. then use the target converter to convert the string to target type.
if (converter.CanConvertFrom(typeof(String))) {
TypeConverter propertyConverter = TypeDescriptor.GetConverter(o);
try {
string s = propertyConverter.ConvertToInvariantString(o);
convertedObject = converter.ConvertFromInvariantString(s);
return true;
}
catch {
if (throwOnError) {
throw;
}
else {
convertedObject = null;
return false;
}
}
}
// We can't convert object o to the target type, but perhaps o can be
// assigned directly to type?
if (type.IsAssignableFrom(o.GetType())) {
convertedObject = o;
return true;
}
// Nothing works
if (throwOnError) {
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, AtlasWeb.JSON_CannotConvertObjectToType, o.GetType(), type));
}
else {
convertedObject = null;
return false;
}
}
// Method that converts client array to the request type. It handles the following cases:
// 1. type is not passed in - An ArrayList will be returned.
// 2. type is an array - An array of the right type will be returned.
// 3. type is an abstract collection interface, e.g. IEnumerable, ICollection -
// An ArrayList will be returned.
// 4. type is an generic abstract collection interface, e.g. IEnumerable -
// An List will be returned.
// 5. type is a concrete type that implements IList -
// The type will be instantiated and returned.
// Otherwise we throw InvalidOperationException.
private static bool ConvertListToObject(IList list, Type type, JavaScriptSerializer serializer, bool throwOnError, out IList convertedList) {
// Add the items into an ArrayList then convert to custom type when
// 1. Type is null or typeof(Object)
// 2. Type is an Array, in which case we call ArrayList.ToArray(type) or
// 3. Type is already an ArrayList
if (type == null || type == typeof(Object) || IsArrayListCompatible(type)) {
Type elementType = typeof(Object);
if (type != null && type != typeof(Object)) {
elementType = type.GetElementType();
}
ArrayList newList = new ArrayList();
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, elementType, serializer, throwOnError)) {
convertedList = null;
return false;
}
if (type == typeof(ArrayList) || type == typeof(IEnumerable) || type == typeof(IList) || type == typeof(ICollection)) {
convertedList = newList;
return true;
}
convertedList = newList.ToArray(elementType);
return true;
}
// Add the items into an List then convert to the custom generic type when
// 1. Type is a generic collection type
// 2. Type only has one generic parameter, eg. List vs MyCustom
// 3. Type implements IEnumerable
else if (type.IsGenericType &&
type.GetGenericArguments().Length == 1) {
// gets the T of List as the elementType
Type elementType = type.GetGenericArguments()[0];
// Get the strongly typed IEnumerable
Type strongTypedEnumerable = _enumerableGenericType.MakeGenericType(elementType);
// Make sure the custom type can be assigned to IEnumerable
if (strongTypedEnumerable.IsAssignableFrom(type)) {
// Get the strongly typed List
Type t = _listGenericType.MakeGenericType(elementType);
// Create the List instance or a MyList
IList newList = null;
if (IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type)) {
newList = (IList)Activator.CreateInstance(type);
}
else {
// If this is MyList and we can't assign to it, throw
if (t.IsAssignableFrom(type)) {
if (throwOnError) {
throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, AtlasWeb.JSON_CannotCreateListType, type.FullName));
}
else {
convertedList = null;
return false;
}
}
newList = (IList)Activator.CreateInstance(t);
}
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, elementType, serializer, throwOnError)) {
convertedList = null;
return false;
}
convertedList = newList;
return true;
}
}
// If the custom type implements IList and it's instantiable. Use that type.
else if (IsClientInstantiatableType(type, serializer) && typeof(IList).IsAssignableFrom(type)) {
IList newList = (IList)Activator.CreateInstance(type);
// Add the items to the new List and recursive into each item.
if (!AddItemToList(list, newList, null, serializer, throwOnError)) {
convertedList = null;
return false;
}
convertedList = newList;
return true;
}
if (throwOnError) {
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture, AtlasWeb.JSON_ArrayTypeNotSupported, type.FullName));
}
else {
convertedList = null;
return false;
}
}
private static bool IsArrayListCompatible(Type type) {
return type.IsArray || type == typeof(ArrayList) || type == typeof(IEnumerable) || type == typeof(IList) || type == typeof(ICollection);
}
// Is this a type for which we want to instantiate based on the client stub
internal static bool IsClientInstantiatableType(Type t, JavaScriptSerializer 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.
JavaScriptConverter 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;
}
// these helper methods replace inline code.
// they simplify the code and reduce our cyclomatic complexity
private static bool IsGenericDictionary(Type type) {
return type != null &&
type.IsGenericType &&
(typeof(IDictionary).IsAssignableFrom(type) || type.GetGenericTypeDefinition() == _idictionaryGenericType) &&
type.GetGenericArguments().Length == 2;
}
private static bool IsNonNullableValueType(Type type) {
// the the type a value type, and if it is, is it not the nullable variety
return type != null && type.IsValueType &&
!(type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>));
}
internal static bool TryConvertObjectToType(object o, Type type, JavaScriptSerializer serializer, out object convertedObject) {
return ConvertObjectToTypeMain(o, type, serializer, false, out convertedObject);
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SerializationSectionGroup.cs
- StateMachine.cs
- Decorator.cs
- ObjectStateManagerMetadata.cs
- OutArgumentConverter.cs
- BaseHashHelper.cs
- ProxyElement.cs
- ClipboardData.cs
- DependencyObjectProvider.cs
- tibetanshape.cs
- IdleTimeoutMonitor.cs
- Margins.cs
- ContentPathSegment.cs
- HealthMonitoringSection.cs
- MultiTrigger.cs
- ColorMatrix.cs
- TreeViewItemAutomationPeer.cs
- SQLStringStorage.cs
- FlowLayoutPanelDesigner.cs
- RegionIterator.cs
- FormsIdentity.cs
- StreamResourceInfo.cs
- NavigationEventArgs.cs
- WebPartExportVerb.cs
- GeometryConverter.cs
- BufferedStream.cs
- TextEffect.cs
- DataSourceListEditor.cs
- ForwardPositionQuery.cs
- IfJoinedCondition.cs
- ElementHostPropertyMap.cs
- DataServiceClientException.cs
- SqlDataSourceConfigureSortForm.cs
- XamlReaderHelper.cs
- ComponentDispatcherThread.cs
- UpdateProgress.cs
- QilCloneVisitor.cs
- FontFamilyIdentifier.cs
- Int32AnimationUsingKeyFrames.cs
- SettingsPropertyValueCollection.cs
- Schedule.cs
- RectAnimationBase.cs
- StorageAssociationTypeMapping.cs
- TagPrefixCollection.cs
- AsyncCompletedEventArgs.cs
- ServiceModelEnhancedConfigurationElementCollection.cs
- HideDisabledControlAdapter.cs
- PageTheme.cs
- BitStream.cs
- Attributes.cs
- UserControlCodeDomTreeGenerator.cs
- DataSet.cs
- HttpBrowserCapabilitiesWrapper.cs
- UserPreferenceChangedEventArgs.cs
- XmlSchemaAttributeGroupRef.cs
- ConnectionStringsExpressionBuilder.cs
- ExpandCollapsePattern.cs
- IntellisenseTextBox.designer.cs
- TripleDES.cs
- GridViewDeletedEventArgs.cs
- XmlILIndex.cs
- EntityCollection.cs
- BitmapEffect.cs
- XmlWrappingReader.cs
- ObjectDataSourceMethodEventArgs.cs
- CompareInfo.cs
- KeyboardInputProviderAcquireFocusEventArgs.cs
- FontClient.cs
- ControlBuilder.cs
- RootContext.cs
- DesignerVerbCollection.cs
- HandlerBase.cs
- XamlTreeBuilderBamlRecordWriter.cs
- GridView.cs
- XmlSchemaSimpleType.cs
- PriorityBinding.cs
- NeutralResourcesLanguageAttribute.cs
- EventWaitHandle.cs
- ConditionValidator.cs
- EntityDataSourceDesigner.cs
- JavaScriptString.cs
- VScrollProperties.cs
- filewebresponse.cs
- WebRequestModuleElementCollection.cs
- WorkflowMarkupSerializer.cs
- RadioButtonPopupAdapter.cs
- ComboBox.cs
- SecurityCookieModeValidator.cs
- CategoryAttribute.cs
- StyleXamlTreeBuilder.cs
- ElementNotAvailableException.cs
- DataPointer.cs
- Parallel.cs
- MemberExpression.cs
- BaseTemplateCodeDomTreeGenerator.cs
- QueryGenerator.cs
- IFlowDocumentViewer.cs
- PreProcessInputEventArgs.cs
- ProtectedConfiguration.cs
- LongTypeConverter.cs