【代码片段】序列化和反序列化之接口和控制类

    /// <summary>
    /// 序列化接口
    /// </summary>
    public interface ILibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        Stream SerializeToStream(object instance, Type type);
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        void SerializeToFile(string fileName, object instance, Type type);
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象字符串流</returns>
        string SerializeToString(object instance, Type type);
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        object DeserializeFromString(string objectString, Type type);
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        object DeserializeFromStream(Stream stream, Type type);
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        object DeserializeFromFile(string fileName, Type type);
    }
    /// <summary>
    /// 序列化基类
    /// </summary>
    public class LibSerializer : ILibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public virtual Stream SerializeToStream(object instance, Type type)
        {
            return null;
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public virtual void SerializeToFile(string fileName, object instance, Type type)
        {
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>字符串</returns>
        public virtual string SerializeToString(object instance, Type type)
        {
            return String.Empty;
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public virtual object DeserializeFromString(string objectString, Type type)
        {
            return null;
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public virtual object DeserializeFromStream(Stream stream, Type type)
        {
            return null;
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public virtual object DeserializeFromFile(string fileName, Type type)
        {
            return null;
        }
    }
    /// <summary>
    /// 二进制序列化类
    /// </summary>
    public class LibBinarySerializer : LibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public override Stream SerializeToStream(object instance, Type type)
        {
            BinaryFormatter bf = new BinaryFormatter();
            bf.Binder = new CustomSerializationBinder();
            MemoryStream stream = new MemoryStream();
            bf.Serialize(stream, instance);

            return stream;
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public override void SerializeToFile(string fileName, object instance, Type type)
        {
            string sDirPath = LibSysUtils.GetDirectory(fileName);
            if (!LibSysUtils.PathExists(sDirPath))
            {
                LibSysUtils.CreatePath(sDirPath);
            }
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Binder = new CustomSerializationBinder();
                bf.Serialize(fs, instance);

                fs.Close();
            }
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>字符串</returns>
        public override string SerializeToString(object instance, Type type)
        {
            using (MemoryStream stream = (MemoryStream)SerializeToStream(instance, type))
            {
                byte[] dataBuf = stream.ToArray();
                string result = Convert.ToBase64String(dataBuf);
                return result;
            }
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromString(string objectString, Type type)
        {
            byte[] dataBuf = Convert.FromBase64String(objectString);
            using (MemoryStream stream = new MemoryStream(dataBuf))
            {
                stream.Position = 0;
                stream.Seek(0, SeekOrigin.Begin);
                object result = DeserializeFromStream(stream, type);
                return result;
            }
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromStream(Stream stream, Type type)
        {
            BinaryFormatter bf = new BinaryFormatter();
            bf.Binder = new CustomSerializationBinder();
            return bf.Deserialize(stream);
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromFile(string fileName, Type type)
        {
            object objResult = null;
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Binder = new CustomSerializationBinder();
                objResult = bf.Deserialize(fs);
                fs.Close();
            }
            return objResult;
        }
    }
    /// <summary>
    /// SOAP格式序列化类
    /// </summary>
    public class LibSoapSerializer : LibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public override Stream SerializeToStream(object instance, Type type)
        {
            MemoryStream stream = new MemoryStream();
            SoapFormatter sf = new SoapFormatter();
            sf.Binder = new CustomSerializationBinder();
            sf.Serialize(stream, instance);

            return stream;
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public override void SerializeToFile(string fileName, object instance, Type type)
        {
            string sDirPath = LibSysUtils.GetDirectory(fileName);
            if (!LibSysUtils.PathExists(sDirPath))
            {
                LibSysUtils.CreatePath(sDirPath);
            }
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                SoapFormatter sf = new SoapFormatter();
                sf.Binder = new CustomSerializationBinder();
                sf.Serialize(fs, instance);

                fs.Close();
            }
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>字符串</returns>
        public override string SerializeToString(object instance, Type type)
        {
            using (MemoryStream ms = SerializeToStream(instance, type) as MemoryStream)
            {                
                ms.Position = 0;
                ms.Seek(0, SeekOrigin.Begin);
                byte[] dataBuf = ms.ToArray();
                string result = UTF8Encoding.UTF8.GetString(dataBuf);
                ms.Close();
                return result;
            }
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromString(string objectString, Type type)
        {
            using (MemoryStream ms = new MemoryStream(UTF8Encoding.UTF8.GetBytes(objectString)))
            {
                ms.Position = 0;
                ms.Seek(0, SeekOrigin.Begin);
                object result = DeserializeFromStream(ms, type);
                ms.Close();
                return result;
            }
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromStream(Stream stream, Type type)
        {
            SoapFormatter sf = new SoapFormatter();
            sf.Binder = new CustomSerializationBinder();
            return sf.Deserialize(stream);
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromFile(string fileName, Type type)
        {
            object objResult = null;
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                SoapFormatter sf = new SoapFormatter();
                sf.Binder = new CustomSerializationBinder();
                objResult = sf.Deserialize(fs);
                fs.Close();
            }
            return objResult;
        }
    }
    /// <summary>
    /// XML格式序列化类
    /// </summary>
    public class LibXmlSerializer : LibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public override Stream SerializeToStream(object instance, Type type)
        {
            XmlSerializer serializer = new XmlSerializer(type);
            MemoryStream stream = new MemoryStream();
            serializer.Serialize(stream, instance);
            return stream;
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public override void SerializeToFile(string fileName, object instance, Type type)
        {
            string sDirPath = LibSysUtils.GetDirectory(fileName);
            if (!LibSysUtils.PathExists(sDirPath))
            {
                LibSysUtils.CreatePath(sDirPath);
            }
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                XmlSerializer serializer = new XmlSerializer(type);
                serializer.Serialize(fs, instance);

                fs.Close();
            }
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>字符串</returns>
        public override string SerializeToString(object instance, Type type)
        {
            using (StringWriter sw = new StringWriter())
            {
                XmlSerializer xz = new XmlSerializer(type);
                xz.Serialize(sw, type);
                return sw.ToString();
            }
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromString(string objectString, Type type)
        {
            using (StringReader sr = new StringReader(objectString))
            {
                XmlSerializer xz = new XmlSerializer(type); 
                return xz.Deserialize(sr); 
            }
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromStream(Stream stream, Type type)
        {
            XmlSerializer serializer = new XmlSerializer(type);
            return serializer.Deserialize(stream);
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromFile(string fileName, Type type)
        {
            object objResult = null;
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                XmlSerializer serializer = new XmlSerializer(type);
                objResult = serializer.Deserialize(fs);
                fs.Close();
            }
            return objResult;
        }
    }
    /// <summary>
    /// Json格式序列化类
    /// </summary>
    public class LibJsonSerializer : LibSerializer
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public override Stream SerializeToStream(object instance, Type type)
        {
            MemoryStream stream = new MemoryStream();
            string result = this.SerializeToString(instance, type);
            byte[] resultBytes = Encoding.UTF8.GetBytes(result);
            stream.Write(resultBytes, 0, resultBytes.Length);
            stream.Position = 0;
            return stream;
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public override void SerializeToFile(string fileName, object instance, Type type)
        {
            string sDirPath = LibSysUtils.GetDirectory(fileName);
            if (!LibSysUtils.PathExists(sDirPath))
            {
                LibSysUtils.CreatePath(sDirPath);
            }
            using (FileStream fs = new FileStream(fileName, FileMode.Create))
            {
                string result = this.SerializeToString(instance, type);
                byte[] resultBytes = Encoding.UTF8.GetBytes(result);
                fs.Write(resultBytes, 0, resultBytes.Length);
                fs.Close();
            }
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>字符串</returns>
        public override string SerializeToString(object instance, Type type)
        {
            return JsonConvert.SerializeObject(instance);
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="objectString">对象字符串</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromString(string objectString, Type type)
        {
            object result = JsonConvert.DeserializeObject(objectString, type);
            return result;
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromStream(Stream stream, Type type)
        {
            byte[] dataBuf = new byte[stream.Length];
            stream.Read(dataBuf, 0, dataBuf.Length);
            string dataStr = Encoding.UTF8.GetString(dataBuf);
            object result = this.DeserializeFromString(dataStr, type);
            return result;
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public override object DeserializeFromFile(string fileName, Type type)
        {
            object objResult = null;
            using (FileStream fs = new FileStream(fileName, FileMode.Open))
            {
                byte[] dataBuf = new byte[fs.Length];
                fs.Read(dataBuf, 0, dataBuf.Length);
                string dataStr = Encoding.UTF8.GetString(dataBuf);
                objResult = this.DeserializeFromString(dataStr, type);
                fs.Close();
            }
            return objResult;
        }
    }
    /// <summary>
    /// 序列化控制类
    /// </summary>
    public class LibSerializerControl
    {
        /// <summary>
        /// 序列化对象到流
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>流</returns>
        public static Stream SerializeToStream<T>(object instance, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            return serializer.SerializeToStream(instance, type);
        }
        /// <summary>
        /// 序列化对象到文件
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        public static void SerializeToFile<T>(string fileName, object instance, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            serializer.SerializeToFile(fileName, instance, type);
        }
        /// <summary>
        /// 序列化对象到字符串
        /// </summary>
        /// <param name="instance">对象</param>
        /// <param name="type">对象类型</param>
        /// <returns>返回对象字符串流</returns>
        public static string SerializeToString<T>(object instance, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            return serializer.SerializeToString(instance, type);
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="stream">对象字符串流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public static object DeserializeFromString<T>(string objectString, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            return serializer.DeserializeFromString(objectString, type);
        }
        /// <summary>
        /// 从字符串中反序列化出对象
        /// </summary>
        /// <param name="stream">对象字符串流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public static object TryDeserializeFromString<T>(string objectString, Type type)
            where T : ILibSerializer
        {
            try
            {
                ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
                return serializer.DeserializeFromString(objectString, type);
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 从流中反序列化出对象
        /// </summary>
        /// <param name="stream">对象流</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public static object DeserializeFromStream<T>(Stream stream, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            return serializer.DeserializeFromStream(stream, type);
        }
        /// <summary>
        /// 从文件反序列化出对象
        /// </summary>
        /// <param name="fileName">文件路径</param>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public static object DeserializeFromFile<T>(string fileName, Type type)
            where T : ILibSerializer
        {
            ILibSerializer serializer = Activator.CreateInstance(typeof(T)) as ILibSerializer;
            return serializer.DeserializeFromFile(fileName, type);
        }
        /// <summary>
        /// 克隆对象
        /// </summary>
        /// <param name="instance">对象</param>
        /// <returns>返回流对象</returns>
        public static object CloneObject(object instance)
        {
            object result = null;
            using (Stream stream = SerializeToStream<LibBinarySerializer>(instance, instance.GetType()))
            {
                stream.Position = 0;
                result = DeserializeFromStream<LibBinarySerializer>(stream, instance.GetType());
                stream.Close();
                return result;
            }
        }
    }