protected MethodBinding(MethodDispatch dispatch)
{
if (dispatch == null)
{
throw new ArgumentNullException(nameof(dispatch));
}
Dispatcher = dispatch;
AddFilters(FilterAttribute.GetFilters(Dispatcher.Method));
}
public void Should_Infer_Result_Filter_Generic_Types()
{
var handler = new FilterResolver();
var provider = new FilterAttribute(typeof(RequestFilterRes <>));
var filter = provider.GetFilters(typeof(string), typeof(int), handler)
.ToArray();
Assert.AreEqual(typeof(RequestFilterRes <int>), handler.RequestedType);
}
private bool Invoke(object target, object callback,
IHandler composer, Type resultType, Func <object, bool> results,
out object result)
{
var args = Rule.ResolveArgs(this, callback, composer);
if (callback is INoFiltersCallback)
{
result = Dispatcher.Invoke(target, args, resultType);
return(true);
}
Type callbackType;
var dispatcher = Dispatcher.CloseDispatch(args, resultType);
var actualCallback = GetCallbackInfo(
callback, args, dispatcher, out callbackType);
var returnType = dispatcher.ReturnType;
var logicalType = dispatcher.LogicalReturnType;
var filters = composer
.GetOrderedFilters(callbackType, logicalType, Filters,
FilterAttribute.GetFilters(target.GetType(), true),
Policy.Filters)
.ToArray();
if (filters.Length == 0)
{
result = dispatcher.Invoke(target, args, resultType);
}
else if (!MethodPipeline.GetPipeline(callbackType, logicalType)
.Invoke(this, target, actualCallback, comp => dispatcher.Invoke(
target, GetArgs(callback, args, composer, comp),
resultType), composer, filters, out result))
{
return(false);
}
var accepted = Policy.AcceptResult?.Invoke(result, this)
?? result != null;
if (accepted && (result != null) && !Dispatcher.IsVoid)
{
var asyncCallback = callback as IAsyncCallback;
result = CoerceResult(result, returnType, asyncCallback?.WantsAsync);
return(results?.Invoke(result) != false);
}
return(accepted);
}
private bool Invoke(
HandleMethod handleMethod, object target, IHandler composer)
{
var arguments = handleMethod.Arguments;
var filters = composer.GetOrderedFilters(
typeof(HandleMethod), typeof(object),
FilterAttribute.GetFilters(target.GetType(), true),
FilterAttribute.GetFilters(Dispatcher.Method))
.ToArray();
bool handled;
object returnValue;
if (filters.Length == 0)
{
returnValue = Dispatcher.Invoke(target, arguments);
handled = !Unhandled;
}
else
{
handled = Pipeline.Invoke(
this, target, handleMethod, comp =>
{
if (comp != null && !ReferenceEquals(composer, comp))
{
Composer = comp;
}
return(Dispatcher.Invoke(target, arguments));
},
composer, filters, out returnValue) && !Unhandled;
}
handleMethod.ReturnValue = handled
? returnValue
: RuntimeHelper.GetDefault(handleMethod.ResultType);
return(handled);
}
