It can also be very difficult to configure the accumulators with delegation.

We know that in ASP. net mvc, when the ActionFilter method is applied to the Action method, its execution process is as follows:

, Kairong North nose...

The functionality of ASP. net mvc involves too much code, which looks messy. The following uses an example to introduce this code!

The example environment is as follows:

1. There is such an interface IFilterFunction, which defines two methods!

    public interface IFilterFunction    {        void Before();        void After();    }

2. One method!

Public string ActionMethed () {Console. WriteLine ("Action Method Content"); return "Action ";}

Demand comesTo perform operations Before and after the ActionMethod method, you must first execute all Before methods of all classes that implement the IFilterFunction interface, and then execute the ActionMethed method, then, execute the After method for all classes that implement the IFilterFunction interface! (The purpose is to perform some operations before and after the ActionMethod method is executed)

For such a requirement, the first thought can be implemented as follows:

Small hanging implementation:

Class for implementing the IFilterFunction Interface

public string Start(){FilterOne filterOne = new FilterOne();FilterTwo filterTwo = new FilterTwo();FilterThree filterThree = new FilterThree();filterThree.Before();filterTwo.Before();filterOne.Before();string str = ActionMethed();filterOne.After();filterTwo.After();filterThree.After();return str;}

Although it can be achieved, it is a little too pediatric to do so. What if I say yes?
Come on ......

Implementation of large cranes:

Class that implements the IFilterFunction Interface

Public string Start () {Func <string> continuation = () => ActionMethed (); List <IFilterFunction> lists = new List <IFilterFunction> (); lists. add (new FilterOne (); lists. add (new FilterTwo (); lists. add (new FilterThree (); // It is its Func <string> p = lists. aggregate (continuation, (newcontinuation, filter) => () => Do (newcontinuation, filter); return p ();} public string Do (Func <string> continuation, IFilterFunction filter) {filter. before (); string str = continuation (); filter. after (); return str ;}

The execution result is:

 

 

 

 

 

That's right, it's so awesome. You can use the accumulators to perform a layer-by-layer packaging delegate, then execute the delegate, and then execute it layer-by-layer. Its Process

ASP. net mvc uses this method to execute the Action method and ActionFilter. That is, use the accumulators to package the delegate!

FriendCan you write such code? Download instance source code