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