C# ICall.GetArguments方法代码示例

 public IEnumerable<ArgumentMatchInfo> NonMatchingArguments(ICall call)
 {
     var arguments = call.GetArguments();
     return arguments
             .Select((arg, index) => new ArgumentMatchInfo(index, arg, _argumentSpecifications[index]))
             .Where(x => !x.IsMatch);
 }

 private void If(ICall call, Func<ICall, Predicate<EventInfo>> meetsThisSpecification, Action<string, object> takeThisAction)
 {
     var events = GetEvents(call, meetsThisSpecification);
     if (events.Any())
     {
         takeThisAction(events.First().Name, call.GetArguments()[0]);
     }            
 }

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

        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 IEnumerable<int> NonMatchingArgumentIndicies(ICall call)
 {
     var arguments = call.GetArguments();
     for (var i = 0; i < arguments.Length; i++)
     {
         var argumentMatchesSpecification = ArgIsSpecifiedAndMatchesSpec(arguments[i], i);
         if (!argumentMatchesSpecification) yield return i;
     }
 }

 public RouteAction Handle(ICall call)
 {
     if (_propertyHelper.IsCallToSetAReadWriteProperty(call))
     {
         var callToPropertyGetter = _propertyHelper.CreateCallToPropertyGetterFromSetterCall(call);
         var valueBeingSetOnProperty = call.GetArguments().First();
         _resultSetter.SetResultForCall(callToPropertyGetter, new ReturnValue(valueBeingSetOnProperty), MatchArgs.AsSpecifiedInCall);
     }
     return RouteAction.Continue();
 }

 public object Handle(ICall call)
 {
     if (_propertyHelper.IsCallToSetAReadWriteProperty(call))
     {
         var callToPropertyGetter = _propertyHelper.CreateCallToPropertyGetterFromSetterCall(call);
         var valueBeingSetOnProperty = call.GetArguments().First();
         _resultSetter.SetResultForCall(callToPropertyGetter, valueBeingSetOnProperty);
     }
     return null;
 }

        private static IEnumerable<Argument> GetArgumentsFromCall(ICall call)
        {
            var values = call.GetArguments();
            var types = call.GetParameterInfos().Select(x => x.ParameterType).ToArray();

            for (var index = 0; index < values.Length; index++)
            {
                var i = index;
                yield return new Argument(types[i], () => values[i], x => values[i] = x);
            }
        }

 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 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 object Handle(ICall call)
 {
     _actionToPerform(call.GetArguments());
     return null;
 }

 private bool HasDifferentNumberOfArguments(ICall call)
 {
     return _argumentSpecifications.Length != call.GetArguments().Length;
 }

 public string Format(ICall call, ICallSpecification withRespectToCallSpec)
 {
     return Format(call.GetMethodInfo(), call.GetArguments(), withRespectToCallSpec.NonMatchingArgumentIndicies(call));
 }

 private string Format(ICall call)
 {
     return _callFormatter.Format(call.GetMethodInfo(), FormatArgs(call.GetArguments()));
 }