首页 / NETCORE / net core天马行空系列：原生DI+AOP实现spring boot注解式编程

net core天马行空系列：原生DI+AOP实现spring boot注解式编程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了net core天马行空系列：原生DI+AOP实现spring boot注解式编程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12919字，纯文字阅读大概需要19分钟。

内容图文

原文:net core天马行空系列：原生DI+AOP实现spring boot注解式编程

写过spring boot之后，那种无处不在的注解让我非常喜欢，比如属性注入@autowire，配置值注入@value，声明式事物@Transactional等，都非常简洁优雅，那么我就在想，这些在net core里能实现么？经过一番摸索，终于实现并整理成此文。

IOC方面，个人非常喜欢net core自带的DI，因为他注册服务简洁优雅，3个生命周期通俗易懂，所以就没使用autofac等其他容器，AOP方面，使用了业内鼎鼎大名的Castle.DynamicProxy(简称DP),所以要在nuget中添加Castle.Core的依赖包，这里大家可能会有疑问，利用mvc的actionFilter不就可以实现了么，为什么还要引用DP呢，因为呀，actionFilter只在controller层有效，普通类他就无能为力了，而DP无所不能。

1.定义注解和需要用到的类

属性注入注解

  [AttributeUsage(AttributeTargets.Property)]
    publicclass AutowiredAttribute : Attribute
    {
    }

配置值注入注解

   [AttributeUsage(AttributeTargets.Property)]
    publicclass ValueAttribute : Attribute
    {
        public ValueAttribute(string value = "")
        {
            this.Value = value;
        }

        publicstring Value { get; }
    }

声明式事物注解

   [AttributeUsage(AttributeTargets.Method)]
    publicclass TransactionalAttribute : Attribute
    {
    }

工作单元接口及实现类，用来实现事物操作，注入级别为scope，一次请求公用一个工作单元实例

publicinterface IUnitOfWork : IDisposable
    {
        ///<summary>/// 开启事务
        ///</summary>void BeginTransaction();
        
        ///<summary>/// 提交
        ///</summary>void Commit();

        ///<summary>/// 事物回滚
        ///</summary>void RollBack();
    }

publicclass UnitOfWork : IUnitOfWork
    {
        publicvoid BeginTransaction()
        {
            Console.WriteLine("开启事务");
        }

        publicvoid Commit()
        {
            Console.WriteLine("提交事务");
        }

        publicvoid Dispose()
        {
            //throw new System.NotImplementedException();        }

        publicvoid RollBack()
        {
            Console.WriteLine("回滚事务");
        }
    }

拦截器

///<summary>/// 事物拦截器
    ///</summary>publicclass TransactionalInterceptor : StandardInterceptor
    {
        private IUnitOfWork Uow { set; get; }

        public TransactionalInterceptor(IUnitOfWork uow)
        {
            Uow = uow;
        }

        protectedoverridevoid PreProceed(IInvocation invocation)
        {
            Console.WriteLine("{0}拦截前", invocation.Method.Name);

            var method = invocation.TargetType.GetMethod(invocation.Method.Name);
            if (method != null && method.GetCustomAttribute<TransactionalAttribute>() != null)
            {
                Uow.BeginTransaction();
            }
        }

        protectedoverridevoid PerformProceed(IInvocation invocation)
        {
            invocation.Proceed();
        }

        protectedoverridevoid PostProceed(IInvocation invocation)
        {
            Console.WriteLine("{0}拦截后， 返回值是{1}", invocation.Method.Name, invocation.ReturnValue);

            var method = invocation.TargetType.GetMethod(invocation.Method.Name);
            if (method != null && method.GetCustomAttribute<TransactionalAttribute>() != null)
            {
                Uow.Commit();
            }
        }
    }

用来测试注入效果的接口以及实现类，这里我们定义一辆汽车，汽车拥有一个引擎（属性注入），它能点火启动，点火操作带事物，这里为了演示【接口-实现类】注入和【实现类】注入2种情况，引擎就没添加接口，只有实现类，并且AOP拦截仅有【实现类】的类时，只能拦截虚方法，所以Start和Stop函数为虚函数。

///<summary>/// 汽车引擎
    ///</summary>publicclass Engine
    {
        [Value("HelpNumber")]
        publicstring HelpNumber { set; get; }

        publicvirtualvoid Start()
        {
            Console.WriteLine("发动机启动");
            Stop();
        }

        publicvirtualvoid Stop()
        {
            Console.WriteLine("发动机熄火,拨打求救电话" + HelpNumber);
        }
    }

publicinterface ICar
    {
        Engine Engine { set; get; }

        void Fire();
    }

publicclass Car : ICar
    {
        [Autowired]
        public Engine Engine { set; get; }

        [Value("oilNo")]
        publicint OilNo { set; get; }

        [Transactional]
        publicvoid Fire()
        {
            Console.WriteLine("加满" + OilNo + "号汽油,点火");
            Engine.Start();
        }
    }

控制器HomeController

publicclass HomeController : Controller
    {
        [Autowired]
        public ICar Car{ set; get; }

        [Value("description")]
        publicstring Description { set; get; }

        public IActionResult Index()
        {
            var car = Car;

            Console.WriteLine(Description);

            Car.Fire();

            return View();
        }
    }

修改appsettings.json，添加一些测试键值对，（如果测试时发现输出的中文乱码，把appsettings.json保存为utf8格式即可），具体代码如下，

{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*",
  "oilNo": 95,
  "HelpNumber": "110",
  "description": "我要开始飙车了"
}

2.效果图

技术分享图片

从上图可以看到，正常注入，正常开启拦截器和事务，正确读取配置值。

技术分享图片

从上图可以看到，我们的控制器，ICar和Engine全部都是动态代理类，注入正常。

3.核心代码

第一部分，添加一个扩展类，名叫SummerBootExtentions.cs，代码如下

publicstaticclass SummerBootExtentions
    {
        ///<summary>/// 瞬时
        ///</summary>///<typeparam name="TService"></typeparam>///<typeparam name="TImplementation"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbTransient<TService, TImplementation>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), typeof(TImplementation), ServiceLifetime.Transient, interceptorTypes);
        }

        ///<summary>/// 请求级别
        ///</summary>///<typeparam name="TService"></typeparam>///<typeparam name="TImplementation"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbScoped<TService, TImplementation>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), typeof(TImplementation), ServiceLifetime.Scoped, interceptorTypes);
        }

        ///<summary>/// 单例
        ///</summary>///<typeparam name="TService"></typeparam>///<typeparam name="TImplementation"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbSingleton<TService, TImplementation>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), typeof(TImplementation), ServiceLifetime.Singleton, interceptorTypes);
        }

        publicstatic IServiceCollection AddSbService(this IServiceCollection services, Type serviceType, Type implementationType,
            ServiceLifetime lifetime, params Type[] interceptorTypes)
        {
            services.Add(new ServiceDescriptor(implementationType, implementationType, lifetime));

            object Factory(IServiceProvider provider)
            {
                var target = provider.GetService(implementationType);
                var properties = implementationType.GetTypeInfo().DeclaredProperties;

                foreach (PropertyInfo info in properties)
                {
                    //属性注入if (info.GetCustomAttribute<AutowiredAttribute>() != null)
                    {
                        var propertyType = info.PropertyType;
                        var impl = provider.GetService(propertyType);
                        if (impl != null)
                        {
                            info.SetValue(target, impl);
                        }
                    }

                    //配置值注入if (info.GetCustomAttribute<ValueAttribute>() is ValueAttribute valueAttribute)
                    {
                        var value = valueAttribute.Value;
                        if (provider.GetService(typeof(IConfiguration)) is IConfiguration configService)
                        {
                            var pathValue = configService.GetSection(value).Value;
                            if (pathValue != null)
                            {
                                var pathV = Convert.ChangeType(pathValue, info.PropertyType);
                                info.SetValue(target, pathV);
                            }
                        }

                    }
                }

                List<IInterceptor> interceptors = interceptorTypes.ToList()
                    .ConvertAll<IInterceptor>(interceptorType => provider.GetService(interceptorType) as IInterceptor);

                var proxy = new ProxyGenerator().CreateInterfaceProxyWithTarget(serviceType, target, interceptors.ToArray());

                return proxy;
            };

            var serviceDescriptor = new ServiceDescriptor(serviceType, Factory, lifetime);
            services.Add(serviceDescriptor);

            return services;
        }

        ///<summary>/// 瞬时
        ///</summary>///<typeparam name="TService"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbTransient<TService>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), ServiceLifetime.Transient, interceptorTypes);
        }

        ///<summary>/// 请求
        ///</summary>///<typeparam name="TService"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbScoped<TService>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), ServiceLifetime.Scoped, interceptorTypes);
        }

        ///<summary>/// 单例
        ///</summary>///<typeparam name="TService"></typeparam>///<param name="services"></param>///<param name="interceptorTypes"></param>///<returns></returns>publicstatic IServiceCollection AddSbSingleton<TService>(this IServiceCollection services, params Type[] interceptorTypes)
        {
            return services.AddSbService(typeof(TService), ServiceLifetime.Singleton, interceptorTypes);
        }

        publicstatic IServiceCollection AddSbService(this IServiceCollection services, Type serviceType,
            ServiceLifetime lifetime, params Type[] interceptorTypes)
        {
            if (services == null)
                thrownew ArgumentNullException(nameof(services));
            if (serviceType == (Type)null)
                thrownew ArgumentNullException(nameof(serviceType));

            object Factory(IServiceProvider provider)
            {
                List<IInterceptor> interceptors = interceptorTypes.ToList()
                    .ConvertAll<IInterceptor>(interceptorType => provider.GetService(interceptorType) as IInterceptor);


                var proxy = new ProxyGenerator().CreateClassProxy(serviceType, interceptors.ToArray());

                var properties = serviceType.GetTypeInfo().DeclaredProperties;

                foreach (PropertyInfo info in properties)
                {
                    //属性注入if (info.GetCustomAttribute<AutowiredAttribute>() != null)
                    {
                        var propertyType = info.PropertyType;
                        var impl = provider.GetService(propertyType);
                        if (impl != null)
                        {
                            info.SetValue(proxy, impl);
                        }
                    }

                    //配置值注入if (info.GetCustomAttribute<ValueAttribute>() is ValueAttribute valueAttribute)
                    {
                        var value = valueAttribute.Value;
                        if (provider.GetService(typeof(IConfiguration)) is IConfiguration configService)
                        {
                            var pathValue = configService.GetSection(value).Value;
                            if (pathValue != null)
                            {
                                var pathV = Convert.ChangeType(pathValue, info.PropertyType);
                                info.SetValue(proxy, pathV);
                            }
                        }
                    }
                }

                return proxy;
            };

            var serviceDescriptor = new ServiceDescriptor(serviceType, Factory, lifetime);
            services.Add(serviceDescriptor);

            return services;
        }

        ///<summary>/// 添加summer boot扩展
        ///</summary>///<param name="builder"></param>///<returns></returns>publicstatic IMvcBuilder AddSB(this IMvcBuilder builder)
        {
            if (builder == null)
                thrownew ArgumentNullException(nameof(builder));
            ControllerFeature feature = new ControllerFeature();
            builder.PartManager.PopulateFeature<ControllerFeature>(feature);
            foreach (Type type in feature.Controllers.Select<TypeInfo, Type>((Func<TypeInfo, Type>)(c => c.AsType())))
                builder.Services.TryAddTransient(type, type);
            builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, SbControllerActivator>());

            return builder;
        }
    }

View Code

第二部分，添加一个自定义控制器激活类，用以替换掉mvc自带的激活类，这个类命名为SbControllerActivator.cs，代码如下

publicclass SbControllerActivator : IControllerActivator
    {
        ///<inheritdoc />publicobject Create(ControllerContext actionContext)
        {
            if (actionContext == null)
                thrownew ArgumentNullException(nameof(actionContext));

            Type serviceType = actionContext.ActionDescriptor.ControllerTypeInfo.AsType();

            var target = actionContext.HttpContext.RequestServices.GetRequiredService(serviceType);

            var properties = serviceType.GetTypeInfo().DeclaredProperties;
            var proxy = new ProxyGenerator().CreateClassProxyWithTarget(serviceType, target);

            foreach (PropertyInfo info in properties)
            {
                //属性注入if (info.GetCustomAttribute<AutowiredAttribute>() != null)
                {
                    var propertyType = info.PropertyType;
                    var impl = actionContext.HttpContext.RequestServices.GetService(propertyType);
                    if (impl != null)
                    {
                        info.SetValue(proxy, impl);
                    }
                }

                //配置值注入if (info.GetCustomAttribute<ValueAttribute>() is ValueAttribute valueAttribute)
                {
                    var value = valueAttribute.Value;
                    if (actionContext.HttpContext.RequestServices.GetService(typeof(IConfiguration)) is IConfiguration configService)
                    {
                        var pathValue = configService.GetSection(value).Value;
                        if (pathValue != null)
                        {
                            var pathV = Convert.ChangeType(pathValue, info.PropertyType);
                            info.SetValue(proxy, pathV);
                        }
                    }

                }
            }

            return proxy;
        }

        ///<inheritdoc />publicvirtualvoid Release(ControllerContext context, object controller)
        {
        }
    }

View Code

第三部分，在Startup.cs中，修改ConfigureServices方法如下

publicvoid ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            
            services.AddMvc()
                .SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
                .AddSB();

            services.AddSbScoped<Engine>(typeof(TransactionalInterceptor));
            
            services.AddScoped<IUnitOfWork,UnitOfWork>();
            services.AddScoped(typeof(TransactionalInterceptor));

            services.AddSbScoped<ICar, Car>(typeof(TransactionalInterceptor));

        }

从上面代码我们可以看到，在addMvc后加上了我们替换默认控制器的AddSB方法，接管了控制器的生成。AddSbScoped<Engine>和AddSbScoped<ICar, Car>这种添加依赖注入的方式也保持了net core自带DI的原滋原味，简洁优雅，并且实现了动态代理，只需要在参数里添加拦截器，就能实时拦截，这里参数为params Type[],可以添加N个拦截器。

4.写在最后

在博客园潜水了好几年，见证了net core从1.0到快出3.0，这也是第一次尝试着写博客，为net core的发扬光大尽自己的一份力。

原文：https://www.cnblogs.com/lonelyxmas/p/12766602.html

内容总结

以上是互联网集市为您收集整理的net core天马行空系列：原生DI+AOP实现spring boot注解式编程全部内容，希望文章能够帮你解决net core天马行空系列：原生DI+AOP实现spring boot注解式编程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1122990.html

来源：【匿名】

【上一篇】.Net Core定时调度hangfire：仪表板UI 【下一篇】.NET Core 中的并发编程

更多 ►

【net core天马行空系列：原生DI+AOP实现spring boot注解式编程】教程文章相关的互联网学习教程文章

.net core 3.1 过滤器(Filter) 和AOP面向切面拦截器【代码】【图】

Filter总共有五种，Authorization Filter，Resource Filter，Exception Filter，Action Filter，Result FilterException Filter 设置新增全局异常过滤器GlobalExceptionFilter.cs，当出现异常时进入此方法，可在这针对不同的异常做相关处理并返回指定数据，避免直接把错误暴露给用户 publicclass GlobalExceptionFilter : IExceptionFilter {publicvoid OnException(ExceptionContext context){Exception ex = context.Exception;s...

ASP.NET Core 整合Autofac和Castle实现自动AOP拦截【代码】

原文:ASP.NET Core 整合Autofac和Castle实现自动AOP拦截前言：除了ASP.NETCore自带的IOC容器外，我们还可以使用其他成熟的DI框架，如Autofac，StructureMap等（笔者只用过Unity，Ninject和Castle）。1.ASP.NET Core中的Autofac首先在Project.json的Dependency节点为中添加如下引用： "Microsoft.Extensions.DependencyInjection": "1.0.0","Autofac": "4.1.1","Autofac.Extensions.DependencyInjection": "4.0.0",接着我们也修改St...

asp.net core 不依赖autofac实现aop

https://www.cnblogs.com/youring2/p/10962573.htmlhttps://www.cnblogs.com/youring2/p/11253116.html原文：https://www.cnblogs.com/baiqian/p/13061583.html

Dora.Interception，为.NET Core度身打造的AOP框架 [1]：更加简练的编程体验【代码】【图】

很久之前开发了一个名为Dora.Interception的开源AOP框架（github地址：https://github.com/jiangjinnan/Dora，如果你觉得这个这框架还有那么一点价值，请不吝多点一颗星）,最近对它作了一些改进（包括编程模式和性能，目前最新版本2.1.4）。一直以来我对软件设计秉承的一个理念就是：好的设计应该是简单的设计。和其他AOP框架相比，虽然Dora.Interception提供的编程模式已经显得足够简单，但是我觉得还应该再简单点，再简单点。这个...

Asp.net Core 3.1基于AspectCore实现AOP，实现事务、缓存拦截器【代码】【图】

最近想给我的框架加一种功能，就是比如给一个方法加一个事务的特性Attribute，那这个方法就会启用事务处理。给一个方法加一个缓存特性，那这个方法就会进行缓存。这个也是网上说的面向切面编程AOP。 AOP的概念也很好理解，跟中间件差不多，说白了，就是我可以任意地在方法的前面或后面添加代码，这很适合用于缓存、日志等处理。在net core2.2时，我当时就尝试过用autofac实现aop，但这次我不想用autofac，我用了一个更轻量级的...

ASP.NET Core搭建多层网站架构【6.1-使用AOP动态拦截器进行服务层日志记录】

2020/01/26, ASP.NET Core 3.1, VS2019 摘要：基于ASP.NET Core 3.1 WebApi搭建后端多层网站架构【6.1-使用AOP动态拦截器进行服务层日志记录】文章目录此分支项目代码本章节介绍了本项目的分层结构，建立了各层级的类库，修改网站项目的启动配置

.net core系列之《对AOP思想的理解及使用AspectCore实现自定义日志拦截》【代码】【图】

对于AOP这个名词，相信对于搞过MVC开发的人来说，都很熟悉，里面各种各样的Filter简直是将AOP体现到了极致。那么什么是AOP呢？ AOP（Aspect Oriented Programming，面向切面编程），它是可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。OOP是关注将需求功能划分为不同的并且相对独立，封装良好的类，并让它们有着属于自己的行...

.NET Core类库System.Reflection.DispatchProxy实现简易Aop的方法

前言 aop即是面向切面编程，众多Aop框架里Castle是最为人所知的，另外还有死去的Spring.NET，当然，.NET Core社区新秀AspectCore在性能与功能上都非常优秀，已经逐渐被社区推崇和有越来越多的人使用。感谢柠檬同学的礼物！如果大家出于自身需求或者学习，想实现一个Aop，是不是觉得一来就要使用Emit去做？最近我了解到了System.Reflection.DispatchProxy这个corefx类库，已经实现了动态代理功能。 1|1System.Reflection.DispatchP...

Asp.Net Core轻量级Aop解决方案：AspectCore

什么是AspectCore Project ? AspectCore Project 是适用于Asp.Net Core 平台的轻量级 Aop(Aspect-oriented programming) 解决方案，它更好的遵循Asp.Net Core的模块化开发理念，使用AspectCore可以更容易构建低耦合、易扩展的Web应用程序。AspectCore使用Emit实现高效的动态代理从而不依赖任何第三方Aop库。开使使用AspectCore 启动 Visual Studio。从 File 菜单, 选择 New > Project。选择 ASP.NET Core Web Application 项目模版...

ASP.Net Core 5.0 MVC中AOP思想的体现(五种过滤器)并结合项目案例说明过滤器的用法【代码】【图】

执行顺序使用方法，首先实现各自的接口，override里面的方法，然后在startup 类的 ConfigureServices 方法，注册它们。 services.AddTransient(typeof(MyAction));services.AddTransient(typeof(MyResult));services.AddTransient(typeof(MyException));services.AddTransient(typeof(MyAuthorize));services.AddTransient(typeof(MyResource));services.AddTransient(typeof(CheckLogin)); 下面我将代码贴出来，照...

Asp.netCore 3.1控制器属性注入and异步事务Aop by AutoFac【代码】

Aspect Oriented Programming（AOP）是较为热门的一个话题。AOP，国内我们都习惯称之为：面向切面编程下面直接code 干货展示：(一般人我还不告诉,嘻嘻) 1:导入相关的包：AutoFac 默认最新稳定版即可Autofac.Extensions.DependencyInjection Version="7.1.0" Autofac.Extras.DynamicProxy Version="6.0.0" 2：AutoFac注入的扩展方法 1 using System;2 using System.Linq;3 namespace ZRF.CRM.Commoms4 {5 using Autofac;6 ...

[译]如何在ASP.NET Core中实现面向切面编程(AOP)【代码】【图】

原文地址：ASPECT ORIENTED PROGRAMMING USING PROXIES IN ASP.NET CORE 原文作者：ZANID HAYTAM 译文地址：如何在ASP.NET Core中实现面向切面编程(AOP) 译文作者：Lamond Lu前言在使用了Spring Boot数月之后, 　我发觉ASP.NET Core中缺失了对面向切面编程(AOP)的默认支持。维基百科中针对AOP的定义：面向切面编程(AOP)是一种编程范例，其旨在通过允许跨领域关注点的分离来提高模块化。它通过“切入点”规范指定要修改的代码，不...

Dora.Interception，为.NET Core度身打造的AOP框架 [1]：更加简练的编程体验【代码】

AOP - 相关标签

aop原理

NETCORE - 最热教程

ASP.NET Core MVC 中实现中英文切换 ASP.NET Core WebAPI实现本地化（单资源...彻底解决Asp.netCore WebApi 3.1 跨域时...C#.NET Core 2.1跨度和内存性能注意事项 ASP.NET Core 搭配 Nginx 的真实IP问题 asp.net core API 如何接收参数【翻译】- ASP.NET Core 中的内存管理和...c# – ASP.NET核心 – 自定义AspNetCor...详解.Net Core 权限验证与授权（Author...在.NET Core控制台程序中如何使用依赖注...

首页 / NETCORE / net core天马行空系列：原生DI+AOP实现spring boot注解式编程

net core天马行空系列：原生DI+AOP实现spring boot注解式编程

内容导读

内容图文

1.定义注解和需要用到的类

2.效果图

3.核心代码

4.写在最后

内容总结

内容备注

内容手机端

【net core天马行空系列：原生DI+AOP实现spring boot注解式编程】教程文章相关的互联网学习教程文章

AOP - 相关标签

NETCORE - 最新教程

NETCORE - 最热教程