net core管道模式小探

接口方式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SimulateMiddleware
{
    public class MiddlewareBuilder
    {
        private IList<Func<IMiddleware, IMiddleware>> components = new List<Func<IMiddleware, IMiddleware>>();

        public IMiddleware Builder()
        {         
            components.Add(next =>
                {
                    return new MiddlewareA(next);
                });
            components.Add(next =>
            {
                return new MiddlewareB(next);
            });
            IMiddleware start = new BaseMiddleware();
            foreach (var component in components.Reverse())
            {
                start = component(start);
            }
            return start;
        }
    }
    public interface IMiddleware
    {
        Task Invoke();
    }

    class BaseMiddleware : IMiddleware
    {
        public Task Invoke()
        {
            Console.WriteLine("BaseMiddleware Mark");
            return Task.CompletedTask;
        }
    }

    public class MiddlewareA : IMiddleware
    {
        IMiddleware _next;
        public MiddlewareA(IMiddleware next)
        {
            _next = next;
        }

        public async Task Invoke()
        {
            Console.WriteLine("MiddlewareA Begin");
            await _next.Invoke();
            Console.WriteLine("MiddlewareA End");
        }
    }

    public class MiddlewareB : IMiddleware
    {
        IMiddleware _next;
        public MiddlewareB(IMiddleware next)
        {
            _next = next;
        }

        public async Task Invoke()
        {
            Console.WriteLine("MiddlewareB Begin");
            await _next.Invoke();
            Console.WriteLine("MiddlewareB End");
        }
    }
}

委托方式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace SimulateMiddleware
{
    public delegate Task DelegateMiddleware();
    public class DelegateMiddlewareBuilder
    {
        private IList<Func<DelegateMiddleware, DelegateMiddleware>> components = new List<Func<DelegateMiddleware, DelegateMiddleware>>();
        public DelegateMiddleware DirectBuilder()
        {
            components.Add(next =>
            {
                return new DelegateMiddlewareA(next).Invoke;
            });
            components.Add(next =>
            {
                return new DelegateMiddlewareB(next).Invoke;
            });
            DelegateMiddleware start = new BaseDelegateMiddleware().Invoke;
            foreach (var component in components.Reverse())
            {
                start = component(start);
            }
            return start;
        }

        public DelegateMiddleware UseBuilder()
        {
            Use<DelegateMiddlewareA>();
            Use<DelegateMiddlewareB>();
            DelegateMiddleware start = () =>
            {
                Console.WriteLine("BaseDelegateMiddleware Mark");
                return Task.CompletedTask;
            };
            foreach (var component in components.Reverse())
            {
                start = component(start);
            }
            return start;
        }

        public void Use<TMiddleware>()
        {
            var middlewareType = typeof(TMiddleware);
            var methodInfos = middlewareType.GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);
            var delegateMethodInfo = methodInfos.FirstOrDefault(m => m.Name.Equals("Invoke", StringComparison.OrdinalIgnoreCase));
            if (delegateMethodInfo == null)
            {
                return;
            }
            var isTaskReturn = typeof(Task).Equals(delegateMethodInfo.ReturnType);
            if (!isTaskReturn)
            {
                return;
            }
            var constructorInfo = middlewareType.GetConstructor(new Type[] { typeof(DelegateMiddleware) });
            components.Add(next =>
            {
                var instance = constructorInfo.Invoke(new object[] { next });
                var targetDelegate = (DelegateMiddleware)delegateMethodInfo.CreateDelegate(typeof(DelegateMiddleware), instance);
                return targetDelegate;
            });
        }
    }

    public class BaseDelegateMiddleware
    {
        public Task Invoke()
        {
            Console.WriteLine("BaseDelegateMiddleware Mark");
            return Task.CompletedTask;
        }
    }

    public class DelegateMiddlewareA
    {
        DelegateMiddleware _next;
        public DelegateMiddlewareA(DelegateMiddleware next)
        {
            _next = next;
        }

        public async Task Invoke()
        {
            Console.WriteLine("DelegateMiddlewareA Begin");
            await _next.Invoke();
            Console.WriteLine("DelegateMiddlewareA End");
        }
    }

    public class DelegateMiddlewareB 
    {
        DelegateMiddleware _next;
        public DelegateMiddlewareB(DelegateMiddleware next)
        {
            _next = next;
        }

        public async Task Invoke()
        {
            Console.WriteLine("DelegateMiddlewareB Begin");
            await _next.Invoke();
            Console.WriteLine("DelegateMiddlewareB End");
        }
    }
}