Json格式类的转换相关代码

创建Json数据类型，以用来生成树状结构

 1 namespace HIS.Common
 2 {
 3     public class JsonDataCreater
 4     {
 5         public JsonDataCreater()
 6         {
 7             //
 8             // TODO: 在此处添加构造函数逻辑
 9             //
10         }
11         /// <summary>
12         /// 将数据转换成JasonData，以便extjs和jquery使用
13         /// </summary>
14         /// <param name="dt"></param>
15         /// <param name="displayCount"></param>
16         /// <returns></returns>
17         public static string CreateJsonParameters(DataTable dt, bool displayCount)
18         {
19             StringBuilder JsonString = new StringBuilder();
20 
21             if (dt != null)
22             {
23                 JsonString.Append("{ ");
24                 JsonString.Append("\"data\":[ ");
25                 for (int i = 0; i < dt.Rows.Count; i++)
26                 {
27                     JsonString.Append("{ ");
28                     for (int j = 0; j < dt.Columns.Count; j++)
29                     {
30                         if (j < dt.Columns.Count - 1)
31                         {
32                             if (dt.Columns[j].DataType == typeof(bool))
33                             {
34                                 JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + dt.Rows[i][j].ToString().ToLower() + ",");
35                             }
36                             else
37                             {
38                                 JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + "\"" + dt.Rows[i][j].ToString() + "\",");
39                             }
40                         }
41                         else if (j == dt.Columns.Count - 1)
42                         {
43                             if (dt.Columns[j].DataType == typeof(bool))
44                             {
45                                 JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + dt.Rows[i][j].ToString().ToLower());
46                             }
47                             else
48                             {
49                                 JsonString.Append("\"" + dt.Columns[j].ColumnName.ToString() + "\":" + "\"" + dt.Rows[i][j].ToString() + "\"");
50                             }
51                         }
52                     }
53                     /*截取string的最后末尾*/
54                     if (i == dt.Rows.Count - 1)
55                     {
56                         JsonString.Append("} ");
57                     }
58                     else
59                     {
60                         JsonString.Append("}, ");
61                     }
62                 }
63                 JsonString.Append("]");
64 
65                 if (displayCount)
66                 {
67                     JsonString.Append(",");
68 
69                     JsonString.Append("\"totalcount\":");
70                     JsonString.Append(dt.Rows.Count);
71                 }
72 
73                 JsonString.Append("}");
74                 return JsonString.ToString();
75             }
76             else
77             {
78                 return null;
79             }
80         }
81     }
82 }

JsonHelper类，都是通用的

  1 namespace HIS.Common
  2 {
  3     public class JsonHelper
  4     {
  5         public static string CreateJsonParameters(DataTable dt, bool displayCount)
  6         {
  7             return CreateJsonParameters(dt, displayCount, dt.Rows.Count);
  8         }
  9 
 10         public static string CreateJsonParameters(DataTable dt)
 11         {
 12             return CreateJsonParameters(dt, true);
 13         }
 14 
 15         public static string CreateJsonParameters(DataTable dt, bool displayCount, int totalcount)
 16         {
 17             StringBuilder JsonString = new StringBuilder();
 18             //Exception Handling        
 19 
 20             if (dt != null)
 21             {
 22                 JsonString.Append("{ ");
 23                 JsonString.Append("\"data\":[ ");
 24                 for (int i = 0; i < dt.Rows.Count; i++)
 25                 {
 26                     JsonString.Append("{ ");
 27                     for (int j = 0; j < dt.Columns.Count; j++)
 28                     {
 29                         if (j < dt.Columns.Count - 1)
 30                         {
 31                             //if (dt.Rows[i][j] == DBNull.Value) continue;
 32                             if (dt.Columns[j].DataType == typeof(bool))
 33                             {
 34                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" +
 35                                                   dt.Rows[i][j].ToString().ToLower() + ",");
 36                             }
 37                             else if (dt.Columns[j].DataType == typeof(string))
 38                             {
 39                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" + "\"" +
 40                                                   dt.Rows[i][j].ToString().Replace("\"", "\\\"") + "\",");
 41                             }
 42                             else
 43                             {
 44                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" + "\"" + dt.Rows[i][j] + "\",");
 45                             }
 46                         }
 47                         else if (j == dt.Columns.Count - 1)
 48                         {
 49                             //if (dt.Rows[i][j] == DBNull.Value) continue;
 50                             if (dt.Columns[j].DataType == typeof(bool))
 51                             {
 52                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" +
 53                                                   dt.Rows[i][j].ToString().ToLower());
 54                             }
 55                             else if (dt.Columns[j].DataType == typeof(string))
 56                             {
 57                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" + "\"" +
 58                                                   dt.Rows[i][j].ToString().Replace("\"", "\\\"") + "\"");
 59                             }
 60                             else
 61                             {
 62                                 JsonString.Append("\"" + dt.Columns[j].ColumnName + "\":" + "\"" + dt.Rows[i][j] + "\"");
 63                             }
 64                         }
 65                     }
 66                     /*end Of String*/
 67                     if (i == dt.Rows.Count - 1)
 68                     {
 69                         JsonString.Append("} ");
 70                     }
 71                     else
 72                     {
 73                         JsonString.Append("}, ");
 74                     }
 75                 }
 76                 JsonString.Append("]");
 77 
 78                 if (displayCount)
 79                 {
 80                     JsonString.Append(",");
 81 
 82                     JsonString.Append("\"totalcount\":");
 83                     JsonString.Append(totalcount);
 84                 }
 85 
 86                 JsonString.Append("}");
 87                 return JsonString.ToString().Replace("\n", "");
 88             }
 89             else
 90             {
 91                 return null;
 92             }
 93         }
 94 
 95         #region object 2 json
 96 
 97         private static void WriteDataRow(StringBuilder sb, DataRow row)
 98         {
 99             sb.Append("{");
100             foreach (DataColumn column in row.Table.Columns)
101             {
102                 sb.AppendFormat("\"{0}\":", column.ColumnName);
103                 WriteValue(sb, row[column]);
104                 sb.Append(",");
105             }
106             // Remove the trailing comma.
107             if (row.Table.Columns.Count > 0)
108             {
109                 --sb.Length;
110             }
111             sb.Append("}");
112         }
113 
114         private static void WriteDataSet(StringBuilder sb, DataSet ds)
115         {
116             sb.Append("{\"Tables\":{");
117             foreach (DataTable table in ds.Tables)
118             {
119                 sb.AppendFormat("\"{0}\":", table.TableName);
120                 WriteDataTable(sb, table);
121                 sb.Append(",");
122             }
123             // Remove the trailing comma.
124             if (ds.Tables.Count > 0)
125             {
126                 --sb.Length;
127             }
128             sb.Append("}}");
129         }
130 
131         private static void WriteDataTable(StringBuilder sb, DataTable table)
132         {
133             sb.Append("{\"Rows\":[");
134             foreach (DataRow row in table.Rows)
135             {
136                 WriteDataRow(sb, row);
137                 sb.Append(",");
138             }
139             // Remove the trailing comma.
140             if (table.Rows.Count > 0)
141             {
142                 --sb.Length;
143             }
144             sb.Append("]}");
145         }
146 
147         private static void WriteEnumerable(StringBuilder sb, IEnumerable e)
148         {
149             bool hasItems = false;
150             sb.Append("[");
151             foreach (object val in e)
152             {
153                 WriteValue(sb, val);
154                 sb.Append(",");
155                 hasItems = true;
156             }
157             // Remove the trailing comma.
158             if (hasItems)
159             {
160                 --sb.Length;
161             }
162             sb.Append("]");
163         }
164 
165         private static void WriteHashtable(StringBuilder sb, IDictionary e)
166         {
167             bool hasItems = false;
168             sb.Append("{");
169             foreach (string key in e.Keys)
170             {
171                 sb.AppendFormat("\"{0}\":", key.ToLower());
172                 WriteValue(sb, e[key]);
173                 sb.Append(",");
174                 hasItems = true;
175             }
176             // Remove the trailing comma.
177             if (hasItems)
178             {
179                 --sb.Length;
180             }
181             sb.Append("}");
182         }
183 
184         private static void WriteObject(StringBuilder sb, object o)
185         {
186             MemberInfo[] members = o.GetType().GetMembers(BindingFlags.Instance | BindingFlags.Public);
187             sb.Append("{");
188             bool hasMembers = false;
189             foreach (MemberInfo member in members)
190             {
191                 bool hasValue = false;
192                 object val = null;
193                 if ((member.MemberType & MemberTypes.Field) == MemberTypes.Field)
194                 {
195                     FieldInfo field = (FieldInfo)member;
196                     val = field.GetValue(o);
197                     hasValue = true;
198                 }
199                 else if ((member.MemberType & MemberTypes.Property) == MemberTypes.Property)
200                 {
201                     PropertyInfo property = (PropertyInfo)member;
202                     if (property.CanRead && property.GetIndexParameters().Length == 0)
203                     {
204                         val = property.GetValue(o, null);
205                         hasValue = true;
206                     }
207                 }
208                 if (hasValue)
209                 {
210                     sb.Append("\"");
211                     sb.Append(member.Name);
212                     sb.Append("\":");
213                     WriteValue(sb, val);
214                     sb.Append(",");
215                     hasMembers = true;
216                 }
217             }
218             if (hasMembers)
219             {
220                 --sb.Length;
221             }
222             sb.Append("}");
223         }
224 
225         private static void WriteString(StringBuilder sb, IEnumerable s)
226         {
227             sb.Append("\"");
228             foreach (char c in s)
229             {
230                 switch (c)
231                 {
232                     case '\"':
233                         sb.Append("\\\"");
234                         break;
235                     case '\\':
236                         sb.Append("\\\\");
237                         break;
238                     case '\b':
239                         sb.Append("\\b");
240                         break;
241                     case '\f':
242                         sb.Append("\\f");
243                         break;
244                     case '\n':
245                         sb.Append("\\n");
246                         break;
247                     case '\r':
248                         sb.Append("\\r");
249                         break;
250                     case '\t':
251                         sb.Append("\\t");
252                         break;
253                     default:
254                         int i = c;
255                         if (i < 32 || i > 127)
256                         {
257                             sb.AppendFormat("\\u{0:X04}", i);
258                         }
259                         else
260                         {
261                             sb.Append(c);
262                         }
263                         break;
264                 }
265             }
266             sb.Append("\"");
267         }
268 
269         public static void WriteValue(StringBuilder sb, object val)
270         {
271             if (val == null || val == DBNull.Value)
272             {
273                 sb.Append("null");
274             }
275             else if (val is string || val is Guid)
276             {
277                 WriteString(sb, val.ToString());
278             }
279             else if (val is bool)
280             {
281                 sb.Append(val.ToString().ToLower());
282             }
283             else if (val is double ||
284                      val is float ||
285                      val is long ||
286                      val is int ||
287                      val is short ||
288                      val is byte ||
289                      val is decimal)
290             {
291                 sb.AppendFormat(CultureInfo.InvariantCulture.NumberFormat, "{0}", val);
292             }
293             else if (val.GetType().IsEnum)
294             {
295                 sb.Append((int)val);
296             }
297             else if (val is DateTime)
298             {
299                 sb.Append("new Date(\"");
300                 sb.Append(((DateTime)val).ToString("MMMM, d yyyy HH:mm:ss",
301                                                     new CultureInfo("en-US", false).DateTimeFormat));
302                 sb.Append("\")");
303             }
304             else if (val is DataSet)
305             {
306                 WriteDataSet(sb, val as DataSet);
307             }
308             else if (val is DataTable)
309             {
310                 WriteDataTable(sb, val as DataTable);
311             }
312             else if (val is DataRow)
313             {
314                 WriteDataRow(sb, val as DataRow);
315             }
316             else if (val is Hashtable)
317             {
318                 WriteHashtable(sb, val as Hashtable);
319             }
320             else if (val is IEnumerable)
321             {
322                 WriteEnumerable(sb, val as IEnumerable);
323             }
324             else
325             {
326                 WriteObject(sb, val);
327             }
328         }
329 
330         public static string Convert2Json(object o)
331         {
332             StringBuilder sb = new StringBuilder();
333             WriteValue(sb, o);
334             return sb.ToString();
335         }
336 
337         #endregion
338     }
339 }