(转)任意类型转换成json

项目中经常要用到json格式的数据，把收集和整理的转换json数据的方法发布如下：
在.net framework2.0中，没有JavaScriptSerializer（3.0） 和DataContractJsonSerializer （3.5），所以经常要用手写的转换类，这样调试也方便些，何况JavaScriptSerializer 和DataContractJsonSerializer 还有一些对特殊字符解析的bug。

---

1. /// <summary> 
2.     /// List转成json  
3.     /// </summary> 
4.     /// <typeparam name="T"></typeparam> 
5.     /// <param name="jsonName"></param> 
6.     /// <param name="list"></param> 
7.     /// <returns></returns> 
8.     public static string ListToJson<T>(IList<T> list, string jsonName) 
9.     { 
10.         StringBuilder Json = new StringBuilder(); 
11.         if (string.IsNullOrEmpty(jsonName)) 
12.             jsonName = list[0].GetType().Name; 
13.         Json.Append("{\"" + jsonName + "\":["); 
14.         if (list.Count > 0) 
15.         { 
16.             for (int i = 0; i < list.Count; i++) 
17.             { 
18.                 T obj = Activator.CreateInstance<T>(); 
19.                 PropertyInfo[] pi = obj.GetType().GetProperties(); 
20.                 Json.Append("{"); 
21.                 for (int j = 0; j < pi.Length; j++) 
22.                 { 
23.                     Type type = pi[j].GetValue(list[i], null).GetType(); 
24.                     Json.Append("\"" + pi[j].Name.ToString() + "\":" + StringFormat(pi[j].GetValue(list[i], null).ToString(), type)); 
25.  
26.                     if (j < pi.Length - 1) 
27.                     { 
28.                         Json.Append(","); 
29.                     } 
30.                 } 
31.                 Json.Append("}"); 
32.                 if (i < list.Count - 1) 
33.                 { 
34.                     Json.Append(","); 
35.                 } 
36.             } 
37.         } 
38.         Json.Append("]}"); 
39.         return Json.ToString(); 
40.     } 
41.  
42.     /// <summary> 
43.     /// List转成json  
44.     /// </summary> 
45.     /// <typeparam name="T"></typeparam> 
46.     /// <param name="list"></param> 
47.     /// <returns></returns> 
48.     public static string ListToJson<T>(IList<T> list) 
49.     { 
50.         object obj = list[0]; 
51.         return ListToJson<T>(list, obj.GetType().Name); 
52.     } 
53.  
54.     /// <summary>  
55.     /// 对象转换为Json字符串  
56.     /// </summary>  
57.     /// <param name="jsonObject">对象</param>  
58.     /// <returns>Json字符串</returns>  
59.     public static string ToJson(object jsonObject) 
60.     { 
61.         string jsonString = "{"; 
62.         PropertyInfo[] propertyInfo = jsonObject.GetType().GetProperties(); 
63.         for (int i = 0; i < propertyInfo.Length; i++) 
64.         { 
65.             object objectValue = propertyInfo[i].GetGetMethod().Invoke(jsonObject, null); 
66.             string value = string.Empty; 
67.             if (objectValue is DateTime || objectValue is Guid || objectValue is TimeSpan) 
68.             { 
69.                 value = "'" + objectValue.ToString() + "'"; 
70.             } 
71.             else if (objectValue is string) 
72.             { 
73.                 value = "'" + ToJson(objectValue.ToString()) + "'"; 
74.             } 
75.             else if (objectValue is IEnumerable) 
76.             { 
77.                 value = ToJson((IEnumerable)objectValue); 
78.             } 
79.             else 
80.             { 
81.                 value = ToJson(objectValue.ToString()); 
82.             } 
83.             jsonString += "\"" + ToJson(propertyInfo[i].Name) + "\":" + value + ","; 
84.         } 
85.         jsonString.Remove(jsonString.Length - 1, jsonString.Length); 
86.         return jsonString + "}"; 
87.     } 
88.  
89.     /// <summary>  
90.     /// 对象集合转换Json  
91.     /// </summary>  
92.     /// <param name="array">集合对象</param>  
93.     /// <returns>Json字符串</returns>  
94.     public static string ToJson(IEnumerable array) 
95.     { 
96.         string jsonString = "["; 
97.         foreach (object item in array) 
98.         { 
99.             jsonString += ToJson(item) + ","; 
100.         } 
101.         jsonString.Remove(jsonString.Length - 1, jsonString.Length); 
102.         return jsonString + "]"; 
103.     } 
104.  
105.     /// <summary>  
106.     /// 普通集合转换Json  
107.     /// </summary>  
108.     /// <param name="array">集合对象</param>  
109.     /// <returns>Json字符串</returns>  
110.     public static string ToArrayString(IEnumerable array) 
111.     { 
112.         string jsonString = "["; 
113.         foreach (object item in array) 
114.         { 
115.             jsonString = ToJson(item.ToString()) + ","; 
116.         } 
117.         jsonString.Remove(jsonString.Length - 1, jsonString.Length); 
118.         return jsonString + "]"; 
119.     } 
120.  
121.     /// <summary>  
122.     /// Datatable转换为Json  
123.     /// </summary>  
124.     /// <param name="table">Datatable对象</param>  
125.     /// <returns>Json字符串</returns>  
126.     public static string ToJson(DataTable dt) 
127.     { 
128.         StringBuilder jsonString = new StringBuilder(); 
129.         jsonString.Append("["); 
130.         DataRowCollection drc = dt.Rows; 
131.         for (int i = 0; i < drc.Count; i++) 
132.         { 
133.             jsonString.Append("{"); 
134.             for (int j = 0; j < dt.Columns.Count; j++) 
135.             { 
136.                 string strKey = dt.Columns[j].ColumnName; 
137.                 string strValue = drc[i][j].ToString(); 
138.                 Type type = dt.Columns[j].DataType; 
139.                 jsonString.Append("\"" + strKey + "\":"); 
140.                 strValue = StringFormat(strValue, type); 
141.                 if (j < dt.Columns.Count - 1) 
142.                 { 
143.                     jsonString.Append(strValue + ","); 
144.                 } 
145.                 else 
146.                 { 
147.                     jsonString.Append(strValue); 
148.                 } 
149.             } 
150.             jsonString.Append("},"); 
151.         } 
152.         jsonString.Remove(jsonString.Length - 1, 1); 
153.         jsonString.Append("]"); 
154.         return jsonString.ToString(); 
155.     } 
156.  
157.     /// <summary> 
158.     /// DataTable转成Json  
159.     /// </summary> 
160.     /// <param name="jsonName"></param> 
161.     /// <param name="dt"></param> 
162.     /// <returns></returns> 
163.     public static string ToJson(DataTable dt, string jsonName) 
164.     { 
165.         StringBuilder Json = new StringBuilder(); 
166.         if (string.IsNullOrEmpty(jsonName)) 
167.             jsonName = dt.TableName; 
168.         Json.Append("{\"" + jsonName + "\":["); 
169.         if (dt.Rows.Count > 0) 
170.         { 
171.             for (int i = 0; i < dt.Rows.Count; i++) 
172.             { 
173.                 Json.Append("{"); 
174.                 for (int j = 0; j < dt.Columns.Count; j++) 
175.                 { 
176.                     Type type = dt.Rows[i][j].GetType(); 
177.                     Json.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + StringFormat(dt.Rows[i][j].ToString(), type)); 
178.                     if (j < dt.Columns.Count - 1) 
179.                     { 
180.                         Json.Append(","); 
181.                     } 
182.                 } 
183.                 Json.Append("}"); 
184.                 if (i < dt.Rows.Count - 1) 
185.                 { 
186.                     Json.Append(","); 
187.                 } 
188.             } 
189.         } 
190.         Json.Append("]}"); 
191.         return Json.ToString(); 
192.     } 
193.  
194.     /// <summary>  
195.     /// DataReader转换为Json  
196.     /// </summary>  
197.     /// <param name="dataReader">DataReader对象</param>  
198.     /// <returns>Json字符串</returns>  
199.     public static string ToJson(DbDataReader dataReader) 
200.     { 
201.         StringBuilder jsonString = new StringBuilder(); 
202.         jsonString.Append("["); 
203.         while (dataReader.Read()) 
204.         { 
205.             jsonString.Append("{"); 
206.             for (int i = 0; i < dataReader.FieldCount; i++) 
207.             { 
208.                 Type type = dataReader.GetFieldType(i); 
209.                 string strKey = dataReader.GetName(i); 
210.                 string strValue = dataReader[i].ToString(); 
211.                 jsonString.Append("\"" + strKey + "\":"); 
212.                 strValue = StringFormat(strValue, type); 
213.                 if (i < dataReader.FieldCount - 1) 
214.                 { 
215.                     jsonString.Append(strValue + ","); 
216.                 } 
217.                 else 
218.                 { 
219.                     jsonString.Append(strValue); 
220.                 } 
221.             } 
222.             jsonString.Append("},"); 
223.         } 
224.         dataReader.Close(); 
225.         jsonString.Remove(jsonString.Length - 1, 1); 
226.         jsonString.Append("]"); 
227.         return jsonString.ToString(); 
228.     } 
229.  
230.     /// <summary>  
231.     /// DataSet转换为Json  
232.     /// </summary>  
233.     /// <param name="dataSet">DataSet对象</param>  
234.     /// <returns>Json字符串</returns>  
235.     public static string ToJson(DataSet dataSet) 
236.     { 
237.         string jsonString = "{"; 
238.         foreach (DataTable table in dataSet.Tables) 
239.         { 
240.             jsonString += "\"" + table.TableName + "\":" + ToJson(table) + ","; 
241.         } 
242.         jsonString = jsonString.TrimEnd(','); 
243.         return jsonString + "}"; 
244.     } 
245.  
246.     /// <summary> 
247.     /// 过滤特殊字符 
248.     /// </summary> 
249.     /// <param name="s"></param> 
250.     /// <returns></returns> 
251.     private static string String2Json(String s) 
252.     { 
253.         StringBuilder sb = new StringBuilder(); 
254.         for (int i = 0; i < s.Length; i++) 
255.         { 
256.             char c = s.ToCharArray()[i]; 
257.             switch (c) 
258.             { 
259.                 case '\"': 
260.                     sb.Append("\\\""); break; 
261.                 case '\\': 
262.                     sb.Append("\\\\"); break; 
263.                 case '/': 
264.                     sb.Append("\\/"); break; 
265.                 case '\b': 
266.                     sb.Append("\\b"); break; 
267.                 case '\f': 
268.                     sb.Append("\\f"); break; 
269.                 case '\n': 
270.                     sb.Append("\\n"); break; 
271.                 case '\r': 
272.                     sb.Append("\\r"); break; 
273.                 case '\t': 
274.                     sb.Append("\\t"); break; 
275.                 default: 
276.                     sb.Append(c); break; 
277.             } 
278.         } 
279.         return sb.ToString(); 
280.     } 
281.  
282.     /// <summary> 
283.     /// 格式化字符型、日期型、布尔型 
284.     /// </summary> 
285.     /// <param name="str"></param> 
286.     /// <param name="type"></param> 
287.     /// <returns></returns> 
288.     private static string StringFormat(string str, Type type) 
289.     { 
290.         if (type == typeof(string)) 
291.         { 
292.             str = String2Json(str); 
293.             str = "\"" + str + "\""; 
294.         } 
295.         else if (type == typeof(DateTime)) 
296.         { 
297.             str = "\"" + str + "\""; 
298.         } 
299.         else if (type == typeof(bool)) 
300.         { 
301.             str = str.ToLower(); 
302.         } 
303.         else if (type != typeof(string) && string.IsNullOrEmpty(str)) 
304.         { 
305.             str = "\"" + str + "\""; 
306.         } 
307.         return str; 
308.     }