C# Attribute 实现简单的 AOP 处理的例子(转)

工作中遇到这样的情况，项目开发之前，没提过什么日志的东西。

项目开发的差不多了，说需要记录日志文件。

比如客户端调用服务器的时候，都什么时间，谁，调用了什么之类的。

 

目前还不确定，这个日志到底要怎么记录，以及都记录哪些信息。

上网查询了一下 AOP 的东西，实现办法还真不少。

这里就写个简单的，使用 Attribute 实现的例子。

 

首先是个 目标类，也就是针对这个类的方法，来做AOP的操作。

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

namespace A0075_AOPAttributes.Sample
{
    public class ObjectClass
    {
        public void Test1()
        {
            Console.WriteLine("Test");
        }
        public void Test2(string para)
        {
            Console.WriteLine("Test:" + para);
        }
        public void Test3(int para)
        {
            Console.WriteLine("Test:" + para);
        }
    }
}

出于演示的目的，这个类只有3个方法。只输出点基本的信息。

由于实际的项目，那个类有几十个方法，每个方法，都复制/粘贴一段 Log 代码上去，也不现实。

下面是 Attribute的代码

 

using System;
using System.Text;
using System.Runtime.Remoting.Messaging;

namespace A0075_AOPAttributes.Sample
{

    public class AutoLogSink : IMessageSink
    {

        /// <summary>
        /// 保存下一个接收器
        /// </summary>
        private IMessageSink nextSink;

        /// <summary>
        /// 在构造器中初始化下一个接收器
        /// </summary>
        /// <param name="next"></param>
        public AutoLogSink(IMessageSink next)
        {
            nextSink = next;
        }

        /// <summary>
        /// 必须实现的IMessageSink接口属性
        /// </summary>
        public IMessageSink NextSink
        {
            get
            {
                return nextSink;
            }
        }

        /// <summary>
        /// 实现IMessageSink的接口方法，当消息传递的时候，该方法被调用
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        public IMessage SyncProcessMessage(IMessage msg)
        {
            //拦截消息，做前处理
            Preprocess(msg);
            //传递消息给下一个接收器
            IMessage retMsg = nextSink.SyncProcessMessage(msg);
            //调用返回时进行拦截，并进行后处理
            Postprocess(msg, retMsg);
            return retMsg;
        }


        /// <summary>
        /// IMessageSink接口方法，用于异步处理，我们不实现异步处理，所以简单返回null,
        /// 不管是同步还是异步，这个方法都需要定义
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="replySink"></param>
        /// <returns></returns>
        public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
        {
            return null;
        }

        /// <summary>
        /// 前处理.
        /// </summary>
        /// <param name="msg"></param>
        private void Preprocess(IMessage msg)
        {
            //检查是否是方法调用，我们只拦截Order的Submit方法。
            IMethodCallMessage call = msg as IMethodCallMessage;
            if (call == null)
                return;
            StringBuilder buff = new StringBuilder();
            buff.AppendFormat("$LOG$:开始调用{0}方法。参数数量：{1}", call.MethodName, call.InArgCount);
            buff.AppendLine();
            for (int i = 0; i < call.InArgCount; i++)
            {
                buff.AppendFormat("  参数[{0}] : {1}", i + 1, call.InArgs[i]);
                buff.AppendLine();
            }
            Console.Write(buff.ToString());
        }

        /// <summary>
        /// 后处理
        /// </summary>
        /// <param name="msg"></param>
        /// <param name="retMsg"></param>
        private void Postprocess(IMessage msg, IMessage retMsg)
        {
            IMethodCallMessage call = msg as IMethodCallMessage;
            if (call == null)
                return;
            StringBuilder buff = new StringBuilder();
            buff.AppendFormat("$LOG$:调用{0}方法结束", call.MethodName);
            buff.AppendLine();
            Console.Write(buff.ToString());
        }
    }

 

    public class AutoLogProperty : IContextProperty, IContributeObjectSink
    {
        public AutoLogProperty()
        {
        }

        /// <summary>
        /// IContributeObjectSink的接口方法，实例化消息接收器
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="next"></param>
        /// <returns></returns>
        public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink next)
        {
            return new AutoLogSink(next);
        }

        /// <summary>
        /// IContextProperty接口方法，如果该方法返回ture,在新的上下文环境中激活对象
        /// </summary>
        /// <param name="newCtx"></param>
        /// <returns></returns>
        public bool IsNewContextOK(Context newCtx)
        {
            return true;
        }

        /// <summary>
        /// IContextProperty接口方法，提供高级使用
        /// </summary>
        /// <param name="newCtx"></param>
        public void Freeze(Context newCtx)
        {
        }

        /// <summary>
        /// IContextProperty接口属性
        /// </summary>
        public string Name
        {
            get { return "AutoLog"; }
        }
    }

 

    [AttributeUsage(AttributeTargets.Class)]
    public class AutoLogAttribute : ContextAttribute
    {
        public AutoLogAttribute() : base("AutoLog")
        {
        }

        /// <summary>
        /// 覆盖 ContextAttribute方法，创建一个上下文环境属性
        /// </summary>
        /// <param name="ctorMsg"></param>
        public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
        {
            ctorMsg.ContextProperties.Add(new AutoLogProperty());
        }
    }

}

下面是 使用 Attribute 实现简单的 AOP 目标代码 [粗体的地方，为在原代码的基础上增加的代码]

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

namespace A0075_AOPAttributes.Sample
{
    [AutoLog]
    public class ObjectClassAOP: ContextBoundObject
    {
        public void Test1()
        {
            Console.WriteLine("Test");
        }
        public void Test2(string para)
        {
            Console.WriteLine("Test:" + para);
        }
        public void Test3(int para)
        {
            Console.WriteLine("Test:" + para);
        }
    }
}

 

测试运行代码

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

using A0075_AOPAttributes.Sample;

namespace A0075_AOPAttributes
{
    class Program
    {
        static void Main(string[] args)
        {

            ObjectClass obj = new ObjectClass();
            obj.Test1();
            obj.Test2("Test");
            obj.Test3(1024);

            ObjectClassAOP objAop = new ObjectClassAOP();
            objAop.Test1();
            objAop.Test2("Test");
            objAop.Test3(1024);

            Console.ReadLine();
        }
    }
}

运行结果：

Test
Test:Test
Test:1024
$LOG$:开始调用Test1方法。参数数量：0
Test
$LOG$:调用Test1方法结束
$LOG$:开始调用Test2方法。参数数量：1
  参数[1] : Test
Test:Test
$LOG$:调用Test2方法结束
$LOG$:开始调用Test3方法。参数数量：1
  参数[1] : 1024
Test:1024
$LOG$:调用Test3方法结束