///// <summary> ///// Executes the list of action filters that have their OnActionExecuting executed ///// </summary> ///// <param name="executedActionFilters">The list of executed action filters</param> ///// <param name="postContext">The context of the execution</param> ///// <returns></returns> //ActionExecutedContext InvokeExecutedFilters(IActionFilter[] executedActionFilters, ActionExecutedContext postContext) //{ // //Executing the list of all Executed action filters // foreach (IActionFilter executedActionFilter in executedActionFilters) // executedActionFilter.OnActionExecuted(postContext); // return postContext; //} /// <summary> /// Launch the execution of filters and action method /// </summary> /// <param name="context">The context</param> /// <param name="filters">The list of action filters</param> /// <param name="parameters">The parameters.</param> /// <returns> /// The actionExecutedContext build by the execution /// </returns> protected virtual ActionExecutedContext InvokeActionMethodWithFilters(BaseController context, IActionFilter[] filters, object[] parameters) { //If there is no ActionFilter, the action is simple executed if (filters == null) { var postContext = new ActionExecutedContext(false, null) { Controller = context, ActionParameters = parameters, ActionMethod = _actionMethod, Result = InvokeActionMethod(context, parameters) }; return(postContext); } ////Now we know that there is, at least one actionFilter //if (_executedActionFilters == null) _executedActionFilters = new List<IActionFilter>(); //else _executedActionFilters.Clear(); var preContext = new ActionExecutingContext { Controller = context, ActionParameters = parameters, ActionMethod = _actionMethod }; //Passing the list throught the lambda expression Delegates.Func <ActionExecutedContext> continuation = () => { var actContext = new ActionExecutedContext(false, null) { Controller = context, ActionParameters = parameters, ActionMethod = _actionMethod, Result = InvokeActionMethod(context, parameters) }; return(actContext); }; //Delegates.Func<ActionExecutedContext> reverseFilters = continuation; //// need to reverse the filter list because the continuations are built up backward //for (int i = filters.Length - 1; i >= 0; i--) //{ // var filter = filters[i]; // Delegates.Func<ActionExecutedContext> next = () => InvokeActionMethodFilter(filter, preContext, continuation); // reverseFilters += next; //} Delegates.Func <ActionExecutedContext> reverseFilters = filters.Reverse().Aggregate(continuation, (next, filter) => () => InvokeActionMethodFilter(filter, preContext, next)); return(reverseFilters()); }
/// <summary> /// Execute filters and result /// </summary> /// <param name="context">The context</param> /// <param name="filters">The list of filters</param> /// <param name="actionResult">The result to executed</param> /// <returns> /// The resultExecutedContext /// </returns> protected virtual ResultExecutedContext InvokeActionResultWithFilters(BaseController context, IResultFilter[] filters, IActionResult actionResult, object[] parameters) { //if there is no available result filter the actionResult is simply saved if (filters == null) { InvokeActionResult(context, actionResult); return(null); } Delegates.Func <ResultExecutedContext> continuation = () => { InvokeActionResult(context, actionResult); return(new ResultExecutedContext(actionResult, false /* canceled */, null /* exception */) { Controller = context, ActionParameters = parameters, ActionMethod = _actionMethod }); }; var preContext = new ResultExecutingContext(actionResult) { Controller = context, ActionParameters = parameters, ActionMethod = _actionMethod }; //Delegates.Func<ResultExecutedContext> reverseFilters = continuation; //// need to reverse the filter list because the continuations are built up backward //for (int i = filters.Length - 1; i >= 0; i--) //{ // var filter = filters[i]; // Delegates.Func<ResultExecutedContext> next = () => InvokeActionResultFilter(filter, preContext, continuation); // reverseFilters += next; //} // need to reverse the filter list because the continuations are built up backward Delegates.Func <ResultExecutedContext> reverseFilters = filters.Reverse().Aggregate(continuation, (next, filter) => () => InvokeActionResultFilter(filter, preContext, next)); return(reverseFilters()); }
/// <summary> /// Execute the prefilter result, the actionResult and the postfilter result /// </summary> /// <param name="filter">The result filter</param> /// <param name="preContext">The builded preContext</param> /// <param name="continuation">The lambda expression wich execute the actionResult and the post filter result attribute</param> /// <returns>The result of the execution of the post filter result attribute</returns> ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Delegates.Func <ResultExecutedContext> continuation) { //Executing the filter filter.OnResultExecuting(preContext); //If the execution is cancelled if (preContext.Cancel) { return(new ResultExecutedContext(preContext.Result, true /* canceled */, null /* exception */) { Controller = preContext.Controller, ActionParameters = preContext.ActionParameters, ActionMethod = _actionMethod }); } bool wasError = false; ResultExecutedContext postContext = null; try { //Creating the ResultExecutedContext by executing the actionResult postContext = continuation(); } catch (TargetInvocationException ex) { wasError = true; ProcessExceptionWhenInvokeActionResultFilter(filter, preContext, ex.InnerException ?? ex); } catch (Exception ex) { wasError = true; ProcessExceptionWhenInvokeActionResultFilter(filter, preContext, ex); } //Everything is executed well if (!wasError) { filter.OnResultExecuted(postContext); } return(postContext); }
/// <summary> /// Execute the pre filter, the action and the post filter attribute /// </summary> /// <param name="filter">The action filter attribute</param> /// <param name="preContext">The builded executing context</param> /// <param name="continuation">Lambda expression that create the actionExecutedContext </param> /// <returns></returns> ActionExecutedContext InvokeActionMethodFilter(IActionFilter filter, ActionExecutingContext preContext, Delegates.Func <ActionExecutedContext> continuation) { //Execute the filter filter.OnActionExecuting(preContext); //if the execution process is cancelled by the pre filter if (preContext.Result != null) { return(new ActionExecutedContext(true /*cancelled*/, null /*exception*/) { Controller = preContext.Controller, ActionParameters = preContext.ActionParameters, ActionMethod = _actionMethod, Result = preContext.Result }); } bool wasError = false; ActionExecutedContext postContext = null; try { //Executing the action and initializing the postContext postContext = continuation(); } catch (TargetInvocationException ex) { wasError = true; ProcessExceptionWhenInvokeActionMethodFilter(filter, preContext, ex.InnerException ?? ex); } catch (Exception ex) { //An exception is caught wasError = true; ProcessExceptionWhenInvokeActionMethodFilter(filter, preContext, ex); } //Everything is well done if (!wasError && postContext.Result != null) { filter.OnActionExecuted(postContext); } return(postContext); }