.NET中三种AOP实现方式：Remoting、Castle、Autofac

最新推荐文章于 2024-08-18 08:43:02 发布
最新推荐文章于 2024-08-18 08:43:02 发布
阅读量4.3k 收藏 16
点赞数 1
分类专栏： AOP .NET 文章标签： .NET AOP 面向切面编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21571303/article/details/100138057
版权
.NET 同时被 2 个专栏收录
4 篇文章 0 订阅
订阅专栏
AOP
1 篇文章 0 订阅
订阅专栏

.NET中三种AOP实现方式

前言

一直忙于撸码，难得有时间，研究了下AOP，与大家分享一下，也便于以后查看。(￣▽￣)~*
因为.NET CORE中集成的IOC容器是Castle，日常大家常用的是Autofac，所以本人只研究了下.NET默认的Remoting实现方式，Castle实现方式和Autofac实现方式。其中，Castle有两个插件，Castle.Windsor（IOC容器）和Castle.Core（核心），Autofac的拦截器是使用的Castle.Core的动态代理。

基本概念

AOP

AOP(Aspect Oriented Programming)：面向切面（方面）编程，是OOP的延续，用来在不修改代码的情况下，动态的添加功能，将核心逻辑与非核心逻辑分开。其中，记录日志便是AOP最普遍的使用场景之一。

IOC和DI

DI(Dependency Injection)依赖注入，实际上是IOC（控制翻转）的一种实现方式，之所以叫依赖注入，是因为调用者和被调用者的依赖关系是通过第三方注入的，这个第三方通常说的便是IOC容器。IOC是一种思想，依赖倒置原则提倡程序要依赖于抽象，不要依赖于具体实现，以便降低耦合，而控制实现接口的，通常还是调用者，调用者和具体实现之间还是存在依赖关系，现在把这个控制权交给第三方，这便是IOC思想。在这里讲这些内容，是因为实现动态代理，往往需要依托于IOC容器。

实现方式

AOP的拦截器有两种实现方式：动态代理和静态代理

动态代理：

是在程序运行中，动态的添加切入点，这便是通常需要用到IOC容器的原因。
优缺点：效率相对于静态代理要低，但灵活性强，不需要额外的编译。
我们所讲的三种方式，都是动态代理实现的。

静态代理：

是在程序预编译阶段插进去的。
优缺点：相对于动态代理，性能要高，但灵活性较差，需要额外的编译。

Remoting实现方式

  1. 需要引用的命名空间
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
  1. 因为实现比较简单，所以就把代码全部贴到下面了
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;
using System.Text;
using System.Threading.Tasks;

/// <summary>
/// 默认实现方式（Remoting方式）
/// </summary>
namespace DefaultDemo
{

    class Program
    {
        static void Main(string[] args)
        {
            var per = new Proxy<King>(new King()).GetTransparentProxy() as King;
            if (per != null)
            {
                var str = per.RuleTheCastle("fffff");
            }
            Console.ReadKey();
        }
    }


    /// <summary>
    /// 基本类型
    /// </summary>
    class King : MarshalByRefObject
    {
        public string RuleTheCastle(string str)
        {
            str = "hello word," + str;
            return str;
        }
    }


    public class Proxy<T> : RealProxy where T : new()
    {
        private object _obj;
        public Proxy(object obj)
            : base(typeof(T))
        {
            _obj = obj;
        }
        public override IMessage Invoke(IMessage msg)
        {
            IDictionary oProperties = msg.Properties;

            object oMethodName = null;
            if (oProperties.Contains("__MethodName"))
            {
                oMethodName = oProperties["__MethodName"];
            }
            Console.WriteLine("方法名:{0}", oMethodName);

            //入参
            object[] oArguments;
            if (oProperties.Contains("__Args"))
            {
                oArguments = oProperties["__Args"] as object[];
            }
            else
            {
                oArguments = new object[0];
            }
            foreach (var oArgument in oArguments)
            {
                Console.WriteLine("入参:{0}", oArgument);
            }


            //调用和出参
            object oReturnValue = ((IMethodCallMessage)msg).MethodBase.Invoke(_obj, oArguments);
            Console.WriteLine("出参:{0}", oReturnValue);

            return new ReturnMessage(oReturnValue, null, 0, null, null);
        }
    }

}

Castle实现方式

  1. 在NuGet管理器中安装Castle.Windsor程序包
    在这里插入图片描述
    安装完成后会自动引用Castle.Windsor和Castle.Core类库
    在这里插入图片描述
  2. 引用对应的命名空间
using Castle.Core;
using Castle.DynamicProxy;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;

依赖注入的实现

  1. 添加一个抽象接口，和这个抽象接口的实现类
	public interface IKing
    {
        string RuleTheCastle(string name);
    }


    class King : IKing
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string RuleTheCastle(string name)
        {
            Console.WriteLine("方法已执行");
            return "Hello Word，" + name;
        }
    }

2、添加一个安装类RepositoriesInstaller ，需要继承IWindsorInstaller接口，在里面注册组件

    public class RepositoriesInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                Component.For<IKing>().ImplementedBy<King>().LifestyleSingleton()
                );
        }
    }
  1. 实例化一个容器，并运行安装程序，以便它们在容器中注册组件
	IWindsorContainer container = new WindsorContainer();

    container.Install(new RepositoriesInstaller());
  1. 获取组件实例，依赖注入
	var king = container.Resolve<IKing>();
	string ret = king.RuleTheCastle("tzj");
  1. 释放掉IOC容器
	container.Dispose();

添加拦截器

  1. 声明一个日志的拦截器类LoggingInterceptor，并让他继承IInterceptor接口
 public class LoggingInterceptor : IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            try
            {
                //类型
                var type = invocation.TargetType;

                //对象
                var oObject = invocation.InvocationTarget;

                //方法
                string strMethodName = invocation.Method.Name;
                Console.WriteLine("调用的方法是：" + strMethodName);

                //入参
                var oArguments = invocation.Arguments;
                if (oArguments != null && oArguments.Length > 0)
                {
                    for (int i = 0; i < oArguments.Length; i++)
                    {
                        Console.WriteLine("入参{0}:{1}", i, oArguments[i]);
                    }

                }

                //执行此方法，正式调用方法
                //执行之前，可获取入参
                //执行成功之后，可获取出参
                invocation.Proceed();

                //输出参数和ref只能通过对比入参来实现

                //出参
                var oReturnValue = invocation.ReturnValue;
                Console.WriteLine("出参：" + oReturnValue);
            }
            catch (Exception ex)
            {
                //不管是被拦截方法中报错，还是拦截方法中报错，都会走这里
                Console.WriteLine("错误信息:" + ex.ToString());
            }
        }
    }

2.在实现类上添加对应的拦截器属性，需要注意的是，这个实现类必须是受本IOC容器控制的

[Interceptor(typeof(LoggingInterceptor))]
  1. 将拦截器也注册的容器中
 Component.For<LoggingInterceptor>()

这样便完成了

完整代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Castle.Core;
using Castle.DynamicProxy;
using Castle.MicroKernel.Registration;
using Castle.MicroKernel.SubSystems.Configuration;
using Castle.Windsor;

namespace CastleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            IWindsorContainer container = new WindsorContainer();

            container.Install(new RepositoriesInstaller());

            var king = container.Resolve<IKing>();

            string ret = king.RuleTheCastle("tzj");
            Console.WriteLine(ret);

            container.Dispose();

            Console.ReadKey();
        }
    }

    public interface IKing
    {
        string RuleTheCastle(string name);
    }

    //切面的类必须是受本容器控制的
    [Interceptor(typeof(LoggingInterceptor))]
    class King : IKing
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string RuleTheCastle(string name)
        {
            Console.WriteLine("方法已执行");
            return "Hello Word，" + name;
        }
    }

    public class RepositoriesInstaller : IWindsorInstaller
    {
        public void Install(IWindsorContainer container, IConfigurationStore store)
        {
            container.Register(
                Component.For<LoggingInterceptor>(),
                Component.For<IKing>().ImplementedBy<King>().LifestyleSingleton()
                );
        }
    }


    public class LoggingInterceptor : IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            try
            {
                //类型
                var type = invocation.TargetType;

                //对象
                var oObject = invocation.InvocationTarget;

                //方法
                string strMethodName = invocation.Method.Name;
                Console.WriteLine("调用的方法是：" + strMethodName);

                //入参
                var oArguments = invocation.Arguments;
                if (oArguments != null && oArguments.Length > 0)
                {
                    for (int i = 0; i < oArguments.Length; i++)
                    {
                        Console.WriteLine("入参{0}:{1}", i, oArguments[i]);
                    }

                }

                //执行此方法，正式调用方法
                //执行之前，可获取入参
                //执行成功之后，可获取出参
                invocation.Proceed();

                //输出参数和ref只能通过对比入参来实现

                //出参
                var oReturnValue = invocation.ReturnValue;
                Console.WriteLine("出参：" + oReturnValue);
            }
            catch (Exception ex)
            {
                //不管是被拦截方法中报错，还是拦截方法中报错，都会走这里
                Console.WriteLine("错误信息:" + ex.ToString());
            }
        }
    }
}

Autofac实现方式

  1. 在NuGet管理器中安装Autofac.Extras.DynamicProxy程序包
    在这里插入图片描述
    程序会自动引用
    在这里插入图片描述
  2. 引用所需的命名空间
using Autofac;
using Autofac.Extras.DynamicProxy;
using Castle.DynamicProxy;

依赖注入的实现

这块与上面类似，直接贴代码了

private static IContainer Container { get; set; }
        static void Main(string[] args)
        {
            var builder = new ContainerBuilder();
            
            builder.RegisterType<King>().As<IKing>();

            Container = builder.Build();

            using (var scope = Container.BeginLifetimeScope())
            {
                var writer = scope.Resolve<IKing>();

                writer.RuleTheCastle("aaa");
            }

            Console.Read();
        }

    }

    public interface IKing
    {
        string RuleTheCastle(string name);
    }

    public class King : IKing
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string RuleTheCastle(string name)
        {
            Console.WriteLine("方法已执行");
            return "Hello Word，" + name;
        }

    }

添加拦截器

拦截器也类似

  1. 添加拦截器属性
[Intercept(typeof(LoggingInterceptor))]
  1. 在注册组件的时候要启用代理

启用类代理，这种方式需要切面类的权限是public，并且方法是virtual方法

builder.RegisterType<King>().As<IKing>().EnableClassInterceptors();

启用接口代理

builder.RegisterType<King>().As<IKing>().EnableInterfaceInterceptors();
  1. 同样需要将拦截器注入到容器中
builder.RegisterType<LoggingInterceptor>();

完整代码

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

namespace AutofacDemo
{
    class Program
    {
        private static IContainer Container { get; set; }
        static void Main(string[] args)
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<LoggingInterceptor>();

            //EnableClassInterceptors 启用类代理 要求方法是virtual
            //builder.RegisterType<King>().As<IKing>().EnableClassInterceptors();

            //EnableInterfaceInterceptors 启用接口代理
            builder.RegisterType<King>().As<IKing>().EnableInterfaceInterceptors();

            Container = builder.Build();

            using (var scope = Container.BeginLifetimeScope())
            {
                var writer = scope.Resolve<IKing>();

                writer.RuleTheCastle("aaa");
            }

            Console.Read();
        }

    }

    public interface IKing
    {
        string RuleTheCastle(string name);
    }

    //切面的类必须是受本容器控制的
    [Intercept(typeof(LoggingInterceptor))]
    public class King : IKing
    {
        public string Name { get; set; }

        public int Age { get; set; }

        public string RuleTheCastle(string name)
        {
            Console.WriteLine("方法已执行");
            return "Hello Word，" + name;
        }

    }

    public class LoggingInterceptor : IInterceptor
    {
        public void Intercept(IInvocation invocation)
        {
            try
            {
                //类型
                var type = invocation.TargetType;

                //对象
                var oObject = invocation.InvocationTarget;

                //方法
                string strMethodName = invocation.Method.Name;
                Console.WriteLine("调用的方法是：" + strMethodName);

                //入参
                var oArguments = invocation.Arguments;
                if (oArguments != null && oArguments.Length > 0)
                {
                    for (int i = 0; i < oArguments.Length; i++)
                    {
                        Console.WriteLine("入参{0}:{1}", i, oArguments[i]);
                    }

                }

                //执行此方法，正式调用方法
                //执行之前，可获取入参
                //执行成功之后，可获取出参
                invocation.Proceed();

                //输出参数和ref只能通过对比入参来实现


                //出参
                var oReturnValue = invocation.ReturnValue;
                Console.WriteLine("出参：" + oReturnValue);


            }
            catch (Exception ex)
            {
                //不管是被拦截方法中报错，还是拦截方法中报错，都会走这里
                Console.WriteLine("错误信息:" + ex.ToString());
            }
        }
    }
}

后记

文章中，有些地方没写那么细，不过注释中大部分都有，等我有时间再往细加，还望见谅。(✪ω✪)
第一次正式写博客，如果哪有问题，还请大佬们不惜赐教。(〃‘▽’〃)

自言人
关注
专栏目录
Castle 整合.NET Remoting
shanyou的专栏
10-22 1044
  今天研究了一下Castle的Remoting Facility.记录如下： 微软以前使用COM/DCOM的技术来处理分布式系统架构，通过Client端的Proxy代理程序来呼叫远程Server机器上的对象。.NET Framework则使用.NET Remoting或Web Services技术来实作分布式处理的工作概念；在这里针对.NET Remoting的设计架构做一个初步的
aop在.net中的实现
01-24
aop在.net中的实现。。。。。。aop在.net中的实现aop在.net中的实现。。。。。。aop在.net中的实现
ASP.NET Core入门——使用Autofac实现DI与AOP
最新发布
dotNET跨平台
08-18 61
在ASP.NET Core应用程序中，依赖注入（DI）和面向切面编程（AOP）是构建模块化、可维护和可扩展应用程序的关键技术。Autofac是一个流行的.NET依赖注入容器，它不仅支持依赖注入，还提供了AOP的支持，通过拦截器（Interceptors）实现横切关注点（Cross-Cutting Concerns）的处理。本文将详细介绍如何在ASP.NET Core项目中使用Autofac来实现依...
AOP技术研究——.Net平台AOP技术研究
weixin_34126215的博客
09-07 240
4.1.Net平台AOP技术概览 .Net平台与Java平台相比，由于它至今在服务端仍不具备与unix系统的兼容性，也不具备类似于Java平台下J2EE这样的企业级容器，使得.Net平台在大型的企业级应用上，常常为人所诟病。就目前而言，.Net平台并没有提供AOP技术的直接实现，而微软在未来对于.Net的发展战略目标，我们仍未可知。但我相信微软对于目前炙手可热的AOP技术应该不会视而不见。也...
.NET里简易实现AOP
金源
06-26 1073
在MVC的过滤器章节中对于过滤器的使用就是AOP的一个实现了吧，时常在工作学习中遇到AOP对于它的运用可以说是很熟练了，就是没想过如果自己来实现的话是怎么实现的，性子比较犟硬是没想明白，茶不思饭不想的，主要问题就是卡在了怎么能拦截用户调用，如果可以解决了这个问题AOP的实现也就引刃而解了，为此在网上看了一些文章解决了这个问题，在这里和大家分享一下。
AOP技术研究——AOP技术基础
weixin_33800593的博客
09-07 348
2.1 AOP技术起源 AOP技术的诞生并不算晚，早在1990年开始，来自Xerox Palo Alto Research Lab（即PARC）的研究人员就对面向对象思想的局限性进行了分析。他们研究出了一种新的编程思想，借助这一思想或许可以通过减少代码重复模块从而帮助开发人员提高工作效率。随着研究的逐渐深入，AOP也逐渐发展成一套完整的程序设计思想，各种应用AOP的技术也应运而生。 AOP...
基于.net简单实现AOP
Mcdull28的专栏
02-06 6660
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
在.Net中关于AOP的实现
02-27
一、AOP实现初步AOP将软件系统分为两个部分：核心关注点和横切关注点。核心关注点更多的是DomainLogic，关注的是系统核心的业务；而横切关注点虽与核心的业务实现无关，但它却是一种更Common的业务，各个关注点离散...
Asp.net Core 3.1基于AspectCore实现AOP实现事务、缓存拦截器功能
01-19
在net core2.2时，我当时就尝试过用autofac实现aop，但这次我不想用autofac，我用了一个更轻量级的框架，AspectCore。 用起来非常非常的简单，但一开始还是走了一点弯路，主要是网上都是net core3以下的教程，3以下...
【ASP.NET编程知识】Asp.Net Core轻量级Aop解决方案：AspectCore.docx
05-15
AspectCore使用Emit实现高效的动态代理，从而不依赖任何第三方Aop库。 AspectCore的主要特点： * 轻量级：AspectCore是一个轻量级的Aop解决方案，不依赖任何第三方Aop库。 * 高效：AspectCore使用Emit实现高效的...
Asp.Net Core轻量级Aop解决方案：AspectCore
10-19
AspectCore 是一个专门为 Asp.Net Core 设计的轻量级 AOP（面向切面编程）框架，它使得在 .NET Core 应用程序中实现切面编程变得更加简单和高效。AOP 的核心思想是将关注点分离，允许开发者将业务逻辑与系统服务，如...
.net AOP资料
08-26
自己在网上找的一些关于.net下AOP的资料，给大家节省一些时间吧。
.NET中的AOP介绍
Man_Humble
12-03 3288
.NET中的AOP
.Net平台AOP技术研究
weixin_33989058的博客
12-10 90
1、引言2、AOP技术基础3、Java平台AOP技术研究4、.Net平台AOP技术研究 4.1.Net平台AOP技术概览 .Net平台与Java平台相比，由于它至今在服务端仍不具备与unix系统的兼容性，也不具备类似于Java平台下J2EE这样的企业级容器，使得.Net平台在大型的企业级应用上，常常为人所诟病。就目前而言，.Net平台并没有提供AOP技术的直接实现，而微软在未来对于.Net...
.NET AOP
何鹏飞的博客
07-27 149
【代码】.NET AOP。
Autofac+Castle 实现 AOP事务
qq165285727的专栏
06-08 369
最近公司新项目，需要搭架构进行开发，其中需要保证事务的一致性，经过一番查找，发现很多博文都是通过Spring.Net、Unity、PostSharp、Castle Windsor这些方式实现AOP的。博主对Autofac进行了封装，可能与你们的配置不一样，但是，Load(ContainerBuilder builder)该方法内容是一致的，因此注入方式一致的。//故意重复，判断是否会回滚。定义属性，通过当前方法是否包含该属性进行判断开启事务，如果存在该属性则开启事务，否则忽略事务。//设置事务隔离级别。
.NET 时代里的AOP
我的生活,我的BLOG
12-15 1102
   我们将再次访问与第一个程序结构相关的许多概念，以及具体代码都放到了本文中。如果已经很熟悉MVC设计模式，可以直接看后面的内容。 MVC设计模式    在这个模式下面，应用程序中有三个清晰分明的关注点。    • Model（模式）：这是此程序结构的一部分，此程序结构包含你的商业实体的数据以及商业实体的行为。这是唯一一个管理数据库的模式，例如：执行某种行为。    • View（视图）:这是显
【C#】使用 Castle 实现 AOP，以及 Autofac 集成 Castle
chinaherolts2008的博客
07-22 699
Castle 是 2003 年诞sql教程生于 Apache Avalon 项目，目的java基础教程是为了创建一个IOC 框架。发展到现在已经有四个组件： ORM组件：ActiveRecord IOC组件：Windsor 动态代理组件：DynamicProxy Web MVC组件：MonoRail 本文主python基础教程要介绍 动态代理组件Castle.DynamicProxy 基本用法 Castle.DynamicProxy是通过 Emit 反射动态生成c#教程代理类来实现的，效率相..
.NET(C#) 面向切面编程(AOP) Autofac
m0_60105488的博客
04-13 498
AOP（Aspect Oriented Programming）是面向切面编程，用来在不修改代码的情况下，动态的添加功能，通过预编译方式和运行期动态代理实现程序功能的中统一处理业务逻辑的一种技术，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。比较常见的场景是：日志记录，错误捕获、性能监控等。本文主介绍Autofac实现AOP方法，以及相关的示例代码。 原文地址：.NET(C#) 面向切面编程(AOP) Autofac ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值