/// <summary>通过字典参数调用</summary>
/// <param name="obj"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public Object InvokeByDictionaryParameter(Object obj, IDictionary parameters)
{
//// 没有传入参数
//if (parameters == null || parameters.Count < 1) return Invoke(obj, null);
//! 注意：有可能没有传入参数，但是该方法是需要参数的，这个时候采用全部null的方法
// 该方法没有参数，无视外部传入参数
var pis = Method.GetParameters();
if (pis == null || pis.Length < 1)
{
return(Invoke(obj, null));
}
Object[] ps = new Object[pis.Length];
for (int i = 0; i < pis.Length; i++)
{
Object v = null;
if (parameters != null && parameters.Contains(pis[i].Name))
{
v = parameters[pis[i].Name];
}
ps[i] = TypeX.ChangeType(v, pis[i].ParameterType);
}
return(Handler.Invoke(obj, ps));
}
public override void SetValue(Object obj, Object value)
{
if (SetHandler == null)
{
throw new InvalidOperationException("不支持SetValue操作！");
}
// 如果类型不匹配，先做类型转换
if (value != null && !Type.IsAssignableFrom(value.GetType()))
{
value = TypeX.ChangeType(value, Type);
}
SetHandler.Invoke(obj, value);
}
/// <summary>创建</summary>
/// <param name="type"></param>
/// <param name="name"></param>
/// <param name="paramTypes">参数类型</param>
/// <returns></returns>
public static MethodInfoX Create(Type type, String name, Type[] paramTypes)
{
//var method = type.GetMethod(name, paramTypes);
//if (method == null) method = type.GetMethod(name, DefaultBinding, null, paramTypes, null);
//if (method == null) method = type.GetMethod(name, DefaultBinding | BindingFlags.IgnoreCase, null, paramTypes, null);
//if (method == null && type.BaseType != typeof(Object)) return Create(type.BaseType, name, paramTypes);
var method = TypeX.GetMethod(type, name, paramTypes);
if (method == null)
{
return(null);
}
return(Create(method));
}
/// <summary>快速调用静态方法</summary>
/// <typeparam name="TTarget">目标类型</typeparam>
/// <typeparam name="TResult">返回类型</typeparam>
/// <param name="name"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static TResult Invoke <TTarget, TResult>(String name, params Object[] parameters)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
MethodInfoX mix = Create(typeof(TTarget), name, TypeX.GetTypeArray(parameters));
if (mix == null)
{
throw new Exception(string.Format("类{0}中无法找到{1}方法！", typeof(TTarget).Name, name));
}
return((TResult)mix.Invoke(null, parameters));
}
String GetName(Boolean isfull, Boolean includeDefType = true)
{
var method = _Method;
var sb = new StringBuilder();
String name = null;
if (includeDefType)
{
var type = method.DeclaringType ?? method.ReflectedType;
if (type != null)
{
var tx = TypeX.Create(type);
name = isfull ? tx.FullName : tx.Name;
}
else
{
name = "";
}
}
sb.AppendFormat("{0}.", name);
sb.Append(method.Name);
sb.Append("(");
var ps = method.GetParameters();
for (int i = 0; i < ps.Length; i++)
{
if (i > 0)
{
sb.Append(",");
}
if (ps[i].ParameterType != null)
{
var tx = TypeX.Create(ps[i].ParameterType);
name = isfull ? tx.FullName : tx.Name;
}
else
{
name = "";
}
sb.AppendFormat("{0} {1}", name, ps[i].Name);
}
sb.Append(")");
return(sb.ToString());
}
String GetName(Boolean isfull)
{
Type type = Type;
if (type.IsNested)
{
var tx = TypeX.Create(type.DeclaringType);
return((isfull ? tx.FullName : tx.Name) + "." + type.Name);
}
else if (type.IsGenericType)
{
var sb = new StringBuilder();
var typeDef = type.GetGenericTypeDefinition();
var name = isfull ? typeDef.FullName : typeDef.Name;
var p = name.IndexOf("`");
if (p >= 0)
{
sb.Append(name.Substring(0, p));
}
else
{
sb.Append(name);
}
sb.Append("<");
var ts = type.GetGenericArguments();
for (int i = 0; i < ts.Length; i++)
{
if (i > 0)
{
sb.Append(",");
}
if (!ts[i].IsGenericParameter)
{
var tx = TypeX.Create(ts[i]);
sb.Append(isfull ? tx.FullName : tx.Name);
}
}
sb.Append(">");
return(sb.ToString());
}
else
{
return(isfull ? type.FullName : type.Name);
}
}
public override Object Invoke(Object obj, params Object[] parameters)
{
if (parameters == null || parameters.Length <= 0)
{
return(Handler.Invoke(obj, null));
}
else
{
// 预处理参数类型
var pis = Parameters;
for (int i = 0; i < parameters.Length && i < pis.Length; i++)
{
parameters[i] = TypeX.ChangeType(parameters[i], pis[i].ParameterType);
}
return(Handler.Invoke(obj, parameters));
}
}
/// <summary>创建快速访问成员</summary>
/// <param name="member"></param>
/// <returns></returns>
public static MemberInfoX Create(MemberInfo member)
{
if (member == null)
{
return(null);
}
switch (member.MemberType)
{
case MemberTypes.All:
break;
case MemberTypes.Constructor:
return(ConstructorInfoX.Create(member as ConstructorInfo));
case MemberTypes.Custom:
break;
case MemberTypes.Event:
return(EventInfoX.Create(member as EventInfo));
case MemberTypes.Field:
return(FieldInfoX.Create(member as FieldInfo));
case MemberTypes.Method:
return(MethodInfoX.Create(member as MethodInfo));
case MemberTypes.Property:
return(PropertyInfoX.Create(member as PropertyInfo));
case MemberTypes.TypeInfo:
case MemberTypes.NestedType:
return(TypeX.Create(member as Type));
default:
break;
}
return(null);
}
public override void SetValue(Object obj, Object value)
{
// 如果类型不匹配，先做类型转换
if (value != null && !Type.IsAssignableFrom(value.GetType()))
{
value = TypeX.ChangeType(value, Type);
}
// SetHandler不支持值类型
if (Field.DeclaringType.IsValueType)
{
// 不相等才赋值
Object v = GetValue(obj);
if (!Object.Equals(value, v))
{
Field.SetValue(obj, value);
}
}
else
{
SetHandler.Invoke(obj, value);
}
}
public override Object CreateInstance(params Object[] parameters)
{
if (Type.ContainsGenericParameters || Type.IsGenericTypeDefinition)
{
throw new Exception(Type.FullName + "类是泛型定义类，缺少泛型参数！");
}
if (Type.IsValueType || Type.IsArray)
{
return(Handler.Invoke(parameters));
}
// 准备参数类型数组，以匹配构造函数
//var paramTypes = Type.EmptyTypes;
//if (parameters != null && parameters.Length > 0)
//{
// var list = new List<Type>();
// foreach (var item in parameters)
// {
// if (item != null)
// list.Add(item.GetType());
// else
// list.Add(typeof(Object));
// }
// paramTypes = list.ToArray();
//}
var paramTypes = TypeX.GetTypeArray(parameters);
var ctor = GetConstructor(paramTypes);
var handler = GetHandler(ctor);
if (handler != null)
{
return(handler.Invoke(parameters));
}
if (paramTypes != Type.EmptyTypes)
{
paramTypes = Type.EmptyTypes;
ctor = GetConstructor(paramTypes);
handler = GetHandler(ctor);
if (handler != null)
{
// 更换了构造函数，要重新构造构造函数的参数
var ps = ctor.GetParameters();
parameters = new Object[ps.Length];
for (int i = 0; i < ps.Length; i++)
{
// 处理值类型
if (ps[i].ParameterType.IsValueType)
{
parameters[i] = TypeX.CreateInstance(ps[i].ParameterType);
}
else
{
parameters[i] = null;
}
}
// 如果这里创建失败，后面还可以创建一个未初始化
try
{
return(handler.Invoke(parameters));
}
catch { }
}
}
// 如果没有找到构造函数，则创建一个未初始化的对象
return(FormatterServices.GetSafeUninitializedObject(Type));
}