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);
}
}
