private static ConvertResult TryConvertInternal(object initialValue, CultureInfo culture, Type targetType, out object value) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type initialType = initialValue.GetType(); if (targetType == initialType) { value = initialValue; return(ConvertResult.Success); } // use Convert.ChangeType if both types are IConvertible if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { value = Enum.Parse(targetType, initialValue.ToString(), true); return(ConvertResult.Success); } else if (IsInteger(initialValue)) { value = Enum.ToObject(targetType, initialValue); return(ConvertResult.Success); } } value = System.Convert.ChangeType(initialValue, targetType, culture); return(ConvertResult.Success); } #if !NET20 if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { value = new DateTimeOffset((DateTime)initialValue); return(ConvertResult.Success); } #endif if (initialValue is byte[] && targetType == typeof(Guid)) { value = new Guid((byte[])initialValue); return(ConvertResult.Success); } if (initialValue is Guid && targetType == typeof(byte[])) { value = ((Guid)initialValue).ToByteArray(); return(ConvertResult.Success); } string s = initialValue as string; if (s != null) { if (targetType == typeof(Guid)) { value = new Guid(s); return(ConvertResult.Success); } if (targetType == typeof(Uri)) { value = new Uri(s, UriKind.RelativeOrAbsolute); return(ConvertResult.Success); } if (targetType == typeof(TimeSpan)) { value = ParseTimeSpan(s); return(ConvertResult.Success); } if (targetType == typeof(byte[])) { value = System.Convert.FromBase64String(s); return(ConvertResult.Success); } if (targetType == typeof(Version)) { Version result; if (VersionTryParse(s, out result)) { value = result; return(ConvertResult.Success); } value = null; return(ConvertResult.NoValidConversion); } if (typeof(Type).IsAssignableFrom(targetType)) { value = Type.GetType(s, true); return(ConvertResult.Success); } } #if !(NET20 || NET35 || PORTABLE40 || PORTABLE) if (targetType == typeof(BigInteger)) { value = ToBigInteger(initialValue); return(ConvertResult.Success); } if (initialValue is BigInteger) { value = FromBigInteger((BigInteger)initialValue, targetType); return(ConvertResult.Success); } #endif #if !(PORTABLE40 || PORTABLE) // see if source or target types have a TypeConverter that converts between the two TypeConverter toConverter = GetConverter(initialType); if (toConverter != null && toConverter.CanConvertTo(targetType)) { value = toConverter.ConvertTo(null, culture, initialValue, targetType); return(ConvertResult.Success); } TypeConverter fromConverter = GetConverter(targetType); if (fromConverter != null && fromConverter.CanConvertFrom(initialType)) { value = fromConverter.ConvertFrom(null, culture, initialValue); return(ConvertResult.Success); } #endif #if !(DOTNET || PORTABLE40 || PORTABLE) // handle DBNull and INullable if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { value = EnsureTypeAssignable(null, initialType, targetType); return(ConvertResult.Success); } // cannot convert null to non-nullable value = null; return(ConvertResult.CannotConvertNull); } #endif #if !(DOTNET || PORTABLE40 || PORTABLE) if (initialValue is INullable) { value = EnsureTypeAssignable(ToValue((INullable)initialValue), initialType, targetType); return(ConvertResult.Success); } #endif if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract()) { value = null; return(ConvertResult.NotInstantiableType); } value = null; return(ConvertResult.NoValidConversion); }
/// <summary> /// Converts the value to the specified type. /// </summary> /// <param name="initialValue">The value to convert.</param> /// <param name="culture">The culture to use when converting.</param> /// <param name="targetType">The type to convert the value to.</param> /// <returns>The converted type.</returns> public static object Convert(object initialValue, CultureInfo culture, Type targetType) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type initialType = initialValue.GetType(); if (targetType == initialType) { return(initialValue); } if (initialValue is string && typeof(Type).IsAssignableFrom(targetType)) { return(Type.GetType((string)initialValue, true)); } if (targetType.IsInterface || targetType.IsGenericTypeDefinition || targetType.IsAbstract) { throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), "targetType"); } // use Convert.ChangeType if both types are IConvertible if (initialValue is IConvertible && typeof(IConvertible).IsAssignableFrom(targetType)) { if (targetType.IsEnum) { if (initialValue is string) { return(Enum.Parse(targetType, initialValue.ToString(), true)); } else if (IsInteger(initialValue)) { return(Enum.ToObject(targetType, initialValue)); } } return(System.Convert.ChangeType(initialValue, targetType, culture)); } if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { return(new DateTimeOffset((DateTime)initialValue)); } if (initialValue is string) { if (targetType == typeof(Guid)) { return(new Guid((string)initialValue)); } if (targetType == typeof(Uri)) { return(new Uri((string)initialValue)); } if (targetType == typeof(TimeSpan)) { return(TimeSpan.Parse((string)initialValue)); } } #if !(UNITY_WP8 || UNITY_WP_8_1) // see if source or target types have a TypeConverter that converts between the two TypeConverter toConverter = GetConverter(initialType); if (toConverter != null && toConverter.CanConvertTo(targetType)) { #if !(UNITY_WP8 || UNITY_WP_8_1) return(toConverter.ConvertTo(null, culture, initialValue, targetType)); #else return(toConverter.ConvertTo(initialValue, targetType)); #endif } TypeConverter fromConverter = GetConverter(targetType); if (fromConverter != null && fromConverter.CanConvertFrom(initialType)) { #if !(UNITY_WP8 || UNITY_WP_8_1) return(fromConverter.ConvertFrom(null, culture, initialValue)); #else return(fromConverter.ConvertFrom(initialValue)); #endif } #endif // handle DBNull and INullable if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { return(EnsureTypeAssignable(null, initialType, targetType)); } throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType)); } throw new Exception("Can not convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType)); }
public static object GetDefaultValue(Type type) { if (!type.IsValueType()) { return(null); } PrimitiveTypeCode typeCode = ConvertUtils.GetTypeCode(type); switch (typeCode) { case PrimitiveTypeCode.Char: case PrimitiveTypeCode.SByte: case PrimitiveTypeCode.Int16: case PrimitiveTypeCode.UInt16: case PrimitiveTypeCode.Int32: case PrimitiveTypeCode.Byte: case PrimitiveTypeCode.UInt32: return(0); case PrimitiveTypeCode.CharNullable: case PrimitiveTypeCode.BooleanNullable: case PrimitiveTypeCode.SByteNullable: case PrimitiveTypeCode.Int16Nullable: case PrimitiveTypeCode.UInt16Nullable: case PrimitiveTypeCode.Int32Nullable: case PrimitiveTypeCode.ByteNullable: case PrimitiveTypeCode.UInt32Nullable: case PrimitiveTypeCode.Int64Nullable: case PrimitiveTypeCode.UInt64Nullable: case PrimitiveTypeCode.SingleNullable: case PrimitiveTypeCode.DoubleNullable: case PrimitiveTypeCode.DateTimeNullable: case PrimitiveTypeCode.DateTimeOffsetNullable: case PrimitiveTypeCode.DecimalNullable: break; case PrimitiveTypeCode.Boolean: return(false); case PrimitiveTypeCode.Int64: case PrimitiveTypeCode.UInt64: return(0L); case PrimitiveTypeCode.Single: return(0f); case PrimitiveTypeCode.Double: return(0.0); case PrimitiveTypeCode.DateTime: return(default(DateTime)); case PrimitiveTypeCode.DateTimeOffset: return(default(DateTimeOffset)); case PrimitiveTypeCode.Decimal: return(0m); case PrimitiveTypeCode.Guid: return(default(Guid)); default: if (typeCode == PrimitiveTypeCode.BigInteger) { return(default(BigInteger)); } break; } if (ReflectionUtils.IsNullable(type)) { return(null); } return(Activator.CreateInstance(type)); }
/// <summary> /// Converts the value to the specified type. /// </summary> /// <param name="initialValue">The value to convert.</param> /// <param name="culture">The culture to use when converting.</param> /// <param name="targetType">The type to convert the value to.</param> /// <returns>The converted type.</returns> public static object Convert(object initialValue, CultureInfo culture, Type targetType) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type initialType = initialValue.GetType(); if (targetType == initialType) { return(initialValue); } // use Convert.ChangeType if both types are IConvertible if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { return(Enum.Parse(targetType, initialValue.ToString(), true)); } else if (IsInteger(initialValue)) { return(Enum.ToObject(targetType, initialValue)); } } return(System.Convert.ChangeType(initialValue, targetType, culture)); } #if !NET20 if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { return(new DateTimeOffset((DateTime)initialValue)); } #endif if (initialValue is byte[] && targetType == typeof(Guid)) { return(new Guid((byte[])initialValue)); } if (initialValue is string) { if (targetType == typeof(Guid)) { return(new Guid((string)initialValue)); } if (targetType == typeof(Uri)) { return(new Uri((string)initialValue, UriKind.RelativeOrAbsolute)); } if (targetType == typeof(TimeSpan)) { return(ParseTimeSpan((string)initialValue)); } if (typeof(Type).IsAssignableFrom(targetType)) { return(Type.GetType((string)initialValue, true)); } } #if !(NET20 || NET35 || SILVERLIGHT || PORTABLE40 || PORTABLE) if (targetType == typeof(BigInteger)) { return(ToBigInteger(initialValue)); } if (initialValue is BigInteger) { return(FromBigInteger((BigInteger)initialValue, targetType)); } #endif #if !(NETFX_CORE || PORTABLE40 || PORTABLE) // see if source or target types have a TypeConverter that converts between the two TypeConverter toConverter = GetConverter(initialType); if (toConverter != null && toConverter.CanConvertTo(targetType)) { #if !SILVERLIGHT return(toConverter.ConvertTo(null, culture, initialValue, targetType)); #else return(toConverter.ConvertTo(initialValue, targetType)); #endif } TypeConverter fromConverter = GetConverter(targetType); if (fromConverter != null && fromConverter.CanConvertFrom(initialType)) { #if !SILVERLIGHT return(fromConverter.ConvertFrom(null, culture, initialValue)); #else return(fromConverter.ConvertFrom(initialValue)); #endif } #endif #if !(NETFX_CORE || PORTABLE40 || PORTABLE) // handle DBNull and INullable if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { return(EnsureTypeAssignable(null, initialType, targetType)); } throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType)); } #endif #if !(SILVERLIGHT || NETFX_CORE || PORTABLE40 || PORTABLE) if (initialValue is INullable) { return(EnsureTypeAssignable(ToValue((INullable)initialValue), initialType, targetType)); } #endif if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract()) { throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), "targetType"); } throw new InvalidOperationException("Can not convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, initialType, targetType)); }
public static bool CanConvertType(Type initialType, Type targetType, bool allowTypeNameToString) { ValidationUtils.ArgumentNotNull(initialType, "initialType"); ValidationUtils.ArgumentNotNull(targetType, "targetType"); if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } if (targetType == initialType) { return(true); } if (typeof(IConvertible).IsAssignableFrom(initialType) && typeof(IConvertible).IsAssignableFrom(targetType)) { return(true); } if (initialType == typeof(DateTime) && targetType == typeof(DateTimeOffset)) { return(true); } if (initialType == typeof(Guid) && (targetType == typeof(Guid) || targetType == typeof(string))) { return(true); } if (initialType == typeof(Type) && targetType == typeof(string)) { return(true); } #if !(UNITY_WP8 || UNITY_WP_8_1) // see if source or target types have a TypeConverter that converts between the two TypeConverter toConverter = GetConverter(initialType); if (toConverter != null && !IsComponentConverter(toConverter) && toConverter.CanConvertTo(targetType)) { if (allowTypeNameToString || toConverter.GetType() != typeof(TypeConverter)) { return(true); } } TypeConverter fromConverter = GetConverter(targetType); if (fromConverter != null && !IsComponentConverter(fromConverter) && fromConverter.CanConvertFrom(initialType)) { return(true); } #endif // handle DBNull and INullable if (initialType == typeof(DBNull)) { if (ReflectionUtils.IsNullable(targetType)) { return(true); } } return(false); }
public static object Convert(object initialValue, CultureInfo culture, Type targetType) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { return(initialValue); } if (ConvertUtils.IsConvertible(initialValue) && ConvertUtils.IsConvertible(targetType)) { if (TypeExtensions.IsEnum(targetType)) { if (initialValue is string) { return(Enum.Parse(targetType, initialValue.ToString(), true)); } if (ConvertUtils.IsInteger(initialValue)) { return(Enum.ToObject(targetType, initialValue)); } } return(Convert.ChangeType(initialValue, targetType, (IFormatProvider)culture)); } else { if (initialValue is string && typeof(Type).IsAssignableFrom(targetType)) { return((object)Type.GetType((string)initialValue, true)); } if (TypeExtensions.IsInterface(targetType) || TypeExtensions.IsGenericTypeDefinition(targetType) || TypeExtensions.IsAbstract(targetType)) { throw new ArgumentException(StringUtils.FormatWith("Target type {0} is not a value type or a non-abstract class.", (IFormatProvider)CultureInfo.InvariantCulture, (object)targetType), "targetType"); } if (initialValue is string) { if (targetType == typeof(Guid)) { return((object)new Guid((string)initialValue)); } if (targetType == typeof(Uri)) { return((object)new Uri((string)initialValue, UriKind.RelativeOrAbsolute)); } if (targetType == typeof(TimeSpan)) { return((object)TimeSpan.Parse((string)initialValue)); } } TypeConverter converter1 = ConvertUtils.GetConverter(type); if (converter1 != null && converter1.CanConvertTo(targetType)) { return(converter1.ConvertTo((ITypeDescriptorContext)null, culture, initialValue, targetType)); } TypeConverter converter2 = ConvertUtils.GetConverter(targetType); if (converter2 != null && converter2.CanConvertFrom(type)) { return(converter2.ConvertFrom((ITypeDescriptorContext)null, culture, initialValue)); } if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { return(ConvertUtils.EnsureTypeAssignable((object)null, type, targetType)); } else { throw new Exception(StringUtils.FormatWith("Can not convert null {0} into non-nullable {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)type, (object)targetType)); } } else if (initialValue is INullable) { return(ConvertUtils.EnsureTypeAssignable(ConvertUtils.ToValue((INullable)initialValue), type, targetType)); } else { throw new InvalidOperationException(StringUtils.FormatWith("Can not convert from {0} to {1}.", (IFormatProvider)CultureInfo.InvariantCulture, (object)type, (object)targetType)); } } }
private static ConvertUtils.ConvertResult TryConvertInternal(object initialValue, CultureInfo culture, Type targetType, out object value) { Version version; if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { value = initialValue; return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { value = Enum.Parse(targetType, initialValue.ToString(), true); return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsInteger(initialValue)) { value = Enum.ToObject(targetType, initialValue); return(ConvertUtils.ConvertResult.Success); } } value = Convert.ChangeType(initialValue, targetType, culture); return(ConvertUtils.ConvertResult.Success); } object obj = initialValue; object obj1 = obj; if (obj is DateTime) { DateTime dateTime = (DateTime)obj1; if (targetType == typeof(DateTimeOffset)) { value = new DateTimeOffset(dateTime); return(ConvertUtils.ConvertResult.Success); } } byte[] numArray = initialValue as byte[]; byte[] numArray1 = numArray; if (numArray != null && targetType == typeof(Guid)) { value = new Guid(numArray1); return(ConvertUtils.ConvertResult.Success); } object obj2 = initialValue; obj1 = obj2; if (obj2 is Guid) { Guid guid = (Guid)obj1; if (targetType == typeof(byte[])) { value = guid.ToByteArray(); return(ConvertUtils.ConvertResult.Success); } } string str = initialValue as string; string str1 = str; if (str != null) { if (targetType == typeof(Guid)) { value = new Guid(str1); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Uri)) { value = new Uri(str1, UriKind.RelativeOrAbsolute); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(TimeSpan)) { value = ConvertUtils.ParseTimeSpan(str1); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(byte[])) { value = Convert.FromBase64String(str1); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Version)) { if (Version.TryParse(str1, out version)) { value = version; return(ConvertUtils.ConvertResult.Success); } value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } if (typeof(Type).IsAssignableFrom(targetType)) { value = Type.GetType(str1, true); return(ConvertUtils.ConvertResult.Success); } } if (targetType == typeof(BigInteger)) { value = ConvertUtils.ToBigInteger(initialValue); return(ConvertUtils.ConvertResult.Success); } object obj3 = initialValue; obj1 = obj3; if (obj3 is BigInteger) { value = ConvertUtils.FromBigInteger((BigInteger)obj1, targetType); return(ConvertUtils.ConvertResult.Success); } TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertTo(targetType)) { value = converter.ConvertTo(null, culture, initialValue, targetType); return(ConvertUtils.ConvertResult.Success); } TypeConverter typeConverter = TypeDescriptor.GetConverter(targetType); if (typeConverter != null && typeConverter.CanConvertFrom(type)) { value = typeConverter.ConvertFrom(null, culture, initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue == DBNull.Value) { if (!ReflectionUtils.IsNullable(targetType)) { value = null; return(ConvertUtils.ConvertResult.CannotConvertNull); } value = ConvertUtils.EnsureTypeAssignable(null, type, targetType); return(ConvertUtils.ConvertResult.Success); } if (!targetType.IsInterface() && !targetType.IsGenericTypeDefinition() && !targetType.IsAbstract()) { value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } value = null; return(ConvertUtils.ConvertResult.NotInstantiableType); }
// Token: 0x06000CFA RID: 3322 RVA: 0x0004A7F8 File Offset: 0x000489F8 private static ConvertUtils.ConvertResult TryConvertInternal([Nullable(2)] object initialValue, CultureInfo culture, Type targetType, [Nullable(2)] out object value) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { value = initialValue; return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { value = Enum.Parse(targetType, initialValue.ToString(), true); return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsInteger(initialValue)) { value = Enum.ToObject(targetType, initialValue); return(ConvertUtils.ConvertResult.Success); } } value = System.Convert.ChangeType(initialValue, targetType, culture); return(ConvertUtils.ConvertResult.Success); } if (initialValue is DateTime) { DateTime dateTime = (DateTime)initialValue; if (targetType == typeof(DateTimeOffset)) { value = new DateTimeOffset(dateTime); return(ConvertUtils.ConvertResult.Success); } } byte[] array = initialValue as byte[]; if (array != null && targetType == typeof(Guid)) { value = new Guid(array); return(ConvertUtils.ConvertResult.Success); } if (initialValue is Guid) { Guid guid = (Guid)initialValue; if (targetType == typeof(byte[])) { value = guid.ToByteArray(); return(ConvertUtils.ConvertResult.Success); } } string text = initialValue as string; if (text != null) { if (targetType == typeof(Guid)) { value = new Guid(text); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Uri)) { value = new Uri(text, UriKind.RelativeOrAbsolute); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(TimeSpan)) { value = ConvertUtils.ParseTimeSpan(text); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(byte[])) { value = System.Convert.FromBase64String(text); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Version)) { Version version; if (ConvertUtils.VersionTryParse(text, out version)) { value = version; return(ConvertUtils.ConvertResult.Success); } value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } else if (typeof(Type).IsAssignableFrom(targetType)) { value = Type.GetType(text, true); return(ConvertUtils.ConvertResult.Success); } } if (targetType == typeof(System.Numerics.BigInteger)) { value = ConvertUtils.ToBigInteger(initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue is System.Numerics.BigInteger) { System.Numerics.BigInteger i = (System.Numerics.BigInteger)initialValue; value = ConvertUtils.FromBigInteger(i, targetType); return(ConvertUtils.ConvertResult.Success); } TypeConverter converter = TypeDescriptor.GetConverter(type); if (converter != null && converter.CanConvertTo(targetType)) { value = converter.ConvertTo(null, culture, initialValue, targetType); return(ConvertUtils.ConvertResult.Success); } TypeConverter converter2 = TypeDescriptor.GetConverter(targetType); if (converter2 != null && converter2.CanConvertFrom(type)) { value = converter2.ConvertFrom(null, culture, initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { value = ConvertUtils.EnsureTypeAssignable(null, type, targetType); return(ConvertUtils.ConvertResult.Success); } value = null; return(ConvertUtils.ConvertResult.CannotConvertNull); } else { if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract()) { value = null; return(ConvertUtils.ConvertResult.NotInstantiableType); } value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } }
public static bool CanConvertType(Type initialType, Type targetType, bool allowTypeNameToString) { ValidationUtils.ArgumentNotNull(initialType, "initialType"); ValidationUtils.ArgumentNotNull(targetType, "targetType"); if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } if (targetType == initialType) { return(true); } if (typeof(IConvertible).IsAssignableFrom(initialType) && typeof(IConvertible).IsAssignableFrom(targetType)) { return(true); } if (initialType == typeof(DateTime) && targetType == typeof(DateTimeOffset)) { return(true); } if (initialType == typeof(Guid) && (targetType == typeof(Guid) || targetType == typeof(string))) { return(true); } if (initialType == typeof(Type) && targetType == typeof(string)) { return(true); } TypeConverter converter = ConvertUtils.GetConverter(initialType); if (converter != null && !ConvertUtils.IsComponentConverter(converter) && converter.CanConvertTo(targetType) && (allowTypeNameToString || converter.GetType() != typeof(TypeConverter))) { return(true); } TypeConverter converter2 = ConvertUtils.GetConverter(targetType); return((converter2 != null && !ConvertUtils.IsComponentConverter(converter2) && converter2.CanConvertFrom(initialType)) || (initialType == typeof(DBNull) && ReflectionUtils.IsNullable(targetType))); }
public static object Convert(object initialValue, CultureInfo culture, Type targetType) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { return(initialValue); } if (initialValue is string && typeof(Type).IsAssignableFrom(targetType)) { return(Type.GetType((string)initialValue, true)); } if (targetType.get_IsInterface() || targetType.get_IsGenericTypeDefinition() || targetType.get_IsAbstract()) { throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { targetType }), "targetType"); } if (initialValue is IConvertible && typeof(IConvertible).IsAssignableFrom(targetType)) { if (targetType.get_IsEnum()) { if (initialValue is string) { return(Enum.Parse(targetType, initialValue.ToString(), true)); } if (ConvertUtils.IsInteger(initialValue)) { return(Enum.ToObject(targetType, initialValue)); } } return(System.Convert.ChangeType(initialValue, targetType, culture)); } if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { return(new DateTimeOffset((DateTime)initialValue)); } if (initialValue is string) { if (targetType == typeof(Guid)) { return(new Guid((string)initialValue)); } if (targetType == typeof(Uri)) { return(new Uri((string)initialValue)); } if (targetType == typeof(TimeSpan)) { return(TimeSpan.Parse((string)initialValue)); } } TypeConverter converter = ConvertUtils.GetConverter(type); if (converter != null && converter.CanConvertTo(targetType)) { return(converter.ConvertTo(null, culture, initialValue, targetType)); } TypeConverter converter2 = ConvertUtils.GetConverter(targetType); if (converter2 != null && converter2.CanConvertFrom(type)) { return(converter2.ConvertFrom(null, culture, initialValue)); } if (initialValue != DBNull.Value) { throw new Exception("Can not convert from {0} to {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { type, targetType })); } if (ReflectionUtils.IsNullable(targetType)) { return(ConvertUtils.EnsureTypeAssignable(null, type, targetType)); } throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.get_InvariantCulture(), new object[] { type, targetType })); }
private static ConvertUtils.ConvertResult TryConvertInternal(object initialValue, CultureInfo culture, Type targetType, out object value) { Version version; if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { value = initialValue; return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { value = Enum.Parse(targetType, initialValue.ToString(), true); return(ConvertUtils.ConvertResult.Success); } if (ConvertUtils.IsInteger(initialValue)) { value = Enum.ToObject(targetType, initialValue); return(ConvertUtils.ConvertResult.Success); } } value = Convert.ChangeType(initialValue, targetType, culture); return(ConvertUtils.ConvertResult.Success); } if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { value = new DateTimeOffset((DateTime)initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue is byte[] && targetType == typeof(Guid)) { value = new Guid((byte[])initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue is Guid && targetType == typeof(byte[])) { value = ((Guid)initialValue).ToByteArray(); return(ConvertUtils.ConvertResult.Success); } string str = initialValue as string; if (str != null) { if (targetType == typeof(Guid)) { value = new Guid(str); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Uri)) { value = new Uri(str, UriKind.RelativeOrAbsolute); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(TimeSpan)) { value = ConvertUtils.ParseTimeSpan(str); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(byte[])) { value = Convert.FromBase64String(str); return(ConvertUtils.ConvertResult.Success); } if (targetType == typeof(Version)) { if (ConvertUtils.VersionTryParse(str, out version)) { value = version; return(ConvertUtils.ConvertResult.Success); } value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } if (typeof(Type).IsAssignableFrom(targetType)) { value = Type.GetType(str, true); return(ConvertUtils.ConvertResult.Success); } } TypeConverter converter = ConvertUtils.GetConverter(type); if (converter != null && converter.CanConvertTo(targetType)) { value = converter.ConvertTo(null, culture, initialValue, targetType); return(ConvertUtils.ConvertResult.Success); } TypeConverter typeConverter = ConvertUtils.GetConverter(targetType); if (typeConverter != null && typeConverter.CanConvertFrom(type)) { value = typeConverter.ConvertFrom(null, culture, initialValue); return(ConvertUtils.ConvertResult.Success); } if (initialValue == DBNull.Value) { if (!ReflectionUtils.IsNullable(targetType)) { value = null; return(ConvertUtils.ConvertResult.CannotConvertNull); } value = ConvertUtils.EnsureTypeAssignable(null, type, targetType); return(ConvertUtils.ConvertResult.Success); } if (!targetType.IsInterface() && !targetType.IsGenericTypeDefinition() && !targetType.IsAbstract()) { value = null; return(ConvertUtils.ConvertResult.NoValidConversion); } value = null; return(ConvertUtils.ConvertResult.NotInstantiableType); }
public static object Convert(object initialValue, CultureInfo culture, Type targetType) { if (initialValue == null) { throw new ArgumentNullException("initialValue"); } if (ReflectionUtils.IsNullableType(targetType)) { targetType = Nullable.GetUnderlyingType(targetType); } Type type = initialValue.GetType(); if (targetType == type) { return(initialValue); } if (ConvertUtils.IsConvertible(initialValue.GetType()) && ConvertUtils.IsConvertible(targetType)) { if (targetType.IsEnum()) { if (initialValue is string) { return(Enum.Parse(targetType, initialValue.ToString(), true)); } if (ConvertUtils.IsInteger(initialValue)) { return(Enum.ToObject(targetType, initialValue)); } } return(System.Convert.ChangeType(initialValue, targetType, culture)); } if (initialValue is DateTime && targetType == typeof(DateTimeOffset)) { return(new DateTimeOffset((DateTime)initialValue)); } if (initialValue is byte[] && targetType == typeof(Guid)) { return(new Guid((byte[])initialValue)); } if (initialValue is string) { if (targetType == typeof(Guid)) { return(new Guid((string)initialValue)); } if (targetType == typeof(Uri)) { return(new Uri((string)initialValue, UriKind.RelativeOrAbsolute)); } if (targetType == typeof(TimeSpan)) { return(ConvertUtils.ParseTimeSpan((string)initialValue)); } if (targetType == typeof(byte[])) { return(System.Convert.FromBase64String((string)initialValue)); } if (typeof(Type).IsAssignableFrom(targetType)) { return(Type.GetType((string)initialValue, true)); } } if (targetType == typeof(BigInteger)) { return(ConvertUtils.ToBigInteger(initialValue)); } if (initialValue is BigInteger) { return(ConvertUtils.FromBigInteger((BigInteger)initialValue, targetType)); } TypeConverter converter = ConvertUtils.GetConverter(type); if (converter != null && converter.CanConvertTo(targetType)) { return(converter.ConvertTo(null, culture, initialValue, targetType)); } TypeConverter converter2 = ConvertUtils.GetConverter(targetType); if (converter2 != null && converter2.CanConvertFrom(type)) { return(converter2.ConvertFrom(null, culture, initialValue)); } if (initialValue == DBNull.Value) { if (ReflectionUtils.IsNullable(targetType)) { return(ConvertUtils.EnsureTypeAssignable(null, type, targetType)); } throw new Exception("Can not convert null {0} into non-nullable {1}.".FormatWith(CultureInfo.InvariantCulture, type, targetType)); } else { if (initialValue is INullable) { return(ConvertUtils.EnsureTypeAssignable(ConvertUtils.ToValue((INullable)initialValue), type, targetType)); } if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract()) { throw new ArgumentException("Target type {0} is not a value type or a non-abstract class.".FormatWith(CultureInfo.InvariantCulture, targetType), "targetType"); } throw new InvalidOperationException("Can not convert from {0} to {1}.".FormatWith(CultureInfo.InvariantCulture, type, targetType)); } }