跟我一起 掌握AspNetCore底层技术和构建原理

Posted dotNET跨平台

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了跟我一起 掌握AspNetCore底层技术和构建原理相关的知识,希望对你有一定的参考价值。

我打算录制一个免费的基础课程从原理、思维、实现等角度详细讲解。IOC、Options、Configuration、Logging、AOP、管道中间件、路由终结点,mvc的原理。掌握这些基础知识之后,我会基于这些技术+scoket手写一个aspnetcore。用以窥探aspnetcore的内部是如何运行的。

下面我详细解释两点基础技术IOC和AOP,大家感受一下我授课的风格。

注意基础课里讲到的知识,在整个net平台几乎都适用,及支持aspnet,winform,wpf。

这个课程学习下来你将掌握:容器技术和原理,AOP思想和各种实现手段及原理,微软常用的一些设计模式思想,配置选项,日志,管道中间件,路由终结点,aspnetcore运行机理。如果课程能够受到欢迎,我会后续会继续讲解框架设计,emit,表达式树等框架技术,我想为社区和生态做一点点贡献。

本人开发过,《Soul.IdentityServer》《Dapper.Linq》、《SqlBatis》等框架,对net掌握也算是比较深入

视频课程

【AspNetCore企业级开发《公开课》】 https://www.bilibili.com/video/BV1W14y1c7yt/?share_source=copy_web&vd_source=9caac72726a42a51e94b8d403bc6a3ac

IOC

基础知识

我们如何理解IOC?我们可以通过一个现实世界的模型来进行解释。比如有一本菜谱这个菜谱就是我们的IServiceCollection,里面记录了菜(Service)的描述信息(ServiceDescriptor)菜名(ServiceDescriptor.ServiceType)以及菜具体制作方法(ServiceDescriptor.ImplementationType),通过菜名(ServiceType)告诉厨师(IServiceProvider)制作(实列化、解析)出来我们要吃的菜。这就是IOC技术。

  • 依赖项

    Microsoft.Extensions.DependencyInjection.Abstractions:抽象包,用于扩展容器

    Microsoft.Extensions.DependencyInjection:实现包,实现IOC的基本功能

  • 核心接口
    Service:就是我们需要的服务实列(菜)

    ServiceDescriptor:用于描述服务的信息。比如服务名(ServiceType)、实现类(ImplementationType)、生命周期(Lifetime)。(某道菜的制作描述信息)

    IServiceCollection:是一个List集合,用于保存服务描述信息。(菜谱,记录了很多菜的描述信息)

    IServiceProvider:用于解析服务实列,根容器和子容器实现类不同(厨师)实现类里面有字段用于标记是否是根容器,以及记录所有解析的实列,为将来释放做准备。

    ActivatorUtilities:用于解析一个容器中不存在,但是依赖了容器中的服务的实列。

  • 关键字

    依赖:如果一个类A的构造器中有一个类B的参数,我们说A依赖B

    注入:如果A依赖B,要想实列化A,就必须先实列化B,然后把B载入A的构造器的过程

    依赖注入:IOC容器根据反射得到一个类的依赖关系,自动帮你载入依赖项的过程

服务注册

  • 万能公式

    //需要安装:Microsoft.Extensions.DependencyInjection
    //创建IServiceCollection实列
    IServiceCollection services = new ServiceCollection();
    //由于IServiceCollection实现了IList<ServiceDescriptor>接口
    //因此下面是一个万能公式,其它的都是扩展方法,本质调用的还是这个万能公式,包括委托的方式(他的实现类型是一个委托)
    services.Add(new ServiceDescriptor(typeof(IConnection),typeof(SqlConnection),ServiceLifetime.Singleton));
  • 泛型接口

    //泛型接口需要提前知道类型
    services.AddSingleton<IDbConnection, SqlConnection>();
  • 反射接口

    //反射的方式在编写框架时十分有用,无反射无框架
    services.AddSingleton(typeof(IDbConnection), typeof(SqlConnection);
  • 委托方式

    //当我们构建的对象需要编写逻辑时,委托方式十分有用
    services.AddSingleton<IDbConnection, SqlConnection>();
    //低级用法
    //假设DbContext依赖IDbConnection,并且需要一个name
    services.AddSingleton(sp =>
    	
        var connection = sp.GetRequiredService<IDbConnection>();
    	return new DbContext(connection, "c1");
    );  
    //高级用法
    //sp是一个IServiceProvider的实列
    //委托方式在注册的同时还能进行预解析
    //sp到底是根容器还是子容器由解析时的IServiceProvider
    services.AddSingleton(sp =>
    	    
    	return ActivatorUtilities.CreateInstance<DbContext>(sp,"c1");
    );
  • 泛型注册

    //注册泛型时,只能使用反射接口,并且泛型参数不要写入,解析时来确立,如果有多个泛型参数使用逗号隔开
    services.AddSingleton(typeof(ILogger<>), typeof(ConsoleLogger<>);

构建容器

IServiceProvider container = services.BuildServiceProvider(new ServiceProviderOptions 

     ValidateOnBuild = true,//构建时检查是否有依赖没有注册的服务
     ValidateScopes = true,//在解析服务时检查是否通过根容器来解析Scoped类型的实列
);

服务解析

//如果同一个服务类型,注册多个实现,那么默认获取最后一个实现。
services.AddSingleton<IDbConnection, SqlConnection>();
services.AddSingleton<IDbConnection, mysqlConnection>();
IServiceProvider container = services.BuildServiceProvider();
//如果服务未注册,返回null
IDbConnection? connection = container.GetService<IDbConnection>();
//服务不存在讲引发异常
IDbConnection connection = container.GetRequiredService<IDbConnection>();
//获取IDbConnection所有实现
IEnumerable<IDbConnection> connections = container.GetRequiredServices<IDbConnection>();
//假设DbContext依赖IDbConnection,并且需要一个name,但是容器没有注册DbContext
var context = ActivatorUtilities.CreateInstance<DbContext>(container,"c1");

生命周期

我们需要会搭建测试案例,来验证是否是同一个实列,以及释放问题。

public class A : IDisposable

    public string ID  get; 

    public A()
    
        ID = Guid.NewGuid().ToString();
    

    public void Dispose()
    
        Console.WriteLine(ID + ":已释放...");
    

//你可以测试其他生命周期
services.AddScoped<A>();//替换其他生命周期
//根容器:通过Debug模式查看container可以看到一个属性IsRootScope用来标记它是否是根容器
IServiceProvider container = services.BuildServiceProvider(new ServiceProviderOptions 
    
    ValidateOnBuild = true,//构建时检查是否有依赖没有注册的服务
    ValidateScopes = false,//在解析服务时检查是否通过根容器来解析Scoped类型的实列
);
//a1:通过根容器创建,需要设ValidateScopes为false(危险)
var a1 = container.GetRequiredService<A>();
var a2 = container.GetRequiredService<A>();
using(var scope = rootContainer.CreateScope())

    //a2:通过子容器创建(合法)
    var a3 = scope.ServiceProvider.GetRequiredService<A>();
    var a4 = scope.ServiceProvider.GetRequiredService<A>();
    Console.WriteLine(a1.ID);
    Console.WriteLine(a2.ID);
    Console.WriteLine(a3.ID);
    Console.WriteLine(a4.ID);

Console.ReadLine();

通过修改A服务注册的生命周期我们可以得到一下结论。

测试Singleton发现:a1,a2,a3,a4的Id都相同
测试Scope发现:a1和a2的Id相同,a3和a4的Id相同,a1和a3的Id不相同
测试Transient发现:a1,a2,a3,a4的Id都不同

Singleton:无论通过根容器还是子容器,获取的都是同一实列,而且不会执行释放(除非释放根容器)。

Scoped:同一scope获取的都是同一实列,不同的scope获取的实列不同。scope释放会释放由它解析出来的所有实列(除了单实例以外),如果并执行Dispose方法(前提实现了IDisposable)。

Transient:无论是否同一scope获取的实列都不同,每次获取都是一个新的实列,scope释放会释放所有的实列。

注意:ServiceProvider会记录由它创建的所有实列,如果释放IServiceScope的实列,则会释放(ServiceProvider)和所有(单实列除外)由它创建的实列。

Scope范围:scope的范围有多大取决于你何时创建何时释放。从创建到释放就是他的生命周期。

//按时间5s之后释放
public class A : IDisposable

    public string ID  get;  = Guid.NewGuid().ToString();
    public void Dispose()
    
        Console.WriteLine(ID + ":已释放...");
    

IServiceProvider container = services.BuildServiceProvider();
var scope = rootContainer.CreateScope();
var a1 = container.GetRequiredService<A>();
Thread.Sleep(5 * 1000);
scope.Dispose();

组件扫描

这里我们演示如何通过注解来扫描,大家也可以根据接口的方式来扫描

[AttributeUsage(AttributeTargets.Class)]
public class InjectionAttribute : Attribute

    public Type? ServiceType  get; set; 
    public ServiceLifetime Lifetime  get; set;  = ServiceLifetime.Transient;

public static class InjectionIServiceCollectionExtensions

    public static IServiceCollection AddServicesByInjection<T>(this IServiceCollection services)
    
        var serviceTypes = typeof(T).Assembly.GetTypes()
            .Where(a => a.IsClass)
            .Where(a => a.GetCustomAttribute<InjectionAttribute>() != null)//扫描注解
            .Where(a => !a.IsAbstract);
        foreach (var item in serviceTypes)
        
            var injection = item.GetCustomAttribute<InjectionAttribute>();
            if (injection!.ServiceType == null)
            
                services.Add(new ServiceDescriptor(item, item, injection.Lifetime));
            
            else
            
                services.Add(new ServiceDescriptor(injection!.ServiceType, item, injection.Lifetime));
            
        
        return services;
    


public interface IDbConnection




[Injection(ServiceType = typeof(IDbConnection), Lifetime = ServiceLifetime.Scoped)]
public class DbConnection : IDbConnection



 //测试
var services = new ServiceCollection();
//传入需要扫描的程序集
services.AddServicesByInjection<Program>();
var sp = services.BuildServiceProvider();
var connection = sp.GetService<IDbConnection>();

构造模式

  • 构造模式用于简化被构造对象的创建,通过提供一大堆的api来丰富简化构造过程,增加调用者的体验。

  • 构造者需要提供一个Build方法用于构建和返回将要构造的对象实列。

  • 在容器中一般需要提供一个公开的IServiceCollection类型的属性,用于注册服务。

public enum ServiceLifetime

    Transient,
    Scoped,

public class ServiceDescriptor

    public Type ServiceType  get; 
  
    public ServiceLifetime Lifetime  get; 

    public ServiceDescriptor(Type serviceType, ServiceLifetime lifetime)
    
        ServiceType = serviceType;
        Lifetime = lifetime;
    

//目标对象
public interface IContainer



//如果直接创建成本很高,体验很差
public class Container: IContainer

    private List<ServiceDescriptor> _services = new();
   
    public Container(List<ServiceDescriptor> services)
    
        _services = services;
    

//目标对象的构造者
public interface IContainerBuilder

    //接口只提供一个通用方法,降低实现成本
    void Add(ServiceDescriptor descriptor);
    //构造目标对象
    IContainer Build();

//实现构造者
public class ContainerBuilder : IContainerBuilder

    private List<ServiceDescriptor> _services = new();

    public void Add(ServiceDescriptor descriptor)
    
        _services.Add(descriptor);
    

    public IContainer Build()
    
        return new Container(_services);
    

//扩展构造者,提供更加便捷的api
public static class IContainerBuilderExtensions

    public static void AddTransient<T>(this IContainerBuilder builder)
    
        builder.Add(new ServiceDescriptor(typeof(T), ServiceLifetime.Transient));
    
    public static void AddScoped<T>(this IContainerBuilder builder)
    
        builder.Add(new ServiceDescriptor(typeof(T), ServiceLifetime.Scoped));
    


//测试
var containerBuilder = new ContainerBuilder();
containerBuilder.AddScoped<DbContext>();
var container = containerBuilder.Build();

工厂模式

  • 工厂模式侧重于对象的管理,一般提供一个Create方法,支持命名创建。

  • 通过上面的学习我们发现IOC有一个弊端,就是他是通过服务类型的解析服务的。有些情况下我们需要通过命名的方式来解析服务。此时可以使用工厂模式

public interface IDbConnection



public class MySqlDbConnection : IDbConnection



public class SqlDbConnection : IDbConnection




public class DbConnectionFactory

    private IServiceProvider _serviceProvider;

    private Dictionary<string, Type> _connections;

    public DbConnectionFactory(IServiceProvider provider, Dictionary<string, Type> connections)
    
        _serviceProvider = provider;
        _connections = connections;
    

    public IDbConnection? Create(string name)
    
        if (_connections.TryGetValue(name, out Type? connectionType))
        
            return _serviceProvider.GetRequiredService(connectionType) as IDbConnection;
        
        return default;
    


//测试
var services = new ServiceCollection();
services.AddScoped<MySqlDbConnection>();
services.AddScoped<SqlDbConnection>();
services.AddSingleton(sp => 

    var connections = new Dictionary<string, Type>
    
         "s1", typeof(SqlDbConnection) ,
         "s2", typeof(MySqlDbConnection) 
    ;
    return new DbConnectionFactory(connections);
);
var sp = services.BuildServiceProvider();
var factory = sp.GetRequiredService<DbConnectionFactory>();
var s1 = factory.Create(sp, "s1");
var s2 = factory.Create(sp, "s2");

提供模式

  • 如果看到提供者模式,说明我们可以提供多个方案,支持多实现

  • 一般通过工厂来管理提供者,用以支持命名实列

public interface ILogger

    void Info(string message);


public interface ILoggerProvider

    ILogger CreateLogger(string name);


public class ConsoleLoggerProvider : ILoggerProvider

    public ILogger CreateLogger(string name)
    
        return new ConsoleLogger(name);
    
    class ConsoleLogger : ILogger
    
        private string _name;
        public ConsoleLogger(string name)
        
            _name = name;
        
        public void Info(string message)
        
            Console.WriteLine($"_name:message");
        
    


public class DebugLoggerProvider : ILoggerProvider

    public ILogger CreateLogger(string name)
    
        return new DebugLogger(name);
    

    class DebugLogger : ILogger
    
        private string _name;
        public DebugLogger(string name)
        
            _name = name;
        
        public void Info(string message)
        
            Debug.WriteLine($"_name:message");
        
    


public class LoggerFactory

    private IEnumerable<ILoggerProvider> _providers;

    public LoggerFactory(IEnumerable<ILoggerProvider> providers)
    
        _providers = providers;
    

    public ILogger Create(string name)
    
        var loggers = _providers.Select(s=>s.CreateLogger(name));
        return new LoggerCollection(loggers);
    
    class LoggerCollection : ILogger
    
        private IEnumerable<ILogger> _loggers;
        public LoggerCollection(IEnumerable<ILogger> loggers)
        
            _loggers = loggers;
        

        public void Info(string message)
        
            foreach (var logger in _loggers)
            
                logger.Info(message);
            
        
    

代理模式

  • 代理模式侧重于对目标对象进行加强,通过实现目标对象的接口具备目标对象的能力。

  • 一般通过实现和目标对象相同的接口来获得目标对象的能力

  • 代理可以通过目标对象来简化实现成本,代理只负责编写加强逻辑

  • 一般代理器只代理单个目标对象,我们把下面这个模式也可以归纳到代理模式,因为它能满足代理的许多特点比如加强、拥有目标对象的能力

  • 思考我们需要一个LoggerCollection,需要实现ICollection

    接口,如何降低实现成本?
public interface ILogger

    void Info(string message);


public class LoggerCollection : ILogger

    private IEnumerable<ILogger> _loggers;
    public LoggerCollection(IEnumerable<ILogger> loggers)
    
        _loggers = loggers;
    

    public void Info(string message)
       //加强逻辑
        foreach (var logger in _loggers)
        
            //具体实现由目标对象实现
            logger.Info(message);
        
    

容器实现

实现容器有三个重要的对象,通过IContainerBuilder来构建Container实列。Container负责根据服务描述来找到服务实现,通过服务实现的依赖来进行注入。下面我们写一个简化版本的容器。

  • ServiceDescriptor:负责描述服务信息

  • IContainerBuilder:负责构建容器

  • IContainer:负责根据服务描述信息解析服务

public class DbConnection



public class DbContext

    public DbConnection Connection  get; 

    public DbContext(DbConnection connection)
    
        Connection = connection;
    


public class ServiceDescriptor

    public Type ServiceType  get; 
    public Type ImplementionType  get; 
    public object? Instance  get; 

    public ServiceDescriptor(Type serviceType, Type implementionType, object? instance = null)
    
        ServiceType = serviceType;
        ImplementionType = implementionType;
        Instance = instance;
    


public interface IContainer

    object? GetService(Type serviceType);


public interface IContainerBuilder

    void Add(ServiceDescriptor descriptor);
    IContainer Build();


public class Container : IContainer

    private IEnumerable<ServiceDescriptor> _services;

    public Container(IEnumerable<ServiceDescriptor> services)
    
        _services = services;
    

    public object? GetService(Type serviceType)
    
        var descriptor = _services
            .FirstOrDefault(a => a.ServiceType == serviceType);
        if (descriptor == null)
        
            throw new InvalidOperationException("服务未注册");
        
        //判断是否是委托(涉及到了协变)
        var invokerType = typeof(Func<IContainer, object>);
        if (typeof(Func<IContainer, object>).IsInstanceOfType(descriptor.Instance))
        
            var func = descriptor.Instance as Func<IContainer, object> ?? throw new ArgumentNullException();
            return func(this);
        
        var constructor = serviceType.GetConstructors()
            .OrderByDescending(a => a.GetParameters().Length)
            .FirstOrDefault() ?? throw new ArgumentNullException();
        //递归解析依赖
        var parameters = constructor.GetParameters()
            .Select(s => GetService(s.ParameterType));
        return Activator.CreateInstance(descriptor.ImplementionType, parameters.ToArray());
    


public class ContainerBuilder : IContainerBuilder

    private List<ServiceDescriptor> _services = new();

    public void Add(ServiceDescriptor descriptor)
    
        _services.Add(descriptor);
    

    public IContainer Build()
    
        return new Container(_services);
    


public static class IContainerBuilderExtensions

    public static void Add<TService>(this IContainerBuilder builder)
        where TService : class
    
        builder.Add(new ServiceDescriptor(typeof(TService), typeof(TService)));
    
    public static void Add<TService, TImplement>(this IContainerBuilder builder)
    
        builder.Add(new ServiceDescriptor(typeof(TService), typeof(TImplement)));
    

    public static void Add<TService>(this IContainerBuilder builder, Func<IContainer, TService> func)
    
        builder.Add(new ServiceDescriptor(typeof(TService), typeof(Action<IContainer, TService>), func));
    

//测试
IContainerBuilder builder = new ContainerBuilder();
builder.Add(c => new DbConnection());
builder.Add<DbContext>();
var container = builder.Build();
var context = container.GetService(typeof(DbContext));

AOP

基础知识

假设这是一个U型管道,污水水从一端流入,另一端流出。

现在我们要对污水进行过滤,A负责过滤B负责消毒。显然有四个处理点,他们的顺序分别是:1->2->3->4。其中1,4是A过滤器的处理点,2,3是B过滤器的处理点。显然3个过滤器就有6个处理点。我们可以随意调整A,B过滤器的顺序,可随意插拔。这就是AOP的思想。

执行顺序:先进后出(栈)

执行点数:过滤器数 * 2

AOP是对OOP的一种补充,即面向切面编程,一种编程思想。我们管A,B为切面。1~4为切入点。AOP的优势是面向切面编程,每个切面负责独立的系统逻辑,降低代码的复杂度,提高代码的复用率。可以随意调整顺序,随意插拔。用于对业务逻辑进行增强。面向切面编程可以使得系统逻辑和业务逻辑进行分离。

系统逻辑:比如身份认证,异常处理,参数校验

业务逻辑:就是我们真正关心不得不写的业务逻辑。

public class Demo

    public void A()
    
        Console.WriteLine(1);
        B();
        Console.WriteLine(4);
    
    public void B()
    
        Console.WriteLine(2);
        Console.WriteLine(3);
    

//这段代码没有实际意义,但是它展示了函数调用的执行过程。(先进后出)

静态代理

假设我们需要实现一个IList接口,我们知道IList接口有很多方法,实现成本非常高。我们可以通过代理模式来实现

代理模式可以降低实现的成本,还可以对目标对象进行加强。代理者不需要实现具体的业务逻辑,只需要编写加强逻辑即可。

//实现IEnumerable接口只能加强两个方法,但是实现IList接口可以加强很多方法
class MyCollection : IEnumerable<object>

    private IEnumerable<object> _target;

    public MyCollection(IEnumerable<object> target)
    
        _target = target;
    

    public IEnumerator<object> GetEnumerator()
    
        //编写加强逻辑比如打印
        Console.WriteLine("调用迭代器了");
        //通过target来实现,代理类之关系加强逻辑,不关心接口实现
        return _target.GetEnumerator();
    

    IEnumerator IEnumerable.GetEnumerator()
    
        return ((IEnumerable)_target).GetEnumerator();
    


//测试
var target= new List<object>();
//可以看到MyCollection对target进行了代理,加强了GetEnumerator函数(可以打印消息)
var collection = new MyCollection(target);
//此时GetEnumerator就会被加强,返回target的迭代器。
var it = collection.GetEnumerator();

我们可以通过静态代理来实现链式调用,完成污水处理问题。

public interface IWater

     void Invoke();

public class Water : IWater

    public void Invoke()
    
        //业务逻辑
        Console.WriteLine("水已经净化了");
    

//实现目标对象的接口IWater
public class WaterProxy1 : IWater

    private readonly IWater _target;
    
    public WaterProxy1(IWater target)
    
        _target = target;
    
   
    public void Invoke()
    
        Console.WriteLine("开始消毒杀菌");//系统逻辑
        _target = target;
        Console.WriteLine("完成消毒杀菌");//系统逻辑
    

public class WaterProxy2 : IWater

    private readonly IWater _target;
    
    public WaterProxy2(IWater target)
    
        _target = target;
    
   
    public void Invoke()
    
        Console.WriteLine("开始去除杂质");//系统逻辑
        _target = target;
        Console.WriteLine("完成去除杂质");//系统逻辑
    

//此时是先去除杂质后在消毒
//p1的target是Water,p2的target是p1
var target = new Water();
var p1 = new WaterProxy1(target);
var p2 = new WaterProxy2(p1);
p2.Invoke();
//此时是先消毒后在去除杂质
//p2的target是Water,p1的target是p2
var target = new Water();
var p2 = new WaterProxy2(target);
var p1 = new WaterProxy1(p2);
p2.Invoke();

可以看到系统逻辑和业务逻辑进行了分离,系统逻辑写到了不同的切面。切面之间何以随意组合,增减。这就是AOP思想的一种呈现方式。代码服用度很高,可以代理所有的IWater的实现。(假设Mercury也实现了IWater接口,那么WaterProxy1和WaterProxy2也能对他进行增强)

静态代理的本质是子类继承父类,或者实现接口,对目标对象进行增强。

静态代理的弊端是只能实现一个接口(标准),无法代理其他类型的实列。他的切面的可复用率有限,限定在它实现的接口。

注意:如果是通过实现的方式,那么无论静态代理还是动态代理,都只能代理父类中的虚函数(virtual),因为子类只能重写父类中的虚函数。所以建议使用接口的方式。

动态代理

动态代理可以通过Castle.Core来实现。我们说静态代理和动态代理的区别是,静态代理在代码编译之前就已经确立的代理关系。而动态代理的原理是,在编译之后,运行时通过Emit来动态创建目标对象的子类,或者实现目标对象的接口。把拦截器织入到动态生成的类中,这里的拦截器可以织入到任意的实现类中。(Emit技术可以在运行时生成一个class,大家可以通过打印castle.core返回的实列的类名来进行验证)

动态代理和静态代理的本质都是继承或者实现,但是静态代理是需要手动编写代理类,而动态代理由框架动态生成代理类。

public interface IWater

    void Invoke()

public class Water()

    public void Invoke()
    
        //业务逻辑
     	Console.WriteLine("水已经净化了");
         

//拦截器-切面
public Interceptor1 : IInterceptor

    void Intercept(IInvocation invocation)
    
         Console.WriteLine("开始去除杂质");//系统逻辑
         invocation.Proceed();
         Console.WriteLine("完成去除杂质");//系统逻辑
    

var generator = new ProxyGenerator();
var target = new Water();
//通过框架生成代理类
var proxy = generator.CreateInterfaceProxyWithTarget<IWater>(target,new Interceptor1());
Console.WriteLine(proxy.GetType().FullName);//可以看到这个类并不是我们生成的
proxy.Invoke();

委托方式

这是aspnetcore管道的核心代码

public interface IWater

    void Invoke();


public class Water : IWater

    public void Invoke()
    
        //业务逻辑
        Console.WriteLine("水已经净化了");
    

//定义一个委托
public delegate void WaterDelegate(IWater water);

public class ApplicationBuilder

    private readonly List<Func<WaterDelegate, WaterDelegate>> _components = n

    public void Use(Func<WaterDelegate, WaterDelegate> middleware)
    
        _components.Add(middleware);
    

    public WaterDelegate Build()
    
        //负责兜底
        WaterDelegate app = c =>
        
            throw new InvalidOperationException("无效的管道");
        ;
        for (int i = _components.Count - 1; i > -1; i--)
        
            app = _components[i](app);//完成嵌套
        
        return app;
        

测试

var builder = new ApplicationBuilder();
//过滤器1
builder.Use(next => 

    return water =>
    
        Console.WriteLine("开始去污");
        next(water);
        Console.WriteLine("完成去污");
    ;
);
//过滤器2
builder.Use(next =>

    return water =>
    
        Console.WriteLine("开始消毒");
        next(water);
        Console.WriteLine("完成消毒");
    ;
);
builder.Use(next =>

    return water =>
    
        Console.WriteLine("开始消毒");
        //next(water);最后一个委托不能执行next,因为此时next是兜底的那个会抛出异常
	water.Invoke();
        Console.WriteLine("完成消毒");
    ;
);
//构建管道
var app = builder.Build();
var target = new Water();
//开始处理
app.Invoke(target);

接口方式

public class HttpContext



//链路器
public interface IChain

    Task NextAsync();

//用于执行filter
public class FilterChain : IChain

    private readonly IFilter _filter;
    private readonly HttpContext _context;
    private readonly IChain _next;
    public FilterChain(IFilter filter, HttpContext context, IChain next)
    
        _filter = filter;
        _context = context;
        _next = next;
    
    public async Task NextAsync()
    
        await _filter.InvokeAsync(_context, _next);
    

//用于执行servlet
public class ServletChain : IChain

    private readonly IServlet _servlet;
    private readonly HttpContext _context;

    public ServletChain(IServlet servlet, HttpContext context)
    
        _servlet = servlet;
        _context = context;
    

    public async Task NextAsync()
    
        await _servlet.DoPostAsync(_context);
    

public interface IFilter

    Task InvokeAsync(HttpContext context, IChain chain);

public class Filter1 : IFilter

    public async Task InvokeAsync(HttpContext context, IChain chain)
    
        Console.WriteLine("身份认证开始");
        await chain.NextAsync();
        Console.WriteLine("身份认证结束");
    

public class Filter2 : IFilter

    public async Task InvokeAsync(HttpContext context, IChain chain)
    
        Console.WriteLine("授权认证开始");
        await chain.NextAsync();
        Console.WriteLine("授权认证结束");
    

public interface IServlet

    Task DoPostAsync(HttpContext context);

public class HelloServlet : IServlet

    public Task DoPostAsync(HttpContext context)
    
        Console.WriteLine("Hello World");
        return Task.CompletedTask;
    

public class WebHost

    private readonly List<IFilter> _filters = new List<IFilter>();

    public void AddFilter(IFilter filter)
    
        _filters.Add(filter);
    

    public void Execute(HttpContext context, IServlet servlet)
    
        //自行处理filter为空的情况,就是直接执行serlvet就好了
        var stack = new Stack<IFilter>(_filters);
        var filter = stack.Pop();
        var chain = GetFilterChain(context, servlet, stack);
        filter.InvokeAsync(context, chain);
    
	//构建链路器(递归算法)
    private IChain GetFilterChain(HttpContext context, IServlet servlet, Stack<IFilter> filters)
    
        if (filters.Any())
        
            var filter = filters.Pop();
            var next = GetFilterChain(context, servlet, filters);
            return new FilterChain(filter, context, next);
        
        else
        
            return new ServletChain(servlet, context);
        
    

测试

var host = new WebHost();
host.AddFilter(new Filter1());
host.AddFilter(new Filter2());
var context = new HttpContext();
host.Execute(context);

以上是关于跟我一起 掌握AspNetCore底层技术和构建原理的主要内容,如果未能解决你的问题,请参考以下文章

跟我一起学Hadoop YARN

区块链会2020再次爆发,先学点DAPP压压惊,跟我一起学《区块链DApp入门实战》

要探索JDK的核心底层源码,那必须掌握native用法

要探索JDK的核心底层源码,那必须掌握native用法

跟我一起学extjs5(01--开发的总体说明)

aspnetcore6如何构建管道