public static IEnumerable <IConvertible> ExtractPow2Flags(this IConvertible flags) { return(GetPow2Values(flags.GetType()).Where(flag => flags.IsFlagSet(flag))); }
protected object DeserializeExpression(IDesignerSerializationManager manager, string name, CodeExpression expression) { if (expression == null) { throw new ArgumentNullException("expression"); } if (manager == null) { throw new ArgumentNullException("manager"); } object deserialized = null; // CodeThisReferenceExpression // CodeThisReferenceExpression thisExpr = expression as CodeThisReferenceExpression; if (thisExpr != null) { RootContext context = manager.Context[typeof(RootContext)] as RootContext; if (context != null) { deserialized = context.Value; } else { IDesignerHost host = manager.GetService(typeof(IDesignerHost)) as IDesignerHost; if (host != null) { deserialized = host.RootComponent; } } } // CodeVariableReferenceExpression // CodeVariableReferenceExpression varRef = expression as CodeVariableReferenceExpression; if (deserialized == null && varRef != null) { deserialized = manager.GetInstance(varRef.VariableName); } // CodeFieldReferenceExpression // CodeFieldReferenceExpression fieldRef = expression as CodeFieldReferenceExpression; if (deserialized == null && fieldRef != null) { deserialized = manager.GetInstance(fieldRef.FieldName); } // CodePrimitiveExpression // CodePrimitiveExpression primitiveExp = expression as CodePrimitiveExpression; if (deserialized == null && primitiveExp != null) { deserialized = primitiveExp.Value; } // CodePropertyReferenceExpression // // Enum references are represented by a PropertyReferenceExpression, where // PropertyName is the enum field name and the target object is a TypeReference // to the enum's type // CodePropertyReferenceExpression propRef = expression as CodePropertyReferenceExpression; if (deserialized == null && propRef != null) { object target = DeserializeExpression(manager, null, propRef.TargetObject); if (target != null) { if (target is Type) // Enum reference { FieldInfo field = ((Type)target).GetField(propRef.PropertyName, BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static); if (field != null) { deserialized = field.GetValue(null); } } else { PropertyDescriptor property = TypeDescriptor.GetProperties(target)[propRef.PropertyName]; if (property != null) { deserialized = property.GetValue(target); } } } } // CodeObjectCreateExpression // CodeObjectCreateExpression createExpr = expression as CodeObjectCreateExpression; if (deserialized == null && createExpr != null) { Type type = manager.GetType(createExpr.CreateType.BaseType); object[] arguments = new object[createExpr.Parameters.Count]; for (int i = 0; i < createExpr.Parameters.Count; i++) { arguments[i] = this.DeserializeExpression(manager, null, createExpr.Parameters[i]); } bool addToContainer = false; if (typeof(IComponent).IsAssignableFrom(type)) { addToContainer = true; } deserialized = this.DeserializeInstance(manager, type, arguments, name, addToContainer); } // CodeArrayCreateExpression // CodeArrayCreateExpression arrayCreateExpr = expression as CodeArrayCreateExpression; if (deserialized == null && arrayCreateExpr != null) { Type arrayType = manager.GetType(arrayCreateExpr.CreateType.BaseType); if (arrayType != null) { ArrayList initializers = new ArrayList(); foreach (CodeExpression initExpression in arrayCreateExpr.Initializers) { initializers.Add(this.DeserializeExpression(manager, null, initExpression)); } deserialized = Array.CreateInstance(arrayType, initializers.Count); initializers.CopyTo((Array)deserialized, 0); } } // CodeMethodInvokeExpression // CodeMethodInvokeExpression methodExpr = expression as CodeMethodInvokeExpression; if (deserialized == null && methodExpr != null) { object target = this.DeserializeExpression(manager, null, methodExpr.Method.TargetObject); object[] parameters = new object[methodExpr.Parameters.Count]; for (int i = 0; i < methodExpr.Parameters.Count; i++) { parameters[i] = this.DeserializeExpression(manager, null, methodExpr.Parameters[i]); } MethodInfo method = null; if (target is Type) { method = GetExactMethod((Type)target, methodExpr.Method.MethodName, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Static, parameters); } else { method = GetExactMethod(target.GetType(), methodExpr.Method.MethodName, BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, parameters); } if (method == null) { Console.WriteLine("DeserializeExpression: Unable to find method: " + methodExpr.Method.MethodName); } else { deserialized = method.Invoke(target, parameters); } } // CodeTypeReferenceExpression // CodeTypeReferenceExpression typeRef = expression as CodeTypeReferenceExpression; if (deserialized == null && typeRef != null) { deserialized = manager.GetType(typeRef.Type.BaseType); } // CodeBinaryOperatorExpression // CodeBinaryOperatorExpression binOperator = expression as CodeBinaryOperatorExpression; if (deserialized == null && binOperator != null) { switch (binOperator.Operator) { case CodeBinaryOperatorType.BitwiseOr: IConvertible left = DeserializeExpression(manager, null, binOperator.Left) as IConvertible; IConvertible right = DeserializeExpression(manager, null, binOperator.Right) as IConvertible; if (left is Enum) { deserialized = Enum.ToObject(left.GetType(), Convert.ToInt64(left) | Convert.ToInt64(right)); } break; } } if (deserialized == null && methodExpr == null && primitiveExp == null) { Console.WriteLine("DeserializeExpression not supported for: " + expression); } return(deserialized); }
internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { Contract.Requires(value != null, "[Convert.DefaultToType]value!=null"); if (targetType==null) { throw new ArgumentNullException("targetType"); } Contract.EndContractBlock(); RuntimeType rtTargetType = targetType as RuntimeType; if (rtTargetType != null) { if (value.GetType() == targetType) { return value; } if (rtTargetType == ConvertTypes[(int)TypeCode.Boolean]) return value.ToBoolean(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Char]) return value.ToChar(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.SByte]) return value.ToSByte(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Byte]) return value.ToByte(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Int16]) return value.ToInt16(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.UInt16]) return value.ToUInt16(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Int32]) return value.ToInt32(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.UInt32]) return value.ToUInt32(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Int64]) return value.ToInt64(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.UInt64]) return value.ToUInt64(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Single]) return value.ToSingle(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Double]) return value.ToDouble(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Decimal]) return value.ToDecimal(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.DateTime]) return value.ToDateTime(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.String]) return value.ToString(provider); if (rtTargetType == ConvertTypes[(int)TypeCode.Object]) return (Object)value; // Need to special case Enum because typecode will be underlying type, e.g. Int32 if (rtTargetType == EnumType) return (Enum)value; if (rtTargetType == ConvertTypes[(int)TypeCode.DBNull]) throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull")); if (rtTargetType == ConvertTypes[(int)TypeCode.Empty]) throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty")); } throw new InvalidCastException(Environment.GetResourceString("InvalidCast_FromTo", value.GetType().FullName, targetType.FullName)); }
// This is a custom version of Convert.ChangeType() which works // with the TypeBuilder defined types when compiling corlib. public static object ChangeType(object value, TypeSpec targetType, out bool error) { IConvertible convert_value = value as IConvertible; if (convert_value == null) { error = true; return(null); } // // We cannot rely on build-in type conversions as they are // more limited than what C# supports. // See char -> float/decimal/double conversion // error = false; try { if (targetType == TypeManager.bool_type) { return(convert_value.ToBoolean(nf_provider)); } if (targetType == TypeManager.byte_type) { return(convert_value.ToByte(nf_provider)); } if (targetType == TypeManager.char_type) { return(convert_value.ToChar(nf_provider)); } if (targetType == TypeManager.short_type) { return(convert_value.ToInt16(nf_provider)); } if (targetType == TypeManager.int32_type) { return(convert_value.ToInt32(nf_provider)); } if (targetType == TypeManager.int64_type) { return(convert_value.ToInt64(nf_provider)); } if (targetType == TypeManager.sbyte_type) { return(convert_value.ToSByte(nf_provider)); } if (targetType == TypeManager.decimal_type) { if (convert_value.GetType() == typeof(char)) { return((decimal)convert_value.ToInt32(nf_provider)); } return(convert_value.ToDecimal(nf_provider)); } if (targetType == TypeManager.double_type) { if (convert_value.GetType() == typeof(char)) { return((double)convert_value.ToInt32(nf_provider)); } return(convert_value.ToDouble(nf_provider)); } if (targetType == TypeManager.float_type) { if (convert_value.GetType() == typeof(char)) { return((float)convert_value.ToInt32(nf_provider)); } return(convert_value.ToSingle(nf_provider)); } if (targetType == TypeManager.string_type) { return(convert_value.ToString(nf_provider)); } if (targetType == TypeManager.ushort_type) { return(convert_value.ToUInt16(nf_provider)); } if (targetType == TypeManager.uint32_type) { return(convert_value.ToUInt32(nf_provider)); } if (targetType == TypeManager.uint64_type) { return(convert_value.ToUInt64(nf_provider)); } if (targetType == TypeManager.object_type) { return(value); } error = true; } catch { error = true; } return(null); }
/// <summary> /// 类型转换扩展 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="convertibleValue"></param> /// <returns></returns> public static T ConvertTo <T>(this IConvertible convertibleValue) { if (null == convertibleValue) { return(default(T)); } if (!typeof(T).IsGenericType) { return((T)Convert.ChangeType(convertibleValue, typeof(T))); } else { Type genericTypeDefinition = typeof(T).GetGenericTypeDefinition(); if (genericTypeDefinition == typeof(Nullable <>)) { return((T)Convert.ChangeType(convertibleValue, Nullable.GetUnderlyingType(typeof(T)))); } } throw new InvalidCastException(string.Format("Invalid cast from type \"{0}\" to type \"{1}\".", convertibleValue.GetType().FullName, typeof(T).FullName)); }
/// <summary> /// 将对象转换到指定类型 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="convertibleValue"></param> /// <returns></returns> public static T ConvertTo <T>(this IConvertible convertibleValue) { if (null == convertibleValue) { return(default(T)); } var t = typeof(T); #if NET35 || NET40 || NET45 if (t.IsGenericType) #else if (t.GetTypeInfo().IsGenericType) #endif { if (t.GetGenericTypeDefinition() != typeof(Nullable <>)) { throw new InvalidCastException(string.Format("Invalid cast from type \"{0}\" to type \"{1}\".", convertibleValue.GetType().FullName, typeof(T).FullName)); } t = Nullable.GetUnderlyingType(t); } return((T)Convert.ChangeType(convertibleValue, t)); }
public static ValidationRule GetTypeValidator(this IConvertible obj) => Type(obj.GetType());
/// <inheritdoc /> public string GetPermissionUniqueIdentifier(IConvertible permissionEnum) { return(permissionEnum.GetType().FullName + "." + permissionEnum); }
public static bool IsIntegralType(IConvertible value) { return(IsIntegralType(value.GetType())); }
internal static object ConvertibleToType(IConvertible value, Type type, IFormatProvider provider) { if (type == null) { throw new ArgumentNullException(nameof(type)); } if (value.GetType() == type) { return(value); } if (type == typeof(object)) { return(value); } if (type.IsEnum) { return((Enum)value); } switch (Type.GetTypeCode(type)) { case TypeCode.Boolean: return(value.ToBoolean(provider)); case TypeCode.Byte: return(value.ToByte(provider)); case TypeCode.Char: return(value.ToChar(provider)); case TypeCode.DateTime: return(value.ToDateTime(provider)); case TypeCode.Decimal: return(value.ToDecimal(provider)); case TypeCode.Double: return(value.ToDouble(provider)); case TypeCode.Int16: return(value.ToInt16(provider)); case TypeCode.Int32: return(value.ToInt32(provider)); case TypeCode.Int64: return(value.ToInt64(provider)); case TypeCode.SByte: return(value.ToSByte(provider)); case TypeCode.Single: return(value.ToSingle(provider)); case TypeCode.String: return(value.ToString(provider)); case TypeCode.UInt16: return(value.ToUInt16(provider)); case TypeCode.UInt32: return(value.ToUInt32(provider)); case TypeCode.UInt64: return(value.ToUInt64(provider)); } throw new InvalidCastException(); }
private object ExecuteBinaryOperator(IConvertible left, IConvertible right, CodeBinaryOperatorType op) { TypeCode typeCode = left.GetTypeCode(); TypeCode code2 = right.GetTypeCode(); TypeCode[] codeArray = new TypeCode[] { TypeCode.Byte, TypeCode.Char, TypeCode.Int16, TypeCode.UInt16, TypeCode.Int32, TypeCode.UInt32, TypeCode.Int64, TypeCode.UInt64 }; int num = -1; int num2 = -1; for (int i = 0; i < codeArray.Length; i++) { if (typeCode == codeArray[i]) { num = i; } if (code2 == codeArray[i]) { num2 = i; } if ((num != -1) && (num2 != -1)) { break; } } if ((num == -1) || (num2 == -1)) { return left; } int index = Math.Max(num, num2); object obj2 = left; switch (codeArray[index]) { case TypeCode.Char: { char ch = left.ToChar(null); char ch2 = right.ToChar(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = ch & ch2; break; } obj2 = ch | ch2; break; } case TypeCode.Byte: { byte num5 = left.ToByte(null); byte num6 = right.ToByte(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num5 & num6; break; } obj2 = num5 | num6; break; } case TypeCode.Int16: { short num7 = left.ToInt16(null); short num8 = right.ToInt16(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num7 & num8; break; } obj2 = (short) (((ushort) num7) | ((ushort) num8)); break; } case TypeCode.UInt16: { ushort num9 = left.ToUInt16(null); ushort num10 = right.ToUInt16(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num9 & num10; break; } obj2 = num9 | num10; break; } case TypeCode.Int32: { int num11 = left.ToInt32(null); int num12 = right.ToInt32(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num11 & num12; break; } obj2 = num11 | num12; break; } case TypeCode.UInt32: { uint num13 = left.ToUInt32(null); uint num14 = right.ToUInt32(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num13 & num14; break; } obj2 = num13 | num14; break; } case TypeCode.Int64: { long num15 = left.ToInt64(null); long num16 = right.ToInt64(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num15 & num16; break; } obj2 = num15 | num16; break; } case TypeCode.UInt64: { ulong num17 = left.ToUInt64(null); ulong num18 = right.ToUInt64(null); if (op != CodeBinaryOperatorType.BitwiseOr) { obj2 = num17 & num18; break; } obj2 = num17 | num18; break; } } if ((obj2 != left) && (left is Enum)) { obj2 = Enum.ToObject(left.GetType(), obj2); } return obj2; }
private static SimpleTypeClassification Classify(IConvertible value) { return (value == null) ? SimpleTypeClassification.NonSimpleType : Classify(value.GetType()); }
/// <summary> /// 向属性填充值(强制使用指定的类型) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <param name="prop"></param> /// <param name="value"></param> /// <param name="specialType"></param> public static void FillSystemType <T>(T entity, PropertyInfo prop, IConvertible value, Type specialType) { object obj = null; if (value.GetType() != specialType) { switch (specialType.Name) { case "Boolean": obj = ConvertTo <bool>(value); break; case "DateTime": obj = DateTimeHelper.GetDateTimeFromXml(value.ToString()); break; case "DateTimeOffset": obj = DateTimeHelper.GetDateTimeOffsetFromXml(value.ToString()); break; case "Int32": obj = ConvertTo <int>(value); break; case "Int32[]": obj = Array.ConvertAll(ConvertTo <string>(value).Split(','), int.Parse); break; case "Int64": obj = ConvertTo <long>(value); break; case "Int64[]": obj = Array.ConvertAll(ConvertTo <string>(value).Split(','), long.Parse); break; case "Double": obj = ConvertTo <double>(value); break; case "String": obj = value.ToString(CultureInfo.InvariantCulture); break; default: obj = value; break; } } string name = specialType.Name; if (name == "Nullable`1") { if (!string.IsNullOrEmpty(value as string)) { Type[] genericArguments = prop.PropertyType.GetGenericArguments(); FillSystemType(entity, prop, value, genericArguments[0]); } else { prop.SetValue(entity, null, null); } } else { prop.SetValue(entity, obj ?? value, null); } }
internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { Debug.Assert(value != null, "[Convert.DefaultToType]value!=null"); if (targetType == null) { throw new ArgumentNullException(nameof(targetType)); } if (ReferenceEquals(value.GetType(), targetType)) { return(value); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Boolean])) { return(value.ToBoolean(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Char])) { return(value.ToChar(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.SByte])) { return(value.ToSByte(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Byte])) { return(value.ToByte(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Int16])) { return(value.ToInt16(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.UInt16])) { return(value.ToUInt16(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Int32])) { return(value.ToInt32(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.UInt32])) { return(value.ToUInt32(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Int64])) { return(value.ToInt64(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.UInt64])) { return(value.ToUInt64(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Single])) { return(value.ToSingle(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Double])) { return(value.ToDouble(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Decimal])) { return(value.ToDecimal(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.DateTime])) { return(value.ToDateTime(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.String])) { return(value.ToString(provider)); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Object])) { return((object)value); } // Need to special case Enum because typecode will be underlying type, e.g. Int32 if (ReferenceEquals(targetType, EnumType)) { return((Enum)value); } if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.DBNull])) { throw new InvalidCastException("Object cannot be cast to DBNull."); } // TODO: SR //throw new InvalidCastException(SR.InvalidCast_DBNull); if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Empty])) { throw new InvalidCastException("Object cannot be cast to Empty."); } // TODO: SR //throw new InvalidCastException(SR.InvalidCast_Empty); throw new InvalidCastException(string.Format("Invalid cast from '{0}' to '{1}'.", value.GetType().FullName, targetType.FullName)); // TODO: SR //throw new InvalidCastException(string.Format(SR.InvalidCast_FromTo, value.GetType().FullName, targetType.FullName)); }
public static byte[] GetBytes(this IConvertible val) { return((byte[])bytesBitConverterProvider.Switch(val.GetType(), val)); }
internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { if (targetType == null) { throw new ArgumentNullException("targetType"); } if (value.GetType() == targetType) { return(value); } if (targetType == ConvertTypes[3]) { return(value.ToBoolean(provider)); } if (targetType == ConvertTypes[3]) { return(value.ToChar(provider)); } if (targetType == ConvertTypes[4]) { return(value.ToSByte(provider)); } if (targetType == ConvertTypes[5]) { return(value.ToByte(provider)); } if (targetType == ConvertTypes[6]) { return(value.ToInt16(provider)); } if (targetType == ConvertTypes[7]) { return(value.ToUInt16(provider)); } if (targetType == ConvertTypes[8]) { return(value.ToInt32(provider)); } if (targetType == ConvertTypes[9]) { return(value.ToUInt32(provider)); } if (targetType == ConvertTypes[10]) { return(value.ToInt64(provider)); } if (targetType == ConvertTypes[11]) { return(value.ToUInt64(provider)); } if (targetType == ConvertTypes[12]) { return(value.ToSingle(provider)); } if (targetType == ConvertTypes[13]) { return(value.ToDouble(provider)); } if (targetType == ConvertTypes[14]) { return(value.ToDecimal(provider)); } if (targetType == ConvertTypes[0xF]) { return(value.ToDateTime(provider)); } if (targetType == ConvertTypes[0x11]) { return(value.ToString(provider)); } if (targetType == ConvertTypes[0]) { return(value); } if (targetType == ConvertTypes[1]) { throw new InvalidCastException("Invalid Cast to DBDefault"); } throw new InvalidCastException(string.Format(CultureInfo.CurrentCulture, string.Format("Invalid Cast From {0} To {1}", value.GetType().FullName, targetType.FullName))); }
public static int MemSize(this IConvertible value) { return(value.GetType().MemSize()); }
public static object ConvertTo(this IConvertible convertibleValue, Type T) { if (convertibleValue == null) { return(null); } if (string.IsNullOrEmpty(convertibleValue.ToString())) { return(null); } if (!T.IsGenericType) { return(Convert.ChangeType(convertibleValue, T)); } else { Type genericTypeDefinition = T.GetGenericTypeDefinition(); if (genericTypeDefinition == typeof(Nullable <>)) { return(Convert.ChangeType(convertibleValue, Nullable.GetUnderlyingType(T))); } } throw new InvalidCastException(string.Format("Invalid cast from type \"{0}\" to type \"{1}\".", convertibleValue.GetType().FullName, T.FullName)); }
public static IType Create(IConvertible oIConvertible, IFormatProvider oIFormatProvider) { IType oIType; switch (oIConvertible.GetTypeCode()) { case TypeCode.Boolean: oIType = new BooleanType(oIConvertible, oIFormatProvider); break; case TypeCode.Byte: oIType = new Int16Type(oIConvertible, oIFormatProvider); break; case TypeCode.Char: oIType = new StringType(oIConvertible, oIFormatProvider); break; case TypeCode.DateTime: oIType = new DateTimeType(oIConvertible, oIFormatProvider); break; case TypeCode.DBNull: oIType = DataType.Empty(DataType.None); break; case TypeCode.Decimal: oIType = new DecimalType(oIConvertible, oIFormatProvider); break; case TypeCode.Double: oIType = new DoubleType(oIConvertible, oIFormatProvider); break; case TypeCode.Int16: oIType = new Int16Type(oIConvertible, oIFormatProvider); break; case TypeCode.Int32: oIType = new Int32Type(oIConvertible, oIFormatProvider); break; case TypeCode.Int64: oIType = new Int64Type(oIConvertible, oIFormatProvider); break; case TypeCode.Object: oIType = oIConvertible as IType ?? new StringType(oIConvertible, oIFormatProvider); break; case TypeCode.SByte: oIType = new Int16Type(oIConvertible, oIFormatProvider); break; case TypeCode.Single: oIType = new SingleType(oIConvertible, oIFormatProvider); break; case TypeCode.String: oIType = new StringType(oIConvertible, oIFormatProvider); break; default: throw new ArgumentException(string.Format("Invalid value type {0} specified", oIConvertible.GetType())); } return(oIType); }
/// <summary> /// 向属性填充值(强制使用指定的类型) /// </summary> /// <typeparam name="T"></typeparam> /// <param name="entity"></param> /// <param name="prop"></param> /// <param name="value"></param> /// <param name="specialType"></param> public static void FillSystemType <T>(T entity, PropertyInfo prop, IConvertible value, Type specialType) { object setValue = null; if (value.GetType() != specialType) { switch (specialType.Name) { case "Boolean": setValue = value.ConvertTo <bool>(); break; case "DateTime": setValue = DateTimeHelper.GetDateTimeFromXml(value.ToString()); break; case "Int32": setValue = value.ConvertTo <int>(); break; case "Int64": setValue = value.ConvertTo <long>(); break; case "Int64[]": setValue = Array.ConvertAll(value.ConvertTo <string>().Split(','), long.Parse); break; case "Double": setValue = value.ConvertTo <double>(); break; case "String": setValue = value.ToString(CultureInfo.InvariantCulture); break; default: setValue = value; break; } } switch (specialType.Name) { case "Nullable`1": //可为空对象 { if (!string.IsNullOrEmpty(value as string)) { var genericArguments = prop.PropertyType.GetGenericArguments(); FillSystemType(entity, prop, value, genericArguments[0]); } else { prop.SetValue(entity, null, null); //默认通常为null } break; } //case "String": // goto default; //case "Boolean": //case "DateTime": //case "Int32": //case "Int64": //case "Double": default: prop.SetValue(entity, setValue ?? value, null); break; } }
internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { BCLDebug.Assert(value!=null, "[Convert.DefaultToType]value!=null"); if (targetType==null) { throw new ArgumentNullException("targetType"); } if (value.GetType()==targetType) { return value; } if (targetType==ConvertTypes[(int)TypeCode.Boolean]) return value.ToBoolean(provider); if (targetType==ConvertTypes[(int)TypeCode.Char]) return value.ToChar(provider); if (targetType==ConvertTypes[(int)TypeCode.SByte]) return value.ToSByte(provider); if (targetType==ConvertTypes[(int)TypeCode.Byte]) return value.ToByte(provider); if (targetType==ConvertTypes[(int)TypeCode.Int16]) return value.ToInt16(provider); if (targetType==ConvertTypes[(int)TypeCode.UInt16]) return value.ToUInt16(provider); if (targetType==ConvertTypes[(int)TypeCode.Int32]) return value.ToInt32(provider); if (targetType==ConvertTypes[(int)TypeCode.UInt32]) return value.ToUInt32(provider); if (targetType==ConvertTypes[(int)TypeCode.Int64]) return value.ToInt64(provider); if (targetType==ConvertTypes[(int)TypeCode.UInt64]) return value.ToUInt64(provider); if (targetType==ConvertTypes[(int)TypeCode.Single]) return value.ToSingle(provider); if (targetType==ConvertTypes[(int)TypeCode.Double]) return value.ToDouble(provider); if (targetType==ConvertTypes[(int)TypeCode.Decimal]) return value.ToDecimal(provider); if (targetType==ConvertTypes[(int)TypeCode.DateTime]) return value.ToDateTime(provider); if (targetType==ConvertTypes[(int)TypeCode.String]) { return value.ToString(provider); } if (targetType==ConvertTypes[(int)TypeCode.Object]) return (Object)value; if (targetType==ConvertTypes[(int)TypeCode.DBNull]) throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull")); if (targetType==ConvertTypes[(int)TypeCode.Empty]) throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty")); throw new InvalidCastException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("InvalidCast_FromTo"), value.GetType().FullName, targetType.FullName)); }
internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { Contract.Requires(value != null, "[Convert.DefaultToType]value!=null"); if (targetType == null) { throw new ArgumentNullException("targetType"); } Contract.EndContractBlock(); if (value.GetType() == targetType) return value; if (targetType == CommonRuntimeTypes.Boolean) return value.ToBoolean(provider); if (targetType == CommonRuntimeTypes.Char) return value.ToChar(provider); if (targetType == CommonRuntimeTypes.SByte) return value.ToSByte(provider); if (targetType == CommonRuntimeTypes.Byte) return value.ToByte(provider); if (targetType == CommonRuntimeTypes.Int16) return value.ToInt16(provider); if (targetType == CommonRuntimeTypes.UInt16) return value.ToUInt16(provider); if (targetType == CommonRuntimeTypes.Int32) return value.ToInt32(provider); if (targetType == CommonRuntimeTypes.UInt32) return value.ToUInt32(provider); if (targetType == CommonRuntimeTypes.Int64) return value.ToInt64(provider); if (targetType == CommonRuntimeTypes.UInt64) return value.ToUInt64(provider); if (targetType == CommonRuntimeTypes.Single) return value.ToSingle(provider); if (targetType == CommonRuntimeTypes.Double) return value.ToDouble(provider); if (targetType == CommonRuntimeTypes.Decimal) return value.ToDecimal(provider); if (targetType == CommonRuntimeTypes.DateTime) return value.ToDateTime(provider); if (targetType == CommonRuntimeTypes.String) return value.ToString(provider); if (targetType == CommonRuntimeTypes.Object) return (Object)value; if (targetType == CommonRuntimeTypes.Enum) return (Enum)value; throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, value.GetType().ToString(), targetType.Name)); }
// Default implementation of the "ToType" methods in // the primitive classes like Byte, Int32, Boolean, etc. internal static Object DefaultToType(IConvertible obj, Type targetType, IFormatProvider provider, bool recursive) { if(targetType != null) { if(obj.GetType() == targetType) { return obj; } else if(targetType == ConvertTypes[(int)TypeCode.Boolean]) { return (Object)(obj.ToBoolean(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Char]) { return (Object)(obj.ToChar(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.SByte]) { return (Object)(obj.ToSByte(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Byte]) { return (Object)(obj.ToByte(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Int16]) { return (Object)(obj.ToInt16(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.UInt16]) { return (Object)(obj.ToUInt16(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Int32]) { return (Object)(obj.ToInt32(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.UInt32]) { return (Object)(obj.ToUInt32(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Int64]) { return (Object)(obj.ToInt64(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.UInt64]) { return (Object)(obj.ToUInt64(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Single]) { return (Object)(obj.ToSingle(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Double]) { return (Object)(obj.ToDouble(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Decimal]) { return (Object)(obj.ToDecimal(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.DateTime]) { return (Object)(obj.ToDateTime(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.String]) { return (Object)(obj.ToString(provider)); } else if(targetType == ConvertTypes[(int)TypeCode.Object]) { return obj; } else if(targetType == ConvertTypes[(int)TypeCode.Empty]) { throw new InvalidCastException (_("InvalidCast_Empty")); } else if(targetType == ConvertTypes[(int)TypeCode.DBNull]) { throw new InvalidCastException (_("InvalidCast_DBNull")); } else if(recursive) { throw new InvalidCastException (String.Format (_("InvalidCast_FromTo"), obj.GetType().FullName, targetType.FullName)); } else { // We weren't called from a "ToType" method, // so we can use it to handle the default case. return obj.ToType(targetType, provider); } } else { throw new ArgumentNullException("targetType"); } }
internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider) { if (targetType == null) { throw new ArgumentNullException("targetType"); } RuntimeType left = targetType as RuntimeType; if (left != null) { if (value.GetType() == targetType) { return value; } if (left == Convert.ConvertTypes[3]) { return value.ToBoolean(provider); } if (left == Convert.ConvertTypes[4]) { return value.ToChar(provider); } if (left == Convert.ConvertTypes[5]) { return value.ToSByte(provider); } if (left == Convert.ConvertTypes[6]) { return value.ToByte(provider); } if (left == Convert.ConvertTypes[7]) { return value.ToInt16(provider); } if (left == Convert.ConvertTypes[8]) { return value.ToUInt16(provider); } if (left == Convert.ConvertTypes[9]) { return value.ToInt32(provider); } if (left == Convert.ConvertTypes[10]) { return value.ToUInt32(provider); } if (left == Convert.ConvertTypes[11]) { return value.ToInt64(provider); } if (left == Convert.ConvertTypes[12]) { return value.ToUInt64(provider); } if (left == Convert.ConvertTypes[13]) { return value.ToSingle(provider); } if (left == Convert.ConvertTypes[14]) { return value.ToDouble(provider); } if (left == Convert.ConvertTypes[15]) { return value.ToDecimal(provider); } if (left == Convert.ConvertTypes[16]) { return value.ToDateTime(provider); } if (left == Convert.ConvertTypes[18]) { return value.ToString(provider); } if (left == Convert.ConvertTypes[1]) { return value; } if (left == Convert.EnumType) { return (Enum)value; } if (left == Convert.ConvertTypes[2]) { throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull")); } if (left == Convert.ConvertTypes[0]) { throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty")); } } throw new InvalidCastException(Environment.GetResourceString("InvalidCast_FromTo", new object[] { value.GetType().FullName, targetType.FullName })); }
/// <summary> /// Converts the given value object to a <c>ConnectionProtocol</c>. /// </summary> /// <param name="value">The value object to convert.</param> /// <returns>The result of the conversion.</returns> /// <exception cref="FormatException"> /// When <c>value</c> has an unsupported format. /// </exception> internal static ConnectionProtocol ConvertToConnectionProtocol(IConvertible value) { if (value == null) { return DefaultValueOf.Protocol; } byte b = ((IConvertible)value).ToByte(CultureInfo.InvariantCulture); Type t = typeof(ConnectionProtocol); if (!Enum.IsDefined(t, b)) { throw new FormatException(string.Format( "{0} value has an unsupported format: {1}", value.GetType().FullName, Convert.ToString(value))); } try { return (ConnectionProtocol)Enum.ToObject(t, b); } catch (Exception ex) { throw new FormatException(string.Format( "{0} value has an unsupported format: {1}", value.GetType().FullName, Convert.ToString(value)), ex); } }