对象序列化

通过socket来发送信息的时候，它只接受byte[]类型的参数，怎么样把一个对象转为byte[]，之后将它通过socket发送呢？
      前段时间测试一个P2P程序，通过UDP来发送数据。UdpClient.Send(..)方法需要一个byte[]这样的参数。想当年用c++Builder的时候，只需要用强制转换就行了。如今时过境迁，.net平台上处理这事却似乎有些麻烦！今天恰好在csdn上见一帖，又看到了另一种处理方法，^_^, 现将我所知的3种方法总结一下。

    一、通过序列化将对象转为byte[], 之后再反序化为对象

     public   class  P2PHelper
     {        /**//// <summary>
        /// 将一个object对象序列化，返回一个byte[]
        /// </summary>
        /// <param name="obj">能序列化的对象</param>
        /// <returns></returns>
        public static byte[] ObjectToBytes(object obj)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(ms, obj);
                return ms.GetBuffer();
            }
        }

        /**//// <summary>
        /// 将一个序列化后的byte[]数组还原
        /// </summary>
        /// <param name="Bytes"></param>
        /// <returns></returns>
        public static object BytesToObject(byte[] Bytes)
        {
            using (MemoryStream ms = new MemoryStream(Bytes))
            {
                IFormatter formatter = new BinaryFormatter();
                return formatter.Deserialize(ms);
            }
        }

    }

       这种方法通过序列化来处理对象，虽然简单，然后每一个对象序列化后都至少有256字节, 会导致网络流量的增大。想想，如果一个对象只有10个字节，然而发送的时候却有256字节~~~~~~恐怖（注：多谢 双鱼座 的指正)

        二、使用BitConvert类来处理
       很麻烦的一种方法，我这等懒人是不敢用这种方法的了。不过这篇文章 http://pierce.cnblogs.com/archive/2005/06/21/178343.aspx 上有些讲解，想了解的朋友可以去看看。

        三、使用Unsafe方式
       先看代码（尚不知是否有memory  leak!!!)：

     class   Test
     {
        public static unsafe  byte[] Struct2Bytes(Object obj)
        {
            int size = Marshal.SizeOf(obj);
            byte[] bytes = new byte[size];
            fixed(byte* pb = &bytes[0])
            {
                Marshal.StructureToPtr(obj,new IntPtr(pb),true);
            }
            return bytes;
        }

        public static unsafe Object Bytes2Struct(byte[] bytes)
        {
            fixed(byte* pb = &bytes[0])
            {
                return Marshal.PtrToStructure(new IntPtr(pb), typeof(Data));
            }
        }
    }

      这种方法的确不错，即不增加网络流量，处理起来也简单。只是，似乎它只能处理Struct, 对于Class就有麻烦了。(注：请查看 sunmast  的评论)

sunmast  的评论:

标准的方法就是方法一。

然后每一个对象序列化后都至少有1K, 会导致网络流量的增大。想想，如果一个对象只有10个字节，然而发送的时候却有1K~~~~~~恐怖

对此我非常质疑。如果对象真的只占10个字节的话，肯定只有256字节。BinaryFormatter使用空间是成倍增长的，当实际占用需要大于256字节时，为512字节；当实际占用需要大于512字节时，为1024字节；然后是2048、4096....依次类推。
除了一个文本的用于描述程序集名、类型名和字段名的内容外，所占用的空间是实际所需的。

如果楼主想节省字节，有两个方案：
最好的方法是采用标准的压缩方式将内容压缩，一般会非常小，甚至可能比实际占用的空间还要小。网上有大量开源的压缩类库可以使用。
如果嫌这个方法麻烦，有个方法更易于实现。就是数一数尾部有多少个0，清除这些0，补上一个字节的空间，写上多少个零就行了。不过这种方式省不了多少字节。

using System;
using System.Collections;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

[Serializable]
public class MyClass
{
 private string _Value;
 
 public string Value
 {
  get
  {
   return _Value;
  }
  set
  {
   _Value = value;
  }
 }
 
 public static void Main()
 {
  int[] lens = new int[] {100, 800, 1000, 3000, 6000, 10000};
  MyClass myClass = new MyClass();
  foreach (int len in lens)
  {
   myClass.Value = new string('z', len);
   byte[] buff = ObjectToBytes(myClass);
   WL("Field Length: {0}, Buffer Length: {1}", len, buff.Length);
  }
  RL();
 }
 
 public static byte[] ObjectToBytes(object obj)
 {
  using (MemoryStream ms = new MemoryStream())
  {
   IFormatter formatter = new BinaryFormatter();
   formatter.Serialize(ms, obj);
   return ms.GetBuffer();
  }
 }

 private static void WL(string text, params object[] args)
 {
  Console.WriteLine(text, args); 
 }
 
 private static void RL()
 {
  Console.ReadLine(); 
 }
 
 private static void Break()
 {
  System.Diagnostics.Debugger.Break();
 }
}