C#序列化與反序列化對象XML和JSON 詳細代碼工具

1. using System.IO;
2. using System.Text;
3. using System.Xml.Serialization;
4. using System.Xml;
5. using System.Runtime.Serialization.Json;
6. using System;
8. namespace cn.ava.PublicsUtil.Util
9. {
10. /// <summary>
11. /// 創建人Rex.liu
12. /// 創建時間：2015年9月6日 14:48:29
13. /// 功能：序列化反序列化XML文件
14. /// </summary>
15. public class JsonAndXmlSerialization
16. {
17. #region 外部調用
18. /// <summary>
19. /// 將對象根據格式（XML/JSON）序列化成字符串結果
20. /// </summary>
21. /// <param name="o">目標對象</param>
22. /// <param name="format">輸出格式</param>
23. /// <returns></returns>
24. public static string Serialize(object o, string format)
25. {
26. if (format.ToLower() == "xml")
27. {
28. return JsonAndXmlSerialization.XmlSerialize(o);
29. }
30. else
31. {
32. return JsonAndXmlSerialization.JsonSerialize(o);
33. }
34. }
36. /// <summary>
37. /// 將字符串根據格式（XML/JSON）反序列化成指定類型的對象
38. /// </summary>
39. /// <typeparam name="T">指定類型</typeparam>
40. /// <param name="s">目標字符串</param>
41. /// <param name="format">輸入格式</param>
42. /// <returns></returns>
43. public static T Deserialize<T>(string s, string format)
44. {
45. if (format.ToLower() == "xml")
46. {
47. return JsonAndXmlSerialization.XmlDeserialize<T>(s);
48. }
49. else
50. {
51. return JsonAndXmlSerialization.JsonDeserialize<T>(s);
52. }
53. }
54. /// <summary>
55. /// 對象序列化成文件並保存
56. /// </summary>
57. /// <typeparam name="T">對象類型</typeparam>
58. /// <param name="t">對象實體</param>
59. /// <param name="path">文件路徑</param>
60. /// <param name="format">格式：json或 xml</param>
61. /// <returns></returns>
62. public static bool SerializableFile<T>(object t, string path, string format)
63. {
64. if (format.ToLower() == "xml")
65. {
66. return JsonAndXmlSerialization.SerializableXML<T>(t, path);
67. }
68. else
69. {
70. return JsonAndXmlSerialization.SerializableJson<T>(t, path);
71. }
72. }
73. /// <summary>
74. /// 將文件反序列化成對象
75. /// </summary>
76. /// <typeparam name="T">對象類型</typeparam>
77. /// <param name="path">文件路徑</param>
78. /// <param name="format">格式： json 或 xml</param>
79. /// <returns></returns>
80. public static T DeserializeFile<T>(string path, string format)
81. {
82. if (format.ToLower() == "xml")
83. {
84. return JsonAndXmlSerialization.DeSerializableXML<T>(path);
85. }
86. else
87. {
88. return JsonAndXmlSerialization.DeSerializableJson<T>(path);
89. }
90. }
91. #endregion
93. #region 對象的序列化與反序列化
94. /// <summary>
95. /// 將object對象序列化成XML
96. /// </summary>
97. /// <param name="o"></param>
98. /// <returns></returns>
99. private static string XmlSerialize(object o)
100. {
101. XmlSerializer ser = new XmlSerializer(o.GetType());
102. System.IO.MemoryStream mem = new MemoryStream();
103. XmlTextWriter writer = new XmlTextWriter(mem, Encoding.UTF8);
104. XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
105. ns.Add("", "");
106. ser.Serialize(writer, o, ns);
107. writer.Close();
108. return Encoding.UTF8.GetString(mem.ToArray());
109. }
111. /// <summary>
112. /// 字符串反序列化成對象
113. /// </summary>
114. /// <typeparam name="T">對象類型</typeparam>
115. /// <param name="s">XML值</param>
116. /// <returns></returns>
117. private static T XmlDeserialize<T>(string s)
118. {
119. XmlDocument xdoc = new XmlDocument();
120. try
121. {
122. xdoc.LoadXml(s);
123. XmlNodeReader reader = new XmlNodeReader(xdoc.DocumentElement);
124. XmlSerializer ser = new XmlSerializer(typeof(T));
125. object obj = ser.Deserialize(reader);
126. return (T)obj;
127. }
128. catch
129. {
130. return default(T);
131. }
132. }
133. /// <summary>
134. /// 對象序列化成Json字符串
135. /// </summary>
136. /// <param name="o"></param>
137. /// <returns></returns>
138. private static string JsonSerialize(object o)
139. {
140. using (var ms = new MemoryStream())
141. {
142. new DataContractJsonSerializer(o.GetType()).WriteObject(ms, o);
143. return Encoding.UTF8.GetString(ms.ToArray());
144. }
145. }
146. /// <summary>
147. /// Json字符串反序列化成對象
148. /// </summary>
149. /// <typeparam name="T"></typeparam>
150. /// <param name="s"></param>
151. /// <returns></returns>
152. private static T JsonDeserialize<T>(string s)
153. {
154. using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(s)))
155. {
156. return (T)new DataContractJsonSerializer(typeof(T)).ReadObject(ms);
157. }
158. }
159. #endregion
160. #region 將對象保存成文件
161. /// <summary>
162. /// 將對象保存爲json文件
163. /// </summary>
164. /// <typeparam name="T">對象類型</typeparam>
165. /// <param name="t">對象</param>
166. /// <param name="path">保存路徑</param>
167. /// <returns></returns>
168. private static bool SerializableJson<T>(object t, string path)
169. {
170. bool bl = false;
171. try
172. {
173. string strjson = JsonSerialize(t);
174. System.IO.StreamWriter sw = System.IO.File.CreateText(path);
175. sw.WriteLine(strjson);
176. sw.Close();
177. }
178. catch
179. {
180. return bl;
181. }
182. return true;
183. }
185. /// <summary>
186. /// 將對象序列化成XML並保存到文件
187. /// </summary>
188. /// <returns></returns>
189. private static bool SerializableXML<T>(object t, string path)
190. {
191. bool bl = false;
192. FileStream fileStream = null;
193. try
194. {
195. if (t != null)
196. {
197. //創建xml格式器
198. XmlSerializer xmls = new XmlSerializer(typeof(T));
199. //創建文件流
200. fileStream = new FileStream(path, FileMode.Create);
201. //將對象序列化到流
202. xmls.Serialize(fileStream, t);
203. bl = true;
204. }
205. }
206. catch (Exception ex)
207. {
209. throw ex;
210. }
211. finally
212. {
213. if (fileStream != null)
214. {
215. fileStream.Close();
216. }
218. }
220. return bl;
221. }
223. #endregion
225. #region 將文件反序列化成對象
226. /// <summary>
227. /// 將文件反序列化json
228. /// </summary>
229. /// <typeparam name="T">類型</typeparam>
230. /// <param name="path">json所存放的路徑</param>
231. /// <returns>實體</returns>
232. private static T DeSerializableJson<T>(string path)
233. {
234. T t = default(T);
235. try
236. {
237. FileInfo fi = new FileInfo(path);
239. if (fi.Exists)
240. {
241. StreamReader sr = new StreamReader(path, Encoding.UTF8);
242. String line;
243. StringBuilder strcontent = new StringBuilder();
244. while ((line = sr.ReadLine()) != null)
245. {
246. strcontent.Append(line.ToString());
247. }
248. t = JsonAndXmlSerialization.JsonDeserialize<T>(strcontent.ToString());
249. }
251. }
252. catch (Exception ex)
253. {
254. throw ex;
255. }
256. return t;
257. }
259. /// <summary>
260. /// 將文件反序列化XML
261. /// </summary>
262. /// <typeparam name="T">類型</typeparam>
263. /// <param name="path">XMl所存放的路徑</param>
264. /// <returns>實體</returns>
265. private static T DeSerializableXML<T>(string path)
266. {
267. T t = default(T);
268. FileStream fileStream = null;
269. try
270. {
271. XmlSerializer xmls = new XmlSerializer(typeof(T));
272. FileInfo fi = new FileInfo(path);
274. if (fi.Exists)
275. {
276. fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
277. t = (T)xmls.Deserialize(fileStream);
278. }
280. }
281. catch (Exception ex)
282. {
284. throw ex;
285. }
286. finally
287. {
288. if (fileStream != null)
289. {
290. fileStream.Close();
291. }
292. }
293. return t;
294. }
296. #endregion
299. }
300. }