WPF-序列化

1. public class SerializeHelper
2. {
4.     #region 二进制格式
5.   /// <summary>
6.   ///  Binary 序列化使用前需要标记类可序列化
7.   /// </summary>
8.   /// <param name="fileName">序列化到指定的文件</param>
9.   /// <param name="obj">需要序列化的类</param>
10.   public static void BinarySerializer<T>(T obj, string fileName) where T : class
11.   {
12.       using (Stream fStream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite))
13.       {
14.           try
15.           {
16.               if (!Directory.GetParent(fileName).Exists)
17.               {
18.                   Directory.GetParent(fileName).Create();
19.               }
20.               BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
21.               binFormat.Serialize(fStream, obj);
22.               fStream.Close();
23.           }
24.           catch (Exception ex)
25.           {
26.               //HelperEvent.OnMessageColor?.Invoke("二进制文件序列化错误: " + ex.ToString(), Color.Red, "Main");
27.           }
28.       }
29.   }
31.   /// <summary>
32.   /// Binary 反序列化使用前需要标记类可序列化
33.   /// </summary>
34.   /// <param name="filePath">从指定的文件序列化成相应对象</param>
35.   /// <returns>反序列化后的类对象通过泛型限定</returns>
36.   public static T BinaryDeserializer<T>(string fileName)
37.   {
38.       T obj = default(T);
39.       if (System.IO.File.Exists(fileName))//检查文件是否存在
40.       {
41.           using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
42.           {
43.               try
44.               {
45.                   fs.Position = 0;
46.                   BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器
47.                   obj = (T)binFormat.Deserialize(fs);
48.                   fs.Close();
49.                   return obj;
50.               }
51.               catch (System.Exception ex)
52.               {
53.                   //HelperEvent.OnMessageColor?.Invoke("二进制文件反序列化错误:" + ex.ToString(), Color.Red,"Main");
54.                   MessageBox.Show("二进制文件反序列化错误:" + fileName + ex.ToString(),"Main");
55.               }
56.           }
57.       }
58.       return obj;
59.   }
60. #endregion
63.         #region Json 格式
64.               /// <summary>
65.               /// 反序列化json文件
66.               /// </summary>
67.               /// <param name="fileName"></param>
68.               /// <returns>反序列化后的类对象通过泛型限定</returns>
69.               public static T DeserializeJson<T>(string fileName)
70.               {
71.                   T obj = default(T);
72.                   try
73.                   {
74.                       if (!File.Exists(fileName)) return obj;
75.                       return JsonConvert.DeserializeObject<T>(File.ReadAllText(fileName));
76.                   }
77.                   catch (Exception ex)
78.                   {
79.                       //HelperEvent.OnMessageColor?.Invoke("Json文件序列化错误: " + ex.ToString(), Color.Red, "Main");
80.                   }
81.                   return obj;
82.               }
84.               /// <summary>
85.               /// 序列化json文件
86.               /// </summary>
87.               /// <typeparam name="T">序列化限定的泛型</typeparam>
88.               /// <param name="fileName">文件路径</param>
89.               public static void SerializeJson<T>(T obj, string fileName) where T : class
90.               {
91.                   try
92.                   {
93.                       string dir = fileName.Substring(0, fileName.LastIndexOf('\\'));
94.                       if (!Directory.Exists(dir))
95.                       {
96.                           Directory.CreateDirectory(dir);
97.                       }
98.                       var jsonSetting = new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore };
99.                       var json = JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented, jsonSetting);
100.                       File.WriteAllText(fileName, json);
101.                   }
102.                   catch (Exception ex)
103.                   {
104.                       //HelperEvent.OnMessageColor?.Invoke("Json文件反序列化错误: " + ex.ToString(), Color.Red, "Main");
105.                   }
106.               }
109.               #endregion
112.               #region XML格式
113.                     /// <summary>
114.                     ///
115.                     ///《/summary>
116.                     /// <typeparam name="T">限定的泛型类型</typeparam>
117.                     /// <param name="fileName">文件路径</param>
118.                     /// <param name="obj">序列化的对象</param>
119.                     /// <param name="omitXmlDeclaration">是否需要xml版本描述</param>
120.                     /// <param name="removeDefaultNameSpace">是否从新开始添加</param>
121.                     public static void XmlSerialize<T>(string fileName, T obj, bool omitXmlDeclaration, bool removeDefaultNameSpace)
122.                     {
123.                         try
124.                         {
125.                             XmlWriterSettings xmlSetting = new XmlWriterSettings();
126.                             xmlSetting.OmitXmlDeclaration = omitXmlDeclaration;
127.                             xmlSetting.Indent = true;
128.                             xmlSetting.Encoding = new UTF8Encoding(false);
129.                             xmlSetting.NewLineChars = Environment.NewLine;
130.                             using (XmlWriter xmlWriter = XmlWriter.Create(fileName, xmlSetting))
131.                             {
132.                                 XmlSerializerNamespaces xmlms = new XmlSerializerNamespaces();
133.                                 if (removeDefaultNameSpace)
134.                                 {
135.                                     xmlms.Add(string.Empty, string.Empty);
136.                                 }
137.                                 XmlSerializer ser = new XmlSerializer(typeof(T));
138.                                 ser.Serialize(xmlWriter, obj, xmlms);
139.                             }
140.                         }
141.                         catch (Exception ex)
142.                         {
143.                             //HelperEvent.OnMessageColor?.Invoke("XML文件序列化错误: " + ex.ToString(), Color.Red, "Main");
144.                         }
145.                     }
147.                     /// <summary>
148.                     /// xml反序列化
149.                     /// </summary>
150.                     /// <typeparam name="T">限定的泛型类型</typeparam>
151.                     /// <param name="fileName">文件路径</param>
152.                     /// <returns>返回限定的泛型类</returns>
153.                     public static T XmlDeserialize<T>(string fileName) where T : class
154.                     {
155.                         try
156.                         {
157.                             XmlReaderSettings xmlReaderSetting = new XmlReaderSettings();
158.                             xmlReaderSetting.CloseInput = true;
159.                             using (XmlReader xmlReader = XmlReader.Create(fileName, xmlReaderSetting))
160.                             {
161.                                 XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
162.                                 return (T)xmlSerializer.Deserialize(xmlReader);
163.                             }
164.                         }
165.                         catch (Exception ex)
166.                         {
167.                             //HelperEvent.OnMessageColor?.Invoke("XML文件反序列化错误: " + ex.ToString(), Color.Red, "Main");
168.                             return null;
169.                         }
170.                     }
172.                 #endregion
174.     }

复制代码

对象序列化需要在类上面加上[Serializable]

调用：path是程序的exe目录，data是序列化文件的


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！