C#中如何实现json转化时只处理部分属性

时间：2023-03-08 16:54:32
C#中如何实现json转化时只处理部分属性

把对象转化为json字符串，很常用，但如果因为现在大部分项目都是用了ORM映射，导致一个对象的属性特别多，如果前台只需要部分属性如何实现？

当然最简单是所有属性都json化，前台只处理需要的属性，多余的不管。那有没有一种方式可以实现，对于同一种类型，按照前台的需要只处理json需要的属性呢？

在.Net中把对象转为json字符串主要有四种方式：具体参考

1自己转化灵活，但难度大，能实现。

2使用Newtonsoft.Json，看了一下官方文档，似乎不能实现，能忽略默认，空值等属性，也可以控制json时输出那些属性，但需要使用特性，也就是说，对于指定的类型，json输出的属性是确定的，不能动态改变。

具体可参考

3使用JavaScriptSerializer类，查看了官方文档，没找到方法，不能实现

4也是使用的是特性，没找到方法，不能实现。

没有现成的方法，也就只能自己实现了。我们知道把对象转化为json字符串，核心自然是使用反射得到需要的属性和属性的值。但如果属性是一个类对象呢？，数组或者是泛型呢？

另外如果字符串中包含特殊字符如何处理？

于是自己也就实现了一个简单的

  1. /// <summary>
  2. /// 把对象转化为json字符串
  3. /// </summary>
  4. /// <typeparam name="T">需要转化的对象的类型</typeparam>
  5. /// <param name="t">需要转化的对象</param>
  6. /// <param name="propertyInfos">需要转换的字段列表，用逗号分隔</param>
  7. /// <returns></returns>
  8. public static string ConvertFromModeTojson<T>(T t, string propertyInfos) where T : class
  9. {
  10. string[] cols = propertyInfos.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
  11. System.Text.StringBuilder sb = new System.Text.StringBuilder(300);
  12. string result = "{";
  13. foreach (string col in cols)
  14. {
  15. string str = GetOneProperty<T>(t, col);
  16. sb.Append(str);
  17. }
  18. result += sb.ToString().TrimEnd(',');
  19. result += "}";
  20. return result;
  21. }
  22. private static string GetOneProperty<T>(T t, string pname) where T : class
  23. {
  24. Type type = t.GetType();
  25. PropertyInfo pinfo = type.GetProperty(pname);//使用反射获得属性
  26. if (pinfo != null)
  27. {
  28. object v = pinfo.GetValue(t, null);//使用反射获得属性的值
  29. string tt = PropertyTypeValue(pinfo.PropertyType, v, pname);
  30. return tt;
  31. }
  32. else
  33. {
  34. throw new Exception("不存在属性" + pname);
  35. }
  37. }
  38. /// <summary>
  39. /// 按照数字格式输入的类型
  40. /// </summary>
  41. private static readonly List<Type> TypeNumCodeList = new List<Type>{
  42. { typeof(sbyte)},
  43. { typeof(sbyte?)},
  44. { typeof(short)},
  45. { typeof(short?)},
  46. { typeof(ushort)},
  47. { typeof(ushort?)},
  48. { typeof(int)},
  49. { typeof(int?)},
  50. { typeof(byte)},
  51. { typeof(byte?)},
  52. { typeof(uint)},
  53. { typeof(uint?)},
  54. { typeof(long)},
  55. { typeof(long?)},
  56. { typeof(ulong)},
  57. { typeof(ulong?)},
  58. { typeof(float)},
  59. { typeof(float?)},
  60. { typeof(double) },
  61. { typeof(double?)},
  62. { typeof(decimal)},
  63. { typeof(decimal?)},
  64. { typeof(bool)},
  65. { typeof(bool?)}
  66. };
  67. /// <summary>
  68. /// 按照文字格式输入的类型
  69. /// </summary>
  70. private static readonly List<Type> TypeStrCodeList = new List<Type>{
  71. { typeof(char)},
  72. { typeof(char?)},
  73. { typeof(DateTime)},
  74. { typeof(DateTime?)}
  75. };
  76. /// <summary>
  77. /// 根据字段类型进行罗列，显然不能处理所有的类型，也没有处理字段是数组，对象的情况
  78. /// </summary>
  79. /// <param name="propertytype"></param>
  80. /// <param name="value"></param>
  81. /// <param name="propertyName"></param>
  82. /// <returns></returns>
  83. private static string PropertyTypeValue(Type propertytype, object value, string propertyName)
  84. {
  85. string valueStr = value != null ? value.ToString() : "";
  86. string returnStr = "";
  87. if (TypeNumCodeList.Contains(propertytype))
  88. {
  89. if (!string.IsNullOrEmpty(valueStr))//忽略掉空值
  90. {
  91. returnStr = string.Format("\"{0}\":{1},", propertyName, valueStr);
  92. }
  93. }
  94. else if (TypeStrCodeList.Contains(propertytype))
  95. {
  96. if (!string.IsNullOrEmpty(valueStr))//忽略掉空值
  97. {
  98. returnStr = string.Format("\"{0}\":\"{1}\",", propertyName, valueStr);
  99. }
  100. }
  101. else if (propertytype == typeof(string))
  102. {
  103. if (!string.IsNullOrEmpty(valueStr))//忽略掉空值，并处理字符串中的特殊字符
  104. {
  105. returnStr = string.Format("\"{0}\":\"{1}\",", propertyName, String2Json(valueStr));
  106. }
  107. }
  108. else //对象，数组等不能处理,
  110. {
  111. returnStr = string.Format("\"{0}\":\"{1}\",", propertyName, String2Json(valueStr));
  112. }
  113. return returnStr;
  114. }
  116. /// <summary>
  117. /// 过滤特殊字符
  118. /// </summary>
  119. /// <param name="s"></param>
  120. /// <returns></returns>
  121. private static string String2Json(string s)
  122. {
  123. StringBuilder sb = new StringBuilder();
  124. for (int i = 0; i < s.Length; i++)
  125. {
  126. char c = s.ToCharArray()[i];
  127. switch (c)
  128. {
  129. case '\"':
  130. sb.Append("\\\""); break;
  131. case '\\':
  132. sb.Append("\\\\"); break;
  133. case '/':
  134. sb.Append("\\/"); break;
  135. case '\b':
  136. sb.Append("\\b"); break;
  137. case '\f':
  138. sb.Append("\\f"); break;
  139. case '\n':
  140. sb.Append("\\n"); break;
  141. case '\r':
  142. sb.Append("\\r"); break;
  143. case '\t':
  144. sb.Append("\\t"); break;
  145. /* case '<':
  146. sb.Append("<"); break;
  147. case '>':
  148. sb.Append(">"); break;*/
  149. default:
  150. if ((c >= 0 && c <= 31) || c == 127)//在ASCⅡ码中，第0～31号及第127号(共33个)是控制字符或通讯专用字符
  151. {
  153. }
  154. else
  155. {
  156. sb.Append(c);
  157. }
  158. break;
  159. }
  160. }
  161. return sb.ToString();
  162. }

很显然，这个实现有很大的问题，字符串中包含的特殊字符不一定处理完了，泛型，数组等属性都没有处理，但是简单对象还是可以处理的。

既然Newtonsoft.Json是开源的，那能不能利用它实现呢？

于是使用Newtonsoft.Json改进了以上代码

  1. private static readonly List<Type> TypeCodeList = new List<Type>{
  2. { typeof(char)},
  3. { typeof(char?)},
  4. { typeof(bool)},
  5. { typeof(bool?)},
  6. { typeof(sbyte)},
  7. { typeof(sbyte?)},
  8. { typeof(short)},
  9. { typeof(short?)},
  10. { typeof(ushort)},
  11. { typeof(ushort?)},
  12. { typeof(int)},
  13. { typeof(int?)},
  14. { typeof(byte)},
  15. { typeof(byte?)},
  16. { typeof(uint)},
  17. { typeof(uint?)},
  18. { typeof(long)},
  19. { typeof(long?)},
  20. { typeof(ulong)},
  21. { typeof(ulong?)},
  22. { typeof(float)},
  23. { typeof(float?)},
  24. { typeof(double) },
  25. { typeof(double?)},
  26. { typeof(DateTime)},
  27. { typeof(DateTime?)},
  28. { typeof(DateTimeOffset)},
  29. { typeof(DateTimeOffset?)},
  30. { typeof(decimal)},
  31. { typeof(decimal?)},
  32. { typeof(Guid)},
  33. { typeof(Guid?)},
  34. { typeof(TimeSpan)},
  35. { typeof(TimeSpan?)},
  36. { typeof(Uri)},
  37. { typeof(string)},
  38. { typeof(byte[])},
  39. { typeof(DBNull)}
  41. };
  43. /// <summary>
  44. /// 把对象转化为json字符串,依然不能处理属性是泛型，数组，对象等类型
  45. /// </summary>
  46. /// <typeparam name="T">需要转化的对象的类型</typeparam>
  47. /// <param name="t">需要转化的对象</param>
  48. /// <param name="propertyInfos">需要转换的字段列表，用逗号分隔</param>
  49. /// <returns></returns>
  50. public static string ConvertFromModeTojson<T>(T t, string propertyInfos) where T : class
  51. {
  52. StringWriter sw = new StringWriter();
  53. using (JsonTextWriter writer = new JsonTextWriter(sw))
  54. {
  55. writer.WriteStartObject();
  56. string[] cols = propertyInfos.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
  57. foreach (string col in cols)
  58. {
  59. Type type = t.GetType();
  60. PropertyInfo pinfo = type.GetProperty(col);//使用反射获得属性
  61. if (pinfo != null)
  62. {
  63. object v = pinfo.GetValue(t, null);//使用反射获得属性的值
  64. Type pinfoType = pinfo.PropertyType;
  65. if (TypeCodeList.Contains(pinfoType))
  66. {
  67. writer.WritePropertyName(col);
  68. writer.WriteValue(v);
  69. }
  70. else
  71. { //其他类型的忽略，避免异常
  73. }
  74. }
  75. else
  76. {
  77. throw new Exception("不存在属性" + col);
  78. }
  79. }
  80. writer.WriteEndObject();
  81. writer.Flush();
  82. }
  83. string jsonText = sw.GetStringBuilder().ToString();
  84. return jsonText;
  85. }

在前面的文章中使用的json方法，可以按照需要只处理需要的属性，但却要求属性不能是复杂的类型，例如泛型，数组，其他用户自定义的类等，限制太多，于是自己看看能不能改进，想不到Newtonsoft.Json提供有相关的接口，只需要实现就可以了。只需要继承DefaultContractResolver，并改写一个方法就可以了。

核心代码：

  1. /// <summary>
  2. /// 对象转为json，所有属性都输出
  3. /// </summary>
  4. /// <typeparam name="ObjType"></typeparam>
  5. /// <param name="obj"></param>
  6. /// <returns></returns>
  7. public static string ObjToJsonString<ObjType>(ObjType obj) where ObjType : class
  8. {
  9. string s = JsonConvert.SerializeObject(obj);
  10. return s;
  11. }
  12. /// <summary>
  13. /// 对象转为json，只输出部分属性
  14. /// </summary>
  15. /// <typeparam name="T">对象类型</typeparam>
  16. /// <param name="t">对象类型值</param>
  17. /// <param name="propertyInfos">需要json处理的属性名称，以逗号分隔</param>
  18. /// <returns></returns>
  19. public static string ObjToJsonString<T>(T t, string propertyInfos) where T : class
  20. {
  21. string[] cols = propertyInfos.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
  22. List<string> _propertyNames = new List<string>();
  23. foreach (string col in cols)
  24. {
  25.  string   colTemp = col.ToLower().Trim();
  26. if (!_propertyNames.Contains(colTemp))
  27. {
  28. _propertyNames.Add(colTemp);
  29. }
  30. }
  31. string s = JsonConvert.SerializeObject(t, Formatting.Indented, new JsonSerializerSettings { ContractResolver = new DynamicContractResolver(_propertyNames) });
  32. return s;
  33. }
  34. /// <summary>
  35. /// json转为对象
  36. /// </summary>
  37. /// <typeparam name="ObjType"></typeparam>
  38. /// <param name="JsonString"></param>
  39. /// <returns></returns>
  40. public static ObjType JsonStringToObj<ObjType>(string JsonString) where ObjType : class
  41. {
  42. ObjType s = JsonConvert.DeserializeObject<ObjType>(JsonString);
  43. return s;
  44. }
  45. class DynamicContractResolver : DefaultContractResolver
  46. {
  48. private readonly List<string> _propertyNames;
  49. public DynamicContractResolver(List<string> propertyNames)
  50. {
  51. _propertyNames = propertyNames;
  52. }
  53. /// <summary>
  54. /// 如果属性是对象，需要把这个对象的属性也传给propertyNames，
  55. /// 否则处理这个对象属性时，就不包含对应的属性值
  56. /// </summary>
  57. /// <param name="type"></param>
  58. /// <param name="memberSerialization"></param>
  59. /// <returns></returns>
  60. protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
  61. {
  62. IList<JsonProperty> properties = base.CreateProperties(type, memberSerialization);
  63. IList<JsonProperty> propertiesReturn = new List<JsonProperty>();//需要json处理的属性
  64. foreach (JsonProperty item in properties)
  65. { 
  67. string PropertyNameTemp = item.PropertyName.ToLower().Trim();
  68. if (_propertyNames.Contains(PropertyNameTemp))
  69. {
  70. propertiesReturn.Add(item);
  71. }
  72. }
  74. return propertiesReturn;
  75. }
  76. }

出处：

https://blog.csdn.net/xuexiaodong009/article/details/46998695

https://blog.csdn.net/xuexiaodong009/article/details/47004105