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