责任链模式

gistfile1.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication7
{
    public abstract class RequestHandler
    {
        public abstract Response SendAsync(Request request);
    }

    public abstract class DelegatingHandler : RequestHandler
    {
        protected DelegatingHandler()
        {
            RequestFunc = request => request;
            ResponseFunc = response => response;
        }

        protected DelegatingHandler(Func<Request, Request> requestFunc, Func<Response, Response> responseFunc)
        {
            RequestFunc = requestFunc;
            ResponseFunc = responseFunc;
        }

        RequestHandler _innerHandler;
        protected Func<Request, Request> RequestFunc;
        protected Func<Response, Response> ResponseFunc;

        public RequestHandler InnerHandler
        {
            get
            {
                return this._innerHandler;
            }
            set
            {
                if (value == null)
                    throw new ArgumentNullException("value");
                this._innerHandler = value;
            }
        }


        public override Response SendAsync(Request request)
        {
            var newRequest = RequestFunc(request);

            var response = _innerHandler.SendAsync(newRequest);

            return ResponseFunc(response);
        }
    }

    public class FooMessageHandler : DelegatingHandler
    {
        public FooMessageHandler()
        {
            RequestFunc = request =>
            {
                request.Content += "=> Foo";
                return request;
            };

        }

        public FooMessageHandler(Func<Request, Request> requestFunc, Func<Response, Response> responseFunc)
            : base(requestFunc, responseFunc)
        {
        }

    }

    public class BarMessageHandler : DelegatingHandler
    {
        public BarMessageHandler()
        {
            RequestFunc = request =>
            {
                request.Content += "=> bar";
                return request;
            };

            ResponseFunc = response =>
            {
                Console.WriteLine("after bar");
                return response;
            };
        }
    }

    public class BazMessageHandler : RequestHandler
    {
        public override Response SendAsync(Request request)
        {
            Console.WriteLine("before dispatcher");
            var resp = new Response();
            resp.Content = request.Content;
            Console.WriteLine("after dispatcher");
            return resp;
        }
    }

    public class Processer : DelegatingHandler
    {
        public Processer(IEnumerable<DelegatingHandler> configuration, RequestHandler dispatcher)
        {
            InnerHandler = dispatcher;
            Initialize(configuration, dispatcher);
        }

        protected void Initialize(IEnumerable<DelegatingHandler> handlers, RequestHandler dispatcher)
        {
            if (handlers == null)
            {
                return;
            }

            RequestHandler pipeline = dispatcher;
            IEnumerable<DelegatingHandler> reversedHandlers = handlers.Reverse();
            foreach (DelegatingHandler handler in reversedHandlers)
            {
                handler.InnerHandler = pipeline;
                pipeline = handler;
            }

            InnerHandler = pipeline;
        }
    }

    public class Request
    {
        public string Content { get; set; }
    }

    public class Response
    {
        public string Content { get; set; }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var hanlders = new List<DelegatingHandler>()
            {
                new FooMessageHandler(),
                new BarMessageHandler(),
            };

            var processer = new Processer(hanlders, new BazMessageHandler());

            var resp = processer.SendAsync(new Request());

            Console.WriteLine(resp.Content);

            Console.ReadKey();
        }
    }
}