private static MethodInfo GetInterceptedMethod(MethodInfo interceptionMethod)
{
var parameterTypes = from parameter in interceptionMethod.GetParameters()
select parameter.ParameterType;
return interceptionMethod.DeclaringType.GetMethod(interceptionMethod.GetMethodNameWithoutTilde(), parameterTypes.ToArray());
}
/// <summary>
/// Creates a new <see cref="MethodInvocationValidator"/> instance.
/// </summary>
/// <param name="method">Method to be validated</param>
/// <param name="parameterValues">List of arguments those are used to call the <paramref name="method"/>.</param>
public MethodInvocationValidator(MethodInfo method, object[] parameterValues)
{
_method = method;
_parameterValues = parameterValues;
_parameters = method.GetParameters();
_validationErrors = new List<ValidationResult>();
}
public static MethodBuilder DefineMethod(this TypeBuilder typeBuilder, MethodInfo method, MethodAttributes? attributes = null, ParameterInfo[] parameters = null)
{
Type[] parametersTypes = null;
MethodBuilder methodBuilder = null;
parameters = parameters ?? method.GetParameters();
parametersTypes = parameters.ToArray(parameter => parameter.ParameterType);
attributes = attributes ?? method.Attributes & ~MethodAttributes.Abstract;
methodBuilder = typeBuilder.DefineMethod(method.Name, attributes.Value, method.ReturnType, parametersTypes);
parameters.ForEach(1, (parameter, i) => {
var parameterBuilder = methodBuilder.DefineParameter(i, parameter.Attributes, parameter.Name);
if (parameter.IsDefined<ParamArrayAttribute>()) {
parameterBuilder.SetCustomAttribute<ParamArrayAttribute>();
}
else if (parameter.IsOut) {
parameterBuilder.SetCustomAttribute<OutAttribute>();
}
else if (parameter.IsOptional) {
parameterBuilder.SetCustomAttribute<OptionalAttribute>()
.SetConstant(parameter.DefaultValue);
}
});
return methodBuilder;
}
public SqlCallProcedureInfo(MethodInfo method, ISerializationTypeInfoProvider typeInfoProvider)
{
if (method == null) {
throw new ArgumentNullException("method");
}
if (typeInfoProvider == null) {
throw new ArgumentNullException("typeInfoProvider");
}
SqlProcAttribute procedure = GetSqlProcAttribute(method);
schemaName = procedure.SchemaName;
name = procedure.Name;
timeout = procedure.Timeout;
deserializeReturnNullOnEmptyReader = procedure.DeserializeReturnNullOnEmptyReader;
deserializeRowLimit = procedure.DeserializeRowLimit;
deserializeCallConstructor = procedure.DeserializeCallConstructor;
SortedDictionary<int, SqlCallParameterInfo> sortedParams = new SortedDictionary<int, SqlCallParameterInfo>();
outArgCount = 0;
foreach (ParameterInfo parameterInfo in method.GetParameters()) {
if ((parameterInfo.GetCustomAttributes(typeof(SqlNameTableAttribute), true).Length > 0) || (typeof(XmlNameTable).IsAssignableFrom(parameterInfo.ParameterType))) {
if (xmlNameTableParameter == null) {
xmlNameTableParameter = parameterInfo;
}
} else {
SqlCallParameterInfo sqlParameterInfo = new SqlCallParameterInfo(parameterInfo, typeInfoProvider, ref outArgCount);
sortedParams.Add(parameterInfo.Position, sqlParameterInfo);
}
}
parameters = sortedParams.Select(p => p.Value).ToArray();
returnTypeInfo = typeInfoProvider.GetSerializationTypeInfo(method.ReturnType);
if ((procedure.UseReturnValue != SqlReturnValue.Auto) || (method.ReturnType != typeof(void))) {
useReturnValue = (procedure.UseReturnValue == SqlReturnValue.ReturnValue) || ((procedure.UseReturnValue == SqlReturnValue.Auto) && (typeInfoProvider.TypeMappingProvider.GetMapping(method.ReturnType).DbType == SqlDbType.Int));
}
}
private bool IsValidFiller(MethodInfo info)
{
return info.GetParameters().Count() == 2
&& info.GetParameters()[0].ParameterType == typeof (Guid?)
&& info.GetParameters()[1].ParameterType == typeof(string)
&& info.ReturnType == typeof (object);
}
public static object InvokeDirect(MethodInfo method, object instance, params object[] parameters) {
if (method == null)
throw new ArgumentNullException("method");
if (!method.IsStatic && instance == null)
throw new ArgumentException("Non-static method requires a non-null instance.");
if (method.IsStatic && instance != null)
throw new ArgumentException("Static method requires a null instance.");
if (method.IsGenericMethodDefinition)
throw new ArgumentException("Cannot invoke generic method definitions. Concretise the generic type first by supplying generic type parameters.");
if (method.GetParameters().Length != parameters.Length)
throw new ArgumentException(string.Format("Parameter count mismatch: {0} parameters given; {1} parameters expected.", parameters.Length, method.GetParameters().Length));
// Create a dynamic assembly for the two types we need
createAssembly();
// Generate a string that identifies the method "signature" (the parameter types and return type, not the method name).
// Different methods which have the same "signature" according to this criterion can re-use the same generated code.
var sig = string.Join(" : ", method.GetParameters().Select(p => p.ParameterType.FullName).Concat(new[] { method.ReturnType.FullName }).ToArray());
if (!invokers.ContainsKey(sig)) {
// Create a delegate type compatible with the method signature
var delegateType = createDelegateType(method, sig);
// Create a class that implements IInvokeDirect
var classType = createClassType(method, sig, delegateType);
// Instantiate the new class and remember the instance for additional future calls
invokers[sig] = (IInvokeDirect) Activator.CreateInstance(classType);
}
// Invoke the interface method, passing it the necessary information to call the right target method.
return invokers[sig].DoInvoke(instance, parameters, method);
}
/// <summary>
/// Creates a <see cref="MethodBuilder"/> and implements a default wrapper.
/// </summary>
/// <param name="owner">The type that will own this method.</param>
/// <param name="interfaceType">Type of interface implemented by the <paramref name="owner"/>.</param>
/// <param name="overrideMethod">Method to override.</param>
/// <param name="fieldBuilders">Fields specified by the <see paramref="owner"/>.</param>
/// <returns>MethodBuilder with an already implemented wrapper.</returns>
public MethodBuilder GenerateInvocation(TypeBuilder owner, Type interfaceType, MethodInfo overrideMethod, IEnumerable<FieldBuilder> fieldBuilders)
{
var result = owner.DefineMethod
(
overrideMethod.Name,
MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.Final |
MethodAttributes.HideBySig | MethodAttributes.NewSlot,
overrideMethod.ReturnType,
overrideMethod.GetParameters().OrderBy(p => p.Position).Select(t => t.ParameterType).ToArray()
);
result.SetImplementationFlags(MethodImplAttributes.AggressiveInlining);
var generator = result.GetILGenerator();
var fieldName = LibraryInterfaceMapper.GetFieldNameForMethodInfo(overrideMethod);
var field = fieldBuilders.First(f => f.Name == fieldName);
var parameters = overrideMethod.GetParameters();
OnInvokeBegin(owner, interfaceType, generator, overrideMethod);
generator.Emit(OpCodes.Ldarg_0); // this
generator.Emit(OpCodes.Ldfld, field); // MethodNameProc _glMethodName. Initialized by constructor.
foreach (var item in parameters.Where(p => !p.IsRetval).Select((p, i) => new { Type = p, Index = i }))
{
generator.Emit(OpCodes.Ldarg, item.Index + 1);
}
generator.EmitCall(OpCodes.Callvirt, field.FieldType.GetMethod("Invoke"), null);
OnInvokeEnd(owner, interfaceType, generator, overrideMethod);
generator.Emit(OpCodes.Ret);
owner.DefineMethodOverride(result, overrideMethod);
return result;
}
public void Build(MethodInfo methodInfo)
{
_name = methodInfo.Name;
_declaringType = methodInfo.DeclaringType.FullName;
_fullName = methodInfo.DeclaringType.FullName + "." + methodInfo.Name;
ArrayList parameters = new ArrayList();
if( methodInfo.GetParameters() != null && methodInfo.GetParameters().Length > 0 )
{
foreach(ParameterInfo parameterInfo in methodInfo.GetParameters())
{
ParameterDescriptor parameterDescriptor = new ParameterDescriptor();
parameterDescriptor.Build(parameterInfo);
parameters.Add(parameterDescriptor);
}
}
_returnValue = new ParameterTypeDescriptor();
_returnValue.Build(methodInfo.ReturnType);
_parameters = parameters.ToArray(typeof(ParameterDescriptor)) as ParameterDescriptor[];
object[] attrs = methodInfo.GetCustomAttributes(typeof(System.ComponentModel.DescriptionAttribute), false);
if( attrs.Length > 0 )
{
System.ComponentModel.DescriptionAttribute descriptionAttribute = attrs[0] as System.ComponentModel.DescriptionAttribute;
_description = descriptionAttribute.Description;
}
}
private bool AllArgumentsEquals(MethodInfo method1, MethodInfo method2)
{
if (method1.GetParameters().Length != method2.GetParameters().Length)
{
return false;
}
foreach (var argument in method1.GetParameters()
.Zip(
method2.GetParameters(),
(method1Parameter, method2Parameter) =>
new
{
Method1Parameter = method1Parameter,
Method2Parameter = method2Parameter
}))
{
if (!object.Equals(argument.Method1Parameter.ParameterType, argument.Method2Parameter.ParameterType) ||
!string.Equals(argument.Method1Parameter.Name, argument.Method2Parameter.Name))
{
return false;
}
}
return true;
}
public override IEnumerable<IRouteAttribute> GetRouteAttributes(MethodInfo actionMethod)
{
// Logic from ApiControllerActionSelector
if (actionMethod.IsSpecialName)
{
// not a normal method, e.g. a constructor or an event
yield break;
}
if (actionMethod.GetBaseDefinition().SafeGet(x => x.DeclaringType).IsAssignableFrom(typeof(ApiController)))
{
// is a method on Object, IHttpController, ApiController
yield break;
}
foreach (var c in Conventions)
{
if (actionMethod.Name.StartsWith(c.HttpMethod.Method, StringComparison.OrdinalIgnoreCase))
{
var requiresId = !string.IsNullOrEmpty(c.Url);
if (!_alreadyUsed.Contains(c))
{
// Check first parameter, if it requires ID
if (!requiresId || (actionMethod.GetParameters().Length > 0 && actionMethod.GetParameters()[0].Name.Equals("id", StringComparison.OrdinalIgnoreCase)))
{
yield return BuildRouteAttribute(c);
_alreadyUsed.Add(c);
}
}
}
}
}
public static DecompositionRule GenerateRule(MethodInfo method)
{
DecompositionAttribute decomposition =
(DecompositionAttribute)Attribute.GetCustomAttribute(method, typeof(DecompositionAttribute), false);
if (decomposition == null)
{
return null;
}
if (method.ReturnType == typeof(void))
{
throw new InvalidOperationException("Decomposition rule must return object.");
}
if (method.GetParameters().Count() != 1)
{
throw new InvalidOperationException("Wrong parameters number in decomposition function. Decomposition is performed on a single module.");
}
return new DecompositionRule()
{
MethodInfo = method,
Type = method.GetParameters()[0].ParameterType
};
}
internal static string GenerateRegexForURL(ModelListMethod mlm, MethodInfo mi)
{
Logger.Debug("Generating regular expression for model list method at path " + mlm.Path);
string ret = "^(GET\t";
if (mlm.Host == "*")
ret += ".+";
else
ret+=mlm.Host;
if (mi.GetParameters().Length > 0)
{
ParameterInfo[] pars = mi.GetParameters();
string[] regexs = new string[pars.Length];
for (int x = 0; x < pars.Length; x++)
{
Logger.Trace("Adding parameter " + pars[x].Name+"["+pars[x].ParameterType.FullName+"]");
regexs[x] = _GetRegexStringForParameter(pars[x]);
}
string path = string.Format((mlm.Path+(mlm.Paged ? (mlm.Path.Contains("?") ? "&" : "?")+"PageStartIndex={"+(regexs.Length-3).ToString()+"}&PageSize={"+(regexs.Length-2).ToString()+"}" : "")).Replace("?","\\?"), regexs);
ret += (path.StartsWith("/") ? path : "/" + path).TrimEnd('/');
}
else
ret += (mlm.Path.StartsWith("/") ? mlm.Path : "/" + mlm.Path).Replace("?", "\\?").TrimEnd('/');
Logger.Trace("Regular expression constructed: " + ret + ")$");
return ret+")$";
}
public string GetClientMethodCode(MethodInfo method, string url)
{
var model = new ClientMethodModel();
var parameterInfos = method.GetParameters();
var inputParameters = parameterInfos.Select(p => string.Format("{0}: {1}", p.Name, TypeMapper.GetTypeScriptType(p.ParameterType)))
.ToList();
model.Traditional = parameterInfos.Any(p => p.ParameterType.IsArray);
var returnType = method.ReturnType;
if (returnType.Name != "Void")
{
var onSucces = "callback: (data: " + TypeMapper.GetTypeScriptType(returnType) + ") => any";
inputParameters.Add(onSucces);
model.OnSucces = "callback";
}
//hacky
var isPost = method.GetCustomAttributes(typeof(HttpPostAttribute), true).Any() || returnType.IsJsonResult() || returnType == typeof(JsonResult);
model.AjaxMethod = isPost ? "POST" : "";
var allParameters = string.Join(", ", inputParameters);
model.Signature = method.Name + "(" + allParameters + ")";
model.Url = url;
var inputJsonTuples = method.GetParameters().Select(p => string.Format("{0}: {0}", p.Name));
model.Data = "{ " + string.Join(", ", inputJsonTuples) + " }";
var template = GetTemplate("ClientMethod");
return RemoveEmptyLines(Razor.Parse(template, model));//.Split("\r\n".ToCharArray(),StringSplitOptions.RemoveEmptyEntries);
}
//public DynamicMethodHandle( MethodInfo info, params object[] parameters )
/// <summary>
/// Initializes a new instance of the <see cref="DynamicMethodHandle"/> class.
/// </summary>
/// <param name="info">MethodInfo</param>
public DynamicMethodHandle( MethodInfo info )
{
if (info == null)
{
this.dynamicMethod = null;
}
else
{
this.methodName = info.Name;
ParameterInfo[] infoParams = info.GetParameters();
//object[] inParams = null;
//if (parameters == null)
//{
// inParams = new object[] { null };
//}
//else
//{
// inParams = parameters;
//}
int pCount = infoParams.Length;
if (pCount > 0 &&
((pCount == 1 && infoParams[0].ParameterType.IsArray) ||
(infoParams[pCount - 1].GetCustomAttributes(typeof(ParamArrayAttribute), true).Length > 0)))
{
this.hasFinalArrayParam = true;
this.methodParamsLength = pCount;
this.finalArrayElementType = infoParams[pCount - 1].ParameterType;
}
this.dynamicMethod = DynamicMethodHandlerFactory.CreateMethod(info);
}
this.parameterInfoList = info.GetParameters();
}
public MessageListMethodAdapter(object obj, MethodInfo method)
{
AssertUtils.ArgumentNotNull(obj, "'obj' must not be null");
AssertUtils.ArgumentNotNull(method, "'method' must not be null");
AssertUtils.IsTrue(method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType.Equals(typeof(IList<IMessage>)),
"Method must accept exactly one parameter, and it must be a List.");
_method = method;
_invoker = new DefaultMethodInvoker(obj, _method);
}
public static bool IsHandlerMethod(MethodInfo m)
{
return (m.IsPublic == true
&& m.Name.Equals("OnMessage")
&& m.GetParameters().Length == 2
&& m.GetParameters()[0].ParameterType.IsSubclassOf(typeof(QuickFix.Message))
&& typeof(QuickFix.SessionID).IsAssignableFrom(m.GetParameters()[1].ParameterType)
&& m.ReturnType == typeof(void));
}
private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
{
ParameterInfo[] parameters = m.GetParameters();
if (parameters.Length != args.Count)
{
return false;
}
if ((!m.IsGenericMethod && (typeArgs != null)) && (typeArgs.Length > 0))
{
return false;
}
if ((!m.IsGenericMethodDefinition && m.IsGenericMethod) && m.ContainsGenericParameters)
{
m = m.GetGenericMethodDefinition();
}
if (m.IsGenericMethodDefinition)
{
if ((typeArgs == null) || (typeArgs.Length == 0))
{
return false;
}
if (m.GetGenericArguments().Length != typeArgs.Length)
{
return false;
}
m = m.MakeGenericMethod(typeArgs);
parameters = m.GetParameters();
}
int index = 0;
int count = args.Count;
while (index < count)
{
Type parameterType = parameters[index].ParameterType;
if (parameterType == null)
{
return false;
}
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
}
Expression operand = args[index];
if (!parameterType.IsAssignableFrom(operand.Type))
{
if (operand.NodeType == ExpressionType.Quote)
{
operand = ((UnaryExpression) operand).Operand;
}
if (!parameterType.IsAssignableFrom(operand.Type) && !parameterType.IsAssignableFrom(StripExpression(operand.Type)))
{
return false;
}
}
index++;
}
return true;
}
/// <summary>
/// 调用方法
/// </summary>
/// <param name="proxy"></param>
/// <param name="method"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public object Invoke(object proxy, MethodInfo method, object[] parameters)
{
var attr = CoreHelper.GetMemberAttribute<PublishMethodAttribute>(method);
if (attr == null) return null;
var httpMethod = HttpMethod.GET;
if (!CoreHelper.CheckPrimitiveType(method.GetParameters().Select(p => p.ParameterType).ToArray()))
httpMethod = HttpMethod.POST;
string name = attribute.Name + "." + attr.Name;
RESTfulParameter parameter = new RESTfulParameter(name, httpMethod, format);
parameter.Token = token;
if (httpMethod == HttpMethod.POST)
{
var collection = new Dictionary<string, object>();
//添加参数
var plist = method.GetParameters();
for (int index = 0; index < parameters.Length; index++)
{
collection[plist[index].Name] = parameters[index];
}
parameter.DataObject = collection;
}
else
{
//添加参数
var plist = method.GetParameters();
for (int index = 0; index < parameters.Length; index++)
{
parameter.AddParameter(plist[index].Name, parameters[index]);
}
}
//处理Cookies
if (HttpContext.Current != null)
{
for (int index = 0; index < HttpContext.Current.Request.Cookies.Count; index++)
{
var cookie = HttpContext.Current.Request.Cookies[index];
parameter.AddCookie(new Cookie
{
Name = cookie.Name,
Value = cookie.Value.Replace(",", "%2C")
});
}
}
RESTfulRequest request = new RESTfulRequest(parameter);
if (!string.IsNullOrEmpty(url)) request.Url = url;
request.Timeout = timeout;
return request.GetResponse(method.ReturnType);
}
/// <summary>
/// Adds SmartObject properties to the given serviceObject and SmartObject method
/// for the parameters of the method provided.
///
/// This uses the webservice assembly to check if the parameter might be a custom object.
/// </summary>
/// <param name="serviceObject"></param>
/// <param name="method"></param>
/// <param name="smoMethod"></param>
/// <param name="webServiceAssembly"></param>
public static void CreateInputParameters(ServiceObject serviceObject, Method smoMethod, MethodInfo method, Assembly webServiceAssembly)
{
ParameterInfo[] parameters = method.GetParameters();
// We first do some checking to see if we support what we need to input.
foreach (ParameterInfo pi in parameters)
{
if (pi.ParameterType.Assembly == webServiceAssembly && parameters.Length > 1)
{
throw new NotSupportedException(string.Format("The method {0} has a Container Object. This is not the only parameter. We do not support this because a SmartObject is a flat object with properties.", method.Name));
}
if (pi.ParameterType.IsArray)
{
throw new NotSupportedException(string.Format("The method {0} has an Array for it's input parameters. We do not support this because a SmartObject doesn't accept a list as one property.", method.Name));
}
}
// Check if it is 1 parameter of a specific type. This is a so-called request object. If we find this
// We use the properties of that object as input. We only support a 'flat'-container object as our SMO is flat as well.
if (parameters.Length == 1 && parameters[0].ParameterType.Assembly == webServiceAssembly)
{
ParameterInfo pi = parameters[0];
PropertyInfo[] props = pi.ParameterType.GetProperties();
foreach (PropertyInfo prop in props)
{
if (MapHelper.IsSimpleMapableType(prop.PropertyType)) // only add simple types..
{
Property property = CreateSmoProperty(prop.Name, prop.PropertyType);
AddServiceObjectProperty(serviceObject, property);
smoMethod.InputProperties.Add(property);
}
else
{
throw new NotSupportedException(string.Format("The input parameter (property) {0} of the request object is of type {1} which is not a type supported by SmartObjects.", pi.Name, pi.ParameterType.ToString()));
}
}
}
else // It's not a request object, so we simply check all the parameters.
{
foreach (ParameterInfo pi in method.GetParameters())
{
if (MapHelper.IsSimpleMapableType(pi.ParameterType)) // only add simple types
{
Property property = CreateSmoProperty(pi.Name, pi.ParameterType);
AddServiceObjectProperty(serviceObject, property);
smoMethod.InputProperties.Add(property);
}
else
{
throw new NotSupportedException(string.Format("The input parameter {0} is of type {1} which is not a type supported by SmartObjects.", pi.Name, pi.ParameterType.ToString()));
}
}
}
}
/// <summary>
/// 取得函数的模版
/// </summary>
/// <param name="method"></param>
/// <param name="format"></param>
/// <param name="httpMethod"></param>
/// <returns></returns>
private static string GetFunctionTemplete(MethodInfo method, ResponseFormat format,string httpMethod)
{
StringBuilder func = new StringBuilder(method.DeclaringType.Name);
func.Append(".prototype." + method.Name);
func.Append("=function");
func.Append("(");
foreach (ParameterInfo p in method.GetParameters())
{
func.Append(p.Name + ",");
}
func.Append("callback)");
func.AppendLine("{");
{
func.Append("\tvar args = {");
foreach (ParameterInfo p in method.GetParameters())
{
func.Append(p.Name + ":" + p.Name + ",");
}
//func.AppendLine("ajax:'jquery1.4.2'};");
func.AppendLine("};");
switch (format)
{
case ResponseFormat.Html:
//func.AppendLine("\tvar options={dataType:'html'};");
func.AppendFormat("\tvar options={{dataType:'html',type:'{0}'}};",httpMethod);
break;
case ResponseFormat.Xml:
//func.AppendLine("\tvar options={dataType:'xml'};");
func.AppendFormat("\tvar options={{dataType:'xml',type:'{0}'}};", httpMethod);
break;
case ResponseFormat.Json:
//func.AppendLine("\tvar options={dataType:'json'};");
func.AppendFormat("\t var options={{dataType:'json',type:'{0}'}};", httpMethod);
break;
case ResponseFormat.Script:
//func.AppendLine("\tvar options={dataType:'script'};");
func.AppendFormat("\tvar options={{dataType:'script',type:'{0}'}};",httpMethod);
break;
case ResponseFormat.Text:
//func.AppendLine("\tvar options={dataType:'text'};");
func.AppendFormat("\tvar options={{dataType:'text',type:'{0}'}};",httpMethod);
break;
default:
//func.AppendLine("\tvar options={dataType:'text'};");
//func.AppendFormat("\tvar options={{dataType:'text',type:'{0}'}};",httpMethod);
break;
}
func.AppendLine("\t$.extend(true,options,{},this.Options);");
func.AppendFormat("\t$.DotNet.CallWebMethod(options,'{0}', args, callback);", method.Name);
func.AppendLine();
}
func.AppendLine("}\t\t");
return func.ToString();
}
public void EmitMethodBody(MethodBuilder generatedMethod, MethodInfo method, FieldInfo field)
{
var IL = generatedMethod.GetILGenerator();
ParameterInfo[] parameters = method.GetParameters();
IL.DeclareLocal(typeof (object[]));
IL.DeclareLocal(typeof (InvocationInfo));
IL.DeclareLocal(typeof(System.Type[]));
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Callvirt, getInterceptor);
// if (interceptor == null)
// return base.method(...);
Label skipBaseCall = IL.DefineLabel();
IL.Emit(OpCodes.Ldnull);
IL.Emit(OpCodes.Bne_Un, skipBaseCall);
IL.Emit(OpCodes.Ldarg_0);
for (int i = 0; i < method.GetParameters().Length; i++)
IL.Emit(OpCodes.Ldarg_S, (sbyte)(i + 1));
IL.Emit(OpCodes.Call, method);
IL.Emit(OpCodes.Ret);
IL.MarkLabel(skipBaseCall);
// Push arguments for InvocationInfo constructor.
IL.Emit(OpCodes.Ldarg_0); // 'this' pointer
PushTargetMethodInfo(IL, generatedMethod, method);
PushStackTrace(IL);
PushGenericArguments(method, IL);
_argumentHandler.PushArguments(parameters, IL, false);
// InvocationInfo info = new InvocationInfo(...);
IL.Emit(OpCodes.Newobj, infoConstructor);
IL.Emit(OpCodes.Stloc_1);
// this.Interceptor.Intercept(info);
IL.Emit(OpCodes.Ldarg_0);
IL.Emit(OpCodes.Callvirt, getInterceptor);
IL.Emit(OpCodes.Ldloc_1);
IL.Emit(OpCodes.Callvirt, handlerMethod);
PackageReturnType(method, IL);
SaveRefArguments(IL, parameters);
IL.Emit(OpCodes.Ret);
}
public static bool IsCandidate(MethodInfo method)
{
int parameterCount = method.GetParameters() == null ? 0 : method.GetParameters().Length;
if (parameterCount > 1) return false;
bool hasOutput = method.ReturnType != typeof (void);
if (hasOutput && !method.ReturnType.IsClass) return false;
if (hasOutput) return true;
return parameterCount == 1;
}
private static bool IsParamterValid(MethodInfo methodInfo)
{
if (methodInfo.GetParameters().Count() != 2)
{
return false;
}
var uiItem = methodInfo.GetParameters()[0].GetType();
if(uiItem.IsAssignableFrom(typeof(IUIItem)))
{
return true;
}
return false;
}
public MethodCommand(IPlugin plugin, String name, String description, PermissionAttribute[] defaultPermissions,
bool @private, MethodInfo method, object obj)
: base(plugin, name)
{
Description = description;
ParameterTypes = method.GetParameters().Skip(1).Select(p => p.ParameterType).ToArray();
ParameterNames = method.GetParameters().Skip(1).Select(p => p.Name).ToArray();
DefaultPermissions = defaultPermissions;
Private = @private;
_method = method;
_obj = obj;
}
static MimeExtensionHelper()
{
Type mimeMappingType = Assembly.GetAssembly(typeof(HttpRuntime)).GetType("System.Web.MimeMapping");
if (mimeMappingType == null)
throw new SystemException("Couldnt find MimeMapping type");
getMimeMappingMethodInfo = mimeMappingType.GetMethod("GetMimeMapping", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
if (getMimeMappingMethodInfo == null)
throw new SystemException("Couldnt find GetMimeMapping method");
if (getMimeMappingMethodInfo.ReturnType != typeof(string))
throw new SystemException("GetMimeMapping method has invalid return type");
if (getMimeMappingMethodInfo.GetParameters().Length != 1 && getMimeMappingMethodInfo.GetParameters()[0].ParameterType != typeof(string))
throw new SystemException("GetMimeMapping method has invalid parameters");
}
private static bool IsUpForLifting(MethodInfo op)
{
foreach (var pi in op.GetParameters().Concat(op.ReturnParameter.AsArray()))
{
var ptype = pi.ParameterType;
if (!ptype.IsGenericParameter)
{
if (!ptype.IsNonNullableValueType()) return false;
}
else
{
// here we need to check only generic parameter attributes
// since one can't inherit from value types
Func<GenericParameterAttributes, bool> isNnvt = gpa =>
(gpa & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0;
if (isNnvt(ptype.GenericParameterAttributes))
{
continue;
}
Func<ICustomAttributeProvider, IEnumerable<SignatureValidWhenAttribute>>
swats = cap => cap.Attrs<SignatureValidWhenAttribute>();
var unrelatedSwats = swats(op).Concat(
swats(op.ReturnTypeCustomAttributes).Concat(
op.GetParameters().Select(fpi => swats(fpi.ParameterType)).Flatten().Concat(
op.XGetGenericArguments().Where(gpi => gpi != ptype).Select(gpi => swats(gpi)).Flatten())));
if (unrelatedSwats.Any(swat =>
isNnvt(swat.InferGenericParameterAttributes(ptype))))
{
continue;
}
if (swats(ptype).Any(swat =>
isNnvt(swat.InferTargetGenericParameterAttributes())))
{
continue;
}
return false;
}
}
if (op.GetOperatorTypes().Any(opType => opType.IsRelational()))
{
if (op.ReturnType != typeof(bool)) return false;
}
return true;
}
public static bool Matches(this MethodInfo method1, MethodInfo method2)
{
if (method1.DeclaringType != method2.DeclaringType || method1.Name != method2.Name)
return false;
var parameters = method1.GetParameters();
if (parameters.Count() != method2.GetParameters().Count())
return false;
for (int i = 0; i < parameters.Count(); i++)
{
if (!Matches(parameters[i], method2.GetParameters()[i]))
return false;
}
return true;
}
public bool SupportsMethod(MethodInfo method)
{
// This will match the following methods:
// NHibernate.Linq.SqlMethods.Like(string, string)
// System.Data.Linq.SqlClient.SqlMethods.Like(string, string) (from Linq2SQL)
// plus any 2-argument method named Like in a class named SqlMethods
//
// The latter case allows application developers to define their own placeholder method
// to avoid referencing Linq2Sql or Linq2NHibernate, if they so wish.
return method != null && method.Name == "Like" &&
(method.GetParameters().Length == 2 || method.GetParameters().Length == 3) &&
method.DeclaringType != null &&
method.DeclaringType.FullName.EndsWith("SqlMethods");
}
private static object[] GetInvokeParametersForMethod(MethodInfo methodInfo, IList<string> arguments)
{
var invokeParameters = new List<object>();
var args = new List<string>(arguments);
var methodParameters = methodInfo.GetParameters();
bool methodHasParams = false;
if (methodParameters.Length == 0) {
if (args.Count == 0)
return invokeParameters.ToArray();
return null;
}
if (methodParameters[methodParameters.Length - 1].ParameterType.IsAssignableFrom(typeof(string[]))) {
methodHasParams = true;
}
if (!methodHasParams && args.Count != methodParameters.Length) return null;
if (methodHasParams && (methodParameters.Length - args.Count >= 2)) return null;
for (int i = 0; i < args.Count; i++) {
if (methodParameters[i].ParameterType.IsAssignableFrom(typeof(string[]))) {
invokeParameters.Add(args.GetRange(i, args.Count - i).ToArray());
break;
}
invokeParameters.Add(Convert.ChangeType(arguments[i], methodParameters[i].ParameterType));
}
if (methodHasParams && (methodParameters.Length - args.Count == 1)) invokeParameters.Add(new string[] { });
return invokeParameters.ToArray();
}
private CombiningStrategy GetStrategy(MethodInfo method, Test suite)
{
ParameterInfo[] parameters = method.GetParameters();
IEnumerable[] sources = new IEnumerable[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
sources[i] = dataPointProvider.GetDataFor(parameters[i], suite);
if (Reflect.HasAttribute(method, SequentialAttribute, false))
return new SequentialStrategy(sources);
if (Reflect.HasAttribute(method, PairwiseAttribute, false) &&
method.GetParameters().Length > 2)
return new PairwiseStrategy(sources);
return new CombinatorialStrategy(sources);
}
public string EjecutarEnBackend(string nombre_metodo, String[] argumentos_json)
{
System.Reflection.MethodInfo metodo = backEndService.GetType().GetMethods().ToList().Find(m => m.Name == nombre_metodo);
if (metodo == null)
{
throw new Exception("Error: No se encontró el método " + nombre_metodo + " en el WEB SERVICE");
}
var argumentos_esperados = metodo.GetParameters();
var argumentos_a_enviar = new List <Object>();
for (int i = 0; i < argumentos_json.Count(); i++)
{
var arg_esperado = argumentos_esperados[i];
var arg_json = argumentos_json[i];
if (arg_esperado.ParameterType == typeof(String))
{
argumentos_a_enviar.Add(arg_json);
}
else
{
argumentos_a_enviar.Add(Newtonsoft.Json.JsonConvert.DeserializeObject(arg_json, arg_esperado.ParameterType));
}
}
if (argumentos_esperados.Any(a => a.Name == "usuario"))
{
try
{
if (usuarioLogueado.GetType().Name == "UsuarioNulo")
{
throw new Exception("Error: Debe estar logueado para acceder a esta funcionalidad");
}
argumentos_a_enviar.Add(usuarioLogueado);
}
catch (Exception)
{
return(Newtonsoft.Json.JsonConvert.SerializeObject(""));
}
}
try
{
var respuesta = metodo.Invoke(backEndService, argumentos_a_enviar.ToArray());
if ((nombre_metodo == "ModificarMiMail") || (nombre_metodo == "ModificarMailRegistro"))
{
this.usuarioLogueado = backEndService.GetUsuarioPorId(this.usuarioLogueado.Id);
Session[ConstantesDeSesion.USUARIO] = this.usuarioLogueado;
}
return(Newtonsoft.Json.JsonConvert.SerializeObject(respuesta));
}
catch (Exception e)
{
return(Newtonsoft.Json.JsonConvert.SerializeObject(e));
}
}
public static System.Type GetUniqueAndExpectedInputParameterType(this System.Reflection.MethodInfo methodInfo)
{
Type inType = null;
try
{
inType = methodInfo.GetParameters().Single().ParameterType;
}
catch (Exception ex)
{
throw new InvalidOperationException(string.Format("Error during get MessageInputParameterType for method {0} ", methodInfo.Name), ex);
}
return(inType);
}
/// <summary>
/// Invokes the method that has the correct Parameter.
/// </summary>
/// <param name="e">The IEventHandler class.</param>
/// <param name="mi">THe method info</param>
/// <param name="o">The parameter that is being called.</param>
private void triggerEvent(IEventHandler e, System.Reflection.MethodInfo mi, object o)
{
bool lookFor = false;
foreach (System.Reflection.ParameterInfo pi in mi.GetParameters())
{
if (pi.ParameterType == o.GetType())
{
lookFor = true;
}
}
if (lookFor)
{
mi.Invoke(e, new object[] { o });
}
}
public static object[] BytesToParams(byte[] bytes, int _offset, System.Reflection.MethodInfo methodInfo)
{
var parameters = methodInfo.GetParameters();
object[] ret = new object[parameters.Length];
int offset = _offset;
for (int i = 0; i < parameters.Length; i++)
{
if (offset >= bytes.Length)
{
Debug.LogWarning("byteslen: " + bytes.Length + " initOffset: " + _offset + " i : " + i);
throw new ArgumentOutOfRangeException();
}
var type = parameters[i].ParameterType;
if (type.IsValueType)
{
ret[i] = Utility.DataUtility.BytesToStruct(type, bytes, offset);
offset += Marshal.SizeOf(type);
}
else if (type == typeof(string))
{
int strByteLen = Utility.DataUtility.ReadInt(bytes, offset);
string str = System.Text.Encoding.UTF8.GetString(bytes, offset + sizeof(int), strByteLen);
ret[i] = str;
offset += strByteLen + sizeof(int);
}
else //Array of ValueType
{
int length = Utility.DataUtility.ReadInt(bytes, offset);
var elemType = type.GetElementType();
var array = Array.CreateInstance(elemType, length);
int elemSize = Marshal.SizeOf(elemType);
var handle = GCHandle.Alloc(array, GCHandleType.Pinned);
IntPtr ptr = handle.AddrOfPinnedObject();
Marshal.Copy(bytes, offset + sizeof(int), ptr, elemSize * length);
handle.Free();
ret[i] = array;
offset += sizeof(int) + elemSize * length;
}
}
return(ret);
}
private String GetArgValue(Assembly scope)
{
if (instruction.Operand == null)
{
return("");
}
else
{
bool isLocalCall;
string s = "";
if (instruction.Operand != null)
{
switch (instruction.Code.OperandType)
{
case OperandType.InlineField:
System.Reflection.FieldInfo fOperand = ((System.Reflection.FieldInfo)instruction.Operand);
s = fOperand.FieldType.FullName + " " + Helper.ProcessSpecialTypes(fOperand.ReflectedType, scope) + "::" + fOperand.Name + "";
break;
case OperandType.InlineMethod:
try
{
System.Reflection.MethodInfo mOperand = (System.Reflection.MethodInfo)instruction.Operand;
String t = Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope);
isLocalCall = t.StartsWith("local");
if (isLocalCall)
{
s = mOperand.ReturnType.ToString() + " " + t + "::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
s = mOperand.ReturnType.ToString() + " " + t + "::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters());
}
}
catch
{
try
{
System.Reflection.ConstructorInfo mOperand = (System.Reflection.ConstructorInfo)instruction.Operand;
String t = Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope);
bool isDelegateCall = ((mOperand.GetMethodImplementationFlags() & System.Reflection.MethodImplAttributes.Runtime) != 0);
if (isDelegateCall)
{
s = "delegate " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
isLocalCall = t.StartsWith("local");
if (isLocalCall)
{
s = "System.Void " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters(), !mOperand.IsStatic);
}
else
{
s = "System.Void " + Helper.ProcessSpecialTypes(mOperand.ReflectedType, scope) +
"::" + mOperand.Name + Helper.ParametersAsString(mOperand.GetParameters());
}
}
}
catch
{
}
}
break;
case OperandType.ShortInlineBrTarget:
case OperandType.InlineBrTarget:
// can assign anything, not used
s = instruction.Offset.ToString();
break;
case OperandType.InlineType:
s = Helper.ProcessSpecialTypes((Type)instruction.Operand, scope);
break;
case OperandType.InlineString:
s = instruction.Operand.ToString();
break;
case OperandType.ShortInlineVar:
s = instruction.Operand.ToString();
break;
case OperandType.InlineI:
case OperandType.InlineI8:
case OperandType.InlineR:
case OperandType.ShortInlineI:
case OperandType.ShortInlineR:
s = instruction.Operand.ToString();
break;
case OperandType.InlineTok:
if (instruction.Operand is Type)
{
s = ((Type)instruction.Operand).FullName;
}
else
{
s = "not supported";
}
break;
default: s = "not supported"; break;
}
}
return(s);
}
}
/// <summary>
/// 获取执行控制器行为的代理函数
/// </summary>
/// <typeparam name="TContext">Http上下文信息类型</typeparam>
/// <typeparam name="TRequest">Http请求信息类型</typeparam>
/// <param name="assembly">程序集</param>
/// <param name="controllerType">控制器类型</param>
/// <param name="actionMethodInfo">控制器行为对应方法的反射信息</param>
/// <returns></returns>
public static ActionExecute <TContext, TRequest> GetRunActionDelegate <TContext, TRequest>(Assembly assembly, Type controllerType, System.Reflection.MethodInfo actionMethodInfo, ActionData <TContext, TRequest> actionData)
{
var TContextType = typeof(TContext);
if (StringContainerOpImplicitMethodInfoDic == null)
{
StringContainerOpImplicitMethodInfoDic = new Dictionary <RuntimeTypeHandle, System.Reflection.MethodInfo>();
System.Reflection.MethodInfo[] methodInfos = typeof(StringContainer).GetMethods();
foreach (var methodInfo in methodInfos)
{
if (methodInfo.Name == "op_Implicit" && methodInfo.ReturnType != typeof(StringContainer))
{
StringContainerOpImplicitMethodInfoDic.Add(methodInfo.ReturnType.TypeHandle, methodInfo);
}
}
}
DynamicMethod method = new DynamicMethod("RunActionX", typeof(void), new Type[] { typeof(TContext), typeof(NFinal.Action.ActionData <TContext, TRequest>), typeof(TRequest), typeof(NameValueCollection) });
ILGenerator methodIL = method.GetILGenerator();
var methodEnd = methodIL.DefineLabel();
var request = methodIL.DeclareLocal(typeof(TRequest));
var controller = methodIL.DeclareLocal(controllerType);
var defaultConstructor = controllerType.GetConstructor(Type.EmptyTypes);
methodIL.Emit(OpCodes.Newobj, defaultConstructor);
methodIL.Emit(OpCodes.Stloc, controller);
//0.context,1.actionData,2.request,3.parameters
//try
methodIL.BeginExceptionBlock();
{
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller,environment
methodIL.Emit(OpCodes.Ldarg_0);
//controller,environment,"methodName"
methodIL.Emit(OpCodes.Ldstr, actionMethodInfo.Name);
//controller,environment,"methodName",null
methodIL.Emit(OpCodes.Ldnull);
//controller,environment,"methodName",null,Request
methodIL.Emit(OpCodes.Ldarg_2);
//controller,environment,"methodName",null,Request,CompressMode
methodIL.Emit(OpCodes.Ldc_I4, (int)CompressMode.Deflate);
//controller,environment,"methodName",null,Request,CompressMode,actionData
methodIL.Emit(OpCodes.Ldarg_1);
//controller,environment,"methodName",null,Request,CompressMode,actionData.plugConfig
methodIL.Emit(OpCodes.Ldfld, typeof(NFinal.Action.ActionData <TContext, TRequest>).GetField("plugConfig"));
methodIL.Emit(OpCodes.Callvirt, controllerType.GetMethod("Initialization",
new Type[] { typeof(TContext),
typeof(string),
typeof(System.IO.Stream),
typeof(TRequest),
typeof(CompressMode),
typeof(NFinal.Config.Plug.PlugConfig) }));
#region 执行用户权限过滤器
//actionData
methodIL.Emit(OpCodes.Ldarg_1);
//actionData.IAuthorizationFilters//泛型的类型必须固定
methodIL.Emit(OpCodes.Ldfld, typeof(NFinal.Action.ActionData <TContext, TRequest>).GetField("IAuthorizationFilters"));
//controller
methodIL.Emit(OpCodes.Ldloc, controller);//泛型的类型必须固定
methodIL.Emit(OpCodes.Call, AuthorizationFilterMethodInfo.MakeGenericMethod(new Type[] { typeof(TContext), typeof(TRequest) }));
var BeforeAuthorizationEnd = methodIL.DefineLabel();
methodIL.Emit(OpCodes.Brtrue_S, BeforeAuthorizationEnd);
methodIL.Emit(OpCodes.Leave, methodEnd);//离函数体较远，使用leave_s会报错。
methodIL.MarkLabel(BeforeAuthorizationEnd);
#endregion
#region 执行Action执行之前的过滤器
//actionData
methodIL.Emit(OpCodes.Ldarg_1);
//actionData.IBeforeActionFilters
methodIL.Emit(OpCodes.Ldfld, typeof(NFinal.Action.ActionData <TContext, TRequest>).GetField("IBeforeActionFilters"));
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//FilterHelper.BeforeActionFilter();
methodIL.Emit(OpCodes.Call, BeforeActionFilterMethodInfo.MakeGenericMethod(new Type[] { typeof(TContext), typeof(TRequest) }));
var BeforeActionEnd = methodIL.DefineLabel();
methodIL.Emit(OpCodes.Brtrue_S, BeforeActionEnd);
methodIL.Emit(OpCodes.Leave, methodEnd);
methodIL.MarkLabel(BeforeActionEnd);
#endregion
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller.Before();
methodIL.Emit(OpCodes.Callvirt, controllerType.GetMethod("Before", Type.EmptyTypes));
//bool,0
var BeforeEnd = methodIL.DefineLabel();
methodIL.Emit(OpCodes.Brtrue_S, BeforeEnd);
methodIL.Emit(OpCodes.Leave, methodEnd);
methodIL.MarkLabel(BeforeEnd);
//ViewBag初始化
if (true)
{
var ControllerViewBagFieldInfo = controllerType.GetField("ViewBag");
Type ViewBagType = Type.GetTypeFromHandle(actionData.viewBagType);
//if (ControllerViewBagFieldInfo.FieldType == typeof(object))
//{
// string modelTypeName = controllerType.Namespace + "." + controllerType.Name + "_Model";
// modelTypeName += "." + actionMethodInfo.Name;
// ViewBagType = assembly.GetType(modelTypeName);
// if (ViewBagType == null)
// {
// throw new NFinal.Exceptions.ModelNotFoundException(modelTypeName);
// }
//}
//else
//{
// ViewBagType = ControllerViewBagFieldInfo.FieldType;
//}
var ViewBagContructorInfo = ViewBagType.GetConstructor(Type.EmptyTypes);
var ViewBag = methodIL.DeclareLocal(ViewBagType);
bool viewBagTypeIsExpandoObject = false;
if (ViewBagType == typeof(System.Dynamic.ExpandoObject))
{
viewBagTypeIsExpandoObject = true;
}
//controller
methodIL.Emit(OpCodes.Newobj, ViewBagContructorInfo);
methodIL.Emit(OpCodes.Stloc, ViewBag);
List <FieldInfo> viewBagFiledInfoList = new List <FieldInfo>();
List <FieldInfo> controllerFieldInfoList = new List <FieldInfo>();
//获取所有字段
var controllerFieldInfos = controllerType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy);
foreach (var controllerFieldInfo in controllerFieldInfos)
{
//查找Controller中具有ViewBagMember特性的字段
var viewBagMemberAttribute = controllerFieldInfo.GetCustomAttributes(typeof(ViewBagMemberAttribute), true);
if (viewBagMemberAttribute.Count() > 0)
{
if (viewBagTypeIsExpandoObject)
{
controllerFieldInfoList.Add(controllerFieldInfo);
}
else
{
var ViewBagFiledInfo = ViewBagType.GetField(
controllerFieldInfo.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
//查找到ViewBag中具有相同名字的字段
if (ViewBagFiledInfo != null && ViewBagFiledInfo.FieldType == controllerFieldInfo.FieldType)
{
viewBagFiledInfoList.Add(ViewBagFiledInfo);
controllerFieldInfoList.Add(controllerFieldInfo);
}
}
}
}
List <MethodInfo> controllerProperyInfoGetMethodList = new List <MethodInfo>();
List <MethodInfo> viewBagPropertyInfoSetMethodList = new List <MethodInfo>();
var controllerPropertyInfos = controllerType.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.FlattenHierarchy);
foreach (var controllerPropertyInfo in controllerPropertyInfos)
{
var viewBagMemberAttribute = controllerPropertyInfo.GetCustomAttributes(typeof(ViewBagMemberAttribute), true);
if (viewBagMemberAttribute.Count() > 0)
{
if (viewBagTypeIsExpandoObject)
{
controllerProperyInfoGetMethodList.Add(controllerPropertyInfo.GetGetMethod());
}
else
{
var viewBagPropertyInfo = ViewBagType.GetProperty(
controllerPropertyInfo.Name, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static);
if (viewBagPropertyInfo != null && viewBagPropertyInfo.PropertyType == controllerPropertyInfo.PropertyType)
{
MethodInfo controllerPropertyInfoGetMethod = controllerPropertyInfo.GetGetMethod();
MethodInfo viewBagPropertyInfoSetMethod = viewBagPropertyInfo.GetSetMethod();
controllerProperyInfoGetMethodList.Add(controllerPropertyInfoGetMethod);
viewBagPropertyInfoSetMethodList.Add(viewBagPropertyInfoSetMethod);
}
}
}
}
Type viewBagOperateStaticType = null;
if (viewBagTypeIsExpandoObject)
{
}
for (int i = 0; i < viewBagFiledInfoList.Count; i++)
{
FieldInfo controllerFieldInfo = controllerFieldInfoList[i];
FieldInfo viewBagFiledInfo = viewBagFiledInfoList[i];
if (controllerFieldInfo.IsStatic)
{
methodIL.Emit(OpCodes.Ldloc, ViewBag);
methodIL.Emit(OpCodes.Ldsfld, controllerFieldInfo);
methodIL.Emit(OpCodes.Stfld, viewBagFiledInfo);
}
else
{
//赋值操作
methodIL.Emit(OpCodes.Ldloc, ViewBag);
methodIL.Emit(OpCodes.Ldloc, controller);
methodIL.Emit(OpCodes.Ldfld, controllerFieldInfo);
methodIL.Emit(OpCodes.Stfld, viewBagFiledInfo);
}
}
for (int i = 0; i < viewBagPropertyInfoSetMethodList.Count; i++)
{
MethodInfo controllerPropertyInfoGetMethod = controllerProperyInfoGetMethodList[i];
MethodInfo viewBagPropertyInfoSetMethod = viewBagPropertyInfoSetMethodList[i];
if (controllerPropertyInfoGetMethod.IsStatic)
{
methodIL.Emit(OpCodes.Ldloc, ViewBag);
methodIL.Emit(OpCodes.Call, controllerPropertyInfoGetMethod);
methodIL.Emit(OpCodes.Callvirt, viewBagPropertyInfoSetMethod);
}
else
{
methodIL.Emit(OpCodes.Ldloc, ViewBag);
methodIL.Emit(OpCodes.Ldloc, controller);
methodIL.Emit(OpCodes.Callvirt, controllerPropertyInfoGetMethod);
methodIL.Emit(OpCodes.Callvirt, viewBagPropertyInfoSetMethod);
}
}
methodIL.Emit(OpCodes.Ldloc, controller);
methodIL.Emit(OpCodes.Ldloc, ViewBag);
methodIL.Emit(OpCodes.Stfld, ControllerViewBagFieldInfo);
}
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
System.Reflection.ParameterInfo[] parameterInfos = actionMethodInfo.GetParameters();
//添加参数
if (parameterInfos.Length > 0)
{
for (int i = 0; i < parameterInfos.Length; i++)
{
Type parameterType = parameterInfos[i].ParameterType;
if (parameterInfos[i].ParameterType
#if (NET40 || NET451 || NET461)
.IsGenericType
#endif
#if NETCORE
.GetTypeInfo().IsGenericType
#endif
&& parameterInfos[i].ParameterType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
parameterType = parameterInfos[i].ParameterType.GetGenericArguments()[0];
}
if (parameterType == typeof(System.String) ||
parameterType == typeof(System.Int32) ||
parameterType == typeof(System.Int16) ||
parameterType == typeof(System.Int64) ||
parameterType == typeof(System.UInt32) ||
parameterType == typeof(System.UInt16) ||
parameterType == typeof(System.UInt64) ||
parameterType == typeof(System.Byte) ||
parameterType == typeof(System.SByte) ||
parameterType == typeof(System.Single) ||
parameterType == typeof(System.Double) ||
parameterType == typeof(System.Decimal) ||
parameterType == typeof(System.DateTime) ||
parameterType == typeof(System.DateTimeOffset) ||
parameterType == typeof(System.Char) ||
parameterType == typeof(System.Boolean) ||
parameterType == typeof(System.Guid))
{
//parameters
methodIL.Emit(OpCodes.Ldarg_3);
//parameters,name
methodIL.Emit(OpCodes.Ldstr, parameterInfos[i].Name);
//parameters[name]
methodIL.Emit(OpCodes.Callvirt, nameValueCollectionGetItemMethodInfo);
//ParameterType op_Implicit(request.parameters[name]);隐式转换
methodIL.Emit(OpCodes.Call, StringContainerOpImplicitMethodInfoDic[parameterInfos[i].ParameterType.TypeHandle]);
}
else
{
//new ParameterModel();
//methodIL.Emit(OpCodes.Newobj, parameterInfos[i].ParameterType.GetConstructor(Type.EmptyTypes));
//parameters
methodIL.Emit(OpCodes.Ldarg_3);
//ModelHelper.GetModel(new ParameterModel(),parameters);
methodIL.Emit(OpCodes.Call, modelHelperGetModelMethodInfo.MakeGenericMethod(parameterType));
}
}
}
//controller.Action(par1,par2,par3.....);
methodIL.Emit(OpCodes.Callvirt, actionMethodInfo);
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller.After();
methodIL.Emit(OpCodes.Callvirt, controllerType.GetMethod("After", Type.EmptyTypes));
#region 执行Action执行之后的过滤器
//actionData
methodIL.Emit(OpCodes.Ldarg_1);
//actionData.IBeforeActionFilters
methodIL.Emit(OpCodes.Ldfld, typeof(NFinal.Action.ActionData <TContext, TRequest>).GetField("IAfterActionFilters"));
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//FilterHelper.BeforeActionFilter();
methodIL.Emit(OpCodes.Call, AfterActionFilterMethodInfo.MakeGenericMethod(new Type[] { typeof(TContext), typeof(TRequest) }));
var AfterActionEnd = methodIL.DefineLabel();
methodIL.Emit(OpCodes.Brtrue_S, AfterActionEnd);
methodIL.Emit(OpCodes.Leave, methodEnd);
methodIL.MarkLabel(AfterActionEnd);
#endregion
//actionData
methodIL.Emit(OpCodes.Ldarg_1);
//actionData.IResponseFilters
methodIL.Emit(OpCodes.Ldfld, typeof(NFinal.Action.ActionData <TContext, TRequest>).GetField("IResponseFilters"));
//actionData.IResponseFilters,controller
methodIL.Emit(OpCodes.Ldloc, controller);
//actionData.IResponseFilters,controller.response
methodIL.Emit(OpCodes.Callvirt, controllerType.GetProperty("response").GetGetMethod());
//FilterHelper.Filter(actionData.IResponseFilters,controller.response)
methodIL.Emit(OpCodes.Call, ResponseFiltersMethodInfo);
var ifResponseFiltersEnd = methodIL.DefineLabel();
methodIL.Emit(OpCodes.Brtrue_S, ifResponseFiltersEnd);
methodIL.Emit(OpCodes.Leave, methodEnd);
methodIL.MarkLabel(ifResponseFiltersEnd);
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller.Close();
methodIL.Emit(OpCodes.Callvirt, controllerType.GetMethod("Close"));
//跳出异常
methodIL.Emit(OpCodes.Leave, methodEnd);
}
if (!Config.Configration.globalConfig.debug.enable)
{
methodIL.BeginCatchBlock(typeof(System.Exception));
{
methodIL.Emit(OpCodes.Throw);
}
}
//finally
methodIL.BeginFinallyBlock();
{
var finallyEnd = methodIL.DefineLabel();
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller==null
methodIL.Emit(OpCodes.Brfalse_S, finallyEnd);
//controller
methodIL.Emit(OpCodes.Ldloc, controller);
//controller.Dispose();
methodIL.Emit(OpCodes.Callvirt, controllerType.GetMethod("Dispose", Type.EmptyTypes));
//methodIL.Emit(OpCodes.Callvirt,typeof(System.IDisposable).GetMethod("Dispose",Type.EmptyTypes));
methodIL.MarkLabel(finallyEnd);
}
//end
methodIL.EndExceptionBlock();
methodIL.MarkLabel(methodEnd);
methodIL.Emit(OpCodes.Ret);
ActionExecute <TContext, TRequest> getRunActionDelegate = (ActionExecute <TContext, TRequest>)method.CreateDelegate(typeof(ActionExecute <TContext, TRequest>));
return(getRunActionDelegate);
}
private void LoadParameter()
{
DescriptionAttribute da = mMethod.GetCustomAttribute <DescriptionAttribute>(false);
if (da != null)
{
this.Remark = da.Description;
}
foreach (System.Reflection.ParameterInfo pi in mMethod.GetParameters())
{
ParameterBinder pb = new DefaultParameter();
ParameterBinder[] customPB = (ParameterBinder[])pi.GetCustomAttributes(typeof(ParameterBinder), false);
if (customPB != null && customPB.Length > 0)
{
pb = customPB[0];
}
else if (pi.ParameterType == typeof(Boolean))
{
pb = new BooleanParameter();
}
else if (pi.ParameterType == typeof(string))
{
pb = new StringParameter();
}
else if (pi.ParameterType == typeof(DateTime))
{
pb = new DateTimeParameter();
}
else if (pi.ParameterType == typeof(Decimal))
{
pb = new DecimalParameter();
}
else if (pi.ParameterType == typeof(float))
{
pb = new FloatParameter();
}
else if (pi.ParameterType == typeof(double))
{
pb = new DoubleParameter();
}
else if (pi.ParameterType == typeof(short))
{
pb = new ShortParameter();
}
else if (pi.ParameterType == typeof(int))
{
pb = new IntParameter();
}
else if (pi.ParameterType == typeof(long))
{
pb = new LongParameter();
}
else if (pi.ParameterType == typeof(ushort))
{
pb = new UShortParameter();
}
else if (pi.ParameterType == typeof(uint))
{
pb = new UIntParameter();
}
else if (pi.ParameterType == typeof(ulong))
{
pb = new ULongParameter();
}
else if (pi.ParameterType == typeof(HttpRequest))
{
pb = new RequestParameter();
}
else if (pi.ParameterType == typeof(IHttpContext))
{
pb = new HttpContextParameter();
}
else if (pi.ParameterType == typeof(IDataContext))
{
pb = new DataContextParameter();
}
else if (pi.ParameterType == typeof(HttpApiServer))
{
pb = new HttpApiServerParameter();
}
else if (pi.ParameterType == typeof(HttpResponse))
{
pb = new ResponseParameter();
}
else
{
pb = new DefaultParameter();
}
pb.Name = pi.Name;
pb.Type = pi.ParameterType;
Parameters.Add(pb);
}
}
// Handles Type, RuntimePropertyInfo and RuntimeMethodInfo.
// The runtime has also cases for RuntimeEventInfo, RuntimeFieldInfo, Assembly and ParameterInfo,
// but for those we return null here.
private static ICustomAttributeProvider?GetBase(ICustomAttributeProvider obj)
{
if (obj == null)
{
return(null);
}
if (obj is Type)
{
return(((Type)obj).BaseType);
}
MethodInfo?method = null;
if (obj is RuntimePropertyInfo)
{
return(GetBasePropertyDefinition((RuntimePropertyInfo)obj));
}
else if (obj is RuntimeEventInfo)
{
return(GetBaseEventDefinition((RuntimeEventInfo)obj));
}
else if (obj is RuntimeMethodInfo)
{
method = (MethodInfo)obj;
}
if (obj is RuntimeParameterInfo parinfo)
{
MemberInfo?member = parinfo.Member;
if (member is MethodInfo)
{
method = (MethodInfo)member;
MethodInfo bmethod = ((RuntimeMethodInfo)method).GetBaseMethod();
if (bmethod == method)
{
return(null);
}
int position = parinfo.Position;
if (position == -1)
{
return(bmethod.ReturnParameter);
}
return(bmethod.GetParameters()[position]);
}
}
/*
* ParameterInfo -> null
* Assembly -> null
* RuntimeEventInfo -> null
* RuntimeFieldInfo -> null
*/
if (method == null || !method.IsVirtual)
{
return(null);
}
MethodInfo baseMethod = ((RuntimeMethodInfo)method).GetBaseMethod();
if (baseMethod == method)
{
return(null);
}
return(baseMethod);
}
public override void CodeCompletion(string Text, Point Position, CodeCompletionArgs e)
{
string text2;
if (((e.CompletionType == CodeCompletionType.ListMembers) || (e.CompletionType == CodeCompletionType.CompleteWord)) || ((e.CompletionType == CodeCompletionType.None) && (e.KeyChar == '.')))
{
string text1;
int num1;
if (this.GetNameAndTypeFromCode(Text, Position.X, out text1, out text2, out num1))
{
object obj1 = base.UnitInfo.GetObjectClass((text1 == string.Empty) ? base.UnitInfo.SelfName : text1, Position);
bool flag1 = false;
if ((obj1 == null) && (text1 != string.Empty))
{
obj1 = base.UnitInfo.GetClassByName(text1);
flag1 = true;
}
IListMembers members1 = null;
if (obj1 != null)
{
members1 = new ListMembers();
if (obj1 is IInterfaceInfo)
{
this.AddCodeMembers(members1, (IInterfaceInfo)obj1, flag1);
}
else if (obj1 is Type)
{
this.AddCodeMembers(members1, (Type)obj1, flag1);
}
}
if (text1 == string.Empty)
{
ArrayList list1 = new ArrayList();
base.UnitInfo.Sections.GetRanges(list1, Position);
for (int num2 = list1.Count - 1; num2 >= 0; num2--)
{
if (list1[num2] is IHasParams)
{
if (members1 == null)
{
members1 = new ListMembers();
}
this.AddCodeMembers(((IHasParams)list1[num2]).Params, members1);
}
if (list1[num2] is IHasLocalVars)
{
if (members1 == null)
{
members1 = new ListMembers();
}
this.AddCodeMembers(((IHasLocalVars)list1[num2]).LocalVars, members1);
}
}
}
e.Provider = members1;
}
if (e.Provider != null)
{
e.Provider.ShowDescriptions = true;
e.StartPosition = new Point(num1, Position.Y);
int num3 = 0;
if (this.FindCodeText(text2, e.Provider, out num3) && (e.CompletionType == CodeCompletionType.CompleteWord))
{
e.SelIndex = num3;
}
e.Provider.SelIndex = Math.Max(num3, 0);
e.Provider.Images = base.UnitInfo.Images;
}
}
else
{
int num4;
int num5;
if (((e.CompletionType == CodeCompletionType.ParameterInfo) || ((e.CompletionType == CodeCompletionType.None) && (e.KeyChar == '('))) && this.GetMethodNameFromCode(Text, Position.X, out text2, out num5, out num4))
{
ArrayList list2 = new ArrayList();
base.UnitInfo.GetMethods(text2, Position, list2);
if (list2.Count > 0)
{
IParameterInfo info1 = new River.Orqa.Editor.Syntax.ParameterInfo();
info1.ShowParams = true;
info1.ShowQualifiers = false;
foreach (object obj2 in list2)
{
IListMember member1 = info1.AddMember();
if (obj2 is IMethodInfo)
{
IMethodInfo info2 = (IMethodInfo)obj2;
member1.Qualifier = base.UnitInfo.GetMethodQualifier(info2);
member1.Name = info2.Name;
member1.DataType = info2.DataType;
member1.ParamText = base.UnitInfo.GetParamText(info2.Params);
continue;
}
if (obj2 is System.Reflection.MethodInfo)
{
System.Reflection.MethodInfo info3 = (System.Reflection.MethodInfo)obj2;
member1.Qualifier = base.UnitInfo.GetMethodQualifier(info3);
member1.DataType = (info3.ReturnType != null) ? info3.ReturnType.Name : string.Empty;
member1.Name = info3.Name;
member1.ParamText = base.UnitInfo.GetParamText(info3.GetParameters());
}
}
e.Provider = info1;
}
e.StartPosition = new Point(num5, Position.Y);
e.EndPosition = new Point(num4, Position.Y);
e.ToolTip = true;
}
}
e.NeedShow = (e.Provider != null) && (e.Provider.Count > 0);
if (e.CompletionType == CodeCompletionType.None)
{
e.Interval = Consts.DefaultHintDelay;
}
}
protected static string GetMethodName(string dotName, System.Reflection.MethodInfo method, Type methodAtType, Dictionary <string, object> staticusenames, Dictionary <string, object> usenames)
{
if (method.IsSpecialName && method.Name.StartsWith("add_") && method.GetParameters().Length == 1 && IsDelegate(method.GetParameters()[0].ParameterType))
{
string eventname = method.Name.Substring(4);
return(eventname + "_addEventListener");
}
else if (method.IsSpecialName && method.Name.StartsWith("remove_") && method.GetParameters().Length == 1 && IsDelegate(method.GetParameters()[0].ParameterType))
{
string eventname = method.Name.Substring(7);
return(eventname + "_removeEventListener");
}
var members = methodAtType.GetMember(dotName);
//var props = methodAtType.GetProperties();
//bool isprop = false;
//foreach (var item in props)
//{
// if (Equals(method, item.GetGetMethod()))
// {
// isprop = true;
// }
// if (Equals(method, item.GetSetMethod()))
// {
// isprop = true;
// }
//}
//if (!isprop)
{
if (Char.IsLower(dotName[0]))
{
List <System.Reflection.MemberInfo> temp = new List <System.Reflection.MemberInfo>();
var ms = methodAtType.GetMember(Char.ToUpper(dotName[0]) + dotName.Substring(1));
foreach (var item in ms)
{
if (item.MemberType != MemberTypes.NestedType)
{
temp.Add(item);
}
}
if (temp.Count > 0)
{
dotName = dotName + "".PadLeft(temp.Count, '_');
}
}
}
if (methodAtType.IsInterface)
{
var extinterface = methodAtType.GetInterfaces();
List <System.Reflection.MemberInfo> inheritmember = new List <System.Reflection.MemberInfo>();
foreach (var item in extinterface)
{
inheritmember.AddRange(item.GetMember(dotName));
}
if (inheritmember.Count > 0)
{
inheritmember.AddRange(members);
members = inheritmember.ToArray();
}
}
else
{
var basetype = methodAtType.BaseType;
List <System.Reflection.MemberInfo> inheritmember = new List <System.Reflection.MemberInfo>();
if (basetype != null)
{
var inherit = basetype.GetMember(dotName);
inheritmember.AddRange(inherit);
basetype = basetype.BaseType;
}
if (inheritmember.Count > 0)
{
inheritmember.AddRange(members);
members = inheritmember.ToArray();
}
}
string ext = string.Empty;
for (int i = 0; i < members.Length; i++)
{
var m = members[i];
if (IsSkipMember(m))
{
continue;
}
if (m is MethodBase)
{
if (((MethodBase)m).IsStatic != method.IsStatic)
{
continue;
}
}
else if (m is PropertyInfo)
{
PropertyInfo p = (PropertyInfo)m;
if (Equals(p.GetGetMethod(), method))
{
break;
}
if (Equals(p.GetSetMethod(), method))
{
break;
}
}
if (members[i].Equals(method))
{
break;
}
else
{
ext = ext + "_";
}
}
string v = dotName.Substring(0, 1).ToLower() + dotName.Substring(1) + ext;
if (dotName.Length > 1)
{
if (Char.IsUpper(dotName.Substring(1, 1)[0]))
{
v = dotName + ext;
}
}
while (as3keywords.ContainsKey(v))
{
v = v + "_";
}
if (method.IsStatic)
{
if (staticusenames != null)
{
while (staticusenames.ContainsKey(v))
{
v = v + "_";
}
}
}
else
{
if (usenames != null)
{
while (usenames.ContainsKey(v))
{
v = v + "_";
}
}
}
return(v);
}
protected override void GenerateMethod(ILGenerator il, System.Reflection.MethodInfo method, System.Reflection.MethodInfo interfaceMethod)
{
// In Parameters
ArrayList inParams = new ArrayList();
// Ref or Out Parameters
ArrayList refOutParams = new ArrayList();
foreach (ParameterInfo paramInfo in interfaceMethod.GetParameters())
{
if (paramInfo.IsRetval || paramInfo.IsOut)
{
refOutParams.Add(paramInfo);
}
else
{
inParams.Add(paramInfo);
}
}
proxyGenerator.PushTarget(il);
//LocalBuilder methodToCall = il.DeclareLocal(typeof(MethodInfo));
//il.Emit(OpCodes.Newobj, interfaceMethod);
//il.Emit(OpCodes.Ldloc, methodToCall);
il.Emit(OpCodes.Ldstr, interfaceMethod.Name);
// Parameter #2
LocalBuilder parameters = il.DeclareLocal(typeof(Object[]));
il.Emit(OpCodes.Ldc_I4, inParams.Count);
il.Emit(OpCodes.Newarr, typeof(Object));
il.Emit(OpCodes.Stloc, parameters);
int paramIndex = 0;
foreach (ParameterInfo paramInfo in inParams)
{
il.Emit(OpCodes.Ldloc, parameters);
il.Emit(OpCodes.Ldc_I4, paramIndex);
il.Emit(OpCodes.Ldarg, paramInfo.Position + 1);
if (paramInfo.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, paramInfo.ParameterType);
}
il.Emit(OpCodes.Stelem_Ref);
paramIndex++;
}
il.Emit(OpCodes.Ldloc, parameters);
// Call Invoke method and save result
LocalBuilder results = il.DeclareLocal(typeof(Object[]));
il.EmitCall(OpCodes.Callvirt, InvokeMethod, null);
il.Emit(OpCodes.Stloc, results);
int resultIndex = (interfaceMethod.ReturnType == typeof(void) ? 0 : 1);
foreach (ParameterInfo paramInfo in refOutParams)
{
il.Emit(OpCodes.Ldarg, paramInfo.Position + 1);
il.Emit(OpCodes.Ldloc, results);
// Cast / Unbox the return value
il.Emit(OpCodes.Ldc_I4, resultIndex);
il.Emit(OpCodes.Ldelem_Ref);
Type elementType = paramInfo.ParameterType.GetElementType();
if (elementType.IsValueType)
{
il.Emit(OpCodes.Unbox, elementType);
il.Emit(OpCodes.Ldobj, elementType);
il.Emit(OpCodes.Stobj, elementType);
}
else
{
il.Emit(OpCodes.Castclass, elementType);
il.Emit(OpCodes.Stind_Ref);
}
resultIndex++;
}
if (interfaceMethod.ReturnType != typeof(void))
{
il.Emit(OpCodes.Ldloc, results);
// Cast / Unbox the return value
il.Emit(OpCodes.Ldc_I4_0);
il.Emit(OpCodes.Ldelem_Ref);
if (interfaceMethod.ReturnType.IsValueType)
{
il.Emit(OpCodes.Unbox, interfaceMethod.ReturnType);
il.Emit(OpCodes.Ldobj, interfaceMethod.ReturnType);
}
else
{
il.Emit(OpCodes.Castclass, interfaceMethod.ReturnType);
}
}
}
private static Type[] GetMethodParametersTypes(System.Reflection.MethodInfo method)
{
return(method.GetParameters()
.Select(x => x.ParameterType)
.ToArray());
}
private void AddMethodImpl(MethodInfo mi)
{
ParameterInfo[] parameters = mi.GetParameters();
Type[] paramTypes = ParamTypes(parameters, false);
MethodBuilder mdb = _tb.DefineMethod(mi.Name, MethodAttributes.Public | MethodAttributes.Virtual, mi.ReturnType, paramTypes);
if (mi.ContainsGenericParameters)
{
Type[] ts = mi.GetGenericArguments();
string[] ss = new string[ts.Length];
for (int i = 0; i < ts.Length; i++)
{
ss[i] = ts[i].Name;
}
GenericTypeParameterBuilder[] genericParameters = mdb.DefineGenericParameters(ss);
for (int i = 0; i < genericParameters.Length; i++)
{
genericParameters[i].SetGenericParameterAttributes(ts[i].GetTypeInfo().GenericParameterAttributes);
}
}
ILGenerator il = mdb.GetILGenerator();
ParametersArray args = new ParametersArray(il, paramTypes);
// object[] args = new object[paramCount];
il.Emit(OpCodes.Nop);
GenericArray <object> argsArr = new GenericArray <object>(il, ParamTypes(parameters, true).Length);
for (int i = 0; i < parameters.Length; i++)
{
// args[i] = argi;
if (!parameters[i].IsOut)
{
argsArr.BeginSet(i);
args.Get(i);
argsArr.EndSet(parameters[i].ParameterType);
}
}
// object[] packed = new object[PackedArgs.PackedTypes.Length];
GenericArray <object> packedArr = new GenericArray <object>(il, PackedArgs.PackedTypes.Length);
// packed[PackedArgs.DispatchProxyPosition] = this;
packedArr.BeginSet(PackedArgs.DispatchProxyPosition);
il.Emit(OpCodes.Ldarg_0);
packedArr.EndSet(typeof(DispatchProxy));
// packed[PackedArgs.DeclaringTypePosition] = typeof(iface);
MethodInfo Type_GetTypeFromHandle = typeof(Type).GetRuntimeMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) });
int methodToken;
Type declaringType;
_assembly.GetTokenForMethod(mi, out declaringType, out methodToken);
packedArr.BeginSet(PackedArgs.DeclaringTypePosition);
il.Emit(OpCodes.Ldtoken, declaringType);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle);
packedArr.EndSet(typeof(object));
// packed[PackedArgs.MethodTokenPosition] = iface method token;
packedArr.BeginSet(PackedArgs.MethodTokenPosition);
il.Emit(OpCodes.Ldc_I4, methodToken);
packedArr.EndSet(typeof(Int32));
// packed[PackedArgs.ArgsPosition] = args;
packedArr.BeginSet(PackedArgs.ArgsPosition);
argsArr.Load();
packedArr.EndSet(typeof(object[]));
// packed[PackedArgs.GenericTypesPosition] = mi.GetGenericArguments();
if (mi.ContainsGenericParameters)
{
packedArr.BeginSet(PackedArgs.GenericTypesPosition);
Type[] genericTypes = mi.GetGenericArguments();
GenericArray <Type> typeArr = new GenericArray <Type>(il, genericTypes.Length);
for (int i = 0; i < genericTypes.Length; ++i)
{
typeArr.BeginSet(i);
il.Emit(OpCodes.Ldtoken, genericTypes[i]);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle);
typeArr.EndSet(typeof(Type));
}
typeArr.Load();
packedArr.EndSet(typeof(Type[]));
}
// Call static DispatchProxyHelper.Invoke(object[])
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _fields[InvokeActionFieldAndCtorParameterIndex]); // delegate
packedArr.Load();
il.Emit(OpCodes.Call, s_delegateInvoke);
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
args.BeginSet(i);
argsArr.Get(i);
args.EndSet(i, typeof(object));
}
}
if (mi.ReturnType != typeof(void))
{
packedArr.Get(PackedArgs.ReturnValuePosition);
Convert(il, typeof(object), mi.ReturnType, false);
}
il.Emit(OpCodes.Ret);
_tb.DefineMethodOverride(mdb, mi);
}
private void FillPropertiesInformation()
{
MemberInfo[] tmpElements = _emptyChildNodeInfos;
MemberInfo[] tmpAttributes = _emptyChildNodeInfos;
if (IsSimpleType)
{
return;
}
ArrayList elements = new ArrayList();
ArrayList attributes = new ArrayList();
_attributesNamed = new HybridDictionary();
int elementIndex = 0;
int attributeIndex = 0;
R.MemberInfo[] members = _type.FindMembers(MemberTypes.Property | MemberTypes.Field, BindingFlags.Instance | BindingFlags.Public, null, null);
SortMembersArray(members);
foreach (R.MemberInfo mi in members)
{
// Create member info
R.PropertyInfo pi = mi as R.PropertyInfo;
R.MethodInfo piGetMethod = null;
MemberInfo nodeInfo = null;
if (pi != null)
{
piGetMethod = pi.GetGetMethod();
if (piGetMethod != null && piGetMethod.GetParameters().Length == 0)
{
nodeInfo = new PropertyInfo(pi);
}
else
{
// This is not a property without arguments.
continue;
}
}
else
{
R.FieldInfo fi = (R.FieldInfo)mi;
nodeInfo = new FieldInfo(fi);
}
nodeInfo._nodeName = mi.Name;
// Get decorations for the original MemberInfo
nodeInfo.GetDecorations(mi);
if (pi != null)
{
// Check for interface's attributes if the member is property
foreach (Type iface in _type.GetInterfaces())
{
int accessorIndex = -1;
InterfaceMapping map = _type.GetInterfaceMap(iface);
for (int i = 0; i < map.TargetMethods.Length; i++)
{
if (map.TargetMethods[i] == piGetMethod)
{
accessorIndex = i;
break;
}
}
if (accessorIndex != -1)
{
R.MethodInfo ifaceMember = map.InterfaceMethods[accessorIndex];
foreach (R.PropertyInfo ifaceProperty in iface.GetProperties())
{
if (ifaceProperty.GetGetMethod() == ifaceMember)
{
nodeInfo.GetDecorations(ifaceProperty);
break;
}
}
break;
}
}
}
// Check for XmlIgnore attribute
if (nodeInfo.XmlIgnore != null)
{
continue;
}
nodeInfo.ProcessDecorations();
TypeInfo declTypeInfo = TypeInfoCache.Instance.GetTypeInfo(mi.DeclaringType);
string declSchemaNs = declTypeInfo.Namespace;
if (declTypeInfo.XmlType != null && declTypeInfo.XmlType.Namespace != null)
{
declSchemaNs = declTypeInfo.XmlType.Namespace;
}
// Add member to the collection
switch (nodeInfo.NodeType)
{
case XPathNodeType.Element:
{
if ((nodeInfo.Form == XmlSchemaForm.None ||
nodeInfo.Form == XmlSchemaForm.Qualified) &&
nodeInfo._namespace == null)
{
// Take NS from declaring type
nodeInfo._namespace = declSchemaNs;
}
goto case XPathNodeType.Text;
}
case XPathNodeType.Text:
{
// Add to array of elements
nodeInfo.Index = elementIndex++;
elements.Add(nodeInfo);
break;
}
default: // Attribute
{
if (nodeInfo.Form == XmlSchemaForm.None)
{
if (nodeInfo._namespace == declSchemaNs)
{
nodeInfo._namespace = null;
}
}
else if (nodeInfo.Form == XmlSchemaForm.Qualified &&
nodeInfo._namespace == null)
{
// Take NS from declaring type
nodeInfo._namespace = declSchemaNs;
}
// Add to array of attributes
nodeInfo.Index = attributeIndex++;
attributes.Add(nodeInfo);
_attributesNamed.Add(new XmlQualifiedName(nodeInfo.Name, nodeInfo.Namespace), nodeInfo);
break;
}
}
}
if (elements.Count > 0)
{
tmpElements = (MemberInfo[])elements.ToArray(typeof(MemberInfo));
}
if (attributes.Count > 0)
{
tmpAttributes = (MemberInfo[])attributes.ToArray(typeof(MemberInfo));
}
_elements = tmpElements;
_attributes = tmpAttributes;
}
protected virtual void OnRequestExecution(string method, string value)
{
if (DEBUG)
{
Response.Write("execute:");
if (!string.IsNullOrEmpty(method))
{
Response.Write(method);
}
Response.Write(", value:");
if (!string.IsNullOrEmpty(value))
{
Response.Write(value);
}
Response.Write("<br>");
}
try
{
System.Reflection.MethodInfo mif = this.GetType().GetMethod(method);
if ((mif != null))
{
ParameterInfo[] pifs = mif.GetParameters();
if (pifs == null || pifs.Length == 0)
{
mif.Invoke(this, new object[] { });
}
else
{
if (pifs.Length == 1)
{
if (pifs[0].ParameterType.Equals(typeof(string)))
{
mif.Invoke(this, new object[] { value });
}
else
{
TypeConverter converter = TypeDescriptor.GetConverter(pifs[0].ParameterType);
if (converter != null)
{
object obj = converter.ConvertFromInvariantString(value);
mif.Invoke(this, new object[] { obj });
}
else
{
//let it fail
mif.Invoke(this, new object[] { value });
}
}
}
else
{
//let it fail
mif.Invoke(this, new object[] { value });
}
}
}
}
catch (Exception err)
{
if (!DEBUG) //if DEBUG is true then the info is already sent
{
Response.Write("execute:");
if (!string.IsNullOrEmpty(method))
{
Response.Write(method);
}
Response.Write(", value:");
if (!string.IsNullOrEmpty(value))
{
Response.Write(value);
}
Response.Write("<br>");
}
Response.Write("Error executing the method. Error message:");
OutputException(err);
Response.Write("<br>");
}
}
/// <summary>
/// Invoke a method async if possible, providing
/// paramters from the params array and from DI
/// </summary>
/// <param name="obj">Target object</param>
/// <param name="info">Method to invoke</param>
/// <param name="parameters">Criteria params array</param>
/// <returns></returns>
public static async Task <object> CallMethodTryAsync(object obj, System.Reflection.MethodInfo info, object[] parameters)
{
if (info == null)
{
throw new NotImplementedException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodNotImplemented);
}
var methodParameters = info.GetParameters();
var plist = new object[methodParameters.Count()];
int index = 0;
int criteriaIndex = 0;
IServiceProvider service = ApplicationContext.ScopedServiceProvider;
foreach (var item in methodParameters)
{
if (item.CustomAttributes.Where(a => a.AttributeType == typeof(InjectAttribute)).Count() > 0)
{
if (service != null)
{
plist[index] = service.GetService(item.ParameterType);
}
}
else
{
if (parameters == null || parameters.Length - 1 < criteriaIndex)
{
plist[index] = null;
}
else
{
plist[index] = parameters[criteriaIndex];
}
criteriaIndex++;
}
index++;
}
var isAsyncTask = (info.ReturnType == typeof(Task));
var isAsyncTaskObject = (info.ReturnType.IsGenericType && (info.ReturnType.GetGenericTypeDefinition() == typeof(Task <>)));
try
{
if (isAsyncTask)
{
await(Task) info.Invoke(obj, plist);
return(null);
}
else if (isAsyncTaskObject)
{
return(await(Task <object>) info.Invoke(obj, plist));
}
else
{
var result = info.Invoke(obj, plist);
return(result);
}
}
catch (Exception ex)
{
Exception inner = null;
if (ex.InnerException == null)
{
inner = ex;
}
else
{
inner = ex.InnerException;
}
throw new CallMethodException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodCallFailed, inner);
}
}
private void CreateParticleMethodCategory(string methodname, float x, float y)
{
Macross.NodesControlAssist NodesControlAssist = mLinkedNodesContainer.HostControl as Macross.NodesControlAssist;
//加入列表信息
Macross.Category category;
var csparam = CSParam as StructNodeControlConstructionParams;
if (!csparam.CategoryDic.TryGetValue(Macross.MacrossPanelBase.GraphCategoryName, out category))
{
return;
}
var HostControl = this.HostNodesContainer.HostControl;
var item = new Macross.CategoryItem(null, category);
item.CategoryItemType = Macross.CategoryItem.enCategoryItemType.OverrideFunction;
var data = new Macross.CategoryItem.InitializeData();
data.Reset();
var MacrossOpPanel = NodesControlAssist.HostControl.MacrossOpPanel;
item.Initialize(MacrossOpPanel.HostControl, data);
//HostControl.CreateNodesContainer(item);
//MainGridItem.Children.Add(item);
item.Name = methodname;
category.Items.Add(item);
//加入结点信息
Type type = typeof(EngineNS.Bricks.Particle.TrailNode);
System.Reflection.MethodInfo methodInfo = type.GetMethod(methodname);
System.Reflection.ParameterInfo[] paramstype = methodInfo.GetParameters();
//拷貝方法的attribute.
var attrts = methodInfo.GetCustomAttributes(true);
string displayname = "";
for (int i = 0; i < attrts.Length; i++)
{
var displayattr = attrts[i] as System.ComponentModel.DisplayNameAttribute;
if (displayattr != null)
{
displayname = displayattr.DisplayName;
break;
}
}
//var CustomFunctionData = new Macross.ResourceInfos.MacrossResourceInfo.CustomFunctionData();
var methodinfo = CodeDomNode.Program.GetMethodInfoAssistFromMethodInfo(methodInfo, type, CodeDomNode.MethodInfoAssist.enHostType.Base, "");
var nodeType = typeof(CodeDomNode.MethodOverride);
var csParam = new CodeDomNode.MethodOverride.MethodOverrideConstructParam()
{
CSType = mLinkedNodesContainer.CSType,
HostNodesContainer = mLinkedNodesContainer,
ConstructParam = "",
MethodInfo = methodinfo,
DisplayName = displayname,
};
//var center = nodesContainer.NodesControl.GetViewCenter();
var node = mLinkedNodesContainer.AddOrigionNode(nodeType, csParam, x, y);
node.IsDeleteable = true;
//重写双击事件 不需要进入二级编辑
//item.OnDoubleClick -= item.OnDoubleClick;
Type ItemType = item.GetType();
FieldInfo _Field = item.GetType().GetField("OnDoubleClick", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
if (_Field != null)
{
object _FieldValue = _Field.GetValue(item);
if (_FieldValue != null && _FieldValue is Delegate)
{
Delegate _ObjectDelegate = (Delegate)_FieldValue;
Delegate[] invokeList = _ObjectDelegate.GetInvocationList();
foreach (Delegate del in invokeList)
{
ItemType.GetEvent("OnDoubleClick").RemoveEventHandler(item, del);
}
}
}
item.OnDoubleClick += (categoryItem) =>
{
mLinkedNodesContainer.FocusNode(node);
};
//NodesControlAssist.Save();
}
public ReturnData doJsDAOMode(string xmlpara)
{
ReturnData rr = new ReturnData();
try
{
DataTable dt = Util.JsonHelper.Json2Dtb(xmlpara);
// Get the constructor and create an instance of MagicClass
object[] arr = new object[] { };
System.Reflection.Assembly aa = System.Reflection.Assembly.Load("BLL");
Type magicType = aa.GetType("" + dt.Rows[0]["dll_className"]);
object magicClassObject = Activator.CreateInstance(magicType);
System.Reflection.MethodInfo magicMethod = magicType.GetMethod("" + dt.Rows[0]["dll_ModeName"]);
System.Reflection.ParameterInfo[] parainfo = magicMethod.GetParameters();
arr = new object[parainfo.Length];
//參數
for (int i = 0; i < parainfo.Length; i++)
{
if (parainfo[i].ParameterType == typeof(byte))
{
arr[i] = byte.Parse("" + dt.Rows[0][parainfo[i].Name]);
}
else if (parainfo[i].ParameterType == typeof(bool))
{
arr[i] = bool.Parse("" + dt.Rows[0][parainfo[i].Name]);
}
else if (parainfo[i].ParameterType == typeof(DateTime))
{
arr[i] = DateTime.Parse("" + dt.Rows[0][parainfo[i].Name]);
}
else if (parainfo[i].ParameterType == typeof(int))
{
arr[i] = int.Parse("" + dt.Rows[0][parainfo[i].Name]);
}
else if (parainfo[i].ParameterType == typeof(decimal))
{
arr[i] = decimal.Parse("" + dt.Rows[0][parainfo[i].Name]);
}
else
{
arr[i] = "" + dt.Rows[0][parainfo[i].Name];
}
}
if (magicMethod.ReturnType == typeof(void))
{
magicMethod.Invoke(magicClassObject, arr); return(null);
}
object magicValue = magicMethod.Invoke(magicClassObject, arr);
if (magicValue.GetType() == typeof(DataTable))
{
dt = (DataTable)magicValue;
rr.data = Util.JsonHelper.Dtb2Json(dt);
rr.type = "" + dt.GetType();
}
else
{
rr.data = "" + magicValue;
rr.type = "" + magicValue.GetType();
}
return(rr);
}
catch (Exception ex)
{
rr.data = "doJsDAOMode ErrMsg:" + ex.Message;
rr.type = "ErrMsg";
return(rr);
}
}
public override void Execute(JoinPointContext context)
{
if (context == null)
{
TraceBuffer.WriteLine("OUT Tracing: Context not set!");
return;
}
// Sender, Target, Methodname
String sender = "unknown";
if (context.Sender != null)
{
sender = context.Sender.GetType().FullName;
}
Type target = null;
if (context.StartTarget != null)
{
target = context.StartTarget.GetType();
}
TraceBuffer.WriteLine("OUT Tracing: Sender={0}, Target={1}, MethodName={2} ", sender, target, context.StartSelector);
System.Reflection.MethodInfo mi = target.GetMethod(context.StartSelector, BindingFlags.Public
| BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
if (mi != null && context.ArgumentCount > 0)
{
System.Reflection.ParameterInfo[] pi = mi.GetParameters();
for (int j = 0; j < pi.Length; j++)
{
if (pi[j].IsOut)
{
ArgumentInfo argumentInfo = context.GetArgumentInfo((short)(j + 1));
if (argumentInfo.Value == null)
{
TraceBuffer.WriteLine(" argument {0} (out) -> {1} = null", j + 1, pi[j].ParameterType.FullName);
continue;
}
String argvalue;
try
{
argvalue = argumentInfo.Value.ToString();
}
catch (Exception)
{
argvalue = "<exception>";
}
TraceBuffer.WriteLine(" argument {0} (out) -> {1} = {2}", j + 1, pi[j].ParameterType.FullName, argvalue);
}
}
}
// Returnvalue
if (context.HasReturnValue)
{
if (context.ReturnType == null)
{
TraceBuffer.WriteLine(" return type = null");
}
else if (context.ReturnValue == null)
{
TraceBuffer.WriteLine(" return type = {0}, return value = null", context.ReturnType.FullName);
}
else if (context.StartSelector != "ToString")
{
TraceBuffer.WriteLine(" return type = {0}, return value = ", context.ReturnType.FullName);
}
else
{
String returnValue;
try
{
returnValue = context.ReturnValue.ToString();
}
catch (Exception)
{
returnValue = "<exception>";
}
TraceBuffer.WriteLine(" return type = {0}, return value = (1)", context.ReturnType.FullName, returnValue);
}
}
//Type t = context.GetProperty("target").GetType();
////Console.WriteLine("Tracing IN method: "+t.get_Name() + "." + rm.getSelector());
//System.Reflection.MethodInfo[] mi = t.GetMethods(BindingFlags.Public
// | BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Instance);
//for (int i = 0; i < mi.Length; i++)
//{
// //Console.WriteLine("\tSearching for method: "+rm.getSelector()+" == "+mi[i].get_Name());
// if (mi[i].Name == (string)context.GetProperty("selector"))
// {
// if (((object[])context.GetProperty("args")).Length == 0)
// {
// Object[] obj = new Object[0];
// Console.WriteLine("TracingOUT: " + t.Name + "." + (string)context.GetProperty("selector"));
// break;
// }
// int k = 0;
// ArrayList list = new ArrayList();
// System.Reflection.ParameterInfo[] pi = mi[i].GetParameters();
// for (int j = 0; j < pi.Length; j++)
// {
// if (pi[j].IsOut)
// {
// list.Add(context.GetProperty("Arg[" + k + "]"));
// }
// k++;
// }
// Console.WriteLine("TracingOUT[" + context.GetProperty("returnvalue") + "][" + list.ToArray().Length + "]: " + list.ToString());
// break;
// }
//}
}
private static Type GetThunk(Delegate kernel, Campy.Types.Extent extent, Structure structure)
{
// Get MethodInfo for lambda.
SR.MethodInfo mi = kernel.Method;
object target = kernel.Target;
Type target_type = target.GetType();
String target_type_name = target_type.FullName;
target_type_name = Campy.Utils.Utility.NormalizeSystemReflectionName(target_type_name);
// Get assembly name which encloses code for kernel.
String kernel_assembly_file_name = mi.DeclaringType.Assembly.Location;
// Get directory containing the assembly.
String full_path = Path.GetFullPath(kernel_assembly_file_name);
full_path = Path.GetDirectoryName(full_path);
// Get full name of kernel, including normalization because they cannot be compared directly with Mono.Cecil names.
String kernel_full_name = string.Format("{0} {1}.{2}({3})", mi.ReturnType.FullName, Campy.Utils.Utility.RemoveGenericParameters(mi.ReflectedType), mi.Name, string.Join(",", mi.GetParameters().Select(o => string.Format("{0}", o.ParameterType)).ToArray()));
kernel_full_name = Campy.Utils.Utility.NormalizeSystemReflectionName(kernel_full_name) + "_managed";
// Get short name of Campy kernel.
String campy_kernel_class_short_name = target_type_name
+ "_managed";
// Derive name of assembly containing corresponding Campy code for lambda.
String campy_assembly_file_name = full_path + "\\" + kernel_full_name;
//String ext = Path.GetExtension(campy_assembly_file_name);
//campy_assembly_file_name = campy_assembly_file_name.Replace(ext, "");
campy_assembly_file_name = campy_assembly_file_name + "_aux";
campy_assembly_file_name = campy_assembly_file_name + ".dll";
bool rebuild = false;
SR.Assembly dll = null;
Type thunk = null;
// Determine if this campy assembly has been seen before.
Assembly assembly = null;
bool found = assemblies.TryGetValue(campy_assembly_file_name, out assembly);
if (!found)
{
assembly = new Assembly(campy_assembly_file_name);
assemblies.Add(campy_assembly_file_name, assembly);
}
// Create app domain in order to test the dll.
//SR.AssemblyName assemblyName = new SR.AssemblyName();
//assemblyName.CodeBase = assembly.Name;
try
{
dll = SR.Assembly.LoadFile(campy_assembly_file_name);
}
catch
{
rebuild = true;
}
// Determine if this kernel has been executed before.
if (!assembly.executed_lambdas.Contains(kernel_full_name))
{
// Check timestamps.
if (!rebuild)
{
DateTime dt_kernel_assembly = File.GetLastWriteTime(kernel_assembly_file_name);
DateTime dt_campy_kernel_assembly = File.GetLastWriteTime(campy_assembly_file_name);
if (dt_campy_kernel_assembly < dt_kernel_assembly)
{
rebuild = true;
}
}
if (!rebuild)
{
//dll = dom.Load(assemblyName);
// Get address of thunk class corresponding to lambda.
thunk = dll.GetType(kernel_full_name);
if (thunk == null)
{
rebuild = true;
}
}
if (rebuild)
{
Converter converter = new Converter(assembly);
// Convert lambda into GPU target code.
converter.Convert(kernel, extent, structure);
// Compile target code into object code.
builder.Compile(assembly);
// Link object code.
builder.Link(assembly);
}
// Note that lambda was generated and compiled.
assembly.executed_lambdas.Add(kernel_full_name);
}
// Load/reload assembly.
//dll = dom.Load(assemblyName);
dll = SR.Assembly.LoadFile(campy_assembly_file_name);
// Get address of thunk class corresponding to lambda.
thunk = dll.GetType(kernel_full_name);
return(thunk);
}
private void LoadParameter()
{
foreach (System.Reflection.ParameterInfo pi in mMethod.GetParameters())
{
ParameterBinder pb = new DefaultParameter();
ParameterBinder[] customPB = (ParameterBinder[])pi.GetCustomAttributes(typeof(ParameterBinder), false);
if (customPB != null && customPB.Length > 0)
{
pb = customPB[0];
}
else if (pi.ParameterType == typeof(string))
{
pb = new StringParameter();
}
else if (pi.ParameterType == typeof(DateTime))
{
pb = new DateTimeParameter();
}
else if (pi.ParameterType == typeof(Decimal))
{
pb = new DecimalParameter();
}
else if (pi.ParameterType == typeof(float))
{
pb = new FloatParameter();
}
else if (pi.ParameterType == typeof(double))
{
pb = new DoubleParameter();
}
else if (pi.ParameterType == typeof(short))
{
pb = new ShortParameter();
}
else if (pi.ParameterType == typeof(int))
{
pb = new IntParameter();
}
else if (pi.ParameterType == typeof(long))
{
pb = new LongParameter();
}
else if (pi.ParameterType == typeof(ushort))
{
pb = new UShortParameter();
}
else if (pi.ParameterType == typeof(uint))
{
pb = new UIntParameter();
}
else if (pi.ParameterType == typeof(ulong))
{
pb = new ULongParameter();
}
else if (pi.ParameterType == typeof(HttpRequest))
{
pb = new RequestParameter();
}
else if (pi.ParameterType == typeof(HttpResponse))
{
pb = new ResponseParameter();
}
else
{
if (pi.ParameterType.GetInterface("BeetleX.HttpExtend.IBodyFlag") != null)
{
pb = new BodyParameter();
}
else
{
pb = new DefaultParameter();
}
}
pb.Name = pi.Name;
pb.Type = pi.ParameterType;
Parameters.Add(pb);
}
}
/// <summary>
/// Returns an collection containing a single ITestCaseData item,
/// constructed from the arguments provided in the constructor and
/// possibly converted to match the specified method.
/// </summary>
/// <param name="method">The method for which data is being provided</param>
/// <returns></returns>
public System.Collections.Generic.IEnumerable <ITestCaseData> GetTestCasesFor(System.Reflection.MethodInfo method)
{
ParameterSet parms;
try
{
ParameterInfo[] parameters = method.GetParameters();
int argsNeeded = parameters.Length;
int argsProvided = Arguments.Length;
parms = new ParameterSet(this);
// Special handling for params arguments
if (argsNeeded > 0 && argsProvided >= argsNeeded - 1)
{
ParameterInfo lastParameter = parameters[argsNeeded - 1];
Type lastParameterType = lastParameter.ParameterType;
Type elementType = lastParameterType.GetElementType();
if (lastParameterType.IsArray && lastParameter.IsDefined(typeof(ParamArrayAttribute), false))
{
if (argsProvided == argsNeeded)
{
Type lastArgumentType = parms.Arguments[argsProvided - 1].GetType();
if (!lastParameterType.IsAssignableFrom(lastArgumentType))
{
Array array = Array.CreateInstance(elementType, 1);
array.SetValue(parms.Arguments[argsProvided - 1], 0);
parms.Arguments[argsProvided - 1] = array;
}
}
else
{
object[] newArglist = new object[argsNeeded];
for (int i = 0; i < argsNeeded && i < argsProvided; i++)
{
newArglist[i] = parms.Arguments[i];
}
int length = argsProvided - argsNeeded + 1;
Array array = Array.CreateInstance(elementType, length);
for (int i = 0; i < length; i++)
{
array.SetValue(parms.Arguments[argsNeeded + i - 1], i);
}
newArglist[argsNeeded - 1] = array;
parms.Arguments = newArglist;
argsProvided = argsNeeded;
}
}
}
//if (method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
// parms.Arguments = new object[]{parms.Arguments};
// Special handling when sole argument is an object[]
if (argsNeeded == 1 && method.GetParameters()[0].ParameterType == typeof(object[]))
{
if (argsProvided > 1 ||
argsProvided == 1 && parms.Arguments[0].GetType() != typeof(object[]))
{
parms.Arguments = new object[] { parms.Arguments };
}
}
if (argsProvided == argsNeeded)
{
PerformSpecialConversions(parms.Arguments, parameters);
}
}
catch (Exception ex)
{
parms = new ParameterSet(ex);
}
return(new ITestCaseData[] { parms });
}
private static object CallMethod(object obj, System.Reflection.MethodInfo info, bool hasParameters, params object[] parameters)
{
#if IOS
var infoParams = info.GetParameters();
var infoParamsCount = infoParams.Length;
bool hasParamArray = infoParamsCount > 0 && infoParams[infoParamsCount - 1].GetCustomAttributes(typeof(ParamArrayAttribute), true).Length > 0;
bool specialParamArray = false;
if (hasParamArray && infoParams[infoParamsCount - 1].ParameterType.Equals(typeof(string[])))
{
specialParamArray = true;
}
if (hasParamArray && infoParams[infoParamsCount - 1].ParameterType.Equals(typeof(object[])))
{
specialParamArray = true;
}
object[] par = null;
if (infoParamsCount == 1 && specialParamArray)
{
par = new object[] { parameters };
}
else if (infoParamsCount > 1 && hasParamArray && specialParamArray)
{
par = new object[infoParamsCount];
for (int i = 0; i < infoParamsCount - 1; i++)
{
par[i] = parameters[i];
}
par[infoParamsCount - 1] = parameters[infoParamsCount - 1];
}
else
{
par = parameters;
}
object result = null;
try
{
result = info.Invoke(obj, par);
}
catch (Exception e)
{
Exception inner = null;
if (e.InnerException == null)
{
inner = e;
}
else
{
inner = e.InnerException;
}
throw new CallMethodException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodCallFailed, inner);
}
return(result);
#else
var mh = GetCachedMethod(obj, info, parameters);
if (mh == null || mh.DynamicMethod == null)
{
throw new NotImplementedException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodNotImplemented);
}
return(CallMethod(obj, mh, hasParameters, parameters));
#endif
}
protected static string GetMethodName(string dotName, bool checkgettersetter, System.Reflection.MethodInfo method, Type methodAtType, Dictionary <string, object> staticusenames, Dictionary <string, object> usenames)
{
if (method.IsSpecialName && method.Name.StartsWith("add_") && method.GetParameters().Length == 1 && IsDelegate(method.GetParameters()[0].ParameterType))
{
string eventname = method.Name.Substring(4);
return(eventname + "_addEventListener");
}
else if (method.IsSpecialName && method.Name.StartsWith("remove_") && method.GetParameters().Length == 1 && IsDelegate(method.GetParameters()[0].ParameterType))
{
string eventname = method.Name.Substring(7);
return(eventname + "_removeEventListener");
}
string fname = dotName;
var members = methodAtType.GetMember(fname);
//***加上受保护的方法***
var pmem = methodAtType.GetMember(fname, BindingFlags.Instance | BindingFlags.NonPublic);
List <MemberInfo> _tempmembers = new List <MemberInfo>();
//_tempmembers.AddRange(members);
foreach (var item in members)
{
if (IsSkipMember(item))
{
continue;
}
if (item is FieldInfo)
{
if (IsSkipType(((FieldInfo)item).FieldType))
{
continue;
}
_tempmembers.Add(item);
}
else if (item is MethodInfo)
{
if (InterfaceCreator.isMethodSkip((MethodInfo)item))
{
continue;
}
_tempmembers.Add(item);
}
else
{
_tempmembers.Add(item);
}
}
foreach (var item in pmem)
{
if (item is FieldInfo)
{
if (((FieldInfo)item).IsFamily)
{
if (IsSkipMember(item))
{
continue;
}
if (IsSkipType(((FieldInfo)item).FieldType))
{
continue;
}
_tempmembers.Add(item);
}
}
else if (item is MethodInfo)
{
if (((MethodInfo)item).IsFamily)
{
if (IsSkipMember(item))
{
continue;
}
if (InterfaceCreator.isMethodSkip((MethodInfo)item))
{
continue;
}
_tempmembers.Add(item);
}
}
}
//if (checkgettersetter && method.Name.Length>5 && Char.IsUpper( method.Name[4]))
//{
// fname = method.Name;
// fname = fname.Substring(0, 4) + Char.ToLower(fname[4]) + fname.Substring(5);
// var mb2 = methodAtType.GetMember(fname);
// List<MemberInfo> temp = new List<MemberInfo>();
// foreach (var item in mb2)
// {
// if (IsSkipMember(item))
// continue;
// if (item is FieldInfo)
// {
// if (IsSkipType(((FieldInfo)item).FieldType))
// continue;
// temp.Add(item);
// }
// else if (item is MethodInfo)
// {
// if (InterfaceCreator.isMethodSkip((MethodInfo)item))
// continue;
// temp.Add(item);
// }
// else
// {
// temp.Add(item);
// }
// }
// if (temp.Count > 0)
// {
// dotName = dotName + "".PadLeft(temp.Count, '_');
// }
//}
members = _tempmembers.ToArray();
//var props = methodAtType.GetProperties();
//bool isprop = false;
//foreach (var item in props)
//{
// if (Equals(method, item.GetGetMethod()))
// {
// isprop = true;
// }
// if (Equals(method, item.GetSetMethod()))
// {
// isprop = true;
// }
//}
//if (!isprop)
{
if (Char.IsUpper(dotName[0]))
{
List <System.Reflection.MemberInfo> temp = new List <System.Reflection.MemberInfo>();
var ms = methodAtType.GetMember(Char.ToLower(dotName[0]) + dotName.Substring(1));
foreach (var item in ms)
{
if (IsSkipMember(item))
{
continue;
}
if (item.MemberType != MemberTypes.NestedType)
{
temp.Add(item);
}
}
if (temp.Count > 0)
{
dotName = dotName + "".PadLeft(temp.Count, '_');
}
}
//查看基类中有无首字符大小写冲突
if (methodAtType.BaseType != null)
{
if (Char.IsLower(dotName[0]))
{
List <System.Reflection.MemberInfo> temp = new List <System.Reflection.MemberInfo>();
var ms = methodAtType.BaseType.GetMember(Char.ToUpper(dotName[0]) + dotName.Substring(1));
foreach (var item in ms)
{
if (IsSkipMember(item))
{
continue;
}
if (item.MemberType != MemberTypes.NestedType)
{
temp.Add(item);
}
}
if (temp.Count > 0)
{
dotName = dotName + "".PadLeft(temp.Count, '_');
}
}
}
}
if (methodAtType.IsInterface)
{
var extinterface = methodAtType.GetInterfaces();
List <System.Reflection.MemberInfo> inheritmember = new List <System.Reflection.MemberInfo>();
foreach (var item in extinterface)
{
inheritmember.AddRange(item.GetMember(dotName));
}
if (inheritmember.Count > 0)
{
inheritmember.AddRange(members);
members = inheritmember.ToArray();
}
}
else
{
var basetype = methodAtType.BaseType;
List <System.Reflection.MemberInfo> inheritmember = new List <System.Reflection.MemberInfo>();
if (basetype != null)
{
var inherit = basetype.GetMember(dotName);
inheritmember.AddRange(inherit);
//***继承的受保护的对象***
var pinherit = basetype.GetMember(dotName, BindingFlags.Instance | BindingFlags.NonPublic);
foreach (var item in pinherit)
{
if (item is FieldInfo)
{
if (((FieldInfo)item).IsFamily)
{
if (IsSkipMember(item))
{
continue;
}
if (IsSkipType(((FieldInfo)item).FieldType))
{
continue;
}
inheritmember.Add(item);
}
}
else if (item is MethodInfo)
{
if (((MethodInfo)item).IsFamily)
{
if (IsSkipMember(item))
{
continue;
}
if (InterfaceCreator.isMethodSkip((MethodInfo)item))
{
continue;
}
inheritmember.Add(item);
}
}
}
//***********************
basetype = basetype.BaseType;
}
if (inheritmember.Count > 0)
{
inheritmember.AddRange(members);
members = inheritmember.ToArray();
}
}
string ext = string.Empty;
for (int i = 0; i < members.Length; i++)
{
var m = members[i];
if (IsSkipMember(m))
{
continue;
}
if (m is MethodBase)
{
if (((MethodBase)m).IsStatic != method.IsStatic)
{
continue;
}
}
else if (m is PropertyInfo)
{
PropertyInfo p = (PropertyInfo)m;
if (Equals(p.GetGetMethod(), method))
{
break;
}
if (Equals(p.GetSetMethod(), method))
{
break;
}
}
if (members[i].Equals(method))
{
break;
}
else
{
ext = ext + "_";
}
}
string v = dotName.Substring(0, 1).ToLower() + dotName.Substring(1) + ext;
if (dotName.Length > 1)
{
if (Char.IsUpper(dotName.Substring(1, 1)[0]))
{
v = dotName + ext;
}
}
while (as3keywords.ContainsKey(v))
{
v = v + "_";
}
if (method.IsStatic)
{
if (staticusenames != null)
{
while (staticusenames.ContainsKey(v))
{
v = v + "_";
}
}
}
else
{
if (usenames != null)
{
while (usenames.ContainsKey(v))
{
v = v + "_";
}
}
}
return(v);
}
/// <summary>
/// Invoke a method async if possible, providing
/// paramters from the params array and from DI
/// </summary>
/// <param name="obj">Target object</param>
/// <param name="info">Method to invoke</param>
/// <param name="parameters">Criteria params array</param>
/// <returns></returns>
public static async Task <object> CallMethodTryAsync(object obj, System.Reflection.MethodInfo info, object[] parameters)
{
if (info == null)
{
throw new NotImplementedException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodNotImplemented);
}
var methodParameters = info.GetParameters();
object[] plist;
if (methodParameters.Length == 1 && methodParameters[0].ParameterType.Equals(typeof(object[])))
{
plist = new object[] { parameters };
}
else
{
plist = new object[methodParameters.Length];
int index = 0;
int criteriaIndex = 0;
#if !NET40 && !NET45
var service = ApplicationContext.ScopedServiceProvider;
#endif
foreach (var item in methodParameters)
{
if (item.GetCustomAttributes <InjectAttribute>().Any())
{
#if !NET40 && !NET45
if (service != null)
{
plist[index] = service.GetService(item.ParameterType);
}
#endif
}
else
{
if (parameters == null || parameters.Length - 1 < criteriaIndex)
{
plist[index] = null;
}
else
{
plist[index] = parameters[criteriaIndex];
}
criteriaIndex++;
}
index++;
}
}
var isAsyncTask = (info.ReturnType == typeof(Task));
var isAsyncTaskObject = (info.ReturnType.IsGenericType && (info.ReturnType.GetGenericTypeDefinition() == typeof(Task <>)));
try
{
if (isAsyncTask)
{
await((Task)info.Invoke(obj, plist)).ConfigureAwait(false);
return(null);
}
else if (isAsyncTaskObject)
{
return(await((Task <object>)info.Invoke(obj, plist)).ConfigureAwait(false));
}
else
{
var result = info.Invoke(obj, plist);
return(result);
}
}
catch (Exception ex)
{
Exception inner = null;
if (ex.InnerException == null)
{
inner = ex;
}
else
{
inner = ex.InnerException;
}
throw new CallMethodException(obj.GetType().Name + "." + info.Name + " " + Resources.MethodCallFailed, inner);
}
}
public static bool FillProperty(object obj, XmlElement node)
{
if (node == null)
{
return(false);
}
Type type = obj.GetType();
System.Reflection.PropertyInfo[] properties = type.GetProperties();
foreach (System.Reflection.PropertyInfo prop in properties)
{
if (prop.CanWrite == false)
{
continue;
}
System.Object[] attrs = prop.GetCustomAttributes(typeof(ServerFrame.Config.DataValueAttribute), true);
if (attrs == null || attrs.Length <= 0)
{
continue;
}
ServerFrame.Config.DataValueAttribute dv = (ServerFrame.Config.DataValueAttribute)attrs[0];
if (dv == null)
{
continue;
}
XmlElement cNode = (XmlElement)node.GetElementsByTagName(dv.Name)[0];
if (cNode == null)
{
continue;
}
XmlAttribute att = cNode.GetAttributeNode("Type");
XmlAttribute attV = cNode.GetAttributeNode("Value");
if (att == null)
{
continue;
}
Type ValueType = Type.GetType(att.Value);
if (ValueType == typeof(Guid))
{
prop.SetValue(obj, new Guid(attV.Value), null);
}
//else if (ValueType == typeof(Vector3))
//{
// string[] strs = attV.Value.Split(',');
// if (strs.Length != 3)
// continue;
// Vector3 vec3 = new Vector3();
// vec3.X = Convert.ToSingle(strs[0]);
// vec3.Y = Convert.ToSingle(strs[1]);
// vec3.Z = Convert.ToSingle(strs[2]);
//}
//else if (ValueType == typeof(Vector2))
//{
// System.String clrStr = attV.Value;
// System.String[] strs = clrStr.Split(',');
// if (strs.Length != 2)
// continue;
// Vector2 point;
// point.X = System.Convert.ToSingle(strs[0]);
// point.Y = System.Convert.ToSingle(strs[1]);
// prop.SetValue(obj, point, null);
//}
else if (ValueType == typeof(Enum))
{
prop.SetValue(obj, Convert.ChangeType(attV.Value, typeof(System.Int32)), null);
}
else if (att.Value.Contains("@"))
{
Assembly assembly = null;
string strClassName = "";
System.String[] substrs = att.Value.Split('@');
if (substrs.Length < 2)
{
continue;
}
string dll = substrs[0];
strClassName = substrs[1];
System.String fullDllName = System.AppDomain.CurrentDomain.BaseDirectory + dll;
fullDllName = fullDllName.Replace('/', '\\');
assembly = System.Reflection.Assembly.LoadFile(fullDllName);
if (assembly == null)
{
continue;
}
System.Object subObj = assembly.CreateInstance(strClassName);
if (subObj == null)
{
continue;
}
if (subObj.GetType() != prop.PropertyType)
{
continue;
}
if (false == FillProperty(subObj, cNode))
{
continue;
}
prop.SetValue(obj, subObj, null);
}
else if (att.Value == "List")
{
var dType = cNode.GetAttributeNode("DataType");
if (dType == null)
{
continue;
}
Assembly assembly = null;
string strClassName = "";
if (dType.Value.Contains("@"))
{
System.String[] substrs = dType.Value.Split('@');
if (substrs.Length < 2)
{
continue;
}
string dll = substrs[0];
strClassName = substrs[1];
System.String fullDllName = System.AppDomain.CurrentDomain.BaseDirectory + dll;
fullDllName = fullDllName.Replace('/', '\\');
assembly = System.Reflection.Assembly.LoadFile(fullDllName);
if (assembly == null)
{
continue;
}
}
else
{
strClassName = dType.Value;
}
System.Reflection.MethodInfo mi = prop.PropertyType.GetMethod("Add");
var p = mi.GetParameters();
System.Object list = System.Activator.CreateInstance(prop.PropertyType);
object[] args = new object[1];
XmlElement nodes = (XmlElement)cNode.FirstChild;
for (; nodes != null; nodes = (XmlElement)nodes.NextSibling)
{
System.Object subObj = assembly != null?assembly.CreateInstance(strClassName) : Activator.CreateInstance(Type.GetType(strClassName));
if (subObj == null)
{
continue;
}
var vType = subObj.GetType();
var nodeValue = nodes.GetAttribute("Value");
if (vType == typeof(Guid))
{
subObj = new Guid(nodeValue);
}
else if (vType.IsEnum)
{
subObj = Convert.ToInt32(nodeValue);
}
else if (vType.IsValueType)
{
if (nodeValue != null)
{
subObj = Convert.ChangeType(nodeValue, vType);
}
}
else if (false == FillProperty(subObj, nodes))
{
continue;
}
args[0] = subObj;
mi.Invoke(list, args);
}
prop.SetValue(obj, list, null);
}
else
{
prop.SetValue(obj, Convert.ChangeType(attV.Value, ValueType), null);
}
}
return(true);
}
public CQ_Value MemberCall(CQ_Content content, object object_this, string function, CQ_Value[] _params, MethodCache cache)
{
//TODO 这里应该优先匹配类型完全相同（含默认参），没有的话再匹配隐式
bool needConvert = false;
List <Type> types = new List <Type>();
List <object> _oparams = new List <object>();
bool pIsEmpty = false;
foreach (CQ_Value p in _params)
{
_oparams.Add(p.GetObject());
if (p.m_stype != null)
{
types.Add(typeof(object));
}
else
{
if (p.m_type == null)
{
pIsEmpty = true;
}
types.Add(p.m_type);
}
}
System.Reflection.MethodInfo methodInfo = null;
if (!pIsEmpty)
{
methodInfo = type.GetMethod(function, types.ToArray());
}
CQ_Value v = new CQ_Value();
if (methodInfo == null)
{
if (function[function.Length - 1] == '>')//这是一个临时的模板函数调用
{
int sppos = function.IndexOf('<', 0);
string tfunc = function.Substring(0, sppos);
string strparam = function.Substring(sppos + 1, function.Length - sppos - 2);
string[] sf = strparam.Split(',');
//string tfunc = sf[0];
Type[] gtypes = new Type[sf.Length];
for (int i = 0; i < sf.Length; i++)
{
gtypes[i] = CQuark.AppDomain.GetTypeByKeyword(sf[i]).typeBridge;
}
methodInfo = FindMethod(type, tfunc, _params, gtypes);
var ps = methodInfo.GetParameters();
for (int i = 0; i < Math.Min(ps.Length, _oparams.Count); i++)
{
if (ps[i].ParameterType != _params[i].m_type)
{
_oparams[i] = _params[i].ConvertTo(ps[i].ParameterType);
}
}
}
else
{
if (!pIsEmpty)
{
foreach (var s in type.GetInterfaces())
{
methodInfo = s.GetMethod(function, types.ToArray());
if (methodInfo != null)
{
break;
}
}
}
if (methodInfo == null) //因为有cache的存在，可以更慢更多的查找啦，哈哈哈哈
{
methodInfo = GetMethodSlow(content, false, function, types, _oparams);
needConvert = true;
}
if (methodInfo == null)
{
throw new Exception("函数不存在function:" + type.ToString() + "." + function);
}
}
}
if (cache != null)
{
cache.info = methodInfo;
cache.needConvert = needConvert;
}
if (methodInfo == null)
{
throw new Exception("函数不存在function:" + type.ToString() + "." + function);
}
v.SetObject(methodInfo.ReturnType, methodInfo.Invoke(object_this, _oparams.ToArray()));
return(v);
}
public void PrintMethod(SysRef.MethodInfo method)
{
if (method.IsStatic)
{
_builder.Append("static ");
}
var callConv = method.CallingConvention;
if ((callConv & SysRef.CallingConventions.VarArgs) == SysRef.CallingConventions.VarArgs)
{
_builder.Append("vararg ");
}
// Owner
if ((_flags & SignaturePrintingFlags.IgnoreMemberOwner) != SignaturePrintingFlags.IgnoreMemberOwner)
{
PrintType(method.DeclaringType);
_builder.Append("::");
}
// Name
PrintIdentifier(method.Name);
// Generic arguments
{
var genericArguments = method.GetGenericArguments();
if (genericArguments.Length > 0)
{
_builder.Append("<");
for (int i = 0; i < genericArguments.Length; i++)
{
if (i > 0)
{
_builder.Append(", ");
}
PrintType(genericArguments[i], false);
}
_builder.Append(">");
}
}
// Parameters
{
var parameters = method.GetParameters();
_builder.Append("(");
for (int i = 0; i < parameters.Length; i++)
{
if (i > 0)
{
_builder.Append(", ");
}
PrintType(parameters[i].ParameterType, false);
}
_builder.Append(")");
}
// Return type
_builder.Append(" : ");
PrintType(method.ReturnType, false);
}
public void RunTest(Generator test, bool exe, string testName = null)
{
if (test == null)
{
throw new ArgumentNullException(nameof(test));
}
testName = testName ?? GetTestName(test);
Console.WriteLine(">>> GEN {0}", testName);
string name = testName;
string exeDir = string.Empty;
string exeFilePath = string.Empty;
if (exe)
{
exeDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
exeFilePath = Path.Combine(exeDir, name + ".exe");
Directory.CreateDirectory(exeDir);
}
AssemblyGen asm;
asm = !exe
? new AssemblyGen(name, new CompilerOptions())
: new AssemblyGen(name, new CompilerOptions()
{
OutputPath = exeFilePath
});
test(asm);
if (exe)
{
asm.Save();
PEVerify.AssertValid(exeFilePath);
}
Console.WriteLine("=== RUN {0}", testName);
string[] testArguments = GetTestArguments(test);
#if !FEAT_IKVM
if (!exe)
{
#if SILVERLIGHT
Type entryType = asm.GetAssembly().DefinedTypes.First(t => t.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) != null);
#else
Type entryType = ((TypeBuilder)asm.GetAssembly().EntryPoint.DeclaringType).CreateType();
#endif
MethodInfo entryMethod = entryType.GetMethod(asm.GetAssembly().EntryPoint?.Name ?? "Main", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
object[] entryArgs = null;
if (entryMethod.GetParameters().Length == 1)
{
entryArgs = new object[] { testArguments };
}
entryMethod.Invoke(null, entryArgs);
}
else
#endif
{
try
{
AppDomain.CurrentDomain.ExecuteAssembly(exeFilePath, null, testArguments);
}
catch (System.BadImageFormatException)
{
throw;
}
catch (AppDomainUnloadedException)
{
throw;
}
catch (Exception e)
{
#if SILVERLIGHT
throw;
#else
throw new TargetInvocationException(e);
#endif
}
}
Console.WriteLine("<<< END {0}", testName);
Console.WriteLine();
if (exe)
{
try
{
File.Delete(exeFilePath);
}
catch { }
}
}
