Cómo excluir la propiedad de la serialización JSON

Question

tengo una clase DTO cual serializar

Json.Serialize(MyClass) 

¿Cómo puedo excluir una propiedad pública de ella?

(tiene que ser público, como lo uso en mi código en otro lugar)

Answer 1

Puede poner un atributo ScriptIgnore en los miembros que no se deben serializar. Vea el ejemplo tomado de here:

Considere el caso siguiente (simplificado):

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

En este caso, sólo el ID y las propiedades Name serán serializados, por lo tanto el objeto JSON resultante se vería de esta manera:

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

PS. No olvide agregar una referencia a "System.Web.Extensions" para que funcione

Answer 2

Puede utilizar [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); } 
    } 
} 

Referencia here

En este caso, la identificación y luego nombre solo será serializado

Answer 3

Si está utilizando Json.Net, el atributo [JsonIgnore] simplemente ignorará el campo/porperty durante la serialización o deserialización.

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; } 
} 

O puede usar el atributo DataContract y DataMember para serializar/deserializar selectivamente propiedades/campos.

[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; } 
} 

Consulte http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size para más detalles

Answer 4

Si no está tan interesado en tener que decorar código con atributos como yo, especialmente cuando usted no puede decir en tiempo de compilación lo que sucederá aquí está mi solución.

Utilizando el Javascript Serializador

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 
     } 
    }