/// <summary>执行表达式，返回结果</summary>
/// <param name="code">代码片段</param>
/// <param name="parameters">参数名值对</param>
/// <returns></returns>
public static Object Execute(String code, IDictionary <String, Object> parameters)
{
if (parameters == null || parameters.Count < 1)
{
return(Execute(code));
}
var ps = new Object[parameters.Count];
parameters.Values.CopyTo(ps, 0);
var se = Create(code);
if (se != null && se.Method != null)
{
return(se.Invoke(ps));
}
var names = new String[parameters.Count];
parameters.Keys.CopyTo(names, 0);
var types = TypeX.GetTypeArray(ps);
var dic = se.Parameters;
for (int i = 0; i < names.Length; i++)
{
dic.Add(names[i], types[i]);
}
return(se.Invoke(ps));
}
/// <summary>执行表达式，返回结果。参数名默认为p0/p1/p2/pn</summary>
/// <param name="code"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static Object Execute(String code, Object[] parameters)
{
if (parameters == null || parameters.Length < 1)
{
return(Execute(code));
}
var se = Create(code);
if (se != null && se.Method != null)
{
return(se.Invoke(parameters));
}
var names = new String[parameters.Length];
for (int i = 0; i < names.Length; i++)
{
names[i] = "p" + i;
}
var types = TypeX.GetTypeArray(parameters);
var dic = se.Parameters;
for (int i = 0; i < names.Length; i++)
{
dic.Add(names[i], types[i]);
}
return(se.Invoke(parameters));
}
/// <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 XException("类{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 XException(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));
}
public override Object CreateInstance(params Object[] parameters)
{
if (Type.ContainsGenericParameters || Type.IsGenericTypeDefinition)
{
throw new XException(Type.FullName + "类是泛型定义类，缺少泛型参数！");
}
if (Type.IsValueType)
{
return(Handler.Invoke(parameters));
}
// 数组的动态构造参数是元素个数，如果未指定，应该默认0
if (Type.IsArray)
{
if (parameters == null || parameters.Length < 1)
{
parameters = new Object[] { 0 }
}
;
return(Handler.Invoke(parameters));
}
//// 无参数，直接构造
//if (parameters == null || parameters.Length < 1) return Handler.Invoke(new Object[0]);
// 准备参数类型数组，以匹配构造函数
//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));
}
DictionaryCache <ConstructorInfo, FastHandler> _cache = new DictionaryCache <ConstructorInfo, FastHandler>();
FastHandler GetHandler(ConstructorInfo constructor)
{
if (constructor == null)
{
return(null);
}
return(_cache.GetItem(constructor, key => GetConstructorInvoker(Type, key)));
}
ConstructorInfo GetConstructor(Type[] paramTypes)
{
var bf = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
// 1，如果参数为null，则找第一个参数
// 2，根据参数找一次，如果参数为空，也许能找到无参构造函数
// 3，如果还没找到，参数又为空，采用第一个构造函数。这里之所以没有和第一步合并，主要是可能调用者只想要无参构造函数，而第一个不是
ConstructorInfo constructor = null;
if (paramTypes == null)
{
constructor = Type.GetConstructors(bf).FirstOrDefault();
paramTypes = Type.EmptyTypes;
}
if (constructor == null)
{
constructor = Type.GetConstructor(bf, null, paramTypes, null);
}
//if (constructor == null) throw new Exception("没有找到匹配的构造函数！");
if (constructor == null && paramTypes == Type.EmptyTypes)
{
constructor = Type.GetConstructors(bf).FirstOrDefault();
}
return(constructor);
}
