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.  
    }
36.  
     
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 //对象，数组等不能处理,
109.  
      
110.  
     {
111.  
     returnStr = string.Format( "\"{0}\":\"{1}\",", propertyName, String2Json(valueStr));
112.  
     }
113.  
     return returnStr;
114.  
     }
115.  
      
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.  
     {
152.  
      
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)}
40.  
     
41.  
    };
42.  
     
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.  
    { //其余类型的忽略，避免异常
72.  
     
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.  
    {
47.  
     
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.  
    { 
66.  
     
67.  
    string PropertyNameTemp = item.PropertyName.ToLower().Trim();
68.  
    if (_propertyNames.Contains(PropertyNameTemp))
69.  
    {
70.  
    propertiesReturn.Add(item);
71.  
    }
72.  
    }
73.  
     
74.  
    return propertiesReturn;
75.  
    }
76.  
    }

 

 

出处：

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