public static bool TryTo <T>(
this object value,
out T result,
string format = "")
{
result = default(T);
if (null == value)
{
return(false);
}
var str = value.ToString();
if (IsJson(str))
{
var t = typeof(T);
if (
!t.IsPrimitive
&&
!t.Is <string>()
&&
!t.Is <byte[]>())
{
try {
result = JsonConvert
.DeserializeObject <T>(str);
return(true);
} catch (Exception ex) {
LogRecord
.Create("Json deserialization error")
//.Add("Json", str)
//.Add("ConvertToType", t.Name)
//.Add(ex)
.Error();
}
}
}
if (value.Is <T>())
{
try {
result = (T)value;
return(true);
} catch { }
}
object val;
if (TryTo(value, typeof(T), out val, format))
{
try {
result = (T)val;
return(true);
} catch { }
}
return(false);
}
public static string Join(
this object[] cols,
Func <object, string> transfer,
string separator,
string quoter0,
string quoter9)
{
if (cols.NullOrEmpty())
{
return(string.Empty);
}
if (separator.NullOrEmpty())
{
separator = string.Empty;
}
if (quoter0.NullOrEmpty())
{
quoter0 = string.Empty;
}
if (quoter9.NullOrEmpty())
{
quoter9 = string.Empty;
}
var sb = new StringBuilder();
foreach (var x in cols)
{
var val = string.Empty;
if (null == transfer)
{
val = x.ToStringX();
}
else
{
try {
val = transfer(x);
} catch (Exception ex) {
LogRecord
.Create("Extender")
.Error();
}
}
sb.Append(quoter0);
sb.Append(val);
sb.Append(quoter9);
sb.Append(separator);
}
return(sb.ToString().TrimEnd(separator));
}
public static List <Type> GatherByInterface(
this Assembly assembly,
Type type)
{
if (null == assembly)
{
return(new List <Type>());
}
var types = new Type[0];
try {
types = Reflector.GetTypes(assembly);
} catch (Exception ex) {
var record = LogRecord.Create("GatherByInterface");
//record.Add("AssemblyFullName", assembly.FullName);
var e = ex as ReflectionTypeLoadException;
if (null != e)
{
foreach (var x in e.LoaderExceptions)
{
//record.Add("LoadExceptions", x.Message);
}
}
//record.Add(ex).Error();
}
if (null == types || types.Length == 0)
{
return(new List <Type>());
}
var interfaceName = type.Name;
var list = new List <Type>();
foreach (var x in types)
{
if (!x.IsClass || x.IsAbstract)
{
continue;
}
if (!x.IsDerived(type))
{
continue;
}
list.Add(x);
}
return(list);
}
public static string GetFriendlyName(this Type type)
{
try {
if (null == type)
{
return(string.Empty);
}
if (type.IsGenericParameter)
{
return(type.Name);
}
if (!type.IsGenericType)
{
return(type.FullName);
}
var sb = new StringBuilder();
var name = type.Name;
var index = name.IndexOf(Symbol.BackQuoter);
sb.AppendFormat(
"{0}.{1}",
type.Namespace,
name.Substring(0, index)
);
sb.Append(Symbol.LessThan);
var first = true;
foreach (var arg in type.GetGenericArguments())
{
if (!first)
{
sb.Append(Symbol.CommaSpace);
}
sb.Append(arg.GetFriendlyName());
first = false;
}
sb.Append(Symbol.GreaterThan);
return(sb.ToString());
} catch (Exception ex) {
LogRecord
.Create("Extender")
.SetMessage("Type.GetFriendlyName()")
//.Add(ex)
.Error();
return(string.Empty);
}
}
public static Type[] GetTypes(Assembly assembly)
{
try {
var types = assembly.GetTypes();
return(types);
} catch (ReflectionTypeLoadException lex) {
LogRecord
.Create()
//.Add("Assembly", assembly.FullName)
//.Add(lex)
//.Add(lex.LoaderExceptions)
.Error();
} catch (Exception ex) {
LogRecord
.Create()
//.Add("Assembly", assembly.FullName)
//.Add(ex)
//.Add(ex.InnerException)
.Error();
}
return(new Type[0]);
}
public static IDictionary <string, T> CollectImplementedObject <T>(
Assembly asm)
where T : class
{
Checker.NotNullArgument(asm, "asm").Throw();
var list = new Dictionary <string, T>();
try {
var types = asm.GatherByInterface <T>();
if (types.Any())
{
foreach (var type in types)
{
if (type.IsAbstract)
{
continue;
}
var one = Activator.CreateInstance(type);
T t = one as T;
if (null == t)
{
continue;
}
list.Add(type.FullName, t);
}
}
} catch (Exception ex) {
LogRecord
.Create()
//.Add("Assembly", asm.FullName)
//.Add("ObjectType", typeof(T).Name)
//.Add(ex)
.Error();
}
return(list);
}
public static string Path(this MethodBase method)
{
if (null == method)
{
LogRecord
.Create("Extender")
.SetMessage("MethodBase.Path(), MethodBase is null.")
.Error();
return(string.Empty);
}
var type = method.ReflectedType;
var methodName = method.Name;
if (null == type)
{
return(methodName);
}
var friendlyName = type.GetFriendlyName();
var path = string.Format("{0}.{1}", friendlyName, methodName);
return(path);
}
private static bool TryFromInt64(
long value,
XInfo from,
XInfo to,
out object result,
string format)
{
result = GetDefaultValue(to.Category);
switch (to.Category)
{
case TypeCategory.Array:
if (to.IsBytes)
{
result = BitConverter.GetBytes(value);
return(true);
}
return(TryToArray(
from,
to,
value,
out result,
format
));
case TypeCategory.Int64:
result = value;
return(true);
case TypeCategory.Stream:
var bytes = BitConverter.GetBytes(value);
result = new MemoryStream(bytes);
return(true);
case TypeCategory.Enum:
case TypeCategory.String:
var s = value.ToString();
return(TryFromString(
s,
XInfo.String.Value,
to,
out result,
format
));
case TypeCategory.Char:
result = Convert.ToChar(value);
return(true);
case TypeCategory.Boolean:
result = value > 0;
return(true);
case TypeCategory.Color:
var i = (Int32)value;
if (!NumericCompare(value, result))
{
return(false);
}
return(TryFromInt32(
i,
XInfo.Int32.Value,
to,
out result,
format
));
case TypeCategory.DateTime:
try {
result = DateTime.FromBinary(value);
return(true);
} catch (Exception ex) {
LogRecord
.Create()
//.Add("value", value)
//.Add(ex)
.Error();
return(false);
}
case TypeCategory.Decimal:
result = (Decimal)value;
return(NumericCompare(value, result));
case TypeCategory.Byte:
checked { result = (Byte)value; }
return(NumericCompare(value, result));
case TypeCategory.SByte:
checked { result = (SByte)value; }
return(NumericCompare(value, result));
case TypeCategory.Int16:
checked { result = (Int16)value; }
return(NumericCompare(value, result));
case TypeCategory.UInt16:
checked { result = (UInt16)value; }
return(NumericCompare(value, result));
case TypeCategory.Int32:
checked { result = (Int32)value; }
return(NumericCompare(value, result));
case TypeCategory.UInt32:
checked { result = (UInt32)value; }
return(NumericCompare(value, result));
case TypeCategory.UInt64:
checked { result = (UInt64)value; }
return(NumericCompare(value, result));
case TypeCategory.Single:
result = (Single)value;
return(NumericCompare(value, result));
case TypeCategory.Double:
result = (Double)value;
return(NumericCompare(value, result));
case TypeCategory.Interface:
case TypeCategory.Class:
case TypeCategory.Struct:
case TypeCategory.IntPtr:
case TypeCategory.UIntPtr:
case TypeCategory.Null:
case TypeCategory.Others:
default:
return(false);
}
}
private static bool TryFromString(
string value,
XInfo from,
XInfo to,
out object result,
string format)
{
result = GetDefaultValue(to.Category);
decimal decimalVal;
var decimalFlag = decimal.TryParse(value, out decimalVal);
switch (to.Category)
{
case TypeCategory.Array:
if (to.IsBytes)
{
result = IsToConfig.Encoding.GetBytes(value);
return(true);
}
var firstElement = to
.ElementInfos
.FirstOrDefault();
if (
null != firstElement
&&
firstElement.Category
==
TypeCategory.Class)
{
if (!IsJson(value))
{
return(false);
}
result = JsonConvert.DeserializeObject(
value,
to.Type
);
return(true);
}
return(TryToArray(
from,
to,
value,
out result,
format
));
case TypeCategory.String:
result = value;
return(true);
case TypeCategory.Stream:
result = new MemoryStream(value.To <byte[]>());
return(true);
case TypeCategory.Enum:
result = IsToConverter.FromString.ToEnum(
to.Type,
value
);
return(true);
case TypeCategory.Class:
case TypeCategory.Struct:
if (IsJson(value))
{
result = JsonConvert.DeserializeObject(
value,
to.Type
);
return(true);
}
return(false);
case TypeCategory.DateTime:
DateTime val;
if (DateTime.TryParse(value, out val))
{
result = val;
return(true);
}
else
{
int[] points;
if (TryParseDate(value, out points))
{
try {
var millisecond = points[6]
.To <string>()
.Left(3)
.To <int>();
result = new DateTime(
ToExtender.Enclosed(points[0], 1, 9999),
ToExtender.Enclosed(points[1], 1, 12),
ToExtender.Enclosed(points[2], 1, 31),
ToExtender.Enclosed(points[3], 0, 23),
ToExtender.Enclosed(points[4], 0, 59),
ToExtender.Enclosed(points[5], 0, 59),
millisecond
);
} catch (Exception ex) {
LogRecord
.Create()
//.Add("Value", value)
//.Add("From", from.FullName)
//.Add("To", to.FullName)
//.Add(
// "Points",
// points
// .Select(x => x.ToString())
// .Join(Symbol.CommaSpace)
//)
//.Add(ex)
.Error();
return(false);
}
return(true);
}
else
{
return(false);
}
}
case TypeCategory.Boolean:
if (IsNumeric(value))
{
var i = value.To <int>();
result = i > 0;
return(true);
}
foreach (var one in IsToConfig.TrueStringArray)
{
if (one.Equals(
value,
StringComparison.OrdinalIgnoreCase))
{
result = true;
break;
}
}
return(true);
case TypeCategory.Char:
result = Convert.ToChar(value);
return(true);
case TypeCategory.Decimal:
result = decimalVal;
return(decimalFlag);
case TypeCategory.Byte:
if (!decimalFlag)
{
return(false);
}
byte byteVal;
if (decimalVal.TryTo <byte>(out byteVal))
{
result = byteVal;
return(true);
}
else
{
return(false);
}
case TypeCategory.SByte:
if (!decimalFlag)
{
return(false);
}
sbyte sbyteVal;
if (decimalVal.TryTo <sbyte>(out sbyteVal))
{
result = sbyteVal;
return(true);
}
else
{
return(false);
}
case TypeCategory.Int16:
if (!decimalFlag)
{
return(false);
}
Int16 int16Val;
if (decimalVal.TryTo <Int16>(out int16Val))
{
result = int16Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.UInt16:
if (!decimalFlag)
{
return(false);
}
UInt16 uint16Val;
if (decimalVal.TryTo <UInt16>(out uint16Val))
{
result = uint16Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.Int32:
if (!decimalFlag)
{
return(false);
}
Int32 int32Val;
if (decimalVal.TryTo <Int32>(out int32Val))
{
result = int32Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.UInt32:
if (!decimalFlag)
{
return(false);
}
UInt32 uint32Val;
if (decimalVal.TryTo <UInt32>(out uint32Val))
{
result = uint32Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.Int64:
if (!decimalFlag)
{
return(false);
}
Int64 int64Val;
if (decimalVal.TryTo <Int64>(out int64Val))
{
result = int64Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.UInt64:
if (!decimalFlag)
{
return(false);
}
UInt64 uint64Val;
if (decimalVal.TryTo <UInt64>(out uint64Val))
{
result = uint64Val;
return(true);
}
else
{
return(false);
}
case TypeCategory.Single:
if (!decimalFlag)
{
return(false);
}
Single singleVal;
if (decimalVal.TryTo <Single>(out singleVal))
{
result = singleVal;
return(true);
}
else
{
return(false);
}
case TypeCategory.Double:
if (!decimalFlag)
{
return(false);
}
Double doubleVal;
if (decimalVal.TryTo <Double>(out doubleVal))
{
result = doubleVal;
return(true);
}
else
{
return(false);
}
case TypeCategory.Interface:
case TypeCategory.IntPtr:
case TypeCategory.UIntPtr:
case TypeCategory.Null:
case TypeCategory.Others:
default:
return(false);
}
}
private static bool TryFromClass(
object value,
XInfo from,
XInfo to,
out object result,
string format)
{
result = GetDefaultValue(to.Category);
switch (to.Category)
{
case TypeCategory.Array:
return(TryToArray(
from,
to,
value,
out result,
format
));
case TypeCategory.Class:
if (from.Equals(to))
{
result = value;
return(true);
}
var underlyingType = Nullable.GetUnderlyingType(
to.Type
);
var converter = underlyingType == null
? TypeDescriptor.GetConverter(to.Type)
: TypeDescriptor.GetConverter(underlyingType);
if (null != converter)
{
try {
result = converter.ConvertFrom(value);
return(true);
} catch (Exception ex) {
LogRecord
.Create()
//.Add("Typeconverter", converter.GetType().Name)
//.Add("From", from?.Type.Name)
//.Add("To", to?.Type.Name)
//.Add("ValueType", value?.GetType().Name)
//.Add("Value", value)
//.Add(ex)
.Error();
}
}
result = ForceClone(value, to.Type);
return(true);
case TypeCategory.Struct:
var dic = GetValues(value);
result = SetValues(dic, to.Type);
return(true);
case TypeCategory.Enum:
case TypeCategory.Interface:
case TypeCategory.Stream:
case TypeCategory.Color:
case TypeCategory.String:
case TypeCategory.DateTime:
case TypeCategory.Decimal:
case TypeCategory.Boolean:
case TypeCategory.Char:
case TypeCategory.Byte:
case TypeCategory.SByte:
case TypeCategory.Int16:
case TypeCategory.UInt16:
case TypeCategory.Int32:
case TypeCategory.UInt32:
case TypeCategory.IntPtr:
case TypeCategory.UIntPtr:
case TypeCategory.Int64:
case TypeCategory.UInt64:
case TypeCategory.Single:
case TypeCategory.Double:
case TypeCategory.Null:
case TypeCategory.Others:
default:
return(false);
}
}
private static bool TryToArray(
XInfo from,
XInfo to,
object value,
out object result,
string format = "")
{
result = null;
try {
var elementType = to
.ElementInfos
.FirstOrDefault()
.Type;
var genericListTypeRunTime = typeof(List <>)
.MakeGenericType(new[] { elementType });
var genericList = Activator.CreateInstance(
genericListTypeRunTime
);
var genericListType = genericList.GetType();
// Add
var addInfo = genericListType
.GetMethods()
.FirstOrDefault(x => x.Name == "Add");
if (from.Category == TypeCategory.Array)
{
if (to.ElementInfos.Count() == 1)
{
var datas = value as IEnumerable;
if (null != datas)
{
var en = datas.GetEnumerator();
while (en.MoveNext())
{
object val;
if (TryTo(
en.Current,
elementType,
out val))
{
addInfo.Invoke(
genericList,
new object[] { val }
);
}
else
{
return(false);
}
}
}
}
else
{
//
}
}
else
{
if (to.ElementInfos.Count() == 1)
{
object val;
if (value.Is(elementType))
{
addInfo.Invoke(
genericList,
new object[] { value }
);
}
else
{
if (TryTo(value, elementType, out val))
{
addInfo.Invoke(
genericList,
new object[] { val }
);
}
else
{
return(false);
}
}
}
else
{
//
}
}
if (to.Type.FullName == genericListType.FullName)
{
// List
result = genericList;
}
else if (to.Type.Is <IQueryable>())
{
// IQueryable
result = ((IList)genericList).AsQueryable();
}
else if (
to.Category == TypeCategory.Interface
&&
to.Type.Is <IList>())
{
// IList
result = (IList)genericList;
}
else
{
// Array
var toarrayInfo = genericListType
.GetMethods()
.FirstOrDefault(x => x.Name == "ToArray");
if (null == toarrayInfo)
{
return(false);
}
result = toarrayInfo.Invoke(
genericList,
new object[] { }
);
}
return(true);
} catch (Exception ex) {
LogRecord
.Create()
//.Add("From", from?.Type.Name)
//.Add("To", to?.Type.Name)
//.Add("ValueType", value?.GetType().Name)
//.Add("Value", value)
//.Add(ex)
.Error();
return(false);
}
}
private static bool TryTo(
object value,
Type type,
out object result,
string format = "")
{
result = string.Empty;
if (null == value || null == type)
{
return(false);
}
var from = ToCache.Get(value);
var interceptor = ToInterceptor.Get(from.Type);
if (null != interceptor)
{
return(interceptor.TryTo(
value,
type,
out result,
format
));
}
var to = ToCache.Get(type);
try {
switch (from.Category)
{
case TypeCategory.Array:
object arry = value as Array;
if (null == arry)
{
var toarrayInfo = from
.Type
.GetMethods()
.FirstOrDefault(x =>
x.Name == "ToArray"
);
if (null == toarrayInfo)
{
return(false);
}
arry = toarrayInfo.Invoke(
value,
new object[] { }
);
}
if (null == arry)
{
return(false);
}
return(TryFromArray(
arry as Array,
from,
to,
out result,
format
));
case TypeCategory.Enum:
return(TryFromEnum(
value,
from,
to,
out result,
format
));
case TypeCategory.Interface:
return(TryFromInterface(
value,
from,
to,
out result,
format
));
case TypeCategory.Class:
return(TryFromClass(
value,
from,
to,
out result,
format
));
case TypeCategory.Stream:
return(TryFromStream(
value as Stream,
from,
to,
out result,
format
));
case TypeCategory.Color:
//return TryFromColor(
// (Color)value,
// from,
// to,
// out result,
// format
//);
case TypeCategory.String:
return(TryFromString(
value as string,
from,
to,
out result,
format
));
case TypeCategory.DateTime:
return(TryFromDateTime(
(DateTime)value,
from,
to,
out result,
format
));
case TypeCategory.Decimal:
return(TryFromDecimal(
(decimal)value,
from,
to,
out result,
format
));
case TypeCategory.Boolean:
return(TryFromBoolean(
(bool)value,
from,
to,
out result,
format
));
case TypeCategory.Char:
return(TryFromChar(
(char)value,
from,
to,
out result,
format
));
case TypeCategory.Byte:
return(TryFromByte(
(byte)value,
from,
to,
out result,
format
));
case TypeCategory.SByte:
return(TryFromSByte(
(sbyte)value,
from,
to,
out result,
format
));
case TypeCategory.Int16:
return(TryFromInt16(
(short)value,
from,
to,
out result,
format
));
case TypeCategory.UInt16:
return(TryFromUInt16(
(ushort)value,
from,
to,
out result,
format
));
case TypeCategory.Int32:
return(TryFromInt32(
(int)value,
from,
to,
out result,
format
));
case TypeCategory.UInt32:
return(TryFromUInt32(
(uint)value,
from,
to,
out result,
format
));
case TypeCategory.IntPtr:
return(TryFromIntPtr(
(IntPtr)value,
from,
to,
out result,
format
));
case TypeCategory.UIntPtr:
return(TryFromUIntPtr(
(UIntPtr)value,
from,
to,
out result,
format
));
case TypeCategory.Int64:
return(TryFromInt64(
(long)value,
from,
to,
out result,
format
));
case TypeCategory.UInt64:
return(TryFromUInt64(
(ulong)value,
from,
to,
out result,
format
));
case TypeCategory.Single:
return(TryFromSingle(
(float)value,
from,
to,
out result,
format
));
case TypeCategory.Double:
return(TryFromDouble(
(double)value,
from,
to,
out result,
format
));
case TypeCategory.Struct:
return(TryFromStruct(
value,
from,
to,
out result,
format
));
case TypeCategory.Null:
return(false);
case TypeCategory.Others:
return(false);
default:
return(false);
}
} catch (Exception ex) {
LogRecord
.Create()
//.Add("Value", value?.ToString())
//.Add("Type", type?.GetType().Name)
//.Add("Result", result)
//.Add("Format", format)
//.Add(ex)
.Error();
return(false);
}
}
