Como ignorar uma propriedade na classe se nula, usando json.net

Estou usando o Json.NET para serializar uma classe para JSON.

Eu tenho a classe assim:

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

Eu quero adicionar um JsonIgnore()atributo à Test2Listpropriedade somente quando Test2Listestiver null. Se não for nulo, quero incluí-lo no meu json.

De acordo com James Newton King: Se você mesmo criar o serializador, em vez de usar JavaScriptConvert, haverá uma NullValueHandlingpropriedade que poderá ser configurada para ignorar.

Aqui está uma amostra:

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

Como alternativa, conforme sugerido por @amit

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

Uma solução alternativa usando o JsonPropertyatributo:

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

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

Como visto neste documento online .

Semelhante à resposta de @ sirthomas, o JSON.NET também respeita a EmitDefaultValuepropriedade em DataMemberAttribute:

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

Isso pode ser desejável se você já estiver usando [DataContract]e [DataMember]no seu tipo de modelo e não quiser adicionar atributos específicos ao JSON.NET.

Você pode escrever: [JsonProperty("property_name",DefaultValueHandling = DefaultValueHandling.Ignore)]

Ele também cuida de não serializar propriedades com valores padrão (não apenas nulos). Pode ser útil para enumerações, por exemplo.

Você pode fazer isso para ignorar todos os nulos em um objeto que você está serializando, e quaisquer propriedades nulas não aparecerão no JSON

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

Como pode ser visto neste link em seu site (http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size.aspx) I suporte usando [Padrão ()] para especificar valores padrão

Retirado do link

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

Uma adaptação à resposta de @ Mrchief / @ amit, mas para pessoas que usam VB

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

Consulte: "Inicializadores de objeto: tipos nomeados e anônimos (Visual Basic)"

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

No .Net Core, isso é muito mais fácil agora. No seu startup.cs, adicione as opções json e você poderá definir as configurações lá.

public void ConfigureServices(IServiceCollection services)

....

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

Com o 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 });

O resultado será:

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

Com System.Text.Jsone .NET Core 3.0, isso funcionou para mim:

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

Para explicar um pouco a resposta muito útil da GlennG (traduzir a sintaxe de C # para VB.Net nem sempre é "óbvia"), você também pode decorar propriedades de classes individuais para gerenciar como os valores nulos são tratados. Se você fizer isso, não use o JsonSerializerSettings global da sugestão da GlennG; caso contrário, ele substituirá as decorações individuais. Isso é útil se você deseja que um item nulo apareça no JSON, para que o consumidor não precise fazer nenhum tratamento especial. Se, por exemplo, o consumidor precisar saber que uma matriz de itens opcionais está normalmente disponível, mas está vazia no momento ... A decoração na declaração de propriedade é semelhante a esta:

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

Para aquelas propriedades que você não deseja que apareçam na alteração JSON : = NullValueHandling.Include a : = NullValueHandling.Ignore . A propósito - eu descobri que você pode decorar uma propriedade para serialização XML e JSON muito bem (apenas coloque-as uma ao lado da outra). Isso me dá a opção de chamar o serializador XML no dotnet ou o NewtonSoft à vontade - ambos trabalham lado a lado e meus clientes têm a opção de trabalhar com XML ou JSON. Isso é liso como ranho em uma maçaneta, pois tenho clientes que exigem os dois!

Aqui está uma opção semelhante, mas oferece outra opção:

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

Então, eu uso assim:

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

A diferença aqui é que:

• Reduz o código repetido, instanciando e configurando JsonSerializerSettingscada local que é usado.
• Economiza tempo na configuração de todas as propriedades de cada objeto a ser serializado.
• Ainda oferece aos outros desenvolvedores flexibilidade nas opções de serialização, em vez de ter a propriedade especificada explicitamente em um objeto reutilizável.
• Meu caso de uso é que o código é uma biblioteca de terceiros e não quero forçar opções de serialização em desenvolvedores que desejam reutilizar minhas classes.
• As desvantagens potenciais são que esse é outro objeto que outros desenvolvedores precisariam conhecer ou se seu aplicativo é pequeno e essa abordagem não importaria para uma única serialização.

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