aspectsink.cs

应用AOP

//
// Write by Peopleyl 2007-04-13
//
using System;
using System.Collections;
using System.Runtime.Remoting.Contexts;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Activation;

namespace Aspect.AopBase
{	
	public delegate void BeforeAopHandle(IMethodCallMessage callMsg);
	public delegate void AfterAopHandle(IMethodReturnMessage returnMsg);

	public class AspectSink : IMessageSink
	{	
		#region AspectSink Members

		private IMessageSink msgSink;
		private SortedList beforeList;
		private SortedList afterList;
		protected string AopPropertyName;

		public AspectSink(IMessageSink messageSink,string aopPropertyName)
		{
			this.msgSink = messageSink;
			AopPropertyName = aopPropertyName;
			beforeList = new SortedList();
			afterList = new SortedList();
		}

		#endregion
		
		#region Add delegate Members

		public void AddBeforeHandle(string aopPropertyName,BeforeAopHandle aopHandle)
		{
			lock(beforeList)
			{
				if(!beforeList.ContainsKey(aopPropertyName))
				{
					beforeList.Add(aopPropertyName,aopHandle);
				}
			}
		}

		public void AddAfterHandle(string aopPropertyName,AfterAopHandle aopHandle)
		{
			lock(afterList)
			{
				if(!afterList.ContainsKey(aopPropertyName))
				{
					afterList.Add(aopPropertyName,aopHandle);
				}
			}
		}

		public BeforeAopHandle FindBeforeHandle(string aopPropertyName)
		{
			if(beforeList.ContainsKey(aopPropertyName))
			{
				return beforeList[aopPropertyName] as BeforeAopHandle;
			}
			return null;
		}

		public AfterAopHandle FindAfterHandle(string aopPropertyName)
		{
			if(afterList.ContainsKey(aopPropertyName))
			{
				return afterList[aopPropertyName] as AfterAopHandle;
			}
			return null;
		}

		#endregion
		
		#region IMessageSink Members

		public IMessageSink NextSink
		{
			get{ return msgSink;}
		}

		public IMessage SyncProcessMessage(IMessage msg)
		{	
			IMethodCallMessage callMsg = msg as IMethodCallMessage;
			IMethodReturnMessage returnMsg = this.NextSink.SyncProcessMessage(callMsg) as IMethodReturnMessage;

			if(!(msg is IConstructionCallMessage))
			{
				BeforeAopHandle beforeHandle = this.FindBeforeHandle(AopPropertyName);
				if(beforeHandle != null)
				{
					beforeHandle(callMsg);
				}

				AfterAopHandle afterHandle = this.FindAfterHandle(AopPropertyName);
				if(afterHandle != null)
				{
					afterHandle(returnMsg);
				}

				return SyncWrapProcessMessage(msg,returnMsg);
			}
			return returnMsg;
		}
		
		public virtual IMessage SyncWrapProcessMessage(IMessage msg,IMethodReturnMessage returnMsg)
		{
			return returnMsg;
		}

		public IMessageCtrl AsyncProcessMessage(IMessage msg, IMessageSink replySink)
		{
			return null;
		}	

		#endregion
	}
}