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);
}
