private static ConvertUtils.ConvertResult TryConvertInternal(
            object initialValue,
            CultureInfo culture,
            Type targetType,
            out object value)
        {
            if (initialValue == null)
            {
                throw new ArgumentNullException(nameof(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, (IFormatProvider)culture);
                return(ConvertUtils.ConvertResult.Success);
            }
            switch (initialValue)
            {
            case DateTime _ when targetType == typeof(DateTimeOffset):
                value = (object)new DateTimeOffset((DateTime)initialValue);
                return(ConvertUtils.ConvertResult.Success);

            case byte[] _ when targetType == typeof(Guid):
                value = (object)new Guid((byte[])initialValue);
                return(ConvertUtils.ConvertResult.Success);

            case Guid _ when targetType == typeof(byte[]):
                value = (object)((Guid)initialValue).ToByteArray();
                return(ConvertUtils.ConvertResult.Success);

            case string str:
                if (targetType == typeof(Guid))
                {
                    value = (object)new Guid(str);
                    return(ConvertUtils.ConvertResult.Success);
                }
                if (targetType == typeof(Uri))
                {
                    value = (object)new Uri(str, UriKind.RelativeOrAbsolute);
                    return(ConvertUtils.ConvertResult.Success);
                }
                if (targetType == typeof(TimeSpan))
                {
                    value = (object)ConvertUtils.ParseTimeSpan(str);
                    return(ConvertUtils.ConvertResult.Success);
                }
                if (targetType == typeof(byte[]))
                {
                    value = (object)Convert.FromBase64String(str);
                    return(ConvertUtils.ConvertResult.Success);
                }
                if (targetType == typeof(Version))
                {
                    Version result;
                    if (ConvertUtils.VersionTryParse(str, out result))
                    {
                        value = (object)result;
                        return(ConvertUtils.ConvertResult.Success);
                    }
                    value = (object)null;
                    return(ConvertUtils.ConvertResult.NoValidConversion);
                }
                if (typeof(Type).IsAssignableFrom(targetType))
                {
                    value = (object)Type.GetType(str, true);
                    return(ConvertUtils.ConvertResult.Success);
                }
                break;
            }
            TypeConverter converter1 = ConvertUtils.GetConverter(type);

            if (converter1 != null && converter1.CanConvertTo(targetType))
            {
                value = converter1.ConvertTo((ITypeDescriptorContext)null, culture, initialValue, targetType);
                return(ConvertUtils.ConvertResult.Success);
            }
            TypeConverter converter2 = ConvertUtils.GetConverter(targetType);

            if (converter2 != null && converter2.CanConvertFrom(type))
            {
                value = converter2.ConvertFrom((ITypeDescriptorContext)null, culture, initialValue);
                return(ConvertUtils.ConvertResult.Success);
            }
            if (initialValue == DBNull.Value)
            {
                if (ReflectionUtils.IsNullable(targetType))
                {
                    value = ConvertUtils.EnsureTypeAssignable((object)null, type, targetType);
                    return(ConvertUtils.ConvertResult.Success);
                }
                value = (object)null;
                return(ConvertUtils.ConvertResult.CannotConvertNull);
            }
            if (targetType.IsInterface() || targetType.IsGenericTypeDefinition() || targetType.IsAbstract())
            {
                value = (object)null;
                return(ConvertUtils.ConvertResult.NotInstantiableType);
            }
            value = (object)null;
            return(ConvertUtils.ConvertResult.NoValidConversion);
        }
Exemple #2
0
        // Token: 0x06000E7F RID: 3711 RVA: 0x00057198 File Offset: 0x00055398
        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.NoValidConversion);
                }
                value = null;
                return(ConvertUtils.ConvertResult.NotInstantiableType);
            }
        }
Exemple #3
0
        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);
        }