如何将一个泛型对象T 转化为 字节流 存在一个Byte[]中，

Question

如题：
如何将一个泛型对象T 转化为 字节流 存在一个Byte[]中，
void Write(T obj, Byte[] b) 
{}
void Read(Byte[] b, T obj)
{}序列化到Memstream么， 泛型T怎么实现～

Answer 1

首先。你被序列化的类需要用[Serializable]特性修饰，例如：
[Serializable]
public class AA
{
    public int i = 5;
}
那么你可以用如下方法序列化和反序列化：///  <summary>  
///  序列化为二进制字节数组  
///  </summary>  
///  <param  name="request">要序列化的对象 </param>  
///  <returns>字节数组 </returns>  
public static byte[] SerializeBinary<T>(T request)
{
    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
    System.IO.MemoryStream memStream = new System.IO.MemoryStream();
    serializer.Serialize(memStream, request);
    return memStream.GetBuffer();
}
///  <summary>  
///  从二进制数组反序列化得到对象  
///  </summary>  
///  <param  name="buf">字节数组 </param>  
///  <returns>得到的对象 </returns>  
public static T DeserializeBinary<T>(byte[] buf)
{
    System.IO.MemoryStream memStream = new MemoryStream(buf);
    memStream.Position = 0;
    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =
        new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
    T newobj = (T)deserializer.Deserialize(memStream);
    memStream.Close();
    return newobj;
} 调用方法AA p = new AA();
p.i = 15;
byte[] bytes = SerializeBinary<AA>(p);
AA p2 = DeserializeBinary<AA>(bytes);

Answer 2

Serializable]
    class Myclass
    {
        public int IntValue { get; set; }
        public string SValue { get; set; }
    }
static byte[] Object2ByteArray(object o)
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            bf.Serialize(ms, o);
            return ms.ToArray();
        }        static object ByteArray2MyClass(byte[] ba)
        {
            MemoryStream ms = new MemoryStream(ba);
            BinaryFormatter bf = new BinaryFormatter();
            return bf.Deserialize(ms);
        }

Answer 3

        static Byte[] b = new Byte[1024];        static void Main()
        {
            string s="abcd";
            Write<string>(s);
            var rst = Read<string>();
            Console.WriteLine(rst);
        }        static void Write<T>(T obj)
        {
            Stream ms=new MemoryStream(b);
            XmlSerializer xs=new XmlSerializer(typeof(T));
            xs.Serialize(ms, obj);
        }
        static T Read<T>()
        {
            Stream ms = new MemoryStream(b);
            XmlSerializer xs = new XmlSerializer(typeof(T));
            return (T)xs.Deserialize(ms);
        }

Answer 4

实现C++中这样的功能 template <typename T> 
void _Write(const T& value) { _Write((uint8*)&value, sizeof(T)); }
template <typename T> 
void _Read(T &value) { _Read((uint8*)&value, sizeof(T)); }

Answer 5

给T类型加上[serializable]属性后，对性能有什么影响没？

Answer 6

这个方法没有看上去最简单，但是没有返回值，我多次序列化后，在反序列化，egstring s = "abcd";
Write<string>(s); // 序列化到内存
Int32 a = 100;
Write<Int32>(a);
Int16 b = 50;
Write<Int16>(b);
Int32 c =Read<Int32>();  // 这样还能的出来么。。xml序列化，二进制序列化，那个的性能最好？

Answer 7

如果转换为泛型T  public static byte[] T2ByteArray(T o)
  {
      BinaryFormatter bf = new BinaryFormatter();
      MemoryStream ms = new MemoryStream();
      bf.Serialize(ms, o);
      return ms.ToArray();
  }  public static T ByteArray2T(byte[] ba)
  {
      MemoryStream ms = new MemoryStream(ba);
      BinaryFormatter bf = new BinaryFormatter();
      return bf.Deserialize(ms);
  }?  我去测测那种性能好些！

Answer 8

4楼序列化的结果是xml字符串，不是二进制流。数据量很大的。

Answer 9

恩，谢谢，逍遥兄C#里面是怎么算一个算法的耗时的？c++里面两个Cpu的tick相减，在除以时钟频率
就得到时间了，C#里是怎么搞的？

Answer 10

...
你那个方法在c++下有时候也不对的，一般c++下用GetTickCount
c#下
int tick = Environment.TickCount;...tick = Environment.TickCount - tick;tick就是经过的毫秒数当然，方法很多，比如StopWatcher,Datetime直接相减得到的TimeSpan获得TotalmMilliSecond属性

Answer 11

            int a = System.Environment.TickCount;
            for (int i = 0; i < 10000; i++)
            {
                Int16 i16 = 100;
                b = Serialize1.SerializeBinary<Int16>(i16);
                Console.WriteLine(Serialize1.DeserializeBinary<Int16>(b));                Int32 i32 = 2000000;
                b = Serialize1.SerializeBinary<Int32>(i32);
                Console.WriteLine(Serialize1.DeserializeBinary<Int32>(b));                Int64 i64 = 40000000000;
                b = Serialize1.SerializeBinary<Int64>(i64);
                Console.WriteLine(Serialize1.DeserializeBinary<Int64>(b));                char ch = 'A';
                b = Serialize1.SerializeBinary<char>(ch);
                Console.WriteLine(Serialize1.DeserializeBinary<char>(b));                String str = "helloooo";
                b = Serialize1.SerializeBinary<String>(str);
                Console.WriteLine(Serialize1.DeserializeBinary<String>(b));
            }
            int c = System.Environment.TickCount - a;
            Console.WriteLine(c);1万次，序列，反序列，
这个代码用了6094个ms是不是慢了点～可以优化不？