C# MethodInfo.ToString方法代码示例

		public Maybe<ITransactionOptions> AsTransactional(MethodInfo target)
		{
			Contract.Requires(target != null);
			Contract.Ensures(Contract.Result<Maybe<TransactionAttribute>>() != null);
			return _TxMethodsHackMap.ContainsKey(target.ToString())
					? Maybe.Some<ITransactionOptions>(_TxMethodsHackMap[target.ToString()])
			       	: Maybe.None<ITransactionOptions>();
		}

		private static IntPtr MethodInfoToFtnptr (MethodInfo method) {
			if (module_builder.Assembly.GetType ("BridgeHelpers" + method.ToString ()) != null)
				return (IntPtr) module_builder.Assembly.GetType ("BridgeHelpers" + method.ToString ()).InvokeMember ("InternalMethodInfoToFtnPtr", BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public, null, null, new object[] { });

			TypeBuilder ftn_converter_builder = module_builder.DefineType ("BridgeHelpers" + method.ToString (), TypeAttributes.Public);
			MethodBuilder ftn_method = ftn_converter_builder.DefineMethod ("InternalMethodInfoToFtnPtr", MethodAttributes.Public | MethodAttributes.Static, typeof (IntPtr), new Type[] { }); 
			ILGenerator il_generator = ftn_method.GetILGenerator ();
			
			il_generator.Emit (OpCodes.Ldftn, method);
			il_generator.Emit (OpCodes.Ret);
			
			Type ftn_converter = ftn_converter_builder.CreateType ();
			return (IntPtr) ftn_converter.InvokeMember ("InternalMethodInfoToFtnPtr", BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public, null, null, new object[] { });
		}

 public MethodNode(object parentObj, MethodInfo m)
     : base(null, NodeTypes.Method, m.ToString())
 {
     parentObject = parentObj;
     method = m;
     CanInvoke = true;
 }

 public static void executeXRuleMethod(MethodInfo methodToExecute, Action<bool,object> executionResult)
 {            
     if (methodToExecute == null)
     {                
         executionResult(false,null);
     }
     else
         try
         {
             DI.log.info("executing method: {0}", methodToExecute.Name);
             // create method's type using default constructor
             var liveObject = DI.reflection.createObjectUsingDefaultConstructor(methodToExecute.DeclaringType);
             // and execute the method
             var returnData = methodToExecute.Invoke(liveObject, new object[] { });            // don't use the DI.reflection methods since we want the exceptions to be thrown
             //DI.reflection.invoke(liveObject, methodInfo, new object[] {});
             executionResult(true, returnData);
         }
         catch (Exception ex)
         {
             DI.log.error("in UnitTestSupport.executeXRuleMethod: {0} threw error: {1} ", methodToExecute.ToString(),
                          ex.Message);
             if (ex.InnerException != null)
             {
                 var innerExceptionMessage = ex.InnerException.Message;
                 DI.log.error("   InnerException value: {0}", innerExceptionMessage);
                 executionResult(false, innerExceptionMessage);
             }
             else
                 executionResult(false, null);
         }
 }

 internal static WebMethodAttribute GetAttribute(MethodInfo implementation, MethodInfo declaration)
 {
     WebMethodAttribute attribute = null;
     WebMethodAttribute attribute2 = null;
     object[] customAttributes;
     if (declaration != null)
     {
         customAttributes = declaration.GetCustomAttributes(typeof(WebMethodAttribute), false);
         if (customAttributes.Length > 0)
         {
             attribute = (WebMethodAttribute) customAttributes[0];
         }
     }
     customAttributes = implementation.GetCustomAttributes(typeof(WebMethodAttribute), false);
     if (customAttributes.Length > 0)
     {
         attribute2 = (WebMethodAttribute) customAttributes[0];
     }
     if (attribute == null)
     {
         return attribute2;
     }
     if (attribute2 == null)
     {
         return attribute;
     }
     if (attribute2.MessageNameSpecified)
     {
         throw new InvalidOperationException(Res.GetString("ContractOverride", new object[] { implementation.Name, implementation.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), "WebMethod.MessageName" }));
     }
     return new WebMethodAttribute(attribute2.EnableSessionSpecified ? attribute2.EnableSession : attribute.EnableSession) { TransactionOption = attribute2.TransactionOptionSpecified ? attribute2.TransactionOption : attribute.TransactionOption, CacheDuration = attribute2.CacheDurationSpecified ? attribute2.CacheDuration : attribute.CacheDuration, BufferResponse = attribute2.BufferResponseSpecified ? attribute2.BufferResponse : attribute.BufferResponse, Description = attribute2.DescriptionSpecified ? attribute2.Description : attribute.Description };
 }

        public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method)
        {
            IHqlGeneratorForMethod methodGenerator;

            if (method.IsGenericMethod)
            {
                method = method.GetGenericMethodDefinition();
            }

            if (_registeredMethods.TryGetValue(method, out methodGenerator))
            {
                return methodGenerator;
            }

            // No method generator registered.  Look to see if it's a standard LinqExtensionMethod
            var attr = method.GetCustomAttributes(typeof (LinqExtensionMethodAttribute), false);
            if (attr.Length == 1)
            {
                // It is
                // TODO - cache this?  Is it worth it?
                return new HqlGeneratorForExtensionMethod((LinqExtensionMethodAttribute) attr[0], method);
            }

            // Not that either.  Let's query each type generator to see if it can handle it
            foreach (var typeGenerator in _typeGenerators)
            {
                if (typeGenerator.SupportsMethod(method))
                {
                    return typeGenerator.GetMethodGenerator(method);
                }
            }

            throw new NotSupportedException(method.ToString());
        }

		protected Command(object target, MethodInfo mi)
			: base(target, mi)
		{
			ParameterInfo[] paramList = mi.GetParameters();

			_names = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			List<Argument> tempList = new List<Argument>();

			foreach (ParameterInfo pi in paramList)
			{
				Argument arg = new Argument(target, pi);
				foreach(string name in arg.AllNames)
					_names.Add(name, tempList.Count);
				tempList.Add(arg);
			}
			_arguments = tempList.ToArray();

			if (base.Description == mi.ToString())
            {//if no description provided, let's build a better one
                StringBuilder sb = new StringBuilder();
                sb.AppendFormat("{0} ", base.DisplayName);
                foreach(Argument a in tempList)
					if(a.Visible)
						sb.AppendFormat("{0} ", a.FormatSyntax(a.DisplayName));
                _description = sb.ToString(0, sb.Length - 1);
            }
		}

        public void EmitCall(OpCode opCode, MethodInfo mi)
        {
            ProcessCommand(
                opCode, 
                (mi.GetParameters().Length + 1) * -1 + (mi.ReturnType == typeof(void) ? 0 : 1), 
                mi.ToString()
                );

            ilGenerator.EmitCall(opCode, mi, null);
        }

        public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method)
        {
            IHqlGeneratorForMethod methodGenerator;

            if (!TryGetMethodGenerator(method, out methodGenerator))
            {
                throw new NotSupportedException(method.ToString());
            }

            return methodGenerator;
        }

        private MethodInfo GetParallelMethod(MethodInfo forkMethod)
        {
            MethodInfo result = null;
            MethodInfo[] methods =
                source.GetMethods(BindingFlags.Instance | BindingFlags.Static |
                                  BindingFlags.Public | BindingFlags.NonPublic);
            foreach (MethodInfo method in methods)
                if (IsParallel(method)
                    && SignatureMatch(forkMethod, method))
                {
                    if (result == null)
                        result = method;
                    else
                        throw new InvalidMethodException(source.Name, forkMethod.ToString(),
                                                         "There is more than one parallel method which has a nonchannel parameter signature that matches this [Fork] method.");

                }

            if (result == null)
                throw new InvalidMethodException(source.Name, forkMethod.ToString(),
                                                 "There is no parallel method which has a nonchannel parameter signature that matches this [Fork] method.");

            return result;
        }

 public static MethodDefinition getMethodDefinitionFromMethodInfo(MethodInfo methodInfo, Mono.Cecil.AssemblyDefinition assemblyDefinition)
 {
     foreach (var methodDefinition in CecilUtils.getMethods(assemblyDefinition))
     {
         var functionSignature1 = new FilteredSignature(methodInfo);
         var functionSignature2 = new FilteredSignature(methodDefinition.ToString());
         if (functionSignature1.sSignature == functionSignature2.sSignature)                
             return methodDefinition;
         if (functionSignature1.sFunctionName == functionSignature2.sFunctionName)
         { 
         }
     }
     PublicDI.log.error("in getMethodDefinitionFromMethodInfo, could not map MethodInfo: {0}", methodInfo.ToString());
     return null;
 }

        // Methods
        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            #region Contracts

            if (controllerContext == null) throw new ArgumentNullException();
            if (methodInfo == null) throw new ArgumentNullException();

            #endregion

            // ParameterInfoArray
            var parameterInfoArray = ParameterInfoFactory.Current.GetAll(controllerContext.Controller.GetType(), methodInfo);
            if (parameterInfoArray == null) throw new InvalidOperationException();

            // Current Overload Action Matching
            if (this.IsOverloadMatched(controllerContext, parameterInfoArray) == false)
            {
                return false;
            }

            // Other MethodInfoArray
            var otherMethodInfoArray = MethodInfoFactory.Current.GetAll(controllerContext.Controller.GetType());
            if (otherMethodInfoArray == null) throw new InvalidOperationException();
            
            // Other Overload Action Matching
            foreach (var otherMethodInfo in otherMethodInfoArray)
            {
                // MethodInfo
                if (otherMethodInfo.Name != methodInfo.Name) continue;
                if (otherMethodInfo.ToString() == methodInfo.ToString()) continue;
                if (otherMethodInfo.GetCustomAttribute<OverloadAttribute>() == null) continue;

                // ParameterInfoArray
                var otherParameterInfoArray = ParameterInfoFactory.Current.GetAll(controllerContext.Controller.GetType(), otherMethodInfo);
                if (otherParameterInfoArray == null) throw new InvalidOperationException();
                if (otherParameterInfoArray.Length < parameterInfoArray.Length) continue;

                // IsOverloadMatched
                if (this.IsOverloadMatched(controllerContext, otherParameterInfoArray) == true) return false;
            }

            // Return
            return true;
        }

        public override DynamicMethodProxyHandler GetMethodDelegate(
            Module targetModule, 
            MethodInfo genericMethodInfo, 
            params Type[] genericParameterTypes)
        {
            #region  Construct cache key

            if (targetModule == null)
            {
                throw new ArgumentNullException("targetModule");
            }

            string key = targetModule.FullyQualifiedName + "|" + genericMethodInfo.DeclaringType.ToString() + "|" + genericMethodInfo.ToString();
            if (genericParameterTypes != null)
            {
                for (int i = 0; i < genericParameterTypes.Length; ++i)
                {
                    key += "|" + genericParameterTypes[i].ToString();
                }
            }

            #endregion

            DynamicMethodProxyHandler dmd;

            lock (cache2)
            {
                if (cache2.ContainsKey(key))
                {
                    dmd = cache2[key];
                }
                else
                {
                    dmd = DoGetMethodDelegate(targetModule, genericMethodInfo, genericParameterTypes);
                    cache2.Add(key, dmd);
                }
            }

            return dmd;
        }

        public static MethodInvokerBase GetMethodInvoker(object targetObject, MethodInfo mi)
        {
            var typeName = "EmitMapper.MethodCaller_" + mi.ToString();

            Type callerType = _typesCache.Get<Type>(
                typeName,
                () =>
                {
                    if (mi.ReturnType == typeof(void))
                    {
                        return BuildActionCallerType(typeName, mi);
                    }
                    else
                    {
                        return BuildFuncCallerType(typeName, mi);
                    }
                }
            );

            MethodInvokerBase result = (MethodInvokerBase)Activator.CreateInstance(callerType);
            result.targetObject = targetObject;
            return result;
        }

        public static ProductionRule GenerateRule(MethodInfo method)
        {
            ProductionAttribute production =
                (ProductionAttribute)Attribute.GetCustomAttribute(method, typeof(ProductionAttribute), false);

            if (production == null)
            {
                return null;
            }

            Type[] newLeft, left, strict, right, newRight;
            production.GetTypes(method, out newLeft, out left, out strict, out right, out newRight);

            var ignoreList = IgnoreAttribute.GetIgnoredTypes(method);
            foreach(var p in method.GetParameters())
            {
                if (ignoreList.Contains(p.ParameterType))
                {
                    throw new InvalidOperationException(string.Format(
                        "ProductionRule: Ignored type is production function parameters list (class: {0}, method: {1}).", method.DeclaringType.Name, method.ToString()));
                }
            }

            Array.Reverse(newLeft);
            Array.Reverse(left);

            return new ProductionRule()
            {
                Method = method,
                NewLeft = newLeft,
                Left = left,
                Strict = strict,
                Right = right,
                NewRight = newRight,
                IgnoreList = ignoreList
            };
        }