通过WCF扩展实现消息压缩

最新推荐文章于 2019-08-02 04:24:33 发布
最新推荐文章于 2019-08-02 04:24:33 发布
阅读量1.1k 收藏
点赞数
文章标签： wcf 扩展 algorithm stream compression parameters

对于需要进行大规模数据传输的WCF应用来说，对于请求消息和回复消息进行传输前的压缩，不但可以降低网络流量，也可以提高网络传输的性能。由于WCF的扩展性，我们可以采用不同的方式实现对消息的压缩，本文提供一种比较简单的实现方式。[源代码从这里下载]

一、三种可行的消息压缩方案     
二、DataCompressor——用于数据压缩与解压缩组件      
三、MessageCompressor——用于消息压缩与解压的组件      
四、CompressionMessageFormatter——用于对请求/回复消息压缩和解压缩的组件      
五、CompressionOperationBehaviorAttribute——将CompressionMessageFormatter用于WCF运行时框架的操作行为      
六、查看结构压缩后的消息      
七、补充说明

一、三种可行的消息压缩方案

消息压缩在WCF中的实现其实很简单，我们只需要在消息（请求消息/回复消息）被序列化之后，发送之前进行压缩；在接收之后，反序列化之前进行解压缩即可。针对压缩/解压缩使用的时机，我们具有三种典型的解决方案。

二、DataCompressor——用于数据压缩与解压缩组件

我们支持两种方式的压缩，Dflate和GZip。两种不同的压缩算法通过如下定义的CompressionAlgorithm枚举表示。

   1: public enum CompressionAlgorithm
   2: {
   3:     GZip,
   4:     Deflate
   5: }

而如下定义的DataCompressor负责基于上述两种压缩算法实际上的压缩和解压缩工作。

   1: internal class DataCompressor
   2: {
   3:     public static byte[] Compress(byte[] decompressedData, CompressionAlgorithm algorithm)
   4:     {
   5:         using (MemoryStream stream = new MemoryStream())
   6:         {
   7:             if (algorithm == CompressionAlgorithm.Deflate)
   8:             {
   9:                 GZipStream stream2 = new GZipStream(stream, CompressionMode.Compress, true);
  10:                 stream2.Write(decompressedData, 0, decompressedData.Length);
  11:                 stream2.Close();
  12:             }
  13:             else
  14:             {
  15:                 DeflateStream stream3 = new DeflateStream(stream, CompressionMode.Compress, true);
  16:                 stream3.Write(decompressedData, 0, decompressedData.Length);
  17:                 stream3.Close();
  18:             }
  19:             return stream.ToArray();
  20:         }
  21:     }
  22:  
  23:     public static byte[] Decompress(byte[] compressedData, CompressionAlgorithm algorithm)
  24:     {
  25:         using (MemoryStream stream = new MemoryStream(compressedData))
  26:         {
  27:             if (algorithm == CompressionAlgorithm.Deflate)
  28:             {
  29:                 using (GZipStream stream2 = new GZipStream(stream, CompressionMode.Decompress))
  30:                 {
  31:                     return LoadToBuffer(stream2);
  32:                 }
  33:             }
  34:             else
  35:             {
  36:                 using (DeflateStream stream3 = new DeflateStream(stream, CompressionMode.Decompress))
  37:                 {
  38:                     return LoadToBuffer(stream3);
  39:                 }
  40:             }
  41:         }
  42:     }
  43:  
  44:     private static byte[] LoadToBuffer(Stream stream)
  45:     {
  46:         using (MemoryStream stream2 = new MemoryStream())
  47:         {
  48:             int num;
  49:             byte[] buffer = new byte[0x400];
  50:             while ((num = stream.Read(buffer, 0, buffer.Length)) > 0)
  51:             {
  52:                 stream2.Write(buffer, 0, num);
  53:             }
  54:             return stream2.ToArray();
  55:         }
  56:     }
  57: }

三、MessageCompressor——用于消息压缩与解压的组件

而针对消息的压缩和解压缩通过如下一个MessageCompressor来完成。具体来说，我们通过上面定义的DataCompressor对消息的主体部分内容进行压缩，并将压缩后的内容存放到一个预定义的XML元素中（名称和命名空间分别为CompressedBody和http://www.artech.com/comporession/），同时添加相应的MessageHeader表示消息经过了压缩，以及采用的压缩算法。对于解压缩，则是通过消息是否具有相应的MessageHeader判断该消息是否经过压缩，如果是则根据相应的算法对其进行解压缩。具体的实现如下：

   1: public class MessageCompressor
   2:  {
   3:      public MessageCompressor(CompressionAlgorithm algorithm)
   4:      {
   5:          this.Algorithm = algorithm;
   6:      }
   7:      public Message CompressMessage(Message sourceMessage)
   8:      {
   9:          byte[] buffer;
  10:          using (XmlDictionaryReader reader1 = sourceMessage.GetReaderAtBodyContents())
  11:          {
  12:              buffer = Encoding.UTF8.GetBytes(reader1.ReadOuterXml());
  13:          }
  14:          if (buffer.Length == 0)
  15:          {
  16:              Message emptyMessage = Message.CreateMessage(sourceMessage.Version, (string)null);
  17:              sourceMessage.Headers.CopyHeadersFrom(sourceMessage);
  18:              sourceMessage.Properties.CopyProperties(sourceMessage.Properties);
  19:              emptyMessage.Close();
  20:              return emptyMessage;
  21:          }
  22:          byte[] compressedData = DataCompressor.Compress(buffer, this.Algorithm);
  23:          string copressedBody = CompressionUtil.CreateCompressedBody(compressedData);
  24:          XmlTextReader reader = new XmlTextReader(new StringReader(copressedBody), new NameTable());
  25:          Message message2 = Message.CreateMessage(sourceMessage.Version, null, (XmlReader)reader);
  26:          message2.Headers.CopyHeadersFrom(sourceMessage);
  27:          message2.Properties.CopyProperties(sourceMessage.Properties);
  28:          message2.AddCompressionHeader(this.Algorithm);
  29:          sourceMessage.Close();
  30:          return message2;
  31:      }
  32:  
  33:      public Message DecompressMessage(Message sourceMessage)
  34:      {
  35:          if (!sourceMessage.IsCompressed())
  36:          {
  37:              return sourceMessage;
  38:          }
  39:          CompressionAlgorithm algorithm = sourceMessage.GetCompressionAlgorithm();
  40:          sourceMessage.RemoveCompressionHeader();
  41:          byte[] compressedBody = sourceMessage.GetCompressedBody();
  42:          byte[] decompressedBody = DataCompressor.Decompress(compressedBody, algorithm);
  43:          string newMessageXml = Encoding.UTF8.GetString(decompressedBody);
  44:          XmlTextReader reader2 = new XmlTextReader(new StringReader(newMessageXml));
  45:          Message newMessage = Message.CreateMessage(sourceMessage.Version, null, reader2);
  46:          newMessage.Headers.CopyHeadersFrom(sourceMessage);
  47:          newMessage.Properties.CopyProperties(sourceMessage.Properties);
  48:          return newMessage;
  49:      }
  50:  
  51:      public CompressionAlgorithm Algorithm { get; private set; }
  52:  }

下面是针对Message类型而定义了一些扩展方法和辅助方法。

   1: public static class CompressionUtil
   2: {
   3:     public const string CompressionMessageHeader = "Compression";
   4:     public const string CompressionMessageBody = "CompressedBody";
   5:     public const string Namespace = "http://www.artech.com/compression";
   6:  
   7:     public static bool IsCompressed(this Message message)
   8:     {
   9:         return message.Headers.FindHeader(CompressionMessageHeader, Namespace) > -1;
  10:     }
  11:  
  12:     public static void AddCompressionHeader(this Message message, CompressionAlgorithm algorithm)
  13:     { 
  14:         message.Headers.Add(MessageHeader.CreateHeader(CompressionMessageHeader, Namespace, string.Format("algorithm = \"{0}\"",algorithm)));
  15:     }
  16:  
  17:     public static void RemoveCompressionHeader(this Message message)
  18:     {
  19:         message.Headers.RemoveAll(CompressionMessageHeader, Namespace);
  20:     }
  21:  
  22:     public static CompressionAlgorithm GetCompressionAlgorithm(this Message message)
  23:     {
  24:         if (message.IsCompressed())
  25:         {
  26:             var algorithm = message.Headers.GetHeader<string>(CompressionMessageHeader, Namespace);
  27:             algorithm = algorithm.Replace("algorithm =", string.Empty).Replace("\"", string.Empty).Trim();
  28:             if (algorithm == CompressionAlgorithm.Deflate.ToString())
  29:             {
  30:                 return CompressionAlgorithm.Deflate;
  31:             }
  32:  
  33:             if (algorithm == CompressionAlgorithm.GZip.ToString())
  34:             {
  35:                 return CompressionAlgorithm.GZip;
  36:             }
  37:             throw new InvalidOperationException("Invalid compression algrorithm!");
  38:         }
  39:         throw new InvalidOperationException("Message is not compressed!");
  40:     }
  41:  
  42:     public static byte[] GetCompressedBody(this Message message)
  43:     {
  44:         byte[] buffer;
  45:         using (XmlReader reader1 = message.GetReaderAtBodyContents())
  46:         {
  47:             buffer = Convert.FromBase64String(reader1.ReadElementString(CompressionMessageBody, Namespace));
  48:         }
  49:         return buffer;
  50:     }
  51:  
  52:     public static string CreateCompressedBody(byte[] content)
  53:     {
  54:         StringWriter output = new StringWriter();
  55:         using (XmlWriter writer2 = XmlWriter.Create(output))
  56:         {
  57:             writer2.WriteStartElement(CompressionMessageBody, Namespace);
  58:             writer2.WriteBase64(content, 0, content.Length);
  59:             writer2.WriteEndElement();
  60:         }
  61:         return output.ToString();
  62:     }
  63: }

四、CompressionMessageFormatter——用于对请求/回复消息压缩和解压缩的组件

消息的序列化和反序列化最终是通过MessageFormatter来完成的。具体来说，客户端通过ClientMessageFormatter实现对请求消息的序列化和对回复消息的序列化，而服务端通过DispatchMessageFormatter实现对请求消息的反序列化和对回复消息的序列化。

在默认的情况下，WCF选用的MessageFormatter为DataContractSerializerOperationFormatter，它采用DataContractSerializer进行实际的序列化和法序列化操作。我们自定义的MessageFormatter实际上是对DataContractSerializerOperationFormatter的封装，我们依然使用它来完成序列化和反序列化工作，额外实现序列化后的压缩和法序列化前的解压缩。

因为DataContractSerializerOperationFormatter是一个internal类型，我们只有通过反射的方式来创建它。如下的代码片断为用于进行消息压缩与解压缩的自定义MessageFormatter，即CompressionMessageFormatter的定义。

   1: public class CompressionMessageFormatter: IDispatchMessageFormatter, IClientMessageFormatter
   2: {
   3:     private const string DataContractSerializerOperationFormatterTypeName = "System.ServiceModel.Dispatcher.DataContractSerializerOperationFormatter, System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
   4:  
   5:     public IDispatchMessageFormatter InnerDispatchMessageFormatter { get; private set; }
   6:     public IClientMessageFormatter InnerClientMessageFormatter { get; private set; }
   7:     public MessageCompressor MessageCompressor { get; private set; }
   8:  
   9:     public CompressionMessageFormatter(CompressionAlgorithm algorithm, OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory)
  10:     {
  11:         this.MessageCompressor = new MessageCompressor(algorithm);
  12:         Type innerFormatterType = Type.GetType(DataContractSerializerOperationFormatterTypeName);
  13:         var innerFormatter = Activator.CreateInstance(innerFormatterType, description, dataContractFormatAttribute, serializerFactory);
  14:         this.InnerClientMessageFormatter = innerFormatter as IClientMessageFormatter;
  15:         this.InnerDispatchMessageFormatter = innerFormatter as IDispatchMessageFormatter;
  16:     }
  17:  
  18:     public void DeserializeRequest(Message message, object[] parameters)
  19:     {
  20:         message = this.MessageCompressor.DecompressMessage(message);
  21:         this.InnerDispatchMessageFormatter.DeserializeRequest(message, parameters);
  22:     }
  23:  
  24:     public Message SerializeReply(MessageVersion messageVersion, object[] parameters, object result)
  25:     {
  26:         var message = this.InnerDispatchMessageFormatter.SerializeReply(messageVersion, parameters, result);
  27:         return this.MessageCompressor.CompressMessage(message);
  28:     }
  29:  
  30:     public object DeserializeReply(Message message, object[] parameters)
  31:     {
  32:         message = this.MessageCompressor.DecompressMessage(message);
  33:         return this.InnerClientMessageFormatter.DeserializeReply(message, parameters);
  34:     }
  35:  
  36:     public Message SerializeRequest(MessageVersion messageVersion, object[] parameters)
  37:     {
  38:         var message = this.InnerClientMessageFormatter.SerializeRequest(messageVersion, parameters);
  39:         return this.MessageCompressor.CompressMessage(message);
  40:     }
  41: }

五、CompressionOperationBehaviorAttribute——将CompressionMessageFormatter用于WCF运行时框架的操作行为

ClientMessageFormatter和DispatchMessageFormatter实际上属于ClientOperation和DispatchOperation的组件。我们可以通过如下一个自定义的操作行为CompressionOperationBehaviorAttribute将其应用到相应的操作上。

   1: [AttributeUsage( AttributeTargets.Method)]
   2: public class CompressionOperationBehaviorAttribute: Attribute, IOperationBehavior
   3: {
   4:     public CompressionAlgorithm Algorithm { get; set; }
   5:  
   6:     public void AddBindingParameters(OperationDescription operationDescription, BindingParameterCollection bindingParameters) { }
   7:  
   8:     public void ApplyClientBehavior(OperationDescription operationDescription, ClientOperation clientOperation)
   9:     {
  10:         clientOperation.SerializeRequest = true;
  11:         clientOperation.DeserializeReply = true;
  12:         var dataContractFormatAttribute = operationDescription.SyncMethod.GetCustomAttributes(typeof(DataContractFormatAttribute), true).FirstOrDefault() as DataContractFormatAttribute;
  13:         if (null == dataContractFormatAttribute)
  14:         {
  15:             dataContractFormatAttribute = new DataContractFormatAttribute();
  16:         }
  17:  
  18:         var dataContractSerializerOperationBehavior = operationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
  19:         clientOperation.Formatter = new CompressionMessageFormatter(this.Algorithm, operationDescription, dataContractFormatAttribute, dataContractSerializerOperationBehavior);            
  20:     }
  21:  
  22:     public void ApplyDispatchBehavior(OperationDescription operationDescription, DispatchOperation dispatchOperation)
  23:     {
  24:         dispatchOperation.SerializeReply        = true;
  25:         dispatchOperation.DeserializeRequest    = true;
  26:         var dataContractFormatAttribute = operationDescription.SyncMethod.GetCustomAttributes(typeof(DataContractFormatAttribute), true).FirstOrDefault() as DataContractFormatAttribute;
  27:         if (null == dataContractFormatAttribute)
  28:         {
  29:             dataContractFormatAttribute = new DataContractFormatAttribute();
  30:         }
  31:         var dataContractSerializerOperationBehavior = operationDescription.Behaviors.Find<DataContractSerializerOperationBehavior>();
  32:         dispatchOperation.Formatter = new CompressionMessageFormatter(this.Algorithm, operationDescription, dataContractFormatAttribute, dataContractSerializerOperationBehavior);     
  33:     }
  34:  
  35:     public void Validate(OperationDescription operationDescription) { }
  36: }

六、查看结构压缩后的消息

为了验证应用了CompressionOperationBehaviorAttribute特性的操作方法对应的消息是否经过了压缩，我们可以通过一个简单的例子来检验。我们采用常用的计算服务的例子，下面是服务契约和服务类型的定义。我们上面定义的CompressionOperationBehaviorAttribute应用到服务契约的Add操作上。

   1: [ServiceContract(Namespace= "http://www.artech.com/")]
   2: public interface ICalculator
   3: {
   4:     [OperationContract]
   5:     [CompressionOperationBehavior]
   6:     double Add(double x, double y);
   7: }
   8: public class CalculatorService : ICalculator
   9: {
  10:     public double Add(double x, double y)
  11:     {
  12:         return x + y;
  13:     }
  14: }

我们采用BasicHttpBinding作为终结点的绑定类型（具体的配置请查看源代码），下面是通过Fiddler获取的消息的内容，它们的主体部分都经过了基于压缩的编码。

   1: <s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
   2:   <s:Header>
   3:     <Compression xmlns="http://www.artech.com/compression">algorithm = "GZip"</Compression>
   4:   </s:Header>
   5:   <s:Body>
   6:     <CompressedBody xmlns="http://www.artech.com/compression">7L0HYBx ... CQAA//8=</CompressedBody>
   7:   </s:Body>
   8: </s:Envelope>

回复消息

   1: <s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
   2:   <s:Header>
   3:     <Compression xmlns="http://www.artech.com/compression">algorithm = "GZip"</Compression>
   4:   </s:Header>
   5:   <s:Body>
   6:     <CompressedBody xmlns="http://www.artech.com/compression">7L0H...PAAAA//8=</CompressedBody>
   7:   </s:Body>
   8: </s:Envelope>

七、补充说明

由于CompressionMessageFormatter使用基于DataContractSerializer序列化器的DataContractSerializerOperationFormatter进行消息的序列化和发序列化工作。而DataContractSerializer仅仅是WCF用于序列化的一种默认的选择（WCF还可以采用传统的XmlSeriaizer）。为了让CompressionMessageFormatter能够使用其他序列化器，你可以对于进行相应的修正。

CodingSir
关注
WCF 数据压缩传输
08-31
WCF 数据压缩传输 .NET VS
wcf扩展性例子
09-05
这个"wcf扩展性例子"很可能包含了以上一种或多种扩展的实现，通过代码示例展示了如何在实际项目中运用这些机制。`description.html`和`description`文件可能提供了详细的案例介绍，而`license.rtf`包含了项目的授权...
WCF的压缩编码
weixin_33835103的博客
11-22 76
    涉及到分布式部署的项目都会有数据的传输问题：要对需要传输的数据进行压缩。较早的项目中，都是将dataset压缩为流对象（经过序列化的）后进行传递的，压缩比1/4的样子。找到的WCF构架下的数据压缩方案主要有微软提供的例子自定义消息编码器：压缩编码器：http://msdn.microsoft.com/zh-cn/library/ms751458.aspx，采用了GZip算法。 代码下载地...
[No0000131]WCF压缩传输方案整理
weixin_30298497的博客
04-13 78
1.WCF进阶:将编码后的字节流压缩传输 2.通过WCF扩展实现消息压缩 3.WCF 消息压缩性能问题及解决方法 转载于:https://www.cnblogs.com/Chary/p/No0000131.html
WCF消息压缩
weixin_33786077的博客
04-05 94
对于WCF应用来说，传输前压缩请求消息和回复消息，不但可以降低网络流量，也可以提高网络传输的性能 一、消息压缩方案 二、用于数据压缩与解压缩组件 三、用于消息压缩与解压的组件 四、用于对请求/回复消息压缩和解压缩的组件 五、将CompressionMessageFormatter用于WCF运行时框架的操作行为 六、查看结构压缩后的消息 七、扩展 一、...
wcf 数据压缩技术dome
11-14
本篇文章将深入探讨WCF数据压缩技术，并通过一个简单的Dome（示例）来展示如何实现这一功能。 WCF数据压缩的核心目标是减小在网络中传输的数据量。这在处理大量数据或者网络环境较差时尤其重要。压缩可以显著降低...
WCFService可以通过web调用和WCF服务访问
04-21
通过对该项目的分析和学习，可以深入理解如何配置和实现一个既支持Web调用又支持WCF调用的WCF服务。 总之，WCF服务的这种多模式调用方式体现了其高度的灵活性和互操作性，使得不同平台和语言的应用程序可以方便地...
WCF服务与消息队列通信：使用消息队列实现WCF服务间通信
通过WCF服务，可以实现跨平台、跨语言的通信，提供了丰富的通信协议与消息格式支持。 ## 1.1 WCF服务概述 WCF服务提供了一种灵活的通信机制，允许开发人员定义自己的服务合同（Service Contracts）、数据合同...
C# 局域网通信WCF
03-27
本文将深入探讨如何使用C#、Windows Communication Foundation (WCF) 和.NET技术来实现局域网(LAN)内的通信，特别是构建一个网络聊天程序。 **WCF简介** Windows Communication Foundation是微软提供的一种面向服务...
WCF压缩传输
11-19
一个WCF压缩传输的案例，大家一起下载学习
WCF编程系列之wcf使用压缩提高传输数据性能的方法
01-18
WCF编程系列之wcf使用压缩提高传输数据性能的方法
WCF数据压缩传输
05-20 142
如何在WCF通信时的通道两端自动进行数据压缩和解压缩。而且，这个过程是完全透明的，用户及编程人员根本不需要知道它的存在，相当于HOOK在两端的一个组件。可以使用中网络带宽较小的网络环境中。 源代码 转载于:https://www.cnblogs.com/jacker1979/archive/2010/05/20/1740156.html...
WCF进阶:将编码后的字节流压缩传输
weixin_33894992的博客
01-08 330
  在前面两篇文章WCF进阶：将消息正文Base64编码和WCF进阶:为每个操作附加身份信息中讲述了如何通过拦截消息的方式来记录或者修改消息，这种方式在特定条件下可以改变消息编码格式，但实现方式并不规范，而且使用范围也有限制。 WCF缺省提供了三种编码器（MessageEncoder）：TextMessageEncoder，BinaryMessageEncoder，MtomMessageEncod...
WCF通信及通信压缩总结
weixin_30379531的博客
08-02 198
　　近期研究发现WCF的压缩或加密方式有多种途径实现，实现的细节网上有很多，不再赘述，这里只做一个总结，以便之后回顾： 　　 　　WCF压缩的主要解决方法主要有以下四种： 通过自定义MessageEncoder和MessageEncodingBindingElement 来完成。具体的实现，可以参阅文章《WCF进阶:将编码后的字节流压缩传输》和MSDN的文章《Custom Message...
WCF 消息压缩性能问题及解决方法
weixin_30642029的博客
08-20 224
最近使用WCF作为通迅框架开发一套信息系统,系统使用传统C/S框架,系统有可能会部署在互联网上,因此决定对传输的数据进行GZIP压缩,原来在使用.NET Remoting时,可以使用插入自定义的ChannelSink来实现数据压缩,作为.NET Remoting的替代方案的WCF,实现起来也很容易，且方法不止一种，主要解决方法主要有以下四种： 通过自定义MessageEncoder和Mess...
WCF传输1-你是否使用过压缩或Json序列化？
weixin_34391445的博客
11-01 141
1.当遇到需要传输大量数据时，怎么样传输数据？ 2.压缩数据有哪几种常见的方式？ 问题1解答：通过压缩来传输数据 问题2解答： （1）WCF自带的压缩方式 （2）自定义WCF binding进行压缩 （3）将对象序列化为JSON格式 今天来探讨一下WCF自带的压缩方式Gzip和Json...
深入解析WCF App案例，掌握WCF应用精髓
开发者可以在WCF中实现复杂的业务逻辑，通过定义接口（即服务合约）来暴露服务的方法，并通过配置文件来配置服务的行为和绑定。 此外，WCF还支持元数据交换（MEX），允许服务公开其元数据，以便客户端可以自动地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值