MethodResolver CreateMethodResolver() { MethodResolver resolver = new MethodResolver { MethodName = this.MethodName, RunAsynchronously = this.RunAsynchronously, TargetType = this.TargetType, TargetObject = this.TargetObject, GenericTypeArguments = this.GenericTypeArguments, Parameters = this.Parameters, Result = this.resultArgument, Parent = this }; if (this.Result != null) { resolver.ResultType = this.Result.ArgumentType; } else { resolver.ResultType = typeof(object); } return(resolver); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>(); Type objectType = TypeHelper.ObjectType; if (this.TargetObject != null) { objectType = this.TargetObject.ArgumentType; } RuntimeArgument argument = new RuntimeArgument("TargetObject", objectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, argument); arguments.Add(argument); Type argumentType = TypeHelper.ObjectType; if (this.Result != null) { argumentType = this.Result.ArgumentType; } this.resultArgument = new RuntimeArgument("Result", argumentType, ArgumentDirection.Out); metadata.Bind(this.Result, this.resultArgument); arguments.Add(this.resultArgument); this.methodResolver = this.CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, out this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
private MethodBase FindMatch(MethodBase[] methodCandidates, BindingFlags bindingAttr, Type[] types, ParameterModifier[] modifiers) { // Try the default binder first. Never gives false positive, but will fail to detect methods w/ parameter array because // it will not expand the formal parameter list when checking against actual parameters. var result = Type.DefaultBinder.SelectMethod(bindingAttr, methodCandidates, types, modifiers); // Could be false negative, check for parameter array and if so condense it back to an array before re-checking. if (result == null) { foreach (var method in methodCandidates) { var methodInfo = method as MethodInfo; var formalParams = methodInfo.GetParameters(); if (MethodResolver.HaveParameterArray(formalParams)) // Check if the last parameter of method is marked w/ "params" attribute { var elementType = formalParams[formalParams.Length - 1].ParameterType.GetElementType(); var allCompatible = true; // There could be more actual parameters than formal parameters, because the formal parameter is a params T'[] for some T'. // So, check that each actual parameter starting at position [formalParams.Length - 1] is compatible with T'. for (var i = formalParams.Length - 1; i < types.Length - 1; i++) { if (!TypeHelper.AreTypesCompatible(types[i], elementType)) { allCompatible = false; break; } } if (!allCompatible) { continue; } // Condense the actual parameter back to an array. var typeArray = new Type[formalParams.Length]; for (var i = 0; i < typeArray.Length - 1; i++) { typeArray[i] = types[i]; } typeArray[typeArray.Length - 1] = elementType.MakeArrayType(); // Recheck the condensed array var newFound = Type.DefaultBinder.SelectMethod(bindingAttr, new MethodBase[] { methodInfo }, typeArray, modifiers); if (result != null && newFound != null) { var type = newFound.ReflectedType.Name; var name = newFound.Name; var bindingType = bindingAttr == staticBindingFlags ? staticString : instanceString; throw FxTrace.Exception.AsError(new AmbiguousMatchException(SR.DuplicateMethodFound(type, bindingType, name, this.parentActivity.DisplayName))); } else { result = newFound; } } } } return(result); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); Type objectType = TypeHelper.ObjectType; if (this.TargetObject != null) { objectType = this.TargetObject.ArgumentType; } RuntimeArgument argument = new RuntimeArgument("TargetObject", objectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, argument); arguments.Add(argument); Type argumentType = TypeHelper.ObjectType; if (this.Result != null) { argumentType = this.Result.ArgumentType; } this.resultArgument = new RuntimeArgument("Result", argumentType, ArgumentDirection.Out); metadata.Bind(this.Result, this.resultArgument); arguments.Add(this.resultArgument); this.methodResolver = this.CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, out this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
public override MethodBase SelectMethod(BindingFlags bindingAttr, MethodBase[] match, Type[] types, ParameterModifier[] modifiers) { MethodBase[] baseArray; Func <MethodBase, bool> predicate = null; this.SelectMethodCalled = true; if (this.genericTypeArguments.Length > 0) { Collection <MethodBase> source = new Collection <MethodBase>(); foreach (MethodBase base2 in match) { MethodInfo item = MethodResolver.Instantiate((MethodInfo)base2, this.genericTypeArguments); if (item != null) { source.Add(item); } } baseArray = source.ToArray <MethodBase>(); } else { baseArray = (from m in match where !m.ContainsGenericParameters select m).ToArray <MethodBase>(); } if (baseArray.Length == 0) { return(null); } Type declaringType = this.declaringType; MethodBase base3 = null; do { if (predicate == null) { predicate = mb => mb.DeclaringType == declaringType; } MethodBase[] methodCandidates = baseArray.Where <MethodBase>(predicate).ToArray <MethodBase>(); if (methodCandidates.Length > 0) { base3 = this.FindMatch(methodCandidates, bindingAttr, types, modifiers); } declaringType = declaringType.BaseType; }while ((declaringType != null) && (base3 == null)); return(base3); }
private MethodBase FindMatch(MethodBase[] methodCandidates, BindingFlags bindingAttr, Type[] types, ParameterModifier[] modifiers) { MethodBase base2 = Type.DefaultBinder.SelectMethod(bindingAttr, methodCandidates, types, modifiers); if (base2 == null) { foreach (MethodBase base3 in methodCandidates) { MethodInfo info = base3 as MethodInfo; ParameterInfo[] parameters = info.GetParameters(); if (MethodResolver.HaveParameterArray(parameters)) { Type elementType = parameters[parameters.Length - 1].ParameterType.GetElementType(); bool flag = true; for (int i = parameters.Length - 1; i < (types.Length - 1); i++) { if (!System.Runtime.TypeHelper.AreTypesCompatible(types[i], elementType)) { flag = false; break; } } if (flag) { Type[] typeArray = new Type[parameters.Length]; for (int j = 0; j < (typeArray.Length - 1); j++) { typeArray[j] = types[j]; } typeArray[typeArray.Length - 1] = elementType.MakeArrayType(); MethodBase base4 = Type.DefaultBinder.SelectMethod(bindingAttr, new MethodBase[] { info }, typeArray, modifiers); if ((base2 != null) && (base4 != null)) { string name = base4.ReflectedType.Name; string str2 = base4.Name; string str3 = (bindingAttr == MethodResolver.staticBindingFlags) ? MethodResolver.staticString : MethodResolver.instanceString; throw FxTrace.Exception.AsError(new AmbiguousMatchException(System.Activities.SR.DuplicateMethodFound(name, str3, str2, this.parentActivity.DisplayName))); } base2 = base4; } } } } return(base2); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>(); Type targetObjectType = TypeHelper.ObjectType; if (this.TargetObject != null) { targetObjectType = this.TargetObject.ArgumentType; } RuntimeArgument targetObjectArgument = new RuntimeArgument("TargetObject", targetObjectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, targetObjectArgument); arguments.Add(targetObjectArgument); Type resultType = TypeHelper.ObjectType; if (this.Result != null) { resultType = this.Result.ArgumentType; } this.resultArgument = new RuntimeArgument("Result", resultType, ArgumentDirection.Out); metadata.Bind(this.Result, this.resultArgument); arguments.Add(resultArgument); // Parameters are named according to MethodInfo name if DetermineMethodInfo // succeeds, otherwise arbitrary names are used. this.methodResolver = CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, funcCache, locker, ref this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
private MethodResolver CreateMethodResolver() { MethodResolver resolver = new MethodResolver { MethodName = this.MethodName, RunAsynchronously = this.RunAsynchronously, TargetType = this.TargetType, TargetObject = this.TargetObject, GenericTypeArguments = this.GenericTypeArguments, Parameters = this.Parameters, Result = this.resultArgument, Parent = this }; if (this.Result != null) { resolver.ResultType = this.Result.ArgumentType; return resolver; } resolver.ResultType = typeof(object); return resolver; }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection<RuntimeArgument> arguments = new Collection<RuntimeArgument>(); Type targetObjectType = TypeHelper.ObjectType; if (this.TargetObject != null) { targetObjectType = this.TargetObject.ArgumentType; } RuntimeArgument targetObjectArgument = new RuntimeArgument("TargetObject", targetObjectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, targetObjectArgument); arguments.Add(targetObjectArgument); Type resultType = TypeHelper.ObjectType; if (this.Result != null) { resultType = this.Result.ArgumentType; } this.resultArgument = new RuntimeArgument("Result", resultType, ArgumentDirection.Out); metadata.Bind(this.Result, this.resultArgument); arguments.Add(resultArgument); // Parameters are named according to MethodInfo name if DetermineMethodInfo // succeeds, otherwise arbitrary names are used. this.methodResolver = CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, funcCache, locker, ref this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
public ExecuteAsyncResult(MethodResolver.InvokeMethodInstanceData instance, MethodResolver.AsyncWaitCallbackMethodExecutor executor, AsyncCallback callback, object state) : base(callback, state) { this.instance = instance; this.executor = executor; ActionItem.Schedule(asyncExecute, this); }