Inheritance: TypeConverter
Esempio n. 1
0
        private static object GenerateRandomValue(PropertyInfo propertyInfo)
        {
            object val = null;

            Type t = propertyInfo.PropertyType;
            if (t.IsNullable()) t = Nullable.GetUnderlyingType(t);

            if (t == typeof(string))
            {
                val = GenerateString(propertyInfo);
            }
            else if (t == typeof(int) || t == typeof(uint) || t == typeof(ushort) || t == typeof(short) || t == typeof(long) || t == typeof(ulong))
            {
                val = GenerateNumeric(propertyInfo);
            }
            else if (t == typeof(bool)) val = true;
            else if (t == typeof(DateTime)) val = DateTime.Now.Date;
            else if (typeof(ISmartReference).IsAssignableFrom(t))
            {
                val = GenerateSmartReference(propertyInfo);
            }

            if (val != null && propertyInfo.PropertyType.IsNullable())
            {
                val = new NullableConverter(propertyInfo.PropertyType).ConvertFrom(val);
            }

            return val;
        }
Esempio n. 2
0
        /// <summary>
        /// Injeta valores apenas para Guids diferentes de null
        /// </summary>
        /// <param name="source">Objeto origem</param>
        /// <param name="target">Objeto Destino</param>
        protected override void Inject(object source, object target)
        {
            var sprops = source.GetProps();
            var tprops = target.GetProps();

            for (int i = 0; i < tprops.Count; i++)
            {
                if (i > sprops.Count)
                    break;

                var sourceProp = sprops[i];
                var targetProp = tprops[i];

                var underlyingType = sourceProp.PropertyType;
                if (underlyingType.IsGenericType && underlyingType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
                {
                    var converter = new NullableConverter(underlyingType);
                    underlyingType = converter.UnderlyingType;
                }

                if (underlyingType == typeof(Guid))
                {
                    var sourceValue = sourceProp.GetValue(source);
                    if (sourceValue != null)
                    {
                        targetProp.SetValue(target, new Guid(sourceValue.ToString()));
                    }
                }
            }
        }
Esempio n. 3
0
        public static object ConvertType(object v, Type t)
        {
            if (Convert.IsDBNull(v) || v == null)
            {
                return null;
            }

            if (t.IsEnum)
            {
                return Convert.ToInt32(v);
            }

            Type convertionType = t;
            if (convertionType.IsGenericType && convertionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                NullableConverter nullableConverter = new NullableConverter(convertionType);
                convertionType = nullableConverter.UnderlyingType;
            }

            if (v is IConvertible)
            {
                TypeCode sourceTC = Type.GetTypeCode(v.GetType());
                TypeCode destTC = Type.GetTypeCode(convertionType);
                if (sourceTC != destTC)
                {
                    return Convert.ChangeType(v, convertionType);
                }
            }

            return v;
        }
Esempio n. 4
0
        /// <summary>
        /// Converts the value.
        /// </summary>
        public static object ConvertValue(object value, Type type)
        {
            // handle null values
            if ((value == null) && (type.IsValueType))
                return Activator.CreateInstance(type);

            // handle nullable types
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                if ((value is string) && ((string)value == string.Empty))
                {
                    // value is an empty string, return null
                    return null;
                }
                else
                {
                    // value is not null
                    var nullableConverter = new NullableConverter(type);
                    type = nullableConverter.UnderlyingType;
                }
            }

            // handle exceptions
            if ((value is string) && (type == typeof(Guid)))
                return new Guid((string)value);
            if (type == typeof(object)) return value;

            // convert
            return Convert.ChangeType(value, type);
        }
Esempio n. 5
0
		public void PropertyValues ()
		{
			NullableConverter converter = new NullableConverter (typeof(MyType?));
			Assert.AreEqual (typeof(MyType?), converter.NullableType, "#1");
			Assert.AreEqual (typeof(MyType), converter.UnderlyingType, "#2");
			Assert.AreEqual (typeof(MyTypeConverter), converter.UnderlyingTypeConverter.GetType(), "#2");
		}
    internal static object ChangeType( object value, Type conversionType, IFormatProvider provider )
    {
      if( conversionType == null )
      {
        throw new ArgumentNullException( "conversionType" );
      }
      if( conversionType == typeof( Guid ) )
      {
        return new Guid( value.ToString() );
      }
      else if( conversionType == typeof( Guid? ) )
      {
        if( value == null )
          return null;
        return new Guid( value.ToString() );
      }
      else if( conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals( typeof( Nullable<> ) ) )
      {
        if( value == null )
          return null;
        NullableConverter nullableConverter = new NullableConverter( conversionType );
        conversionType = nullableConverter.UnderlyingType;
      }

      return System.Convert.ChangeType( value, conversionType, provider );
    }
Esempio n. 7
0
        private TypeMath(Type valueType)
        {
            if (!TypeInfo.IsNumericType(valueType))
                throw new Exception("Numeric type is required for math!");

            Min = TypeMathExpressionHelper.GetMinDelegate<BinOp>(valueType, typeof(object));
            Max = TypeMathExpressionHelper.GetMaxDelegate<BinOp>(valueType, typeof(object));

            Sum = TypeMathExpressionHelper.GetSumDelegate<BinOp>(valueType, typeof(object));
            Multiply = TypeMathExpressionHelper.GetMultiplyDelegate<BinOp>(valueType, typeof(object));

            if (TypeInfo.IsNullableType(valueType))
            {
                var nc = new NullableConverter(valueType);
                Zero = nc.ConvertFrom(Convert.ChangeType(0, Nullable.GetUnderlyingType(valueType)));
                One = nc.ConvertFrom(Convert.ChangeType(1, Nullable.GetUnderlyingType(valueType)));
                SumNullAsZero = TypeMathExpressionHelper.GetSumIsNullDelegate<BinOp>(valueType, typeof(object), Zero);
                MultiplyNullAsOne = TypeMathExpressionHelper.GetMultiplyIsNullDelegate<BinOp>(valueType, typeof(object), One);
            }
            else
            {
                Zero = Convert.ChangeType(0, valueType);
                One = Convert.ChangeType(1, valueType);
                SumNullAsZero = Sum;
                MultiplyNullAsOne = Multiply;
            }
        }
Esempio n. 8
0
        public static object ChangeType(object value, Type conversionType)
        {
            // Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
            // checking properties on conversionType below.
            if (conversionType == null)
            {
                throw new ArgumentNullException("conversionType");
            } // end if

            // If it's not a nullable type, just pass through the parameters to Convert.ChangeType

            if (conversionType.IsGenericType &&
              conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                // It's a nullable type, so determine what the underlying type is
                if (value == null)
                {
                    return null;
                }

                // It's a nullable type, and not null, so that means it can be converted to its underlying type,
                // so overwrite the passed-in conversion type with this underlying type
                NullableConverter nullableConverter = new NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            } // end if

            // Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
            // nullable type), pass the call on to Convert.ChangeType
            return Convert.ChangeType(value, conversionType);
        }
Esempio n. 9
0
 // From http://davidhayden.com/blog/dave/archive/2006/11/26/IsTypeNullableTypeConverter.aspx
 public static Type GetUnderlyingNullableType(Type t)
 {
     if (!IsNullableType(t))
         return t;
     var nc = new NullableConverter(t);
     return nc.UnderlyingType;
 }
        public ConversionResult Convert(ConversionContext conversion)
        {
            if (conversion.HasValue==false)
                return conversion.Unconverted();

            var converter=new NullableConverter(typeof(Nullable<>).MakeGenericType(conversion.GetType()));
            return conversion.Result(converter.ConvertTo(conversion, converter.UnderlyingType));
        }
Esempio n. 11
0
 /// <summary>
 ///     通过类型转换器获取Nullable类型的基础类型
 /// </summary>
 /// <param name="type"> 要处理的类型对象 </param>
 /// <returns> 对应的基础类型</returns>
 public static Type GetUnderlyingType(this Type type)
 {
     if (IsNullableType(type))
     {
         var nullableConverter = new NullableConverter(type);
         return nullableConverter.UnderlyingType;
     }
     return type;
 }
Esempio n. 12
0
 /// <summary>
 ///     Gets the type of the un nullable.
 /// </summary>
 /// <param name="conversionType">Type of the conversion.</param>
 /// <returns>Type.</returns>
 public static Type GetUnNullableType(Type conversionType)
 {
     if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable<>))
     {
         var nullableConverter = new NullableConverter(conversionType);
         conversionType = nullableConverter.UnderlyingType;
     }
     return conversionType;
 }
		protected virtual IEnumerable<FieldInfo> GetOptions(ElementRequest req)
		{
			var propertyType = req.Accessor.PropertyType;
			if (propertyType.IsGenericType)
			{
				propertyType = new NullableConverter(propertyType).UnderlyingType;
			}
			return propertyType.GetFields((BindingFlags.Public | BindingFlags.Static));
		}
Esempio n. 14
0
 protected object ConvertFrom(object value, Type t)
 {
     if (t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
     {
         var nc = new NullableConverter(t);
         return nc.ConvertFrom(value);
     }
     return Convert.ChangeType(value, t);
 }
Esempio n. 15
0
 /// <summary>implement a casting operation that support nullable object type-casting</summary>
 public static object ConvertTo(this object value, Type conversionType)
 {
     //http://aspalliance.com/852
     if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
     {
         NullableConverter nullableConverter = new NullableConverter(conversionType);
         conversionType = nullableConverter.UnderlyingType;
     }
     return Convert.ChangeType(value, conversionType);
 }
 protected virtual IEnumerable<FieldInfo> GetOptions(ElementRequest request)
 {
     var propertyType = request.Accessor.PropertyType;
     if (propertyType.IsGenericType)
     {
         propertyType = new NullableConverter(propertyType).UnderlyingType;
     }
     return propertyType.GetFields((BindingFlags.Public | BindingFlags.Static))
         .Where(f => !f.HasAttribute<ExcludeFromSelect>());
 }
 public bool IsConvertible(ConversionContext conversion)
 {
     var convertible=conversion.HasValue &&
            conversion.ValueType.IsNullableType() == false &&
            conversion.DestinationPropertyType.IsNullableType();
     if(convertible)
     {
         var cnv = new NullableConverter(conversion.DestinationPropertyType);
         return conversion.ValueType == cnv.UnderlyingType;
     }
     return false;
 }
Esempio n. 18
0
 public static object ChangeType(this object value, Type type)
 {
     if (type == null)
         throw new ArgumentNullException("type");
     if (type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
     {
         if (value == null)
             return null;
         var conv = new NullableConverter(type);
         type = conv.UnderlyingType;
     }
     return Convert.ChangeType(value, type);
 }
Esempio n. 19
0
        /// <summary>
        /// Gets the english version of a type's name. For nullable types, the underlying type name is returned
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public static string GetEnglishName(this Type type)
        {
            Type propType;
            if ((type.IsGenericType && type.GetGenericTypeDefinition().Equals(typeof(Nullable<>))))
            {
                var nc = new NullableConverter(type);
                propType = nc.UnderlyingType;
            }
            else
                propType = type;

            return propType.Name.ToLower();
        }
Esempio n. 20
0
        private JsonFxAOT()
        {
            System.ComponentModel.TypeConverter c;

            c = new ArrayConverter();
            m_fakeFlag = c.Equals(c);
            //c = new BaseNumberConverter();
            //m_fakeFlag = c.Equals(c);
            c = new BooleanConverter();
            m_fakeFlag = c.Equals(c);
            c = new ByteConverter();
            m_fakeFlag = c.Equals(c);
            c = new CollectionConverter();
            m_fakeFlag = c.Equals(c);
            c = new ComponentConverter(typeof(int));
            m_fakeFlag = c.Equals(c);
            c = new CultureInfoConverter();
            m_fakeFlag = c.Equals(c);
            c = new DateTimeConverter();
            m_fakeFlag = c.Equals(c);
            c = new DecimalConverter();
            m_fakeFlag = c.Equals(c);
            c = new DoubleConverter();
            m_fakeFlag = c.Equals(c);
            c = new EnumConverter(typeof(int));
            m_fakeFlag = c.Equals(c);
            c = new ExpandableObjectConverter();
            m_fakeFlag = c.Equals(c);
            c = new Int16Converter();
            m_fakeFlag = c.Equals(c);
            c = new Int32Converter();
            m_fakeFlag = c.Equals(c);
            c = new Int64Converter();
            m_fakeFlag = c.Equals(c);
            c = new NullableConverter(typeof(object));
            m_fakeFlag = c.Equals(c);
            c = new SByteConverter();
            m_fakeFlag = c.Equals(c);
            c = new SingleConverter();
            m_fakeFlag = c.Equals(c);
            c = new StringConverter();
            m_fakeFlag = c.Equals(c);
            c = new TimeSpanConverter();
            m_fakeFlag = c.Equals(c);
            c = new UInt16Converter();
            m_fakeFlag = c.Equals(c);
            c = new UInt32Converter();
            m_fakeFlag = c.Equals(c);
            c = new UInt64Converter();
            m_fakeFlag = c.Equals(c);
        }
Esempio n. 21
0
    private static object HackType(object value, Type conversionType)
    {
        if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
        {
            if (value == null)
            {
                return(null);
            }

            System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
            conversionType = nullableConverter.UnderlyingType;
        }
        return(Convert.ChangeType(value, conversionType));
    }
Esempio n. 22
0
        public static object ChangeType(object o, Type type)
        {
            if (type.IsEnum)
                return Enum.Parse(type, o.ToString(), true);

            if (Nullable.IsNullableType(type))
            {
                var underlyingType = Nullable.GetUnderlyingType(type);
                var data = ChangeType(o, underlyingType);
                NullableConverter nullableConverter = new NullableConverter(type);
                return nullableConverter.ConvertFrom(data);
            }
            return System.Convert.ChangeType(o, type);
        }
Esempio n. 23
0
        public static object ChangeType(object value, Type conversionType)
        {
            if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                if (value == null)
                {
                    return null;
                }

                var nullableConverter = new NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            }

            return Convert.ChangeType(value, conversionType);
        }
        private object ConvertValue(object value, Type conversionType)
        {
            if (value == null)
            {
                return null;
            }

            if (conversionType.IsGenericType &&
                conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                var nullableConverter = new NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            }

            return Convert.ChangeType(value, conversionType);
        }
Esempio n. 25
0
        /// <summary>
        /// Sets the new value for a specific property on an object.
        /// </summary>
        /// <param name="instance">Target object to set property at.</param>
        /// <param name="pi">Property info for the property to set.</param>
        /// <param name="newvalue">Value to try to parse.</param>
        /// <param name="culture"></param>
        public void SetValue(object instance, PropertyInfo pi, object newvalue, CultureInfo culture = null)
        {
            var nullableConverter = new NullableConverter(pi.PropertyType);
            object obj;
            try
            {
                obj = nullableConverter.ConvertFrom(null, culture ?? CultureInfo.CurrentCulture, newvalue);
            }
            catch (Exception)
            {
                ValidationManager.AddError(pi, "Adf.Business.NotInstantiable", newvalue, pi.Name);
                return;
            }

            pi.SetValue(instance, obj, null);
        }
Esempio n. 26
0
        public bool WriteNullable(string value, object target)
        {
            var nc = new NullableConverter(this.Property.PropertyType);

            // FormatException (thrown by ConvertFromString) is thrown as Exception.InnerException, so we've to catch directly System.Exception
            try
            {
                this.Property.SetValue(target, nc.ConvertFromString(null, this.parsingCulture, value), null);
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }
Esempio n. 27
0
 //这个类对可空类型进行判断转换,要不然会报错
 private static object HackType(object value, Type conversionType)
 {
     if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable <>))
     {
         if (value == null)
         {
             return(null);
         }
         System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
         conversionType = nullableConverter.UnderlyingType;
     }
     //if (value is System.DateTime)
     //{
     //    value = Convert.ToDateTime(value).ToString("yyyyMMddHHmmss");
     //}
     return(Convert.ChangeType(value, conversionType));
 }
Esempio n. 28
0
 public bool WriteNullable(string value, object target)
 {
     var nc = new NullableConverter(Property.PropertyType);
     try
     {
         // ReSharper disable AssignNullToNotNullAttribute
         Property.SetValue(target, nc.ConvertFromString(null, Thread.CurrentThread.CurrentCulture, value), null);
         // ReSharper restore AssignNullToNotNullAttribute
     }
     // FormatException (thrown by ConvertFromString) is thrown as Exception.InnerException,
     // so we've to catch directly System.Exception
     catch (Exception)
     {
         return false;
     }
     return true;
 }
Esempio n. 29
0
        public ConversionResult Convert(ConversionContext conversion)
        {
            try
            {
                if (IsConvertible(conversion))
                    return conversion.Unconverted();
                var destPropType = conversion.DestinationPropertyType;
                if (destPropType.IsNullableType() && conversion.HasValue)
                    destPropType = new NullableConverter(destPropType).UnderlyingType;

                return conversion.Result(System.Convert.ChangeType(conversion.Value, destPropType));
            }
            catch(InvalidCastException)
            {
                //gulp
                return conversion.Unconverted();
            }
        }
Esempio n. 30
0
        /// <summary>
        /// Use this instead of <see cref="Convert.ChangeType"/> to support 
        /// <see cref="Nullable<>"/> types. Returns an <see cref="Object"/> with the specified
        /// <see cref="Type"/> of which the value is equivelant to the specified object.
        /// </summary>
        /// <param name="obj">Specifies the object for which the type should change.</param>
        /// <param name="toType">Specifies the type to change the specified object to.</param>
        /// <returns>The specified object, converted to the specified type.</returns>
        public static object ChangeType(this object obj, Type toType)
        {
            if (obj.IsNullableType())
            {
                if (obj == null)
                    return null;
                NullableConverter oConverter = new NullableConverter(obj.GetType());
                toType = oConverter.UnderlyingType;
            }
            else if (toType.IsNullableType())
            {
                if (obj == null)
                    return null;
                NullableConverter converter = new NullableConverter(toType);
                toType = converter.UnderlyingType;
            }

            return Convert.ChangeType(obj, toType);
        }
Esempio n. 31
0
        /// <summary>
        /// Returns an Object with the specified Type and whose value is equivalent to the specified object.
        /// </summary>
        /// </remarks>
        public static object ChangeType(this object value, Type conversionType) {
            // Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
            // checking properties on conversionType below.
            if (conversionType == null)
                throw new ArgumentNullException("conversionType");

            // If it's not a nullable type, just pass through the parameters to Convert.ChangeType

            if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>))) {
                if (value == null)
                    return null;
                NullableConverter nullableConverter = new NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;
            }

            // Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
            // nullable type), pass the call on to Convert.ChangeType
            return Convert.ChangeType(value, conversionType);
        }
Esempio n. 32
0
        /// <summary>
        /// 将对象转换为对应类型的值
        /// </summary>
        /// <param name="value"></param>
        /// <param name="convertsionType"></param>
        /// <returns></returns>
        public static object ObjValueToPropType(object value, Type convertsionType)
        {
            //判断convertsionType类型是否为泛型,因为nullable是泛型类,
            if (convertsionType.IsGenericType &&
                //判断convertsionType是否为nullable泛型类
                convertsionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
            {
                if (value == null || value.ToString().Length == 0)
                {
                    return(null);
                }

                //如果convertsionType为nullable类,声明一个NullableConverter类,该类提供从Nullable类到基础基元类型的转换
                System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(convertsionType);
                //将convertsionType转换为nullable对的基础基元类型
                convertsionType = nullableConverter.UnderlyingType;
            }
            return(Convert.ChangeType(value, convertsionType));
        }
Esempio n. 33
0
        /// <summary>
        /// Returns an Object with the specified Type and whose value is equivalent to the specified object.
        /// </summary>
        /// <param name="value">An Object that implements the IConvertible interface.</param>
        /// <param name="conversionType">The Type to which value is to be converted.</param>
        /// <returns>An object whose Type is conversionType (or conversionType's underlying type if conversionType
        /// is Nullable&lt;&gt;) and whose value is equivalent to value. -or- a null reference, if value is a null
        /// reference and conversionType is not a value type.</returns>
        /// <remarks>
        /// This method exists as a workaround to System.Convert.ChangeType(Object, Type) which does not handle
        /// nullables as of version 2.0 (2.0.50727.42) of the .NET Framework. The idea is that this method will
        /// be deleted once Convert.ChangeType is updated in a future version of the .NET Framework to handle
        /// nullable types, so we want this to behave as closely to Convert.ChangeType as possible.
        /// This method was written by Peter Johnson at:
        /// http://aspalliance.com/author.aspx?uId=1026.
        /// </remarks>
        public static object ChangeType(object value, Type conversionType)
        {
            // Note: This if block was taken from Convert.ChangeType as is, and is needed here since we're
            // checking properties on conversionType below.
            if (conversionType == null)
            {
                throw new ArgumentNullException("conversionType");
            } // end if

            // If it's not a nullable type, just pass through the parameters to Convert.ChangeType

            if (conversionType.IsGenericType &&
              conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
            {
                // It's a nullable type, so instead of calling Convert.ChangeType directly which would throw a
                // InvalidCastException (per http://weblogs.asp.net/pjohnson/archive/2006/02/07/437631.aspx),
                // determine what the underlying type is
                // If it's null, it won't convert to the underlying type, but that's fine since nulls don't really
                // have a type--so just return null
                // Note: We only do this check if we're converting to a nullable type, since doing it outside
                // would diverge from Convert.ChangeType's behavior, which throws an InvalidCastException if
                // value is null and conversionType is a value type.
                if (value == null)
                {
                    return null;
                } // end if

                // It's a nullable type, and not null, so that means it can be converted to its underlying type,
                // so overwrite the passed-in conversion type with this underlying type
                NullableConverter nullableConverter = new NullableConverter(conversionType);
                conversionType = nullableConverter.UnderlyingType;

                if (value.ToString() == "0000-00-00 00:00:00" && conversionType.Name == "DateTime") // special case for mysql date
                {
                    return null;
                }
            } // end if

            // Now that we've guaranteed conversionType is something Convert.ChangeType can handle (i.e. not a
            // nullable type), pass the call on to Convert.ChangeType
            return Convert.ChangeType(value, conversionType);
        }
Esempio n. 34
0
        /// <summary>
        /// 转换类型,支持可空类型
        /// </summary>
        public static object ConvertType(this object value, Type conversionType)
        {
            if (conversionType == null)
            {
                throw new ArgumentNullException("conversionType");
            }

            if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable <>)))
            {
                if (value == null)
                {
                    return(null);
                }

                System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);

                conversionType = nullableConverter.UnderlyingType;
            }

            return(Convert.ChangeType(value, conversionType));
        }
Esempio n. 35
0
        /// <summary>
        /// 返回具有指定 System.Type 而且其值等效于指定对象的 System.Object
        /// </summary>
        /// <param name="value">对象值</param>
        /// <param name="type">对象类型</param>
        /// <returns>返回具有指定 System.Type 而且其值等效于指定对象的 System.Object</returns>
        public static object ConvertObjectValue(object value, Type type)
        {
            if (value == DBNull.Value || null == value)
            {
                return(null);
            }

            if (type.IsGenericType &&
                type.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                System.ComponentModel.NullableConverter nullableConverter
                    = new System.ComponentModel.NullableConverter(type);

                type = nullableConverter.UnderlyingType;
            }
            if (type.IsEnum)
            {
                return(Convert.ChangeType(Enum.Parse(type, value.ToString()), type));
            }

            return(Convert.ChangeType(value, type));
        }
Esempio n. 36
0
        private static TypeConverter GetCoreConverterFromCoreType(Type type)
        {
            TypeConverter typeConverter = null;

            if (type == typeof(Int32))
            {
                typeConverter = new System.ComponentModel.Int32Converter();
            }
            else if (type == typeof(Int16))
            {
                typeConverter = new System.ComponentModel.Int16Converter();
            }
            else if (type == typeof(Int64))
            {
                typeConverter = new System.ComponentModel.Int64Converter();
            }
            else if (type == typeof(UInt32))
            {
                typeConverter = new System.ComponentModel.UInt32Converter();
            }
            else if (type == typeof(UInt16))
            {
                typeConverter = new System.ComponentModel.UInt16Converter();
            }
            else if (type == typeof(UInt64))
            {
                typeConverter = new System.ComponentModel.UInt64Converter();
            }
            else if (type == typeof(Boolean))
            {
                typeConverter = new System.ComponentModel.BooleanConverter();
            }
            else if (type == typeof(Double))
            {
                typeConverter = new System.ComponentModel.DoubleConverter();
            }
            else if (type == typeof(Single))
            {
                typeConverter = new System.ComponentModel.SingleConverter();
            }
            else if (type == typeof(Byte))
            {
                typeConverter = new System.ComponentModel.ByteConverter();
            }
            else if (type == typeof(SByte))
            {
                typeConverter = new System.ComponentModel.SByteConverter();
            }
            else if (type == typeof(Char))
            {
                typeConverter = new System.ComponentModel.CharConverter();
            }
            else if (type == typeof(Decimal))
            {
                typeConverter = new System.ComponentModel.DecimalConverter();
            }
            else if (type == typeof(TimeSpan))
            {
                typeConverter = new System.ComponentModel.TimeSpanConverter();
            }
            else if (type == typeof(Guid))
            {
                typeConverter = new System.ComponentModel.GuidConverter();
            }
            else if (type == typeof(String))
            {
                typeConverter = new System.ComponentModel.StringConverter();
            }
            else if (type == typeof(CultureInfo))
            {
                typeConverter = new System.ComponentModel.CultureInfoConverter();
            }
#if !SYSTEM_XAML
            else if (type == typeof(Type))
            {
                typeConverter = new System.Windows.Markup.TypeTypeConverter();
            }
#else
            else if (type == typeof(Type))
            {
                typeConverter = new System.Xaml.Replacements.TypeTypeConverter();
            }
#endif
            else if (type == typeof(DateTime))
            {
                typeConverter = new DateTimeConverter2();
            }
            else if (ReflectionHelper.IsNullableType(type))
            {
                typeConverter = new System.ComponentModel.NullableConverter(type);
            }

            return(typeConverter);
        }
Esempio n. 37
0
 public static DateTime?ToDateTime(object obj)
 {
     System.ComponentModel.NullableConverter nullableDateTime = new System.ComponentModel.NullableConverter(typeof(DateTime?));
     return((DateTime?)nullableDateTime.ConvertFromString(obj.ToString()));
 }