ASP.NET Core MVC 项目 Autofac 支持 AOP

最新推荐文章于 2024-08-18 08:43:02 发布
最新推荐文章于 2024-08-18 08:43:02 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： NET 文章标签： asp.net .netcore mvc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Fei/article/details/129503322
版权

目录

一：Autofac支持AOP

二：Autofac支持AOP的多种方式

一：类扩展

二：接口扩展

三：类扩展和接口扩展的区别

三：Autofac支持AOP扩展日志记录功能

四：Autofac支持AOP扩展缓存功能

五：Autofac支持AOP扩展IInterceptorSelector

一：Autofac支持AOP

当前项目右键管理Nuget包引入：Castle.core

扩展CusotmInterceptor类

using Castle.DynamicProxy;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class CusotmInterceptor : IInterceptor
    {
        /// <summary>
        /// 切入者逻辑
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            //方法之前的逻辑
            Console.WriteLine("Begore");
            //执行真实的方法
            invocation.Proceed();
            //方法之后的逻辑
            Console.WriteLine("After");
        }
    }
}

修改关键类ApplePhone

using Autofac.Extras.DynamicProxy;
using Study_ASP.NET_Core_MVC.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.Net_Core_MVC.Services
{
    /// <summary>
    /// 标识特性支持AOP
    /// </summary>
    [Intercept(typeof(CusotmInterceptor))]
    public class ApplePhone : IPhone
    {
        public IMicroPhone MicroPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public IHeadPhone HeadPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public ApplePhone()
        {
            Console.WriteLine("{0}无参构造函数", this.GetType().Name);
        }
        public ApplePhone(IHeadPhone headPhone)
        {
            Console.WriteLine("{0}有参构造函数：{1}", this.GetType().Name,headPhone);
        }

        /// <summary>
        /// 虚方法
        /// 打电话方法
        /// </summary>
        public virtual void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name);
        }
        /// <summary>
        /// 发短信方法
        /// </summary>
        public void Text()
        {
            Console.WriteLine("{0}发短信", this.GetType().Name);
        }
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        public string ShowTime(string timeInfo)
        {
            Console.WriteLine("显示时间：{0}", timeInfo);
            return $"当前时间：{timeInfo}";
        }
    }
}

修改Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableClassInterceptors();
    //注册切入逻辑
    containerBuilder.RegisterType<CusotmInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改控制器文件

using Autofac;
using Microsoft.AspNetCore.Mvc;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;
using System.Diagnostics;

namespace Study_ASP.NET_Core_MVC.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<HomeController> _logger;
        private IPhone iPhone;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger">控制器构造函数</param>
        /// <param name="serviceProvider">服务构造函数</param>
        /// <param name="componentContext">上下文构造函数</param>
        /// <param name="iPhone">自定义构造函数</param>
        public HomeController(ILogger<HomeController> logger, IServiceProvider serviceProvider, IComponentContext componentContext, IPhone iPhone)
        {
            //通过调试查看获取的数据
            _logger = logger;
            this.iPhone = iPhone;
        }
        /// <summary>
        /// Get请求
        /// Home控制器
        /// Index方法
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index()
        {
            //调用发短信方法
            iPhone.Text();
            //调用打电话方法
            iPhone.Call();
            //电泳显示实践方法
            ViewBag.ShowTime = iPhone.ShowTime(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
            return View();
        }
    }
}

二：Autofac支持AOP的多种方式

一：类扩展

扩展CusotmInterceptor类

using Castle.DynamicProxy;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class CusotmInterceptor : IInterceptor
    {
        /// <summary>
        /// 切入者逻辑
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            //方法之前的逻辑
            Console.WriteLine("Begore");
            //执行真实的方法
            invocation.Proceed();
            //方法之后的逻辑
            Console.WriteLine("After");
        }
    }
}

修改关键类ApplePhone

using Autofac.Extras.DynamicProxy;
using Study_ASP.NET_Core_MVC.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.Net_Core_MVC.Services
{
    /// <summary>
    /// 标识特性支持AOP
    /// </summary>
    [Intercept(typeof(CusotmInterceptor))]
    public class ApplePhone : IPhone
    {
        public IMicroPhone MicroPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public IHeadPhone HeadPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public ApplePhone()
        {
            Console.WriteLine("{0}无参构造函数", this.GetType().Name);
        }
        public ApplePhone(IHeadPhone headPhone)
        {
            Console.WriteLine("{0}有参构造函数：{1}", this.GetType().Name,headPhone);
        }

        /// <summary>
        /// 虚方法
        /// 打电话方法
        /// </summary>
        public virtual void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name);
        }
        /// <summary>
        /// 发短信方法
        /// </summary>
        public void Text()
        {
            Console.WriteLine("{0}发短信", this.GetType().Name);
        }
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        public string ShowTime(string timeInfo)
        {
            Console.WriteLine("显示时间：{0}", timeInfo);
            return $"当前时间：{timeInfo}";
        }
    }
}

修改Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展--类扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableClassInterceptors();
    //注册切入逻辑
    containerBuilder.RegisterType<CusotmInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改控制器文件

using Autofac;
using Microsoft.AspNetCore.Mvc;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;
using System.Diagnostics;

namespace Study_ASP.NET_Core_MVC.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<HomeController> _logger;
        private IPhone iPhone;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger">控制器构造函数</param>
        /// <param name="serviceProvider">服务构造函数</param>
        /// <param name="componentContext">上下文构造函数</param>
        /// <param name="iPhone">自定义构造函数</param>
        public HomeController(ILogger<HomeController> logger, IServiceProvider serviceProvider, IComponentContext componentContext, IPhone iPhone)
        {
            //通过调试查看获取的数据
            _logger = logger;
            this.iPhone = iPhone;
        }
        /// <summary>
        /// Get请求
        /// Home控制器
        /// Index方法
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index()
        {
            //调用发短信方法
            iPhone.Text();
            //调用打电话方法
            iPhone.Call();
            //显示时间方法
            ViewBag.ShowTime = iPhone.ShowTime(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
            return View();
        }
    }
}

二：接口扩展

扩展CusotmInterceptor类

using Castle.DynamicProxy;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class CusotmInterceptor : IInterceptor
    {
        /// <summary>
        /// 切入者逻辑
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            //方法之前的逻辑
            Console.WriteLine("Begore");
            //执行真实的方法
            invocation.Proceed();
            //方法之后的逻辑
            Console.WriteLine("After");
        }
    }
}

修改关键类IPhone

using Autofac.Extras.DynamicProxy;
using DocumentFormat.OpenXml.Drawing.Charts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    /// <summary>
    /// 标识特性支持AOP
    /// </summary>
    [Intercept(typeof(CusotmInterceptor))]
    public interface IPhone
    {
        IMicroPhone MicroPhone { get; set; }
        IHeadPhone HeadPhone { get; set; }
        /// <summary>
        /// 打电话方法
        /// </summary>
        void Call();
        /// <summary>
        /// 发短信方法
        /// </summary>
        void Text();
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        string ShowTime(string timeInfo);
    }
    public interface IMicroPhone { }
    public interface IHeadPhone { }
}

修改Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展--接口扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableInterfaceInterceptors();
    //注册切入逻辑
    containerBuilder.RegisterType<CusotmInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改控制器文件

using Autofac;
using Microsoft.AspNetCore.Mvc;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;
using System.Diagnostics;

namespace Study_ASP.NET_Core_MVC.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<HomeController> _logger;
        private IPhone iPhone;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger">控制器构造函数</param>
        /// <param name="serviceProvider">服务构造函数</param>
        /// <param name="componentContext">上下文构造函数</param>
        /// <param name="iPhone">自定义构造函数</param>
        public HomeController(ILogger<HomeController> logger, IServiceProvider serviceProvider, IComponentContext componentContext, IPhone iPhone)
        {
            //通过调试查看获取的数据
            _logger = logger;
            this.iPhone = iPhone;
        }
        /// <summary>
        /// Get请求
        /// Home控制器
        /// Index方法
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index()
        {
            //调用发短信方法
            iPhone.Text();
            //调用打电话方法
            iPhone.Call();
            //电泳显示实践方法
            ViewBag.ShowTime = iPhone.ShowTime(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
            return View();
        }
    }
}

三：类扩展和接口扩展的区别

通过EnableClassInterceptors类扩展时：

  1. 需要将Intercept标记到具体类上
  2. 只有在这个具体类上，标记了虚方法，虚方法才可以进入到IInterceptor中，来支持AOP扩展。

通过EnableInterfaceInterceptors接口扩展时：

  1. 需要将Intercept标记到抽象类上
  2. 只要是实现了这个接口，无论是否是虚方法，都可以进入到IInterceptor中，来支持AOP扩展。

三：Autofac支持AOP扩展日志记录功能

当前项目右键管理Nuget包引入：Microsoft.Extensions.Logging.Abstractions、Newtonsoft.Json

扩展CusotmLogInterceptor类

using Castle.Core.Logging;
using Castle.DynamicProxy;
using System;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    public class CusotmLogInterceptor : IInterceptor
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<CusotmLogInterceptor> _ILogger;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger"></param>
        public CusotmLogInterceptor(ILogger<CusotmLogInterceptor> logger)
        {
            this._ILogger = logger;
        }
        /// <summary>
        /// 切入者逻辑
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            //方法之前的逻辑
            Console.WriteLine("Begore");
            _ILogger.LogInformation($"参数:{Newtonsoft.Json.JsonConvert.SerializeObject(invocation.Arguments)}");
            _ILogger.LogInformation($"方法{invocation.Method.Name} 开始执行");
            //执行真实的方法
            invocation.Proceed();
            _ILogger.LogInformation($"方法{invocation.Method.Name} 执行完毕");
            //方法之后的逻辑
            Console.WriteLine("After");
            _ILogger.LogInformation($"结果:{Newtonsoft.Json.JsonConvert.SerializeObject(invocation.ReturnValue)}");
        }
    }
}

修改关键类IPhone

using Autofac.Extras.DynamicProxy;
using DocumentFormat.OpenXml.Drawing.Charts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    /// <summary>
    /// 标识特性支持AOP
    /// </summary>
    [Intercept(typeof(CusotmInterceptor))]
    [Intercept(typeof(CusotmLogInterceptor))]
    public interface IPhone
    {
        IMicroPhone MicroPhone { get; set; }
        IHeadPhone HeadPhone { get; set; }
        /// <summary>
        /// 打电话方法
        /// </summary>
        void Call();
        /// <summary>
        /// 发短信方法
        /// </summary>
        void Text();
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        object PlayGame(object play);
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        string ShowTime(string timeInfo);
    }
    public interface IMicroPhone { }
    public interface IHeadPhone { }
}

修改关键类ApplePhone

using Autofac.Extras.DynamicProxy;
using Study_ASP.NET_Core_MVC.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class ApplePhone : IPhone
    {
        public IMicroPhone MicroPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public IHeadPhone HeadPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public ApplePhone()
        {
            Console.WriteLine("{0}无参构造函数", this.GetType().Name);
        }
        public ApplePhone(IHeadPhone headPhone)
        {
            Console.WriteLine("{0}有参构造函数：{1}", this.GetType().Name,headPhone);
        }

        /// <summary>
        /// 虚方法
        /// 打电话方法
        /// </summary>
        public virtual void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name);
        }
        /// <summary>
        /// 发短信方法
        /// </summary>
        public void Text()
        {
            Console.WriteLine("{0}发短信", this.GetType().Name);
        }
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        public object PlayGame(object play)
        {
            return new
            {
                Id = 123,
                Name = "VinCente"
            };
        }
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        public string ShowTime(string timeInfo)
        {
            Console.WriteLine("显示时间：{0}", timeInfo);
            return $"当前时间：{timeInfo}";
        }
    }
}

修改Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展--接口扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableInterfaceInterceptors();
    //注册切入逻辑
    containerBuilder.RegisterType<CusotmInterceptor>();
    containerBuilder.RegisterType<CusotmLogInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改控制器文件

using Autofac;
using Microsoft.AspNetCore.Mvc;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;
using System.Diagnostics;

namespace Study_ASP.NET_Core_MVC.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<HomeController> _logger;
        private IPhone iPhone;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger">控制器构造函数</param>
        /// <param name="serviceProvider">服务构造函数</param>
        /// <param name="componentContext">上下文构造函数</param>
        /// <param name="iPhone">自定义构造函数</param>
        public HomeController(ILogger<HomeController> logger, IServiceProvider serviceProvider, IComponentContext componentContext, IPhone iPhone)
        {
            //通过调试查看获取的数据
            _logger = logger;
            this.iPhone = iPhone;
        }
        /// <summary>
        /// Get请求
        /// Home控制器
        /// Index方法
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index()
        {
            //调用发短信方法
            iPhone.Text();
            //调用打电话方法
            iPhone.Call();
            //调用玩游戏方法
            object oInstance = iPhone.PlayGame(new { playId = 123, playName = "我要玩游戏" });
            //电泳显示实践方法
            ViewBag.ShowTime = iPhone.ShowTime(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
            return View();
        }
    }
}

结果截图

四：Autofac支持AOP扩展缓存功能

扩展CusotmCacheInterceptor类：

using Castle.DynamicProxy;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    public class CusotmCacheInterceptor : IInterceptor
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<CusotmCacheInterceptor> _ILogger;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger"></param>
        public CusotmCacheInterceptor(ILogger<CusotmCacheInterceptor> logger)
        {
            this._ILogger = logger;
        }
        //定义字典
        private static Dictionary<string, object> _cacheDictionary = new Dictionary<string, object>();
        /// <summary>
        /// 切入者逻辑
        /// </summary>
        /// <param name="invocation"></param>
        public void Intercept(IInvocation invocation)
        {
            //方法之前检查缓存的结果
            //定义Key
            string cacheKey = invocation.Method.Name;
            //判断当前是否有缓存结果
            if (_cacheDictionary.ContainsKey(cacheKey))
            {
                invocation.ReturnValue = _cacheDictionary[cacheKey];
            }
            else
            {
                //执行真实的方法
                invocation.Proceed();
                //方法之后保存缓存的结果
                _cacheDictionary[cacheKey] = invocation.ReturnValue;
            }
        }
    }
}

修改关键类IPhone

using Autofac.Extras.DynamicProxy;
using DocumentFormat.OpenXml.Drawing.Charts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    /// <summary>
    /// 标识特性支持AOP
    /// </summary>
    [Intercept(typeof(CusotmCacheInterceptor))]
    public interface IPhone
    {
        IMicroPhone MicroPhone { get; set; }
        IHeadPhone HeadPhone { get; set; }
        /// <summary>
        /// 打电话方法
        /// </summary>
        void Call();
        /// <summary>
        /// 发短信方法
        /// </summary>
        void Text();
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        object PlayGame(object play);
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        string ShowTime(string timeInfo);
    }
    public interface IMicroPhone { }
    public interface IHeadPhone { }
}

修改关键类ApplePhone

using Autofac.Extras.DynamicProxy;
using Study_ASP.NET_Core_MVC.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class ApplePhone : IPhone
    {
        public IMicroPhone MicroPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public IHeadPhone HeadPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public ApplePhone()
        {
            Console.WriteLine("{0}无参构造函数", this.GetType().Name);
        }
        public ApplePhone(IHeadPhone headPhone)
        {
            Console.WriteLine("{0}有参构造函数：{1}", this.GetType().Name,headPhone);
        }

        /// <summary>
        /// 虚方法
        /// 打电话方法
        /// </summary>
        public virtual void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name);
        }
        /// <summary>
        /// 发短信方法
        /// </summary>
        public void Text()
        {
            Console.WriteLine("{0}发短信", this.GetType().Name);
        }
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        public object PlayGame(object play)
        {
            return new
            {
                Id = 123,
                Name = "VinCente",
                DateTime = DateTime.Now
            };
        }
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        public string ShowTime(string timeInfo)
        {
            Console.WriteLine("显示时间：{0}", timeInfo);
            return $"当前时间：{timeInfo}";
        }
    }
}

修改Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展--接口扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableInterfaceInterceptors();
    //注册切入逻辑
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmInterceptor>();
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmLogInterceptor>();
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmCacheInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改控制器文件

using Autofac;
using Microsoft.AspNetCore.Mvc;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;
using System.Diagnostics;

namespace Study_ASP.NET_Core_MVC.Controllers
{
    public class HomeController : Controller
    {
        /// <summary>
        /// 定义构造函数
        /// </summary>
        private readonly ILogger<HomeController> _logger;
        private IPhone iPhone;
        /// <summary>
        /// 初始化构造函数
        /// </summary>
        /// <param name="logger">控制器构造函数</param>
        /// <param name="serviceProvider">服务构造函数</param>
        /// <param name="componentContext">上下文构造函数</param>
        /// <param name="iPhone">自定义构造函数</param>
        public HomeController(ILogger<HomeController> logger, IServiceProvider serviceProvider, IComponentContext componentContext, IPhone iPhone)
        {
            //通过调试查看获取的数据
            _logger = logger;
            this.iPhone = iPhone;
        }
        /// <summary>
        /// Get请求
        /// Home控制器
        /// Index方法
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public IActionResult Index()
        {
            //调用发短信方法
            iPhone.Text();
            //调用打电话方法
            iPhone.Call();
            //调用玩游戏方法
            object oInstance = iPhone.PlayGame(new { playId = 123, playName = "我要玩游戏" });
            //显示时间方法
            ViewBag.ShowTime = iPhone.ShowTime(DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
            return View();
        }
    }
}

结果截图

 

五：Autofac支持AOP扩展IInterceptorSelector

以上扩展方法需要在方法上标注特性。扩展使用IInterceptorSelector时，只需要在Program中注册服务扩展接口时注册，无需在方法上标注特性。

扩展CusotmInterceptorSelector类

using Castle.DynamicProxy;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    public class CusotmInterceptorSelector : IInterceptorSelector
    {
        /// <summary>
        /// 让我们选择使用那个IInterceptor
        /// </summary>
        /// <param name="type"></param>
        /// <param name="method"></param>
        /// <param name="interceptors"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
        {
            return new IInterceptor[]
            {
                new CusotmInterceptor(),
                new CusotmCacheInterceptor()
            };
        }
    }
}

修改关键类Program.cs文件

using Autofac;
using Autofac.Extensions.DependencyInjection;
using Autofac.Extras.DynamicProxy;
using Castle.DynamicProxy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Study_ASP.Net_Core_MVC.Services;
using Study_ASP.NET_Core_MVC.Interfaces;
using Study_ASP.NET_Core_MVC.Models;

//表示整个应用程序，调用CreateBuilder方法创建一个WebApplicationBuilder对象。
var builder = WebApplication.CreateBuilder(args);
//向管道容器添加注册中间件
//添加注册控制器视图中间件
builder.Services.AddControllersWithViews();
//添加注册Session中间件
builder.Services.AddSession();

//添加注册Autofac中间件
//通过工厂替换整合Autofac
builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());
builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
{
    //注册服务
    containerBuilder.RegisterType<MicroPhone>().As<IMicroPhone>();
    containerBuilder.RegisterType<HeadPhone>().As<IHeadPhone>();
    //支持AAOP扩展--接口扩展
    containerBuilder.RegisterType<ApplePhone>().As<IPhone>().EnableInterfaceInterceptors(new ProxyGenerationOptions()
    {
        Selector= new CusotmInterceptorSelector()
    });
    //注册切入逻辑
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmInterceptor>();
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmLogInterceptor>();
    containerBuilder.RegisterType<Study_ASP.NET_Core_MVC.Interfaces.CusotmCacheInterceptor>();
    //注册控制器和抽象关系
    var controllerBaseType = typeof(ControllerBase);
    //支持属性注入到ControllerBase中
    containerBuilder.RegisterAssemblyTypes(typeof(Program).Assembly).Where(t => controllerBaseType.IsAssignableFrom(t) && t != controllerBaseType).PropertiesAutowired(new CusotmPropertySelector());
});
//添加注册控制器属性注入
builder.Services.Replace(ServiceDescriptor.Transient<IControllerActivator, ServiceBasedControllerActivator>());

//配置管道容器中间件，构造WebApplication实例
var app = builder.Build();
//判断是否是开发模式
if (!app.Environment.IsDevelopment())
{
    //向管道中添加中间件，该中间件将捕获异常、记录异常、重置请求路径并重新执行请求。
    app.UseExceptionHandler("/Shared/Error");
    //向管道中添加用于使用HSTS的中间件，该中间件添加了Strict Transport Security标头。默认值为30天
    app.UseHsts();
}
//向管道添加Session中间件
app.UseSession();
//向管道添加用于将HTTP请求重定向到HTTPS的中间件。
app.UseHttpsRedirection();
//向管道添加为当前请求路径启用静态文件服务
app.UseStaticFiles();
//向管道添加路由配置中间件
app.UseRouting();
//向管道添加鉴权中间件
app.UseAuthentication();
//向管道添加授权中间件
app.UseAuthorization();
//向管道添加默认路由中间件
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
//向管道添加启动应用程序中间件
app.Run();

修改关键类IPhone

using Autofac.Extras.DynamicProxy;
using DocumentFormat.OpenXml.Drawing.Charts;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.NET_Core_MVC.Interfaces
{
    public interface IPhone
    {
        IMicroPhone MicroPhone { get; set; }
        IHeadPhone HeadPhone { get; set; }
        /// <summary>
        /// 打电话方法
        /// </summary>
        void Call();
        /// <summary>
        /// 发短信方法
        /// </summary>
        void Text();
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        object PlayGame(object play);
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        string ShowTime(string timeInfo);
    }
    public interface IMicroPhone { }
    public interface IHeadPhone { }
}

修改关键类ApplePhone

using Autofac.Extras.DynamicProxy;
using Study_ASP.NET_Core_MVC.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study_ASP.Net_Core_MVC.Services
{
    public class ApplePhone : IPhone
    {
        public IMicroPhone MicroPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public IHeadPhone HeadPhone { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public ApplePhone()
        {
            Console.WriteLine("{0}无参构造函数", this.GetType().Name);
        }
        public ApplePhone(IHeadPhone headPhone)
        {
            Console.WriteLine("{0}有参构造函数：{1}", this.GetType().Name,headPhone);
        }

        /// <summary>
        /// 虚方法
        /// 打电话方法
        /// </summary>
        public virtual void Call()
        {
            Console.WriteLine("{0}打电话", this.GetType().Name);
        }
        /// <summary>
        /// 发短信方法
        /// </summary>
        public void Text()
        {
            Console.WriteLine("{0}发短信", this.GetType().Name);
        }
        /// <summary>
        /// 玩游戏方法
        /// </summary>
        /// <param name="play"></param>
        /// <returns></returns>
        public object PlayGame(object play)
        {
            return new
            {
                Id = 123,
                Name = "VinCente",
                DateTime = DateTime.Now
            };
        }
        /// <summary>
        /// 显示当前时间信息
        /// </summary>
        /// <param name="msgInfo">时间信息</param>
        /// <returns></returns>
        public string ShowTime(string timeInfo)
        {
            Console.WriteLine("显示时间：{0}", timeInfo);
            return $"当前时间：{timeInfo}";
        }
    }
}

结果截图

[Asp.Net Core]Autofac抽象支持AOP
德仔
12-02 425
AOP面向切面编程；不用修改之前代码的基础上，可以动态的在某个动作之前加一些操作，动态在在某一个动作之后做点什么事儿 1.Nuget引入Castle.Core程序集+Autofac.Extras.DynamicProxy程序集 2.定注意切入者：如下，需要继承IInterceptor，实现方法 namespace DeZai.Net5Demo.Common.AutofacExtension { public class CustomAutofacAop : IInterceptor
asp.net core3.1 实战开发（autofact的使用替换框架的IOC实现AOP）
热门推荐
一点一滴
01-05 3万+
原有core 3.1内置了ioc容器和DI注入，有个缺点就算不能够实现AOP，所以使用第三方autofact来代替原有的容器 一：原有core 3.1的容器使用方法 配置服务 public void ConfigureServices(IServiceCollection services) { services.AddSession(); services.AddContro...
Spring对AOP的支持
weixin_34356310的博客
07-03 98
 Spring对AOP的支持 4.1 AOP介绍 首先让我们从一些重要的AOP概念和术语开始。这些术语不是Spring特有的。不过AOP术语并不是特别的直观，如果Spring使用自己的术语，将会变得更加令人困惑。 ·         切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面...
ASP.NET Core入门——使用Autofac实现DI与AOP
最新发布
dotNET跨平台
08-18 115
在ASP.NET Core应用程序中，依赖注入（DI）和面向切面编程（AOP）是构建模块化、可维护和可扩展应用程序的关键技术。Autofac是一个流行的.NET依赖注入容器，它不仅支持依赖注入，还提供了AOP的支持，通过拦截器（Interceptors）实现横切关注点（Cross-Cutting Concerns）的处理。本文将详细介绍如何在ASP.NET Core项目中使用Autofac来实现依...
Spring 的 AOP 的支持
weixin_33749131的博客
12-18 145
2019独角兽企业重金招聘Python工程师标准>>> ...
Autofac的AOP面向切面编程研究
weixin_30706507的博客
09-29 2718
什么是AOP： 我的理解是 把系统性的编程工作封装起来 =》我给这个取个名字叫 “Aspect”，然后通过AOP技术把它切进我们的业务逻辑代码 =》 “业务“ 这样的好处： “Aspect” 和 “业务” 相互独立，既可以让“业务” 用到了 “Aspect” 又让2者互相独立不耦合，多个“业务”也能复用 同一份“Aspect” 举一个最实用的例子 Transacti...
.NET 通过 Autofac 和 DynamicProxy 实现AOP
weixin_34293059的博客
05-20 359
　　什么是AOP？引用百度百科：AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。实现AOP主要由两种方式，一种是编译时静态植入，优点是效率高，缺点是缺乏灵活性，.net下postsharp为代表者（这个是收费的）。另一种方式是动态代理，优缺点与前者相反，动态为目标类型创建代理，通过代理调用实现...
ORM框架 整合asp.net core mvc和Dapper、Autofac实现依赖注入和AOP，同时结合Redis实现 _缓
07-11
通过以上集成，我们可以构建一个高效、灵活且易于维护的ASP.NET Core MVC应用，同时享受到Dapper的高性能、Autofac的依赖管理、AOP的模块化处理以及Redis的高速缓存优势。这种架构不仅提高了开发效率，还能为大型Web...
Asp.net Core 3.1基于AspectCore实现AOP实现事务、缓存拦截器功能
01-19
在net core2.2时，我当时就尝试过用autofac实现aop，但这次我不想用autofac，我用了一个更轻量级的框架，AspectCore。 用起来非常非常的简单，但一开始还是走了一点弯路，主要是网上都是net core3以下的教程，3以下...
ASp.net Core EF ActionFilterAttribute AOP
dz45693的专栏
08-28 2915
在项目中经常遇到一些数据的修改，很多时候业务方需要一个修改日志记录，这里我们计划用mssql数据库来存放日志记录，用EF来操作，记录日志可以用mvc的ActionFilterAttribute 来完成也可以用AOP来完成。以前在asp.net的AOP用的是IMessageSink这里我们计划用Castle.DynamicProxy来完成。 准备工作： 创建数据库表： CREATE TABL...
基于Autofac实现完全特性方式依赖注入实例以及结合Castle完成AOP横切关注的类库OpenDeepSpace.Autofacastle
weixin_43872830的博客
08-04 1084
基于Autofac实现完全特性方式依赖注入实例以及结合Castle完成AOP横切关注的类库
使用AutoFac完成AOP日志记录
m0_46319477的博客
04-10 345
【代码】使用AutoFac完成AOP日志记录。
【.NET Core】使用autofac实现AOP拦截 记录所有执行方法
GreAmbWang的博客
05-04 4043
说明 首先，说明一下 拦截的方法可能是同步，也可能是异步 方法可能无返回值，也有可能是有返回值的 所以，要分情况 上代码 public class LogAOP : IInterceptor { public LogAOP(ILogger<LogAOP> logger) { _logger = log...
在ASP.NET CORE项目中使用AutoFac设置AOP的Redis缓存
jamenu的博客
01-19 1068
1.创建一个ASP.NET CORE项目 先创建一个asp.net core项目, 可以是WebAPI也可以是MVC或者其他的形式,这并没有关系 这里以WebAPI项目举例 导入相关的依赖包 需要用到AutoFac和stackExchange.redis和Newtonsoft.JSON 当然,这个测试可以不使用数据库,但为了更真实一些,我需要加上SqlClinet.Data去连接测试用的SqlServer数据库 ...
Spring基本用法7——AOP的支持(一)
风清扬
07-30 236
        前言：AOP，也就是面向切面编程，作为面向切面编程的一种补充，已经比较成熟，如果是OOP是从静态角度考虑程序结构，那么AOP则是从动态角度考虑程序运行。本文旨在介绍Spring对AOP的支持，简述其用法。 本篇文章重点关注以下问题： AOP的使用场景 AOP的基本概念 Spring对AOP的支持 1. AOP的使用场景          AOP 广泛应用于处理一...
Autofac之AOP实现执行方法监控
There is no one l would rather be than me
12-02 1730
1. 安装Autofac.Extras.DynamicProxy，准备AutofacAOP类 public class AutofacAOP : IInterceptor { public void Intercept(IInvocation invocation) { var stopwatch = new Stopwatch(); stopwatch.Start(); var dataI
spring对AOP的支持
专注于Groovy语言，grails框架与管理之道
10-23 1610
spring对AOP的支持（采用Annotation的方式）1、spring依赖库 * SPRING_HOME/dist/spring.jar * SPRING_HOME/lib/jakarta-commons/commons-logging.jar * SPRING_HOME/lib/log4j/log4j-1.2.14.jar * SPRING_HOME/lib/aspectj/*.jar
Asp.Net Core 6整合Autofac容器实现IOC和AOP
m0_65664914的博客
05-07 1822
Autofac是一个开源的依赖注入（DI）容器，用于.NET应用程序的组件解耦和管理。它提供了一种简单而强大的方式来实现依赖注入，并且可以与各种.NET框架和库无缝集成。Autofac的原理是基于反射和动态代理技术。它通过扫描应用程序中的类型，自动发现和创建对象的实例，并将这些实例注入到需要它们的地方。这样可以实现组件之间的松耦合，提高代码的可测试性、可维护性和可扩展性。内置DI容器与第三方容器各有优缺点，具体的选择还应视实际应用场景而定。
.Net6 Web Core API --- Autofac -- AOP
againknow的博客
08-04 1574
.Net6 Web Core API --- Autofac -- AOP
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Vin Cente

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值