Come escludere immobili da serializzazione JSON

Question

Ho una classe DTO che ho serializzare

Json.Serialize(MyClass) 

Come posso escludere una proprietà pubblica di esso?

(deve essere pubblico, come lo uso nel mio codice da qualche altra parte)

Answer 1

È possibile inserire un attributo ScriptIgnore sui membri che non deve essere serializzato. Vedere l'esempio tratto da here:

Si consideri il seguente caso (semplificato):

public class User { 
    public int Id { get; set; } 
    public string Name { get; set; } 
    [ScriptIgnore] 
    public bool IsComplete 
    { 
     get { return Id > 0 && !string.IsNullOrEmpty(Name); } 
    } 
} 

In questo caso, solo l'ID e le proprietà del nome verranno serializzati, in tal modo l'oggetto JSON risultante apparirebbe in questo modo:

{ Id: 3, Name: 'Test User' } 

PS. Non dimenticare di aggiungere un riferimento a "System.Web.Extensions" perché funzioni

Answer 2

È possibile utilizzare [ScriptIgnore]:

public class User 
{ 
    public int Id { get; set; } 
    public string Name { get; set; } 
    [ScriptIgnore] 
    public bool IsComplete 
    { 
     get { return Id > 0 && !string.IsNullOrEmpty(Name); } 
    } 
} 

Riferimento here

In questo caso l'ID e poi il nome verrà serializzato solo

Answer 3

Se si utilizza Json.Net, l'attributo [JsonIgnore] semplicemente ignorerà il campo/la porzionatura durante la serializzazione o la deserializzazione.

public class Car 
{ 
    // included in JSON 
    public string Model { get; set; } 
    public DateTime Year { get; set; } 
    public List<string> Features { get; set; } 

    // ignored 
    [JsonIgnore] 
    public DateTime LastModified { get; set; } 
} 

Oppure è possibile utilizzare l'attributo DataContract e DataMember per serializzare in modo selettivo/deserializzare proprietà/campi.

[DataContract] 
public class Computer 
{ 
    // included in JSON 
    [DataMember] 
    public string Name { get; set; } 
    [DataMember] 
    public decimal SalePrice { get; set; } 

    // ignored 
    public string Manufacture { get; set; } 
    public int StockCount { get; set; } 
    public decimal WholeSalePrice { get; set; } 
    public DateTime NextShipmentDate { get; set; } 
} 

consultare http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size per maggiori dettagli

Answer 4

Se non sei così appassionato di avere per decorare codice con attributi come lo sono io, specialmente quando non puoi dire al momento della compilazione che cosa accadrà qui è la mia soluzione.

Usando il Javascript Serializzatore

public static class JsonSerializerExtensions 
    { 
     public static string ToJsonString(this object target,bool ignoreNulls = true) 
     { 
      var javaScriptSerializer = new JavaScriptSerializer(); 
      if(ignoreNulls) 
      { 
       javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(target.GetType(), true) }); 
      } 
      return javaScriptSerializer.Serialize(target); 
     } 

     public static string ToJsonString(this object target, Dictionary<Type, List<string>> ignore, bool ignoreNulls = true) 
     { 
      var javaScriptSerializer = new JavaScriptSerializer(); 
      foreach (var key in ignore.Keys) 
      { 
       javaScriptSerializer.RegisterConverters(new[] { new PropertyExclusionConverter(key, ignore[key], ignoreNulls) }); 
      } 
      return javaScriptSerializer.Serialize(target); 
     } 
    } 


public class PropertyExclusionConverter : JavaScriptConverter 
    { 
     private readonly List<string> propertiesToIgnore; 
     private readonly Type type; 
     private readonly bool ignoreNulls; 

     public PropertyExclusionConverter(Type type, List<string> propertiesToIgnore, bool ignoreNulls) 
     { 
      this.ignoreNulls = ignoreNulls; 
      this.type = type; 
      this.propertiesToIgnore = propertiesToIgnore ?? new List<string>(); 
     } 

     public PropertyExclusionConverter(Type type, bool ignoreNulls) 
      : this(type, null, ignoreNulls){} 

     public override IEnumerable<Type> SupportedTypes 
     { 
      get { return new ReadOnlyCollection<Type>(new List<Type>(new[] { this.type })); } 
     } 

     public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer) 
     { 
      var result = new Dictionary<string, object>(); 
      if (obj == null) 
      { 
       return result; 
      } 
      var properties = obj.GetType().GetProperties(); 
      foreach (var propertyInfo in properties) 
      { 
       if (!this.propertiesToIgnore.Contains(propertyInfo.Name)) 
       { 
        if(this.ignoreNulls && propertyInfo.GetValue(obj, null) == null) 
        { 
         continue; 
        } 
        result.Add(propertyInfo.Name, propertyInfo.GetValue(obj, null)); 
       } 
      } 
      return result; 
     } 

     public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer) 
     { 
      throw new NotImplementedException(); //Converter is currently only used for ignoring properties on serialization 
     } 
    }