Cómo ignorar una propiedad en clase si es nula, usando json.net

Estoy usando Json.NET para serializar una clase a JSON.

Tengo la clase como esta:

class Test1
{
    [JsonProperty("id")]
    public string ID { get; set; }
    [JsonProperty("label")]
    public string Label { get; set; }
    [JsonProperty("url")]
    public string URL { get; set; }
    [JsonProperty("item")]
    public List<Test2> Test2List { get; set; }
}

Quiero agregar un JsonIgnore()atributo a la Test2Listpropiedad solo cuando Test2Listsea null. Si no es nulo, entonces quiero incluirlo en mi json.

Según James Newton King: si crea el serializador usted mismo en lugar de usar JavaScriptConvert, hay una NullValueHandlingpropiedad que puede configurar para ignorar.

Aquí hay una muestra:

JsonSerializer _jsonWriter = new JsonSerializer {
                                 NullValueHandling = NullValueHandling.Ignore
                             };

Alternativamente, como lo sugiere @amit

JsonConvert.SerializeObject(myObject, 
                            Newtonsoft.Json.Formatting.None, 
                            new JsonSerializerSettings { 
                                NullValueHandling = NullValueHandling.Ignore
                            });

Una solución alternativa que utiliza el JsonPropertyatributo:

[JsonProperty(NullValueHandling=NullValueHandling.Ignore)]
// or
[JsonProperty("property_name", NullValueHandling=NullValueHandling.Ignore)]

// or for all properties in a class
[JsonObject(ItemNullValueHandling = NullValueHandling.Ignore)]

Como se ve en este documento en línea .

Similar a la respuesta de @ sirthomas, JSON.NET también respeta la EmitDefaultValuepropiedad en DataMemberAttribute:

[DataMember(Name="property_name", EmitDefaultValue=false)]

Esto puede ser deseable si ya está utilizando [DataContract]y [DataMember]en su tipo de modelo y no desea agregar atributos específicos de JSON.NET.

Puedes escribir: [JsonProperty("property_name",DefaultValueHandling = DefaultValueHandling.Ignore)]

También se ocupa de no serializar propiedades con valores predeterminados (no solo nulos). Puede ser útil para enumeraciones, por ejemplo.

Puede hacer esto para ignorar todos los valores nulos en un objeto que está serializando, y las propiedades nulas no aparecerán en el JSON

JsonSerializerSettings settings = new JsonSerializerSettings();
settings.NullValueHandling = NullValueHandling.Ignore;
var myJson = JsonConvert.SerializeObject(myObject, settings);

Como se puede ver en este enlace en su sitio (http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size.aspx) I admite el uso de [Predeterminado ()] para especificar valores predeterminados

Tomado del enlace

   public class Invoice
{
  public string Company { get; set; }
  public decimal Amount { get; set; }

  // false is default value of bool
  public bool Paid { get; set; }
  // null is default value of nullable
  public DateTime? PaidDate { get; set; }

  // customize default values
  [DefaultValue(30)]
  public int FollowUpDays { get; set; }
  [DefaultValue("")]
  public string FollowUpEmailAddress { get; set; }
}


Invoice invoice = new Invoice
{
  Company = "Acme Ltd.",
  Amount = 50.0m,
  Paid = false,
  FollowUpDays = 30,
  FollowUpEmailAddress = string.Empty,
  PaidDate = null
};

string included = JsonConvert.SerializeObject(invoice,
  Formatting.Indented,
  new JsonSerializerSettings { });

// {
//   "Company": "Acme Ltd.",
//   "Amount": 50.0,
//   "Paid": false,
//   "PaidDate": null,
//   "FollowUpDays": 30,
//   "FollowUpEmailAddress": ""
// }

string ignored = JsonConvert.SerializeObject(invoice,
  Formatting.Indented,
  new JsonSerializerSettings { DefaultValueHandling = DefaultValueHandling.Ignore });

// {
//   "Company": "Acme Ltd.",
//   "Amount": 50.0
// }

Una adaptación a la respuesta de @ Mrchief / @ amit, pero para las personas que usan VB

 Dim JSONOut As String = JsonConvert.SerializeObject(
           myContainerObject, 
           New JsonSerializerSettings With {
                 .NullValueHandling = NullValueHandling.Ignore
               }
  )

Consulte: "Inicializadores de objetos: tipos con nombre y anónimos (Visual Basic)"

https://msdn.microsoft.com/en-us/library/bb385125.aspx

En .Net Core esto es mucho más fácil ahora. En su startup.cs simplemente agregue las opciones de json y puede configurar las configuraciones allí.

public void ConfigureServices(IServiceCollection services)

....

services.AddMvc().AddJsonOptions(options =>
{
   options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;               
});

Con Json.NET

 public class Movie
 {
            public string Name { get; set; }
            public string Description { get; set; }
            public string Classification { get; set; }
            public string Studio { get; set; }
            public DateTime? ReleaseDate { get; set; }
            public List<string> ReleaseCountries { get; set; }
 }

 Movie movie = new Movie();
 movie.Name = "Bad Boys III";
 movie.Description = "It's no Bad Boys";

 string ignored = JsonConvert.SerializeObject(movie,
            Formatting.Indented,
            new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

El resultado será:

{
   "Name": "Bad Boys III",
   "Description": "It's no Bad Boys"
 }

Con System.Text.Jsony .NET Core 3.0 esto funcionó para mí:

var jsonSerializerOptions = new JsonSerializerOptions()
{
    IgnoreNullValues = true
};
var myJson = JsonSerializer.Serialize(myObject, jsonSerializerOptions );

Para exponer un poco la respuesta muy útil de GlennG (traducir la sintaxis de C # a VB.Net no siempre es "obvio") también puede decorar propiedades de clase individuales para administrar cómo se manejan los valores nulos. Si hace esto, no use el JsonSerializerSettings global de la sugerencia de GlennG, de lo contrario, anulará las decoraciones individuales. Esto es útil si desea que aparezca un elemento nulo en el JSON para que el consumidor no tenga que hacer ningún manejo especial. Si, por ejemplo, el consumidor necesita saber que una variedad de artículos opcionales está normalmente disponible, pero actualmente está vacía ... La decoración en la declaración de propiedad se ve así:

<JsonPropertyAttribute("MyProperty", DefaultValueHandling:=NullValueHandling.Include)> Public Property MyProperty As New List(of String)

Para aquellas propiedades que no desea que aparezcan en absoluto en el cambio JSON : = NullValueHandling.Incluye en : = NullValueHandling.Ignore . Por cierto, descubrí que puedes decorar una propiedad para la serialización XML y JSON muy bien (solo ponlas una al lado de la otra). Esto me da la opción de llamar al serializador XML en dotnet o al serializador NewtonSoft a voluntad, ambos trabajan lado a lado y mis clientes tienen la opción de trabajar con XML o JSON. ¡Esto es resbaladizo como un moco en un picaporte porque tengo clientes que requieren ambos!

Aquí hay una opción que es similar, pero ofrece otra opción:

public class DefaultJsonSerializer : JsonSerializerSettings
{
    public DefaultJsonSerializer()
    {
        NullValueHandling = NullValueHandling.Ignore;
    }
}

Entonces, lo uso así:

JsonConvert.SerializeObject(postObj, new DefaultJsonSerializer());

La diferencia aquí es que:

• Reduce el código repetido creando instancias y configurando JsonSerializerSettingscada lugar donde se usa.
• Ahorra tiempo en la configuración de cada propiedad de cada objeto a serializar.
• Todavía ofrece a otros desarrolladores flexibilidad en las opciones de serialización, en lugar de tener la propiedad especificada explícitamente en un objeto reutilizable.
• Mi caso de uso es que el código es una biblioteca de terceros y no quiero forzar las opciones de serialización en los desarrolladores que deseen reutilizar mis clases.
• Los inconvenientes potenciales son que es otro objeto que otros desarrolladores necesitarían saber, o si su aplicación es pequeña y este enfoque no importaría para una sola serialización.

var settings = new JsonSerializerSettings();
settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
settings.NullValueHandling = NullValueHandling.Ignore;
//you can add multiple settings and then use it
var bodyAsJson = JsonConvert.SerializeObject(body, Formatting.Indented, settings);