如何构造请求处理对象链（Pipeline）

在开发中，我们经常会遇到这样一个场景：传入一个对象，经过不同的节点对这个对象做不同的操作，比如ASP.NET Core 中的pipeline，IIS中的HTTPpipeline等。在这类问题中，往往我们允许用户可以自己定义自己的处理节点(Processor Node)，能够实现这一目的的方式很多。本文中分享2种方式，欢迎大家交流。

责任链模式（Chain of Responsibility Pattern）

关于责任链模式的介绍园中已经有很多了，这里我就不再多余的来介绍了，直接上代码：

1. 创建抽象类

    public abstract class ProcessorExecution

    {

        protected ProcessorExecution Next { get; private set; }

        protected ProcessorExecution(ProcessorExecution next = null)

        {

            Next = next;

        }

        public virtual void Execute()

        {

            Next?.Execute();

        }

        public ProcessorExecution SetNext(ProcessorExecution next)

        {

            Next = next;

            return next;

        }

    }

2. 创建具体实现类

    public class Node1ProcessorExecution : ProcessorExecution

    {

        public Node1ProcessorExecution(ProcessorExecution next = null) : base(next)

        {

        }

        public override void Execute()

        {

            Console.WriteLine("Node1 Processor");

            base.Execute();

        }

    }

    public class Node2ProcessorExecution : ProcessorExecution

    {

        public Node2ProcessorExecution(ProcessorExecution next = null) : base(next)

        {

        }

        public override void Execute()

        {

            Console.WriteLine("Node2 Processor");

            base.Execute();

        }

    }

    public class Node3ProcessorExecution : ProcessorExecution

    {

        public Node3ProcessorExecution(ProcessorExecution next = null) : base(next)

        {

        }

        public override void Execute()

        {

            Console.WriteLine("Node3 Processor");

            base.Execute();

        }

    }

    public class TerminalProcessorExecute : ProcessorExecution

    {

        public TerminalProcessorExecute(ProcessorExecution next = null) : base(next)

        {

        }

        public override void Execute()

        {

            Console.WriteLine("Terminal Processor");

            base.Execute();

        }

    }

3. 调用对象链

    class Program

    {

        static void Main(string[] args)

        {

            var header = new Node1ProcessorExecution();

            header.SetNext(new Node2ProcessorExecution())

                .SetNext(new Node3ProcessorExecution())

                .SetNext(new TerminalProcessorExecute());

            header.Execute();

            Console.Read();

        }

    }

委托链

有时候我们很不情愿地为一个Processor Node 去创建一个新类，因为那样显得类文件特别多，毕竟每一个类中只有一个或很少的方法需要重写。这里，我们可以尝试第二种方法 ---- 委托链，帮助我们减少类的创建。

在C#中，委托是一种特殊的类的方式存在，所以我们可以使用委托的方式实现。话不多说，直接上代码：

1. 创建一个委托

我们需要创建一个委托用来替代 ProcessorExecution中的Execute方法（Processor Node 处理的逻辑核心），.NET 4.5提供了async的编程方法，这里我使用Task来作为该委托的返回值：

 public delegate Task ProcessorExecutionDelegate();

2. 创建一个Builder用于构造委托链

Builder中包括三个方法：

ProcessorExecutionBuilder Add(Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate> execution)： 用来维护Current -> Next的关系。我们需要创建一个表示 Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate> 的集合 _components。

ProcessorExecutionBuilder Add(Func<Func<Task>, Task> middleware)：用来表述NodeXProcessorExecution类（Func<Func<Task>, Task> middleware），内部调用Add(Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate> execution)
ProcessorExecutionDelegate Build()：构造委托链，并返回Header节点

    public class ProcessorExecutionBuilder

    {

        private readonly List<Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate>> _components = new List<Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate>>();

        private ProcessorExecutionBuilder Add(Func<ProcessorExecutionDelegate, ProcessorExecutionDelegate> execution)

        {

            _components.Add(execution);

            return this;

        }

        public ProcessorExecutionBuilder Add(Func<Func<Task>, Task> middleware)

        {

            Add((next) => () =>

            {

                Func<Task> func = () => next();

                return middleware(func);

            });

            return this;

        }

        public ProcessorExecutionDelegate Build()

        {

            var next = (ProcessorExecutionDelegate)(() => Task.Run(() => { Console.WriteLine("Terminal Processor"); }));

            _components.Reverse();

            foreach (var item in _components)

            {

                next = item(next);

            }

            return next;

        }

    }

3. 调用对象链

    class Program

    {

        static void Main(string[] args)

        {

            var builder = new ProcessorExecutionBuilder();

            builder.Add((next) =>

                {

                    Console.WriteLine("Node1 Processor");

                    return next();

                })

                .Add((next) =>

                {

                    Console.WriteLine("Node2 Processor");

                    return next();

                }).Add((next) =>

                {

                    Console.WriteLine("Node3 Processor");

                    return next();

                });

            builder.Build().Invoke();

            Console.Read();

        }

    }

巴特西

如何构造请求处理对象链（Pipeline）

责任链模式（Chain of Responsibility Pattern）

1. 创建抽象类

2. 创建具体实现类

3. 调用对象链

委托链

1. 创建一个委托

2. 创建一个Builder用于构造委托链

3. 调用对象链

最新文章

热门文章