无侵入方面编程-用HttpModule+SoapExtension监视页面执行参数（二）

上一篇文章 "无侵入方面编程-用HttpModule+SoapExtension监视页面执行参数(一）"中，我们实现了监视每个页面的执行情况和调用WebService的简单信息。

这次我们继续深入一下SoapExtension的应用，在不改变Soap的WSDL文档的情况下，配合在Dotnet编写的WebService站点配置我们编写的SoapExtension，来穿透传输我们自定义的数据对象。由于SoapExtension是全局的，我们还要加一些标识来区分服务器是否已经配置了我们的SoapExtension，从而不影响其它的WebService调用。

在SoapExtension中，我想到有两种方案：
    一种是直接在SoapMessage.Headers中插入自定义的SoapHeader对象，然后在客户端的序列化后，从SoapUnknownHeader中取出数据，然后反序列化成自定义的对象。
    第二种是对SoapMessage.ContentType 添加一个额外的标识，在另一方检测这个标识，来从流中取出自己长度的数据。反序列化成自定义的对象。

我感觉第二种方案比较简单，高效，我们看一下代码：

    /// <summary>
    /// WSInvokeMonitorExtension 的摘要说明。
    /// </summary>
    public class StreamWSInvokeMonitorExtension : SoapExtension
    {
        private const string WSInvokeMonitorKey = "__WSInvokeMonitorKey__";
        private const int MaxDataLength = 5 * 1024 * 1024;  //5M
        private XmlSerializer serializer = new XmlSerializer(typeof(DbConnInfo));
        private Stream originStream;
        private Stream usingStream = new MemoryStream();
        private WSInvokeInfo invokeInfo = new WSInvokeInfo();
        public override System.IO.Stream ChainStream(System.IO.Stream stream)
        {
            originStream = stream;
            return usingStream;
        }

        public override object GetInitializer(Type serviceType)
        {
            return null;
        }

        public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
        {
            return null;
        }

        public override void Initialize(object initializer)
        {

        }

        public override void ProcessMessage(SoapMessage message)
        {
            if(message is SoapClientMessage)
            {
                switch (message.Stage) 
                {
                    case SoapMessageStage.BeforeSerialize:
                        this.invokeInfo.BeginInvokeTime = DateTime.Now;
                        this.invokeInfo.MethodName = message.MethodInfo.Name;
                        break;

                    case SoapMessageStage.AfterSerialize:
                        usingStream.Seek(0, SeekOrigin.Begin);
                        CopyStream(usingStream, originStream);
                        break;

                    case SoapMessageStage.BeforeDeserialize:
                        usingStream.SetLength(0);
                        CopyStream(originStream, usingStream);
                        usingStream.Seek(0, SeekOrigin.Begin);
                        if(message.ContentType.IndexOf("ExtInfo=true") != -1){
                            //先读出自己的信息
                            byte[] bytesFlags = new byte[]{66,69}; // BE  标识

                            if(usingStream.ReadByte() == bytesFlags[0])  //检验标志位
                            {
                                byte[] bytesLength = new byte[BitConverter.GetBytes((Int32)0).Length];  
                                usingStream.Read(bytesLength,0, bytesLength.Length); //读取长度
                                int length = BitConverter.ToInt32(bytesLength,0);

                                if(length < MaxDataLength)   //检验数据是否非法
                                {
                                    if(usingStream.ReadByte() == bytesFlags[1])   //检验标志位
                                    {
                                        byte[] bytesData = new byte[length];
                                        usingStream.Read(bytesData,0, bytesData.Length);
                                        using(MemoryStream ms = new MemoryStream(bytesData))
                                        {
                                            DbConnInfo header = serializer.Deserialize(ms) as DbConnInfo;
                                            Debug.WriteLine(header.Info);
                                        }

                                        break;
                                    }

                                }

                            }

                            //数据不对,则重置流位置
                            usingStream.Position = 0;
                        }

                        break;

                        // About to call methods
                    case SoapMessageStage.AfterDeserialize:
                        //添加到Module记录
                        this.invokeInfo.EndInvokeTime = DateTime.Now;
                        PageInfo pageInfo = (PageInfo)HttpContext.Current.Items[WSInvokeMonitorKey] ;
                        if(pageInfo != null)
                        {
                            pageInfo.AppendInvokeInfo(this.invokeInfo);
                        }

                        break;

                        // After Method call

                    default:
                        throw new Exception("No stage such as this");
                }

            }
            else if(message is SoapServerMessage)
            {
                switch (message.Stage) 
                {
                        // Incoming from client
                    case SoapMessageStage.BeforeDeserialize:
                        usingStream.SetLength(0);
                        CopyStream(originStream, usingStream);
                        usingStream.Seek(0, SeekOrigin.Begin);

                        break;

                        // About to call methods
                    case SoapMessageStage.AfterDeserialize:
                        break;

                        // After Method call
                    case SoapMessageStage.BeforeSerialize:
                        
                        //设置自定义Header
                        usingStream.SetLength(0);  //清空并先写入自定义的信息
                        

                        byte[] bytesData = null;
                        using(MemoryStream ms = new MemoryStream())
                        {
                            serializer.Serialize(ms,new DbConnInfo("3个数据库连接"));  //服务端自定义的信息
                            bytesData = ms.ToArray();
                        }
                        message.ContentType += ";ExtInfo=true";
                        //写入标识
                        byte[] bytesFlags = new byte[]{66,69}; // BE
                        usingStream.WriteByte(bytesFlags[0]);

                        //写入长度
                        byte[] dataLength = BitConverter.GetBytes(bytesData.Length);
                        usingStream.Write(dataLength, 0, dataLength.Length);

                        //再写入标志
                        usingStream.WriteByte(bytesFlags[1]);

                        //写入数据
                        usingStream.Write(bytesData, 0, bytesData.Length);
                        
                        break;

                        // Outgoing to other 
                    case SoapMessageStage.AfterSerialize:
                        usingStream.Seek(0, SeekOrigin.Begin);
                        CopyStream(usingStream, originStream);
                        break;

                    default:
                        throw new Exception("No stage such as this");
                }

            }
        }

        private void CopyStream(Stream src, Stream des)
        {
            byte[] buf = new byte[1024];
            int length = 0;
            do 
            {
                length = src.Read(buf,0,buf.Length);
                des.Write(buf,0,length);
            } while (length == buf.Length);          

        }
    }

    [System.Serializable]
    public class DbConnInfo 
    {
        private string info;
        public string Info
        {
            get { return info; }
            set { info = value; }
        }

        public DbConnInfo()
        {
        }

        public DbConnInfo(string info)
        {
            this.Info = info;
        }
        
    }

代码中，在服务端写入标识： message.ContentType += ";ExtInfo=true";

然后在客户端检测：if(message.ContentType.IndexOf("ExtInfo=true") != -1){...}
   这样便保证了不会影响其它没有加载Soap扩展的调用。

到目前为至，我们已经成功的把服务端的信息对象，在不改变WSDL的情况下，无侵入的传递到调用端。具体收集什么信息，就要在WebService端进行收集了！我这里的要求是收集数据库连接的情况，下一次继续介绍吧。

附：方案一实现代码：

 

    [System.Serializable]
    public class DbConnInfoSoapHeader 
    {
        private string info;
        public string Info
        {
            get { return info; }
            set { info = value; }
        }

        public DbConnInfoSoapHeader()
        {

        }

        public DbConnInfoSoapHeader(string info)
        {
            this.Info = info;
        }
        
    }

    [System.Serializable]
    public class SoapHeaderWrap : SoapHeader
    {
        private byte[] soapData = null;
        private object data;

        [XmlIgnoreAttribute]
        [SoapIgnoreAttribute]
        public object Data
        {
            get { return data; }
            set 
            {
                data = value;
                soapData = null;
            }
        }
        private string key;
        [XmlAttribute]
        public string Key
        {
            get { return key; }
            set { key = value; }
        }

        [XmlAttribute]
        public string TypeName 
        {
            get{

                return this.Data.GetType().AssemblyQualifiedName;
            }
            set{}
        }

        public byte[] SoapData
        {
            get
            {
                if(soapData == null && this.Data != null)
                {
                    using(MemoryStream ms = new MemoryStream())
                    using(StreamWriter sw = new StreamWriter(ms,new UTF8Encoding(false)))
                    {
                        XmlSerializer serializer = new XmlSerializer(this.Data.GetType());
                        serializer.Serialize(sw, this.Data);
                        ms.Position = 0;
                        soapData = ms.ToArray();
                    }

                }

                return soapData;
            }
            set {

            }
        }

        public SoapHeaderWrap(string key, object soapData)
        {
            this.Key = key;
            this.Data = soapData;
        }

        public SoapHeaderWrap(string key)
            :this(key,null)
        {
        }

        public SoapHeaderWrap()
            :this(string.Empty)
        {
        
        }

    }

http://www.cnblogs.com/evlon/archive/2009/06/01/1493923.html