C# MethodBase.Invoke方法代码示例

        private static TestResult RunTest(object instance, MethodBase method)
        {
            var result = new TestResult { Name = method.Name };

            var sw = new Stopwatch();
            sw.Start();
            try
            {
                method.Invoke(instance, null);
                result.WasSuccessful = true;
            }
            catch (Exception ex)
            {
                result.WasSuccessful = false;
                result.Message = ex.ToString();
            }
            finally
            {
                sw.Stop();

                result.Duration = sw.ElapsedMilliseconds;
            }

            return result;
        }

        private ServiceEntry Create(string serviceId, MethodBase implementationMethod)
        {
            var type = implementationMethod.DeclaringType;

            return new ServiceEntry
            {
                Descriptor = new ServiceDescriptor
                {
                    Id = serviceId
                },
                Func = parameters =>
                {
                    var instance = _serviceFactory.Create(type);

                    var list = new List<object>();
                    foreach (var parameterInfo in implementationMethod.GetParameters())
                    {
                        var value = parameters[parameterInfo.Name];
                        var parameterType = parameterInfo.ParameterType;

                        var parameter = _typeConvertibleService.Convert(value, parameterType);
                        list.Add(parameter);
                    }

                    var result = implementationMethod.Invoke(instance, list.ToArray());

                    return result;
                }
            };
        }

        private void ExecutePrivate(MethodBase entryPoint, IEnumerable<string> additionalReferences)
        {
            AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => CurrentDomainOnAssemblyResolve(args.Name, additionalReferences);

            Environment.SetEnvironmentVariable("CSharpRunner_ArtifactsPath", artifactsPath);

            entryPoint.Invoke(entryPoint.DeclaringType, null);
        }

        public Task<object> callAsync(MethodBase method, object[] args)
        {
            Func<object> work = () =>
            {
                return method.Invoke(target, UnwrapArgs(method, args));
            };

            if (queue != null)
                return Task.Factory.StartNew<object>(work, new System.Threading.CancellationToken(false), TaskCreationOptions.None, queue);
            else
                return Task.FromResult<object>(work.Invoke());
        }

        public object call(MethodBase method, object[] args)
        {
            Func<object> work = () =>
            {
                return method.Invoke(target, UnwrapArgs(method, args));
            };

            if (queue != null)
            {
                var t = Task.Factory.StartNew<object>(work, new System.Threading.CancellationToken(false), TaskCreationOptions.None, queue);
                t.Wait();
                return t.Result;
            }
            else
                return work.Invoke();
        }

 private static object FastCall(object o, MethodBase method, ParameterInfo[] Parameters, object[] args, Type objType, IReflect objIReflect)
 {
     int upperBound = args.GetUpperBound(0);
     for (int i = 0; i <= upperBound; i++)
     {
         ParameterInfo info = Parameters[i];
         object defaultValue = args[i];
         if ((defaultValue is Missing) && info.IsOptional)
         {
             defaultValue = info.DefaultValue;
         }
         args[i] = ObjectType.CTypeHelper(defaultValue, info.ParameterType);
     }
     VBBinder.SecurityCheckForLateboundCalls(method, objType, objIReflect);
     if (((objType != objIReflect) && !method.IsStatic) && !DoesTargetObjectMatch(o, method))
     {
         return InvokeMemberOnIReflect(objIReflect, method, BindingFlags.InvokeMethod, o, args);
     }
     VerifyObjRefPresentForInstanceCall(o, method);
     return method.Invoke(o, args);
 }

        private object HandleVirtualMethods(MethodBase method, object[] args) {
            var methodName = method.Name;

            // Handle properties if they are CMS properties
            if (methodName.StartsWith("get_")) {
                bool propertyExists;
                var currentPage = (CmsPage)_target;
                var propertyName = methodName.Substring(4);
                var propertyData = currentPage.Property.GetPropertyValue(propertyName, out propertyExists);

                if (propertyExists) {
                    return GetPropertyValue(method, propertyData);
                }
            }

            // Handle everything else that isn't a CMS property
            try {
                return method.Invoke(_target, args);
            }
            catch (Exception exception) {
                throw GetExceptionToRethrow(exception);
            }
        }

        public void RunTest(MethodBase method)
        {
            try
            {
                LogTestCaseStart(method.Name);
                teststarted = true;
                method.Invoke(this, null);
                LogTestCasePassed(method.Name);

            }

            catch (TargetInvocationException aex)
            {
                Logger.RecordMessage(aex.InnerException.Message, MessageType.Exception, MessageSeverity.Error);
                LogTestCaseFailed(method.Name);

                throw aex.InnerException;
            }
            finally
            {
                teststarted = false;
            }
        }

		protected static object InvokeAndUnwrapException(MethodBase mb, object obj, object[] args)
		{
#if FIRST_PASS
			return null;
#else
			try
			{
				return mb.Invoke(obj, args);
			}
			catch (TargetInvocationException x)
			{
				throw ikvm.runtime.Util.mapException(x.InnerException);
			}
#endif
		}

        public static object InvokeMethodWithoutTargetInvocationException(MethodBase method, object obj, object[] args)
        {
            if (method == null)
                throw new ArgumentNullException("method");

            try
            {
                return method.Invoke(obj, args);
            }
            catch (TargetInvocationException ex)
            {
                RethrowWithNoStackTraceLoss(ex.InnerException);
                throw;
            }
        }

        ///<summary>
        /// Validate the aspect usage
        ///</summary>
        ///<param name="method">The method that the aspect is applied on</param>
        ///<returns>Returns true if all checks pass</returns>
        public override bool CompileTimeValidate(MethodBase method)
        {
            if (method == null)
            {
                this.RaiseError(1, "The PostCompile aspect can only be applied on methods.", method.AsSignature());

                return false;
            }

            if (!method.IsStatic)
            {
                this.RaiseError(2, "The PostCompile aspect can only be applied on static methods.", method.AsSignature());

                return false;
            }

            if (method.GetParameters().Length > 0)
            {
                this.RaiseError(3, "The PostCompile aspect can only be applied on methods without arguments.", method.AsSignature());

                return false;
            }

            if (method as MethodInfo == null)
            {
                this.RaiseError(4, "The PostCompile aspect can not be applied on constructor/deconstructors", method.AsSignature());

                return false;
            }

            if (((MethodInfo)method).ReturnType != typeof(void))
            {
                this.RaiseError(5, "The PostCompile aspect can only be applied on methods returning nothing.", method.AsSignature());

                return false;
            }

            this.Describe("On compilation, this method will be invoked", method);

            try
            {
                method.Invoke(null, null);
                this.Describe("Last post-compile run succeeded at {0}".F(DateTime.Now), method);
            }
            catch (TargetInvocationException ex) // when this exception is thrown, consider it a success, and optionally check if it has more descriptions to add
            {
                if (ex.InnerException is PostCompileSuccessException)
                {
                    this.Describe("Last post-compile run succeeded at {0}".F(DateTime.Now), method);

                    foreach (var d in (ex.InnerException as PostCompileSuccessException).Descriptions)
                    {
                        this.Describe(d, method);
                    }
                }
                else
                {
                    this.Describe("Last post-compile run failed at {0}".F(DateTime.Now), method);
                    this.Describe(ex.ToString(), method);
                }
            }
            catch (Exception ex)
            {
                this.Describe("Last post-compile run failed at {0}".F(DateTime.Now), method);
                this.Describe(ex.ToString(), method);
            }

            return true;
        }

        /// <summary>
        /// Intercepts the <see cref="MethodBase"/> in the proxy to return a replaced value.
        /// </summary>
        /// <param name="methodBase">
        /// The <see cref="MethodBase"/> containing information about the current
        /// invoked property.
        /// </param>
        /// <param name="value">
        /// The object to set the <see cref="MethodBase"/> to if it is a setter.
        /// </param>
        /// <returns>
        /// The <see cref="object"/> replacing the original implementation value.
        /// </returns>
        public object Intercept(MethodBase methodBase, object value)
        {
            const string Getter = "get_";
            const string Setter = "set_";
            var name = methodBase.Name;
            var key = name.Substring(4);
            var parameters = value == null ? new object[] { } : new[] { value };

            // Attempt to get the value from the lazy members.
            if (name.StartsWith(Getter))
            {
                if (this.lazyDictionary.ContainsKey(key))
                {
                    return this.lazyDictionary[key].Value;
                }
            }

            // Set the value, remove the old lazy value.
            if (name.StartsWith(Setter))
            {
                if (this.lazyDictionary.ContainsKey(key))
                {
                    this.lazyDictionary.Remove(key);
                }
            }

            return methodBase.Invoke(this.target, parameters);
        }

        private object NonOwnerInvocationHandler(object target, MethodBase method, object[] parameters)
        {
            object result = null;

            try
            {
                if(method.Name.Equals("set_HotOrNot"))
                {
                    result = method.Invoke(target, parameters);
                }
                else
                {
                    throw new UnauthorizedAccessException("You are not permitted to update another's personal information!");
                }
            }
            catch(ApplicationException ex)
            {
                return ex.StackTrace;
            }

            return result;
        }

 private void InvokeSetupMethod(MethodBase method)
 {
     if (method == null) return;
     try
     {
         method.Invoke(_testInstance, new Object[0]);
     }
     catch
     {
         Debug.LogError(string.Format("[{2}] {0}.{1}", _testType, method.Name, "FAIL"));
     }
 }

        public override bool Rewrite(CodeDescriptor decompilee, MethodBase callee, StackElement[] args, IDecompiler stack, IFunctionBuilder builder)
        {
            Type returnType;
            if (callee.ReturnsSomething(out returnType))
                throw new ArgumentException("The IgnoreOnDecompilation attribute may only be applied to methods returning a void result. Use StaticEvaluation instead.");

            if (_call)
            {
                callee.Invoke(args.Select(a => a.Sample).ToArray());
            }

            return true;
        }