对象序列化

using System;
using System.Xml;
using System.Xml.Serialization;
using System.Text;
using System.IO;
public class Util
{
    /// <summary>
    /// 对象序列化成 XML String
    /// </summary>
    public static string XmlSerialize<T>(T obj)
    {
        string xmlString = string.Empty;
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        using (MemoryStream ms = new MemoryStream())
        {
            xmlSerializer.Serialize(ms, obj);
            xmlString = Encoding.UTF8.GetString(ms.ToArray());
        }
        return xmlString;
    }

    /// <summary>
    /// XML String 反序列化成对象
    /// </summary>
    public static T XmlDeserialize<T>(string xmlString)
    {
        T t = default(T);
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        using (Stream xmlStream = new MemoryStream(Encoding.UTF8.GetBytes(xmlString)))
        {
            using (XmlReader xmlReader = XmlReader.Create(xmlStream))
            {
                Object obj = xmlSerializer.Deserialize(xmlReader);
                t = (T)obj;
            }
        }
        return t;
    }
}

　　

1.序列化为二进制流

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

namespace Common.Serialization.Byte {
    public class ByteSerializer {
        /// <summary>
        /// 对象转换为二进制流
        /// </summary>
        /// <param name="obj">要序列化的对象</param>
        /// <returns>对象序列化后的二进制流</returns>
        public static byte[] Serialize(object obj) {
            if (obj == null) {return null;}

            MemoryStream ms = new MemoryStream();
            try {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(ms, obj);
                return ms.ToArray();
            } finally {
                ms.Close();
            }
        }

        /// <summary>
        /// 二进制流转换为对象
        /// </summary>
        /// <param name="buffer">二进制流缓存</param>
        /// <returns>反序列化后的对象</returns>
        public static object Deserialize(byte[] buffer) {
            if ((buffer == null) || (buffer.Length == 0)) {
                return null;
            }

            MemoryStream ms = new MemoryStream(buffer);
            try {
                BinaryFormatter formatter = new BinaryFormatter();
                return formatter.Deserialize(ms);
            } finally {
                ms.Close();
            }
        }
    }
}

2.序列化为XML

using System;
using System.Text;
using System.IO;

namespace Common.Serialization.Xml {
    public class XmlSerialization {
        /// <summary>
        /// 对象转换为XML字符串
        /// </summary>
        /// <param name="obj">要序列化的对象</param>
        /// <returns>对象序列化后的XML字符串</returns>
        public static string Serialize(object obj) {
            if (obj == null) {
                return null;
            }

            MemoryStream ms = new MemoryStream();
            try {
                System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(obj.GetType());
                formatter.Serialize(ms, obj);
                return Encoding.Default.GetString(ms.ToArray());
            } finally {
                ms.Close();
            }
        }

        /// <summary>
        /// XML字符串转换为对象
        /// </summary>
        /// <param name="xml">XML字符串</param>
        /// <param name="targetType">要反序列化为的对象类型</param>
        /// <returns>反序列化后的对象</returns>
        public static object Deserialize(string xml, Type targetType) {
            if ((xml == null) || (xml.Length == 0)) {
                return null;
            }

            MemoryStream ms = new MemoryStream(Encoding.Default.GetBytes(xml));
            try {
                System.Xml.Serialization.XmlSerializer formatter = new System.Xml.Serialization.XmlSerializer(targetType);
                return formatter.Deserialize(ms);
            } finally {
                ms.Close();
            }
        }
    }
}

3.序列化为JSON

using System;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Json;

namespace Common.Serialization.Json {
    public class JsonSerializer {
        /// <summary>
        /// 对象转换为JSON字符串
        /// </summary>
        /// <param name="obj">要序列化的对象</param>
        /// <returns>对象序列化后的JSON字符串</returns>
        public static string Serialize(object obj) {
            if (obj == null) {return null;}

            MemoryStream ms = new MemoryStream();
            try {
                DataContractJsonSerializer formatter = new DataContractJsonSerializer(obj.GetType());
                formatter.WriteObject(ms, obj);
                return Encoding.UTF8.GetString(ms.ToArray());
            } finally {
                ms.Close();
            }
        }

        /// <summary>
        /// JSON字符串转换为对象
        /// </summary>
        /// <param name="json">JSON字符串</param>
        /// <param name="targetType">要反序列化为的对象类型</param>
        /// <returns>反序列化后的对象</returns>
        public static object Deserialize(string json, Type targetType) {
            if ((json == null) || (json.Length == 0)) {return null;}

            MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json));
            try {
                DataContractJsonSerializer formatter = new DataContractJsonSerializer(targetType);
                return formatter.ReadObject(ms); 
            } 
            finally 
            { ms.Close(); }
          } 
      } 
}