sophieq

WCF Binary Encoding 產生的大小，幾乎是 .NET Serialization 的一半

http://rickgaribay.net/archive/2008/09/19/comparing-wcf-binary-encoding-to-.net-serialization.aspx

数据序列化之经验积累（2） -- Datacontract formatter

http://blog.csdn.net/nileel/article/details/6043549

 

WCF之資料傳輸Serialization方式之比較: 大量縮減資料大小的方法

 

transferList的型別是List<BU>測試BU共有370個

 

一般WCF在endpoint與server上的預設傳輸大小如下

   maxBufferSize="65536"maxBufferPoolSize="524288"maxReceivedMessageSize="65536"

 

測試下面Serialize三種方式

stringtextSerializeData = TextSerialize(transferList);

byte[] NetBinary = NetBinarySerialize(transferList);

byte[] WcfNetBinary = BinarySerialize(transferList, true);

 

	以物件方式直接傳送	TextSerialize (DataContractSerializer)	BinarySerialize (BinaryFormatter)		BinarySerialize (DataContractSerializer)
壓縮		NO	NO	YES	NO	YES
Capacity		131072			64448
Length		71106 (超過maxBufferSize65536)			47421 (66%)	4866 (6.84%)
資料減少					34%	93.16%
說明	雖然wcf支援物件的資料交換；但 資料交換用物件方式，不好	產生XML之後， 序列化成text	產生XML之後，序列化成Binary		產生XML之後，序列化成Binary   使用DataContractSerializer產生的XML比BinaryFormatter產生的檔案小

BinaryFormatter 沒測試，但是結果是比DataContractSerializer差的，因為他在XML產生就比DataContractSerializer大了，轉Binary就不用看了。

使用DataContractSerializer之後，資料縮減到只剩大小的66% (PS:資料量愈大的話，效果愈好，即還可比66%小)

再壓縮之後，資料縮減到只剩原大小的6.84%(71106->4866)(壓縮比9倍)

 

需要配合的項目:

(1)     Coretronic.BI.Organization中的class需改寫成Serializable

(2)     Serialize method建構

TextSerialize 產生之XML

 

==============================================

   public byte[] BinarySerialize(object obj, bool compress)
        {
            byte[] result;
            if (obj == null)
            {
                return null;
            }

            using (MemoryStream memoryStream = new MemoryStream())
            {
                DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
                using (XmlDictionaryWriter binaryDictionaryWriter = XmlDictionaryWriter.CreateBinaryWriter(memoryStream))
                {
                    serializer.WriteObject(binaryDictionaryWriter, obj);                
                    binaryDictionaryWriter.Flush();
                }
                result = memoryStream.ToArray();
             
                if (compress)
                {
                    result = CompressByte(result);
                }
            }
            return result;
        }



     public List BinaryDeserialize(byte[] info, bool decompress)
        {
            List ret = new List();
            if (info == null || info.Length <= 0)
            {
                return ret;
            }
            if (decompress)
            {
                info = DeCompressByte(info);
            }
            using (MemoryStream stream = new MemoryStream(info))
            {
                System.Runtime.Serialization.DataContractSerializer serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(List));
                using (System.Xml.XmlDictionaryReader binaryDictionaryReader = System.Xml.XmlDictionaryReader.CreateBinaryReader(stream, System.Xml.XmlDictionaryReaderQuotas.Max))
                {
                    ret = (List)serializer.ReadObject(binaryDictionaryReader);
                }
            }
            return ret;
        }


     public static byte[] CompressByte(byte[] data)
        {
            MemoryStream ms = new MemoryStream();
            Stream s = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress);
            s.Write(data, 0, data.Length);
            s.Close();
            return ms.ToArray();
        }


  public static byte[] DeCompressByte(byte[] data)
        {
            byte[] writeData = new byte[2048];
            MemoryStream ms = new MemoryStream(data);
            Stream sm = new System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress);
            MemoryStream outStream = new MemoryStream();
            while (true)
            {
                int size = sm.Read(writeData, 0, writeData.Length);
                if (size > 0)
                {
                    outStream.Write(writeData, 0, size);
                }
                else
                {
                    break;
                }
            }
            sm.Close();
            byte[] outArr = outStream.ToArray();
            outStream.Close();
            return outArr;
        }

   public string TextSerialize(T obj)
        {
            if (obj == null)
            {
                return null;
            }
            string ret = "";
            using (MemoryStream stream = new MemoryStream())
            {
                DataContractSerializer serializer = new DataContractSerializer(obj.GetType());
                using (XmlDictionaryWriter binaryDictionaryWriter = XmlDictionaryWriter.CreateTextWriter(stream, System.Text.Encoding.UTF8))
                {
                    serializer.WriteObject(binaryDictionaryWriter, obj);
                    binaryDictionaryWriter.Flush();
                }
                ret = System.Text.Encoding.UTF8.GetString(stream.ToArray());   
            }
            return ret;
        }


  public  List Deserialize(string xml)
        {
            List ret = new List();
            if (string.IsNullOrEmpty(xml))
            {
                return ret;
            }
            using (MemoryStream stream = new MemoryStream())
            {
                byte[] bytes = Encoding.UTF8.GetBytes(xml);
                stream.Write(bytes, 0, bytes.Length);
                stream.Position = 0L;
                System.Runtime.Serialization.DataContractSerializer serializer = new System.Runtime.Serialization.DataContractSerializer(typeof(List));
                using (System.Xml.XmlDictionaryReader binaryDictionaryReader = System.Xml.XmlDictionaryReader.CreateTextReader(stream, System.Xml.XmlDictionaryReaderQuotas.Max))
                {
                    ret = (List)serializer.ReadObject(binaryDictionaryReader);
                }
            }
            return ret;
        }

 

http://www.plurk.com/SophieQ