static int MatchParameters(ParameterInfo[] parametersToMatch, ParameterInfo[] existingParameters)
{
var matchedParameters = 0;
var existingParametersList = new List <ParameterInfo>(existingParameters);
foreach (var param in parametersToMatch)
{
foreach (var existing in existingParametersList)
{
if (existing.Name != param.Name)
{
continue;
}
if (!GenericBinder.CompareParameterTypes(param.ParameterType, existing.ParameterType))
{
return(-1);
}
++matchedParameters;
existingParametersList.Remove(existing);
break;
}
}
return(matchedParameters);
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
FakeQueueAttribute attribute = parameter.GetCustomAttribute <FakeQueueAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <IBinding>(null));
}
string resolvedName = "fakequeue";
Func <string, FakeQueueClient> invokeStringBinder = (invokeString) => _client;
IBinding binding = GenericBinder.BindCollector <FakeQueueData, FakeQueueClient>(
parameter,
_converterManager,
_client,
(client, valueBindingContext) => client,
resolvedName,
invokeStringBinder
);
return(Task.FromResult(binding));
}
MethodInfo?GetOverloadedMethod(string methodName)
{
var currentMethod = Context.CurrentMethod;
MethodInfo?bestMatch = null;
var bestMatchParametersCount = -1;
var currentMethodParameters = currentMethod.GetParameters();
if (_parameterTypes != null)
{
bestMatch = Context.Type.GetMethod(methodName, _parameterTypes);
return(bestMatch != null && MatchParameters(currentMethodParameters, bestMatch.GetParameters()) >= 0? bestMatch: null);
}
const BindingFlags bindingFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
foreach (var m in Context.Type.GetMethods(bindingFlags))
{
if (m.IsPrivate || m.Name != methodName || m.IsGenericMethod != currentMethod.IsGenericMethod)
{
continue;
}
if (!GenericBinder.CompareParameterTypes(m.ReturnType, currentMethod.ReturnType))
{
continue;
}
if (m.IsDefined(typeof(OverloadAttribute), true))
{
continue;
}
var overloadedMethodParameters = m.GetParameters();
if (overloadedMethodParameters.Length <= bestMatchParametersCount)
{
continue;
}
var matchedParameters = MatchParameters(overloadedMethodParameters, currentMethodParameters);
if (matchedParameters <= bestMatchParametersCount)
{
continue;
}
bestMatchParametersCount = matchedParameters;
bestMatch = m;
}
return(bestMatch);
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
FakeQueueTriggerAttribute attribute = parameter.GetCustomAttribute <FakeQueueTriggerAttribute>(inherit: false);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
var hooks = new FakeQueueTriggerBindingStrategy();
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new FakeQueueListener(factoryContext.Executor, _client, singleDispatch);
return(Task.FromResult(listener));
};
ITriggerBinding binding = GenericBinder.GetTriggerBinding <FakeQueueData, FakeQueueDataBatch>(
hooks, parameter, _converterManager, createListener);
return(Task.FromResult <ITriggerBinding>(binding));
}
