Comment ignorer une propriété de la classe si null, en utilisant json.net

J'utilise Json.NET pour sérialiser une classe en JSON.

J'ai la classe comme ça:

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

Je veux ajouter un JsonIgnore()attribut à la Test2Listpropriété uniquement lorsque l' Test2Listest null. S'il n'est pas nul, je veux l'inclure dans mon json.

Selon James Newton King: si vous créez le sérialiseur vous-même plutôt que d'utiliser JavaScriptConvert, il existe une NullValueHandlingpropriété que vous pouvez définir pour ignorer.

Voici un exemple:

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

Alternativement, comme suggéré par @amit

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

Une solution alternative utilisant l' JsonPropertyattribut:

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

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

Comme vu dans ce document en ligne .

Semblable à la réponse de @ sirthomas, JSON.NET respecte également la EmitDefaultValuepropriété sur DataMemberAttribute:

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

Cela peut être souhaitable si vous utilisez déjà [DataContract]et [DataMember]dans votre type de modèle et que vous ne souhaitez pas ajouter d'attributs spécifiques à JSON.NET.

Tu peux écrire: [JsonProperty("property_name",DefaultValueHandling = DefaultValueHandling.Ignore)]

Il prend également soin de ne pas sérialiser les propriétés avec des valeurs par défaut (pas seulement null). Cela peut être utile pour les énumérations par exemple.

Vous pouvez le faire pour ignorer toutes les valeurs nulles dans un objet que vous sérialisez, et aucune propriété nulle n'apparaîtra alors dans le JSON

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

Comme on peut le voir sur ce lien sur leur site (http://james.newtonking.com/archive/2009/10/23/efficient-json-with-json-net-reducing-serialized-json-size.aspx) I prise en charge en utilisant [Default ()] pour spécifier les valeurs par défaut

Tiré du lien

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

Une adaptation à la réponse de @ Mrchief / @ amit, mais pour les personnes utilisant VB

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

Voir: "Initialiseurs d'objets: types nommés et anonymes (Visual Basic)"

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

Dans .Net Core, c'est beaucoup plus facile maintenant. Dans votre startup.cs, ajoutez simplement les options json et vous pouvez y configurer les paramètres.

public void ConfigureServices(IServiceCollection services)

....

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

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

Le résultat sera:

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

Avec System.Text.Jsonet .NET Core 3.0, cela a fonctionné pour moi:

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

Pour exposer légèrement la réponse très utile de GlennG (la traduction de la syntaxe de C # en VB.Net n'est pas toujours "évidente"), vous pouvez également décorer des propriétés de classe individuelles pour gérer la façon dont les valeurs nulles sont gérées. Si vous faites cela, n'utilisez pas le JsonSerializerSettings global de la suggestion de GlennG, sinon il remplacera les décorations individuelles. Cela est pratique si vous voulez qu'un élément nul apparaisse dans le JSON afin que le consommateur n'ait pas à faire de manipulation spéciale. Si, par exemple, le consommateur a besoin de savoir qu'un tableau d'éléments facultatifs est normalement disponible, mais est actuellement vide ... La décoration de la déclaration de propriété ressemble à ceci:

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

Pour les propriétés que vous ne souhaitez pas voir apparaître du tout dans la modification JSON : = NullValueHandling.Include to : = NullValueHandling.Ignore . Soit dit en passant - j'ai trouvé que vous pouvez très bien décorer une propriété pour la sérialisation XML et JSON (mettez-les juste à côté les unes des autres). Cela me donne la possibilité d'appeler le sérialiseur XML dans dotnet ou le sérialiseur NewtonSoft à volonté - les deux travaillent côte à côte et mes clients ont la possibilité de travailler avec XML ou JSON. C'est lisse comme morve sur une poignée de porte car j'ai des clients qui ont besoin des deux!

Voici une option similaire, mais offrant un autre choix:

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

Ensuite, je l'utilise comme ceci:

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

La différence ici est que:

• Réduit le code répété en instanciant et en configurant JsonSerializerSettings chaque emplacement utilisé.
• Gagne du temps dans la configuration de chaque propriété de chaque objet à sérialiser.
• Donne toujours aux autres développeurs une flexibilité dans les options de sérialisation, plutôt que d'avoir la propriété explicitement spécifiée sur un objet réutilisable.
• Mon cas d'utilisation est que le code est une bibliothèque tierce et je ne veux pas forcer les options de sérialisation sur les développeurs qui voudraient réutiliser mes classes.
• Les inconvénients potentiels sont qu'il s'agit d'un autre objet que les autres développeurs devraient connaître, ou si votre application est petite et que cette approche n'aurait pas d'importance pour une seule sérialisation.

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