public static bool ValueEquals(object objA, object objB)
 {
     if (objA == null && objB == null)
     {
         return(true);
     }
     if (objA != null && objB == null)
     {
         return(false);
     }
     if (objA == null && objB != null)
     {
         return(false);
     }
     if (objA.GetType() == objB.GetType())
     {
         return(objA.Equals(objB));
     }
     if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
     {
         decimal num = Convert.ToDecimal(objA, CultureInfo.CurrentCulture);
         return(num.Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture)));
     }
     if (!(objA is double) && !(objA is float) && !(objA is decimal) || !(objB is double) && !(objB is float) && !(objB is decimal))
     {
         return(false);
     }
     return(MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture)));
 }
예제 #2
0
 public static bool ValueEquals(object objA, object objB)
 {
     if (objA == null && objB == null)
     {
         return(true);
     }
     if (objA != null && objB == null || objA == null && objB != null)
     {
         return(false);
     }
     if (objA.GetType() == objB.GetType())
     {
         return(objA.Equals(objB));
     }
     if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
     {
         return(Convert.ToDecimal(objA, (IFormatProvider)CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, (IFormatProvider)CultureInfo.CurrentCulture)));
     }
     switch (objA)
     {
     case double _:
     case float _:
     case Decimal _:
         switch (objB)
         {
         case double _:
         case float _:
         case Decimal _:
             return(MathUtils.ApproxEquals(Convert.ToDouble(objA, (IFormatProvider)CultureInfo.CurrentCulture), Convert.ToDouble(objB, (IFormatProvider)CultureInfo.CurrentCulture)));
         }
         break;
     }
     return(false);
 }
        public static bool ValueEquals(object?objA, object?objB)
        {
            if (objA == objB)
            {
                return(true);
            }
            if (objA == null || objB == null)
            {
                return(false);
            }

            // comparing an Int32 and Int64 both of the same value returns false
            // make types the same then compare
            if (objA.GetType() != objB.GetType())
            {
                if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
                {
                    return(Convert.ToDecimal(objA, CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture)));
                }
                else if ((objA is double || objA is float || objA is decimal) && (objB is double || objB is float || objB is decimal))
                {
                    return(MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture)));
                }
                else
                {
                    return(false);
                }
            }

            return(objA.Equals(objB));
        }
예제 #4
0
 public static bool ValueEquals(object objA, object objB)
 {
     if (objA == null && objB == null)
     {
         return(true);
     }
     if (objA != null && objB == null || objA == null && objB != null)
     {
         return(false);
     }
     if (objA.GetType() == objB.GetType())
     {
         return(objA.Equals(objB));
     }
     if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
     {
         return(Convert.ToDecimal(objA, (IFormatProvider)CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, (IFormatProvider)CultureInfo.CurrentCulture)));
     }
     if ((objA is double || objA is float || objA is Decimal) && (objB is double || objB is float || objB is Decimal))
     {
         return(MathUtils.ApproxEquals(Convert.ToDouble(objA, (IFormatProvider)CultureInfo.CurrentCulture), Convert.ToDouble(objB, (IFormatProvider)CultureInfo.CurrentCulture)));
     }
     else
     {
         return(false);
     }
 }
        /// <summary>
        /// The default implementation of the values comparision function.
        /// </summary>
        /// <param name="objA">The object a.</param>
        /// <param name="objB">The object b.</param>
        /// <returns>True if both objects are equal, otherwise false.</returns>
        public static bool DefaultValueEquals(object objA, object objB)
        {
            if (objA == objB)
            {
                return(true);
            }
            if (objA == null || objB == null)
            {
                return(false);
            }

            // comparing an Int32 and Int64 both of the same value returns false
            // make types the same then compare
            if (objA.GetType() != objB.GetType())
            {
                if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
                {
                    return(Convert.ToDecimal(objA, CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture)));
                }
                else if ((objA is double || objA is float || objA is decimal) && (objB is double || objB is float || objB is decimal))
                {
                    return(MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture)));
                }
                else
                {
                    return(false);
                }
            }

            // Diff on collections
            if (objA is IList aList && objB is IList bList)
            {
                if (aList.Count != bList.Count)
                {
                    return(false);
                }
            }
            if (objA is IEnumerable aEnumerable && objB is IEnumerable bEnumerable)
            {
                var aEnumerator = aEnumerable.GetEnumerator();
                var bEnumerator = bEnumerable.GetEnumerator();
                while (aEnumerator.MoveNext())
                {
                    if (!bEnumerator.MoveNext() || !ValueEquals(aEnumerator.Current, bEnumerator.Current))
                    {
                        return(false);
                    }
                }
                return(!bEnumerator.MoveNext());
            }

            return(objA.Equals(objB));
        }
        public static bool ValueEquals(object objA, object objB)
        {
            if (objA == objB)
            {
                return(true);
            }
            if (objA == null || objB == null)
            {
                return(false);
            }

            // comparing an Int32 and Int64 both of the same value returns false
            // make types the same then compare
            if (objA.GetType() != objB.GetType())
            {
                if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
                {
                    return(Convert.ToDecimal(objA, CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture)));
                }
                else if ((objA is double || objA is float || objA is decimal) && (objB is double || objB is float || objB is decimal))
                {
                    return(MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture)));
                }
#if (JSON_SmallDecSupport)
                else if (objA is SmallDec || objB is SmallDec)
                {
                    string   FullNameA = objA.GetType().FullName;
                    string   FullNameB = objA.GetType().FullName;
                    SmallDec i1        = objA is SmallDec ? (SmallDec)objA :
                                         (FullNameA == "MS.Internal.NamedObject" ? SmallDec.Zero : SmallDec.Initialize(objA));
                    SmallDec i2 = objB is SmallDec ? (SmallDec)objB :
                                  (FullNameB == "MS.Internal.NamedObject" ? SmallDec.Zero : SmallDec.Initialize(objB));
                    return(i1 == i2);
                }
#endif
                else
                {
                    return(false);
                }
            }

            return(objA.Equals(objB));
        }
예제 #7
0
 public static bool ValueEquals(object objA, object objB)
 {
     if (objA == objB)
     {
         return(true);
     }
     if (objA == null || objB == null)
     {
         return(false);
     }
     if (!(objA.GetType() != objB.GetType()))
     {
         return(objA.Equals(objB));
     }
     if (ConvertUtils.IsInteger(objA) && ConvertUtils.IsInteger(objB))
     {
         return(Convert.ToDecimal(objA, CultureInfo.CurrentCulture).Equals(Convert.ToDecimal(objB, CultureInfo.CurrentCulture)));
     }
     return((objA is double || objA is float || objA is decimal) && (objB is double || objB is float || objB is decimal) && MathUtils.ApproxEquals(Convert.ToDouble(objA, CultureInfo.CurrentCulture), Convert.ToDouble(objB, CultureInfo.CurrentCulture)));
 }
예제 #8
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);
            }
        }
예제 #9
0
        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);
        }
예제 #10
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);
            }
            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);
        }
예제 #11
0
        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));
                }
            }
        }
        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
            }));
        }
예제 #13
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);
        }
예제 #14
0
        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));
            }
        }