|
public static ChangeType ( Object value, |
||
| value | Object | |
| conversionType | ||
| return | Object | |
public static T To <T>(this object obj, T defaultValue = default(T))
{
try
{
if (obj.IsNull())
{
return(defaultValue);
}
if (obj is T)
{
return((T)obj);
}
if (typeof(T) == typeof(Guid))
{
return(obj.ToGuid <T>());
}
if (typeof(T) == typeof(bool))
{
return(obj.ToBoolean <T>());
}
return((T)SystemConvert.ChangeType(obj, typeof(T)));
}
catch (Exception)
{
return(defaultValue);
}
}
/// <summary>
/// Modifies the source data before passing it to the target for display in the UI.
/// </summary>
/// <param name="value">The source data being passed to the target.</param>
/// <param name="targetType">The <see cref="T:System.Type"/> of data expected by the target dependency property.</param>
/// <param name="parameter">An optional parameter to be used in the converter logic.</param>
/// <param name="language">The culture of the conversion.</param>
/// <returns>
/// The value to be passed to the target dependency property.
/// </returns>
public object Convert(object value, Type targetType, object parameter, string language)
{
var result = 0;
var offset = 0;
if (parameter is int)
{
offset = (int)parameter;
}
else if (parameter is string)
{
int.TryParse((string)parameter, NumberStyles.Any, CultureInfo.InvariantCulture, out offset);
}
if (value != null)
{
result = (int)Converter.ChangeType(value, typeof(int), CultureInfo.InvariantCulture);
var typeInfo = value.GetType().GetTypeInfo();
if (typeInfo.IsClass || (typeInfo.IsGenericType && typeInfo.GetGenericTypeDefinition() == typeof(Nullable <>)))
{
result++;
}
result += offset;
}
return(result);
}
///// <summary>
///// 变更类型
///// </summary>
///// <param name="value">值</param>
///// <param name="type">类型</param>
//public static object ChangeType(string value, Type type)
//{
// object obj = null;
// var nullableType = Nullable.GetUnderlyingType(type);
// try
// {
// if (nullableType != null)
// {
// if (value == null)
// obj = null;
// else
// obj = OtherChangeType(value, type);
// }
// else if (typeof(Enum).IsAssignableFrom(type))
// {
// obj = Enum.Parse(type, value);
// }
// else
// {
// obj = Convert.ChangeType(value, type);
// }
// return obj;
// }
// catch
// {
// return default;
// }
//}
/// <summary>
/// 变更类型
/// </summary>
/// <param name="value">值</param>
/// <param name="type">类型</param>
/// <param name="cell">单元格</param>
public static object ChangeType(object value, Type type, ICell cell)
{
try
{
if (value == null && type.IsGenericType)
{
return(Activator.CreateInstance(type));
}
if (value == null || string.IsNullOrWhiteSpace(value.ToString()))
{
return(null);
}
if (type == value.GetType())
{
return(value);
}
if (type.IsEnum)
{
if (value is string)
{
return(Enum.Parse(type, value as string));
}
else
{
return(Enum.ToObject(type, value));
}
}
if (!type.IsInterface && type.IsGenericType)
{
Type innerType = type.GetGenericArguments()[0];
object innerValue = ChangeType(value, innerType, cell);
return(Activator.CreateInstance(type, new object[] { innerValue }));
}
if (value is string && type == typeof(Guid))
{
return(new Guid(value as string));
}
if (value is string && type == typeof(Version))
{
return(new Version(value as string));
}
if (!(value is IConvertible))
{
return(value);
}
return(Convert.ChangeType(value, type));
}
catch (Exception ex)
{
throw new OfficeDataConvertException($"值转换失败。输入值为: {value}, 目标类型为: {type.FullName}", ex)
{
PrimitiveType = value.GetType(),
TargetType = type,
Value = value,
RowIndex = cell.RowIndex + 1,
ColumnIndex = cell.ColumnIndex + 1,
Name = cell.Name,
};
}
}
private IfcValue ConvertToIfcValue(AttributeValue valueBaseType)
{
var decimalType = valueBaseType as DecimalAttributeValue;
if (decimalType != null && decimalType.Value.HasValue)
{
return(new IfcReal((double)SystemConvert.ChangeType(decimalType.Value.Value, typeof(double))));
}
var stringType = valueBaseType as StringAttributeValue;
if (stringType != null && !string.IsNullOrEmpty(stringType.Value))
{
return(new IfcText((string)SystemConvert.ChangeType(stringType.Value, typeof(string))));
}
var integerType = valueBaseType as IntegerAttributeValue;
if (integerType != null)
{
return(new IfcInteger((int)SystemConvert.ChangeType(integerType.Value, typeof(int))));
}
var booleanType = valueBaseType as BooleanAttributeValue;
if (booleanType != null)
{
return(new IfcBoolean((bool)SystemConvert.ChangeType(booleanType.Value, typeof(bool))));
}
return(default(IfcText));
}
/// <summary>
/// Converts an attribute to the required type if possible
/// </summary>
/// <param name="attributeValue"></param>
/// <typeparam name="TType"></typeparam>
/// <returns></returns>
public TType ConvertTo <TType>(AttributeValue attributeValue)
{
var decimalType = attributeValue as DecimalAttributeValue;
if (decimalType != null && decimalType.Value.HasValue)
{
return((TType)SystemConvert.ChangeType(decimalType.Value.Value, typeof(TType)));
}
var stringType = attributeValue as StringAttributeValue;
if (stringType != null && !string.IsNullOrWhiteSpace(stringType.Value))
{
return((TType)SystemConvert.ChangeType(stringType.Value, typeof(TType)));
}
var integerType = attributeValue as IntegerAttributeValue;
if (integerType != null)
{
return((TType)SystemConvert.ChangeType(integerType.Value, typeof(TType)));
}
var booleanType = attributeValue as BooleanAttributeValue;
if (booleanType != null)
{
return((TType)SystemConvert.ChangeType(booleanType.Value, typeof(TType)));
}
return(default(TType));
}
/// <summary>
/// Converts a value to the given <see cref="TypeCode"/>.
/// </summary>
/// <param name="value">The object to convert.</param>
/// <param name="typeCode">The <see cref="TypeCode"/> into which <paramref name="value"/> is converted.</param>
/// <returns>The converted <paramref name="value"/> or null if the <paramref name="typeCode"/> parameter is <see cref="TypeCode.Empty"/>.</returns>
public object Convert(object value, TypeCode typeCode)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
return(SConvert.ChangeType(value, typeCode, CultureInfo.InvariantCulture));
}
private static object GetConvertibleValue(Type type, string value)
{
try
{
return(Convert.ChangeType(value, type));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// 将指定的 <see cref="IConvertible"/> 数字转换为其对应的对数。
/// </summary>
/// <param name="value">要转换的 <see cref="IConvertible"/> 数字。</param>
/// <param name="targetType">绑定目标属性的类型。</param>
/// <param name="parameter">表示对数的底的转换器参数。默认为常数 <see langword="e"/>。</param>
/// <param name="culture">要用在转换器中的区域性。</param>
/// <returns><paramref name="value"/> 的底为 <paramref name="parameter"/> 的对数。</returns>
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
try
{
var number = Convertible.ToDouble(value ?? 0.0, culture);
var @base = Convertible.ToDouble(parameter ?? Math.E, culture);
var result = Math.Log(number, @base);
return(Convertible.ChangeType(result, targetType, culture));
}
catch (Exception) { return(DependencyProperty.UnsetValue); }
}
static object TryConvertPrimitiveType(object value, Type toType)
{
try
{
return(Convert.ChangeType(value, toType));
}
catch (InvalidCastException)
{
}
catch (OverflowException)
{
}
return(System.Activator.CreateInstance(toType));
}
public object CreateValueForField(object fieldValue)
{
object val = null;
if (fieldValue == null)
{
if (mNullValue == null)
{
if (mFieldType.IsValueType)
{
throw new BadUsageException("Null Value found. You must specify a NullValueAttribute in the " + mFieldInfo.Name +
" field of type " + mFieldInfo.FieldType.Name + ", because this is a ValueType.");
}
else
{
val = null;
}
}
else
{
val = mNullValue;
}
}
else if (mFieldType == (Type)fieldValue)
{
val = fieldValue;
}
else
{
if (mConvertProvider == null)
{
val = Convert.ChangeType(fieldValue, mFieldType, null);
}
else
{
try
{
val = Convert.ChangeType(fieldValue, mFieldType, null);
}
catch
{
val = mConvertProvider.StringToField(fieldValue.ToString());
}
}
}
return(val);
}
public object ConvertBack(
object value,
Type targetType,
object parameter,
CultureInfo culture)
{
if (value == null)
{
return(null);
}
if (targetType.IsAssignableFrom(value.GetType()))
{
return(value);
}
return(SysConvert.ChangeType(value, targetType, culture));
}
public Expression Convert(object validator, Expression member)
{
var rangeAttr = (RangeAttribute)validator;
if (rangeAttr.OperandType.Equals(member.Type))
{
return(Expression.AndAlso(
Expression.LessThanOrEqual(
Expression.Constant(TypeConverter.ChangeType(rangeAttr.Minimum, rangeAttr.OperandType), rangeAttr.OperandType),
member),
Expression.LessThanOrEqual(
member,
Expression.Constant(TypeConverter.ChangeType(rangeAttr.Maximum, rangeAttr.OperandType), rangeAttr.OperandType))));
}
else
{
return(Expression.Constant(true));
}
}
public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
{
var result = new object[targetTypes.Length];
if (targetTypes.Length >= 1)
{
try
{
result[0] = SystConvert.ChangeType(value, targetTypes[0]);
}
catch (Exception)
{
result[0] = SystConvert.ChangeType(parameter, targetTypes[0]);
}
for (int i = 1; i < targetTypes.Length; i++)
{
result[i] = true;
}
}
return(result);
}
public static object Parse (Type enumType, string value, bool ignoreCase)
{
if (enumType == null)
throw new ArgumentNullException ("enumType");
if (value == null)
throw new ArgumentNullException ("value");
if (!enumType.IsEnum)
throw new ArgumentException ("enumType is not an Enum type.", "enumType");
value = value.Trim ();
if (value.Length == 0)
throw new ArgumentException ("An empty string is not considered a valid value.");
MonoEnumInfo info;
MonoEnumInfo.GetInfo (enumType, out info);
// is 'value' a named constant?
int loc = FindName (info.name_hash, info.names, value, ignoreCase);
if (loc >= 0)
return info.values.GetValue (loc);
TypeCode typeCode = ((Enum) info.values.GetValue (0)).GetTypeCode ();
// is 'value' a list of named constants?
if (value.IndexOf (',') != -1) {
string [] names = value.Split (split_char);
ulong retVal = 0;
for (int i = 0; i < names.Length; ++i) {
loc = FindName (info.name_hash, info.names, names [i].Trim (), ignoreCase);
if (loc < 0)
throw new ArgumentException ("The requested value was not found.");
retVal |= GetValue (info.values.GetValue (loc), typeCode);
}
return ToObject (enumType, retVal);
}
// is 'value' a number?
#if !NET_2_0
try {
return ToObject (enumType, Convert.ChangeType (value, typeCode));
} catch (FormatException) {
throw new ArgumentException (String.Format ("The requested value '{0}' was not found.", value));
}
#else
switch (typeCode) {
case TypeCode.SByte:
sbyte sb;
if (SByte.TryParse (value, out sb))
return ToObject (enumType, sb);
break;
case TypeCode.Byte:
byte b;
if (Byte.TryParse (value, out b))
return ToObject (enumType, b);
break;
case TypeCode.Int16:
short i16;
if (Int16.TryParse (value, out i16))
return ToObject (enumType, i16);
break;
case TypeCode.UInt16:
ushort u16;
if (UInt16.TryParse (value, out u16))
return ToObject (enumType, u16);
break;
case TypeCode.Int32:
int i32;
if (Int32.TryParse (value, out i32))
return ToObject (enumType, i32);
break;
case TypeCode.UInt32:
uint u32;
if (UInt32.TryParse (value, out u32))
return ToObject (enumType, u32);
break;
case TypeCode.Int64:
long i64;
if (Int64.TryParse (value, out i64))
return ToObject (enumType, i64);
break;
case TypeCode.UInt64:
ulong u64;
if (UInt64.TryParse (value, out u64))
return ToObject (enumType, u64);
break;
default:
break;
}
throw new ArgumentException (String.Format ("The requested value '{0}' was not found.", value));
#endif
}
internal object AssignFromString(ExtractedInfo fieldString, LineInfo line)
{
object val;
switch (mTrimMode)
{
case TrimMode.None:
break;
case TrimMode.Both:
fieldString.TrimBoth(mTrimChars);
break;
case TrimMode.Left:
fieldString.TrimStart(mTrimChars);
break;
case TrimMode.Right:
fieldString.TrimEnd(mTrimChars);
break;
}
try
{
if (mConvertProvider == null)
{
if (mIsStringField)
{
val = fieldString.ExtractedString();
}
else
{
// Trim it to use Convert.ChangeType
fieldString.TrimBoth(WhitespaceChars);
if (fieldString.Length == 0)
{
// Empty stand for null
val = GetNullValue();
}
else
{
val = Convert.ChangeType(fieldString.ExtractedString(), mFieldType, null);
}
}
}
else
{
if (mConvertProvider.CustomNullHandling == false &&
fieldString.HasOnlyThisChars(WhitespaceChars))
{
val = GetNullValue();
}
else
{
var from = fieldString.ExtractedString();
val = mConvertProvider.StringToField(from);
if (val == null)
{
val = GetNullValue();
}
}
}
return(val);
}
catch (ConvertException ex)
{
var e = ConvertException.ReThrowException(ex, mFieldInfo.Name, line.mReader.LineNumber, fieldString.ExtractedFrom + 1);
throw e;
}
}
/// <summary>
/// Converts given object to a value type using <see cref="Convert.ChangeType(object,System.Type)" /> method.
/// </summary>
/// <typeparam name="T">Type of the target object</typeparam>
/// <param name="obj">Object to be converted</param>
/// <returns>Converted object</returns>
public static T To <T>(this object obj)
where T : struct
{
return((T)Convert.ChangeType(obj, typeof(T), CultureInfo.InvariantCulture));
}
/// <summary>
/// 动态调用IService 服务
/// </summary>
/// <param name="serviceString">服务名称:比如IServicer</param>
/// <param name="methodString">方法名称：比如GetSingle</param>
/// <param name="runInUrl">是否可以在Url中运行</param>
/// <param name="paramaters">参数</param>
public static Tuple <ServiceResult, object> ResolveMethod(string serviceString, string methodString,
bool runInUrl = false, params object[] paramaters)
{
//var type = Reflection.GetAllServices().FirstOrDefault(e => e.Name.EndsWith(serviceString, StringComparison.OrdinalIgnoreCase));
var instanse = Resolve(serviceString);
if (instanse == null)
{
return(Tuple.Create(ServiceResult.FailedWithMessage($"未找到{serviceString}服务，检查拼写是否正确"), new object()));
}
var methods = instanse.GetType().GetMethods()
.Where(e => e.Name.Equals(methodString, StringComparison.OrdinalIgnoreCase));
if (methods == null || methods.Count() < 0)
{
return(Tuple.Create(ServiceResult.FailedWithMessage($"未找到{methodString}方法，检查拼写是否正确"), new object()));
}
var method = methods.FirstOrDefault();
if (method == null)
{
return(Tuple.Create(ServiceResult.FailedWithMessage($"未找到{methodString}方法，检查拼写是否正确"), new object()));
}
var instanseExpression = Expression.Convert(Expression.Constant(instanse), instanse.GetType());
// 参数类型是否与当前方法匹配，同时获取参数
var isMatching = false;
ConstantExpression[] parameterExpressions = null;
foreach (var item in methods)
{
method = item;
isMatching = true;
if (paramaters != null && paramaters.Length > 0)
{
parameterExpressions = new ConstantExpression[paramaters.Length];
var methodParameters = method.GetParameters();
// 参数数量是否相同
if (methodParameters.Count() != paramaters.Length)
{
isMatching = false;
continue;
}
for (var i = 0; i < paramaters.Length; i++)
{
try {
if (methodParameters[i].ParameterType == typeof(Guid))
{
parameterExpressions[i] = Expression.Constant(Guid.Parse(paramaters[i].ToString()),
methodParameters[i].ParameterType);
}
else
{
parameterExpressions[i] = Expression.Constant(
Convert.ChangeType(paramaters[i], methodParameters[i].ParameterType),
methodParameters[i].ParameterType);
}
} catch (Exception ex) {
Console.WriteLine(ex.Message);
isMatching = false;
}
}
}
if (isMatching)
{
break;
}
}
// 如果方法在URl中执行，检查方法的安全设置
if (runInUrl)
{
var attribute = method.GetAttribute <MethodAttribute>();
if (attribute == null || attribute.RunInUrl == false)
{
return(Tuple.Create(ServiceResult.FailedWithMessage("该方法未非安全方法，不能通过Url方式来执行，请设置Method特性"),
new object()));
}
}
if (isMatching == false)
{
return(Tuple.Create(ServiceResult.FailedWithMessage($"参数传递不正确，，检查参数是否与{serviceString}.{method}中的方法一样"),
new object()));
}
var callExpression = parameterExpressions == null
? Expression.Call(instanseExpression, method)
: Expression.Call(instanseExpression, method, parameterExpressions);
if (method.ReturnType == typeof(void))
{
var lambdaExpression = Expression.Lambda <Action>(callExpression, null);
lambdaExpression.Compile()();
return(Tuple.Create(ServiceResult.Success, new object()));
}
else
{
var convertExpression = Expression.Convert(callExpression, typeof(object));
var lambdaExpression = Expression.Lambda <Func <object> >(convertExpression, null);
var result = lambdaExpression.Compile()();
return(Tuple.Create(ServiceResult.Success, result));
}
}
static System.Func <object, object> GetConverter(Type fromType, Type toType)
{
if (typeof(UnityObject).IsAssignableFrom(fromType))
{
if (toType.IsAssignableFrom(fromType))
{
return(t => ConvertUnityObject(t, toType));
}
else
{
return(null);
}
}
Dictionary <System.Type, System.Func <object, object> > converters = null;
if (!s_Converters.TryGetValue(fromType, out converters))
{
converters = new Dictionary <System.Type, System.Func <object, object> >();
s_Converters.Add(fromType, converters);
}
System.Func <object, object> converter = null;
if (!converters.TryGetValue(toType, out converter))
{
if (fromType == toType || toType.IsAssignableFrom(fromType))
{
converter = t => t;
}
else if (toType.IsEnum && (fromType == typeof(uint) || fromType == typeof(int)))
{
if (fromType == typeof(uint))
{
converter = t => Enum.ToObject(toType, (uint)t);
}
else
{
converter = t => Enum.ToObject(toType, (int)t);
}
}
else if (fromType.IsEnum && (toType == typeof(uint) || toType == typeof(int)))
{
converter = t => Convert.ChangeType(t, toType);
}
else
{
var implicitMethod = fromType.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)
.FirstOrDefault(m => m.Name == "op_Implicit" && m.ReturnType == toType);
if (implicitMethod != null)
{
converter = t => implicitMethod.Invoke(null, new object[] { t });
}
else
{
implicitMethod = toType.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)
.FirstOrDefault(m => m.Name == "op_Implicit" && m.GetParameters()[0].ParameterType == fromType && m.ReturnType == toType);
if (implicitMethod != null)
{
converter = t => implicitMethod.Invoke(null, new object[] { t });
}
}
if (converter == null)
{
if (toType.IsPrimitive)
{
if (fromType.IsPrimitive)
{
converter = t => TryConvertPrimitiveType(t, toType);
}
else if (toType != typeof(float))
{
var floatConverter = GetConverter(fromType, typeof(float));
if (floatConverter != null)
{
converter = t => TryConvertPrimitiveType(floatConverter(t), toType);
}
}
}
}
}
converters.Add(toType, converter);
}
return(converter);
}
public static T LastOrNull <T>(this IEnumerable <T> enumerable)
{
var en = enumerable as T[] ?? enumerable.ToArray();
return(en.Any() ? en.Last() : (T)Convert.ChangeType(null, typeof(T)));
}
public static T EvalToType <T>(string expression)
{
_CheckMono();
return(( T )Convert.ChangeType(EvalToObject(expression), typeof(T)));
}
public object Convert(object value, TypeCode typeCode)
=> SystemConvert.ChangeType(value, typeCode);
