当前位置: article > 正文

c# 自定义可序列化_c# 自定义序列化

作者：菜鸟追梦旅行 | 2024-02-19 01:34:33

踩

c# 自定义序列化

一、定义一个序列化的类（包含二进制，xml，json 三种方法）


    public class SerializeHelper
    {
        #region 私有的
        #region 字段
        #endregion
        #region 方法
        #endregion
        #endregion
        #region 保护的
        #region 字段
 
        #endregion
        #region 方法
        #endregion
        #endregion
        #region 公开的
 
        #region 属性
 
        #endregion
        #region 方法
 
        #endregion
        #endregion
 
        #region 静态方法
        #region 二进制方式
        /// <summary>
        /// 序列化对像
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="FileName"></param>123456
        /// <param name="Exception">是否显示异常消息</param>
        /// <returns></returns>
        public static bool Serialize(object obj, string FileName, bool showException)
        {
            FileInfo fi = new FileInfo(FileName);
            if (!fi.Directory.Exists) fi.Directory.Create();
            using (FileStream fileStream = new FileStream(FileName, FileMode.Create))
            {
                try
                {
                    BinaryFormatter b = new BinaryFormatter();
                    b.Serialize(fileStream, obj);
                    return true;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return false;
                }
            }
        }
 
        /// <summary>
        /// 序列化对像
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="FileName"></param>123456
        /// <param name="Exception">是否显示异常消息</param>
        /// <returns></returns>
        public static byte[] Serialize(object obj,bool showException)
        {
            using (MemoryStream fileStream = new MemoryStream())
            {
                try
                {
                    BinaryFormatter b = new BinaryFormatter();
                    b.Serialize(fileStream, obj);
                    return fileStream.ToArray();
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return null;
                }
            }
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <returns></returns>
        public static object DeSerialize(string FileName, bool showException)
        {
           return DeSerialize(FileName, showException);
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <returns></returns>
        public static object DeSerialize(byte[] inputBuf, bool showException)
        {
            return DeSerialize<object>(inputBuf, showException);
        }
 
        /// <summary>
        ///  反序列化对像
        /// </summary>
        /// <typeparam name="T">返回的类型</typeparam>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <returns></returns>
        public static T DeSerialize<T>(string FileName, bool showException)
        {
            if (!System.IO.File.Exists(FileName))
            {
                if (showException) throw new Exception("文件不存");
                return default(T);
            }
            using (FileStream fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    BinaryFormatter b = new BinaryFormatter();
                    b.Binder = new ObjBinderEx<T>();
                    object obj = b.Deserialize(fileStream);
                    return (T)obj;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return default(T);
 
                }
            }
        }
        /// <summary>
        ///  反序列化对像
        /// </summary>
        /// <typeparam name="T">返回的类型</typeparam>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <returns></returns>
        public static T DeSerialize<T>(byte[] inputBuf, bool showException)
        {
 
            using (MemoryStream fileStream = new MemoryStream(inputBuf))
            {
                try
                {
                    BinaryFormatter b = new BinaryFormatter();
                    b.Binder = new ObjBinderEx<T>();
                    object obj = b.Deserialize(fileStream);
 
                    return (T)obj;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return default(T);
 
                }
            }
        }
        #endregion
        #region XML方式
        /// <summary>
        /// 序列化对像
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="FileName"></param>
        /// <param name="Exception">是否显示异常消息</param>
        /// <returns></returns>
        public static bool XMLSerialize(object obj, string FileName, bool showException)
        {
            FileInfo fi = new FileInfo(FileName);
            if (!fi.Directory.Exists) fi.Directory.Create();
            using (FileStream fileStream = new FileStream(FileName, FileMode.Create))
            {
                try
                {
                    XmlSerializer b = new XmlSerializer(obj.GetType());
                    b.Serialize(fileStream, obj);
                    return true;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return false;
                }
            }
        }
 
        /// <summary>
        /// 序列化对像
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="FileName"></param>
        /// <param name="Exception">是否显示异常消息</param>
        /// <returns></returns>
        public static byte[] XMLSerialize(object obj, bool showException)
        {
            using (MemoryStream fileStream = new MemoryStream())
            {
                try
                {
                    XmlSerializer b = new XmlSerializer(obj.GetType());
                    b.Serialize(fileStream, obj);
                    return fileStream.ToArray() ;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return null;
                }
            }
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <typeparam name="T">返回对像的类型</typeparam>
        /// <returns></returns>
        public static T XMLDeSerialize<T>(string FileName, bool showException)
        {
            if (!System.IO.File.Exists(FileName))
            {
                if (showException) throw new Exception("文件不存");
                return default(T);
            }
            using (FileStream fileStream = new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                try
                {
                    XmlSerializer b = new XmlSerializer(typeof(T));
                   
                    T obj = (T)b.Deserialize(fileStream);
                    return obj;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return default(T);
 
                }
            }
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <typeparam name="T">返回对像的类型</typeparam>
        /// <returns></returns>
        public static T XMLDeSerialize<T>(byte[] inputBuf, bool showException)
        {
            using (MemoryStream fileStream = new MemoryStream(inputBuf))
            {
                try
                {
                    XmlSerializer b = new XmlSerializer(typeof(T));
                    T obj = (T)b.Deserialize(fileStream);
                    return obj;
                }
                catch (Exception ex)
                {
                    if (showException)
                    {
                        throw new Exception(ex.Message);
                    }
                    return default(T);
 
                }
            }
        }
 
        #endregion
        #region Json方式
        public static string ToJson(object obj,bool showException)
        {
            try
            {
                return Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented);
            }
            catch (Exception ex)
            {
                if (showException)
                {
                    throw new Exception(ex.Message);
                }
                return null;
            }
        }
        /// <summary>
        /// 序列化对像
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="FileName"></param>
        /// <param name="Exception">是否显示异常消息</param>
        /// <returns></returns>
        public static bool JsonSerialize(object obj, string FileName, bool showException)
        {
            FileInfo fi = new FileInfo(FileName);
            if (!fi.Directory.Exists) fi.Directory.Create();
            try
            {
              
                var jsonStr = Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented);
                File.WriteAllText(FileName, jsonStr, Encoding.UTF8);
                return true;
            }
            catch (Exception ex)
            {
                if (showException)
                {
                    throw new Exception(ex.Message);
                }
                return false;
            }
 
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <typeparam name="T">返回对像的类型</typeparam>
        /// <returns></returns>
        public static T JsonDeSerialize<T>(string FileName, bool showException)
        {
            if (!System.IO.File.Exists(FileName))
            {
                if (showException) throw new Exception("文件不存");
                return default(T);
            }
            try
            {
                var jsonStr = File.ReadAllText(FileName, Encoding.UTF8);
                var obj = JsonConvert.DeserializeObject<T>(jsonStr);
                return obj;
            }
            catch (Exception ex)
            {
                if (showException)
                {
                    throw new Exception(ex.Message);
                }
                return default(T);
 
            }
 
        }
 
        /// <summary>
        /// 反序列化对像
        /// </summary>
        /// <param name="FileName"></param>
        /// <param name="showException">是否显示异常消息</param>
        /// <typeparam name="T">返回对像的类型</typeparam>
        /// <returns></returns>
        public static T FromJson<T>(string jsonStr, bool showException)
        {
            if (!string.IsNullOrEmpty(jsonStr))
            {
                if (showException) throw new Exception("空字符串");
                return default(T);
            }
            try
            {
                var obj = JsonConvert.DeserializeObject<T>(jsonStr);
                return obj;
            }
            catch (Exception ex)
            {
                if (showException)
                {
                    throw new Exception(ex.Message);
                }
                return default(T);
 
            }
 
        }
        #endregion
        /// <summary>
        /// 将对像的属性序列化到本地
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="filename"></param>
        /// <returns></returns>
        public static bool SerializePropertys(object obj, string FileName)
        {
            FileInfo fi = new FileInfo(FileName);
            if (!fi.Directory.Exists) fi.Directory.Create();
            PropertyInfo[] pis = obj.GetType().GetProperties();
            SerializeHash dict = new SerializeHash();
            foreach (PropertyInfo pi in pis)
            {
                if (!pi.CanWrite) continue;
                if (pi.GetIndexParameters().Length > 0) continue;
                Type t = pi.PropertyType;
 
                if ((t == typeof(string)) || (t == typeof(int)) || (t == typeof(short)) || (t == typeof(decimal)) || (t == typeof(double)) || (t == typeof(float)) || (t == typeof(byte)) || (t == typeof(bool))
                    || (t == typeof(DateTime)) || (t == typeof(DateTime?)) || (t.IsEnum) || (t == typeof(long))||(t == typeof(Image)))
                {
                    dict.Add(pi.Name, pi.GetValue(obj, null));
                }
            }
            return dict.SaveToFile(FileName, false);
          //  return true;
        }
        /// <summary>
        /// 从本地载入对像的属性
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="filename"></param>
        /// <returns></returns>
        public static bool DeSerializePropertys(object obj, string filename)
        {
            SerializeHash dict = SerializeHash.CreateFromFile(filename, false);
            if (dict == null) return false;
            PropertyInfo[] pis = obj.GetType().GetProperties();
            foreach (PropertyInfo pi in pis)
            {
                if (!pi.CanWrite) continue;
                if (pi.GetIndexParameters().Length > 0) continue;
                if (dict.ContainsKey(pi.Name))
                {
                    try
                    {
                        pi.SetValue(obj, dict[pi.Name], null);
                    }
                    catch
                    {
                    }
                }
            }
            return true;
        }
        #endregion
    }

二、定义一个可序列话字典类


/// <summary>
/// 可序列化的字典类，要求包含对像也可序列化
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TValue"></typeparam>
   [Serializable()]
	public class SerializableDictionary<TKey, TVal> : Dictionary<TKey, TVal>, IXmlSerializable, ISerializable
	{
		#region Constants
		private const string DictionaryNodeName = "Dictionary";
		private const string ItemNodeName = "Item";
		private const string KeyNodeName = "Key";
		private const string ValueNodeName = "Value";
		#endregion
		#region Constructors
		public SerializableDictionary()
		{
		}
 
		public SerializableDictionary(IDictionary<TKey, TVal> dictionary)
			: base(dictionary)
		{
		}
 
		public SerializableDictionary(IEqualityComparer<TKey> comparer)
			: base(comparer)
		{
		}
 
		public SerializableDictionary(int capacity)
			: base(capacity)
		{
		}
 
		public SerializableDictionary(IDictionary<TKey, TVal> dictionary, IEqualityComparer<TKey> comparer)
			: base(dictionary, comparer)
		{
		}
 
		public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer)
			: base(capacity, comparer)
		{
		}
 
		#endregion
		#region ISerializable Members
 
		protected SerializableDictionary(SerializationInfo info, StreamingContext context)
		{
			int itemCount = info.GetInt32("ItemCount");
			for (int i = 0; i < itemCount; i++)
			{
				KeyValuePair<TKey, TVal> kvp = (KeyValuePair<TKey, TVal>)info.GetValue(String.Format("Item{0}", i), typeof(KeyValuePair<TKey, TVal>));
				this.Add(kvp.Key, kvp.Value);
			}
		}
 
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			info.AddValue("ItemCount", this.Count);
			int itemIdx = 0;
			foreach (KeyValuePair<TKey, TVal> kvp in this)
			{
				info.AddValue(String.Format("Item{0}", itemIdx), kvp, typeof(KeyValuePair<TKey, TVal>));
				itemIdx++;
			}
		}
 
		#endregion
		#region IXmlSerializable Members
 
		void IXmlSerializable.WriteXml(System.Xml.XmlWriter writer)
		{
			//writer.WriteStartElement(DictionaryNodeName);
			foreach (KeyValuePair<TKey, TVal> kvp in this)
			{
				writer.WriteStartElement(ItemNodeName);
				writer.WriteStartElement(KeyNodeName);
				KeySerializer.Serialize(writer, kvp.Key);
				writer.WriteEndElement();
				writer.WriteStartElement(ValueNodeName);
				ValueSerializer.Serialize(writer, kvp.Value);
				writer.WriteEndElement();
				writer.WriteEndElement();
			}
			//writer.WriteEndElement();
		}
 
		void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
		{
			if (reader.IsEmptyElement)
			{
				return;
			}
 
			// Move past container
			if (!reader.Read())
			{
				throw new XmlException("Error in Deserialization of Dictionary");
			}
 
			//reader.ReadStartElement(DictionaryNodeName);
			while (reader.NodeType != XmlNodeType.EndElement)
			{
				reader.ReadStartElement(ItemNodeName);
				reader.ReadStartElement(KeyNodeName);
				TKey key = (TKey)KeySerializer.Deserialize(reader);
				reader.ReadEndElement();
				reader.ReadStartElement(ValueNodeName);
				TVal value = (TVal)ValueSerializer.Deserialize(reader);
				reader.ReadEndElement();
				reader.ReadEndElement();
				this.Add(key, value);
				reader.MoveToContent();
			}
			//reader.ReadEndElement();
 
			reader.ReadEndElement(); // Read End Element to close Read of containing node
		}
 
		System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
		{
			return null;
		}
 
		#endregion
		#region Private Properties
		protected XmlSerializer ValueSerializer
		{
			get
			{
				if (valueSerializer == null)
				{
					valueSerializer = new XmlSerializer(typeof(TVal));
				}
				return valueSerializer;
			}
		}
 
		private XmlSerializer KeySerializer
		{
			get
			{
				if (keySerializer == null)
				{
					keySerializer = new XmlSerializer(typeof(TKey));
				}
				return keySerializer;
			}
		}
		#endregion
		#region Private Members
		private XmlSerializer keySerializer = null;
		private XmlSerializer valueSerializer = null;
		#endregion
        public bool SaveToFile(string FileName, bool showException)
        {
           return  SerializeHelper.XMLSerialize(this, FileName, showException);
        }
 
    }

三、定义可序列序列化实例类


   /// <summary>
    ///  可序列的哈希表,只能通过XML序列化
    /// </summary>
    [Serializable]
   public class SerializeHash : SerializableDictionary<string, object>
    {
        public SerializeHash()
            : base()
        {
        }
        public SerializeHash(IDictionary<string, object> dictionary)
            : base(dictionary)
        {
        }
 
        public SerializeHash(IEqualityComparer<string> comparer)
            : base(comparer)
        {
        }
 
        public SerializeHash(int capacity)
            : base(capacity)
        {
        }
 
        public SerializeHash(IDictionary<string, object> dictionary, IEqualityComparer<string> comparer)
            : base(dictionary, comparer)
        {
        }
 
        public SerializeHash(int capacity, IEqualityComparer<string> comparer)
            : base(capacity, comparer)
        {
        }
 
        protected SerializeHash(SerializationInfo info, StreamingContext context)
        {
            int itemCount = info.GetInt32("ItemCount");
            for (int i = 0; i < itemCount; i++)
            {
                KeyValuePair<string, object> kvp = (KeyValuePair<string, object>)info.GetValue(String.Format("Item{0}", i), typeof(KeyValuePair<string, object>));
                this.Add(kvp.Key, kvp.Value);
            }
        }
 
 
        /// <summary>
        /// 将内含数据转为对应的类型
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="Name"></param>
        /// <param name="DefaultValue"></param>
        /// <returns></returns>
        public T GetObject<T>(string Name, T DefaultValue)
        {
            if (!this.ContainsKey(Name)) return DefaultValue;
            object obj = this[Name];
            if(!(obj is T)) return DefaultValue;
           return (T)obj;
        }
 
        public void SetObject(string Name, object Value)
        {
            if (this.ContainsKey(Name)) this[Name] = Value;
            else this.Add(Name, Value);
        }
        public static SerializeHash CreateFromFile(string FileName, bool showException)
        {
            return SerializeHelper.XMLDeSerialize<SerializeHash>(FileName, showException);
        }
 
        public bool SaveToFile(string FileName, bool showException)
        {
            return SerializeHelper.XMLSerialize(this, FileName, showException);
        }
    }

四使用实例：


private static SerializeHash mSystemCachData;
 
SystemCachData.SetObject("weburl", "www.baidu.com")；
 
if (mSystemCachData != null)
            {
                mSystemCachData.SaveToFile(System.IO.Path.Combine(Path, "DefaultData.xml"), false);
            }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/111827