C# ICall.GetMethodInfo方法代码示例

        private string FormatCall(ICall call, bool isAcrossMultipleTargets, TypeInstanceNumberLookup instanceLookup)
        {
            var s = _callFormatter.Format(call.GetMethodInfo(), FormatArgs(call.GetArguments()));
            if (!isAcrossMultipleTargets) return s;

            var target = call.Target();
            var methodInfo = call.GetMethodInfo();
            return FormatCallForInstance(instanceLookup, target, methodInfo, s);
        }

 public bool IsSatisfiedBy(ICall call)
 {
     if (_methodInfo != call.GetMethodInfo()) return false;
     if (HasDifferentNumberOfArguments(call)) return false;
     if (NonMatchingArguments(call).Any()) return false;
     return true;
 }

        public RouteAction Handle(ICall call)
        {
            // We want the proxies to respond to the base object methods (e.g. Equals, GetHashCode)
            if (call.GetMethodInfo().GetBaseDefinition().DeclaringType == typeof(object))
                return RouteAction.Return(call.CallOriginalMethod());

            return RouteAction.Continue();
        }

 public ICallSpecification CreateFrom(ICall call, MatchArgs matchArgs)
 {
     var methodInfo = call.GetMethodInfo();
     var argumentSpecs = call.GetArgumentSpecifications();
     var arguments = call.GetOriginalArguments();
     var parameterInfos = call.GetParameterInfos();
     var argumentSpecificationsForCall = _argumentSpecificationsFactory.Create(argumentSpecs, arguments, parameterInfos, matchArgs);
     return new CallSpecification(methodInfo, argumentSpecificationsForCall);
 }

 public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
 {
     var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
     if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
     {
         throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
     }
     var getter = propertyInfo.GetGetMethod();
     return new CallToPropertyGetter(getter, callToSetter.Target());
 }

 public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
 {
     var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
     if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
     {
         throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
     }
     var setterArgs = callToSetter.GetArguments();
     var getter = propertyInfo.GetGetMethod();
     var getterArgs = setterArgs.Take(setterArgs.Length - 1).ToArray();
     return new Call(getter, getterArgs, callToSetter.Target(), callToSetter.GetArgumentSpecifications());
 }

 public bool IsSatisfiedBy(ICall call)
 {
     if (MethodInfo != call.GetMethodInfo()) return false;
     var arguments = call.GetArguments();
     if (arguments.Length != ArgumentSpecifications.Count) return false;
     for (int i = 0; i < arguments.Length; i++)
     {
         var argumentMatchesSpecification = ArgumentSpecifications[i].IsSatisfiedBy(arguments[i]);
         if (!argumentMatchesSpecification) return false;
     }
     return true;
 }

 public object Handle(ICall call)
 {
     var methodInfo = call.GetMethodInfo();
     var eventInfo = methodInfo.DeclaringType.GetEvents().First(
         x => (x.GetAddMethod() == methodInfo) || (x.GetRemoveMethod() == methodInfo));
     var handlers = _eventHandlerRegistry.GetHandlers(eventInfo.Name);
     var eventArguments = _getEventArguments(call);
     foreach (Delegate handler in handlers)
     {
         handler.DynamicInvoke(eventArguments);
     }
     return null;
 }

 public ICallSpecification CreateFrom(ICall call)
 {
     var result = new CallSpecification(call.GetMethodInfo());
     var argumentSpecs = _context.DequeueAllArgumentSpecifications();
     var arguments = call.GetArguments();
     if (argumentSpecs.Count == 0)
     {
         AddArgumentSpecsToCallSpec(result, arguments.Select(x => (IArgumentSpecification) new ArgumentEqualsSpecification(x)));
     }
     else if (argumentSpecs.Count == arguments.Length)
     {
         AddArgumentSpecsToCallSpec(result, argumentSpecs);
     }
     else
     {
         throw new AmbiguousArgumentsException(
             "Cannot determine argument specifications to use. Please use specifications for all arguments.");
     }
     return result;
 }

        public RouteAction Handle(ICall call)
        {
            var methodInfo = call.GetMethodInfo();
            var eventInfo = methodInfo.DeclaringType.GetEvents().First(
                x => (x.GetAddMethod() == methodInfo) || (x.GetRemoveMethod() == methodInfo));
            var handlers = _eventHandlerRegistry.GetHandlers(eventInfo.Name);
            var eventArguments = _getEventArguments(call);
            foreach (Delegate handler in handlers)
            {
                try
                {
                    handler.DynamicInvoke(eventArguments);
                }
                catch (TargetInvocationException e)
                {
                    PreserveStackTrace(e.InnerException);

                    throw e.InnerException;
                }
            }
            return RouteAction.Continue();
        }

 private IEnumerable<EventInfo> GetEvents(ICall call, Func<ICall, Predicate<EventInfo>> createPredicate)
 {
     var predicate = createPredicate(call);
     return call.GetMethodInfo().DeclaringType.GetEvents().Where(x => predicate(x));
 }

 public string Format(ICall call)
 {
     return CallFormatter.Format(call.GetMethodInfo(), FormatArguments(call.GetArguments()));
 }

 private Predicate<EventInfo> IsEventUnsubscription(ICall call)
 {
     return x => call.GetMethodInfo() == x.GetRemoveMethod();
 }

 private Predicate<EventInfo> IsEventSubscription(ICall call)
 {
     return x => call.GetMethodInfo() == x.GetAddMethod();
 }

 private PropertyInfo GetPropertyFromSetterCallOrNull(ICall call)
 {
     return call.GetMethodInfo().GetPropertyFromSetterCallOrNull();
 }