修改memecache客户端API，解决ttserver反序列化问题

　　之前在一篇随笔中提到使用Memcache的API无法正确将保存在ttserver中的值正确反序列化，原因是，Memcache协议中的对象类型值未被保存到ttserver上，于是简单的修改了一下Memcache API（使用的beit-memcached）中的Serializer.cs文件，将序列化对象的原始类型保存在序列化串的第一个字节中，也就是将值的类型，连同值一起保存到ttserver上。

 

代码

// Copyright (c) 2007-2008 Henrik Schr鰀er, Oliver Kofoed Pedersen

// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:

// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

#region  文件信息
/* =================================================================
 *  文件：Serializer.cs
 *  创建者：<原作者>
 *  创建日期：<未知>
 *  最后修改：（楼下请注意保持队形）
 *  ##############################################################
 *  时间          修改人                      备注
 *  2010-04-19       田真                 因为TT不支持Memcached的类型存储，这里修改了序列化方式，主要体现在对Serialize和Deserialize方法的修改
 *  2010-04-19       田真                 增加了MergedBuffer和ParsedBuffer两个方法
 *  2010-04-19       田真                 修改SerializedType继承自byte，以前是ushort
 *  2010-04-19       田真                 修改CompressedByteArray = 255, CompressedObject = 256, CompressedString = 257
 *                                              为：CompressedByteArray = 253, CompressedObject = 254, CompressedString = 255
 *  ##############################################################
 * ================================================================ */
#endregion

using  System;
using  System.IO;
using  System.IO.Compression;
using  System.Runtime.Serialization.Formatters.Binary;
using  System.Text;

namespace  SubCon.Caching.MemCached
{
     ///   <summary>
     ///  序列化的对象类型
     ///   </summary>
     internal   enum  SerializedType :  byte
    {
        ByteArray     =   0 ,
        Object         =   1 ,
        String         =   2 ,
        Datetime     =   3 ,
        Bool         =   4 ,
         // SByte        = 5,  // Makes no sense.
        Byte         =   6 ,
        Short         =   7 ,
        UShort         =   8 ,
        Int             =   9 ,
        UInt         =   10 ,
        Long         =   11 ,
        ULong         =   12 ,
        Float         =   13 ,
        Double         =   14 ,

        CompressedByteArray     =   253 ,
        CompressedObject     =   254 ,
        CompressedString     =   255 ,
    }

     ///   <summary>
     ///  存储值序列器
     ///   </summary>
     internal   class  Serializer
    {
         ///   <summary>
         ///  序列化存储值
         ///   </summary>
         ///   <param name="value"> 要进行序列化的值 </param>
         ///   <param name="type"> 被序列的值是什么类型 </param>
         ///   <param name="compressionThreshold"> 压缩基准，当序列化后的字节数组长度大于该值时进行压缩 </param>
         ///   <returns></returns>
         public   static   byte [] Serialize( object  value,  out  SerializedType type,  uint  compressionThreshold) {
             byte [] bytes;
             if  (value  is   byte []) {
                bytes  =  ( byte [])value;
                type  =  SerializedType.ByteArray;
                 if  (bytes.Length  >  compressionThreshold) {
                    bytes  =  Compress(bytes);
                    type  =  SerializedType.CompressedByteArray;
                }
            }  else   if  (value  is   string ) {
                bytes  =  Encoding.UTF8.GetBytes(( string )value);
                type  =  SerializedType.String;
                 if  (bytes.Length  >  compressionThreshold) {
                    bytes  =  Compress(bytes);
                    type  =  SerializedType.CompressedString;
                }
            }  else   if  (value  is  DateTime) {
                bytes  =  BitConverter.GetBytes(((DateTime)value).Ticks);
                type  =  SerializedType.Datetime;
            }  else   if  (value  is   bool ) {
                bytes  =   new   byte []{( byte )(( bool )value  ?   1  :  0 )};
                type  =  SerializedType.Bool;
            }  else   if  (value  is   byte ) {
                bytes  =   new   byte []{( byte )value};
                type  =  SerializedType.Byte;
            }  else   if  (value  is   short ) {
                bytes  =  BitConverter.GetBytes(( short )value);
                type  =  SerializedType.Short;
            }  else   if  (value  is   ushort ) {
                bytes  =  BitConverter.GetBytes(( ushort )value);
                type  =  SerializedType.UShort;
            }  else   if  (value  is   int ) {
                bytes  =  BitConverter.GetBytes(( int )value);
                type  =  SerializedType.Int;
            }  else   if  (value  is   uint ) {
                bytes  =  BitConverter.GetBytes(( uint )value);
                type  =  SerializedType.UInt;
            }  else   if  (value  is   long ) {
                bytes  =  BitConverter.GetBytes(( long )value);
                type  =  SerializedType.Long;
            }  else   if  (value  is   ulong ) {
                bytes  =  BitConverter.GetBytes(( ulong )value);
                type  =  SerializedType.ULong;
            }  else   if  (value  is   float ) {
                bytes  =  BitConverter.GetBytes(( float )value);
                type  =  SerializedType.Float;
            }  else   if  (value  is   double ) {
                bytes  =  BitConverter.GetBytes(( double )value);
                type  =  SerializedType.Double;
            }  else  {
                 // Object
                 using (MemoryStream ms  =   new  MemoryStream()) {
                     new  BinaryFormatter().Serialize(ms, value);
                    bytes  =  ms.ToArray();
                    type  =  SerializedType.Object;
                     if  (bytes.Length  >  compressionThreshold) {
                        bytes  =  Compress(bytes);
                        type  =  SerializedType.CompressedObject;
                    }
                }
            }
             // 针对TT进行的修改
             // edited by: 2010-4-19
             // 田真
             return  MergedBuffer(bytes, type);
        }

         ///   <summary>
         ///  解析缓存字节数组，解析出实际数据和数据类型
         ///   </summary>
         ///   <param name="buffer"></param>
         ///   <param name="type"></param>
         ///   <returns></returns>
         private   static   byte [] ParsedBuffer( byte [] buffer,  out  SerializedType type)
        {
             // 构造实际数据字节数组
             byte [] bytes  =   new   byte [buffer.Length  -   1 ];
             // 提取类型
             if  ( ! Enum.IsDefined( typeof (SerializedType), buffer[ 0 ]))
                type  =  SerializedType.ByteArray;
             else
                type  =  (SerializedType)buffer[ 0 ];
             // 提取数据
            Buffer.BlockCopy(buffer,  1 , bytes,  0 , bytes.Length);
             return  bytes;

        }

         ///   <summary>
         ///  将序列化类型整合到存储的字节数组中（因为TT不支持Memcached的Type值存储）
         ///   </summary>
         ///   <param name="bytes"> 字节数组 </param>
         ///   <param name="type"> 字节数组的类型 </param>
         ///   <returns></returns>
         private   static   byte [] MergedBuffer( byte [] bytes, SerializedType type)
        { 
             // 增加一个字节，用于存放字节数组的类型
             byte [] buffer  =   new   byte [bytes.Length  +   1 ];
             // 将类型存储到第一个字节中
            buffer[ 0 ]  =  ( byte )type;
            Buffer.BlockCopy(bytes,  0 , buffer,  1 , bytes.Length);
             return  buffer;
        }

         ///   <summary>
         ///  压缩指定的字节数组
         ///   </summary>
         ///   <param name="bytes"></param>
         ///   <returns></returns>
         private   static   byte [] Compress( byte [] bytes) {
             using  (MemoryStream ms  =   new  MemoryStream()) {
                 using  (DeflateStream gzs  =   new  DeflateStream(ms, CompressionMode.Compress,  false )) {
                    gzs.Write(bytes,  0 , bytes.Length);
                }
                ms.Close();
                 return  ms.ToArray();
            }
        }

         ///   <summary>
         ///  解压缩指定的字节数组
         ///   </summary>
         ///   <param name="bytes"></param>
         ///   <returns></returns>
         private   static   byte [] Decompress ( byte [] bytes) {
             using  (MemoryStream ms  =   new  MemoryStream(bytes,  false )) {
                 using (DeflateStream gzs  =   new  DeflateStream(ms, CompressionMode.Decompress,  false )) {
                     using (MemoryStream dest  =   new  MemoryStream()) {
                         byte [] tmp  =   new   byte [bytes.Length];
                         int  read;
                         while  ((read  =  gzs.Read(tmp,  0 , tmp.Length))  !=   0 ) {
                            dest.Write(tmp,  0 , read);
                        }
                        dest.Close();
                         return  dest.ToArray();
                    }
                }
            }
        }

         ///   <summary>
         ///  反序列化数据
         ///   </summary>
         ///   <param name="bytes"></param>
         ///   <param name="type"></param>
         ///   <returns></returns>
         public   static   object  Deserialize( byte [] bytes, SerializedType type) {
             // 针对TT进行的修改
             // edited by: 2010-4-19
             // 田真
            bytes  =  ParsedBuffer(bytes,  out  type);
             switch  (type) {
                 case  SerializedType.String:
                     return  Encoding.UTF8.GetString(bytes);
                 case  SerializedType.Datetime:
                     return   new  DateTime(BitConverter.ToInt64(bytes,  0 ));
                 case  SerializedType.Bool:
                     return  bytes[ 0 ]  ==   1 ;
                 case  SerializedType.Byte:
                     return  bytes[ 0 ];
                 case  SerializedType.Short:
                     return  BitConverter.ToInt16(bytes,  0 );
                 case  SerializedType.UShort:
                     return  BitConverter.ToUInt16(bytes,  0 );
                 case  SerializedType.Int:
                     return  BitConverter.ToInt32(bytes,  0 );
                 case  SerializedType.UInt:
                     return  BitConverter.ToUInt32(bytes,  0 );
                 case  SerializedType.Long:
                     return  BitConverter.ToInt64(bytes,  0 );
                 case  SerializedType.ULong:
                     return  BitConverter.ToUInt64(bytes,  0 );
                 case  SerializedType.Float:
                     return  BitConverter.ToSingle(bytes,  0 );
                 case  SerializedType.Double:
                     return  BitConverter.ToDouble(bytes,  0 );
                 case  SerializedType.Object:
                     using (MemoryStream ms  =   new  MemoryStream(bytes)) {
                         return   new  BinaryFormatter().Deserialize(ms);
                    }
                 case  SerializedType.CompressedByteArray:
                     return  Deserialize(Decompress(bytes), SerializedType.ByteArray);
                 case  SerializedType.CompressedString:
                     return  Deserialize(Decompress(bytes), SerializedType.String);
                 case  SerializedType.CompressedObject:
                     return  Deserialize(Decompress(bytes), SerializedType.Object);
                 case  SerializedType.ByteArray:
                 default :
                     return  bytes;
            }
        }
    }
}

 

 

Raw file: Serializer.cs