Cara mengabaikan properti di kelas jika null, menggunakan json.net

Saya menggunakan Json.NET untuk membuat cerita bersambung suatu kelas menjadi JSON.

Saya memiliki kelas seperti ini:

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

Saya ingin menambahkan JsonIgnore()atribut ke Test2Listproperti hanya jika Test2Listada null. Jika tidak nol maka saya ingin memasukkannya di json saya.

Sesuai James Newton King: Jika Anda membuat serializer sendiri daripada menggunakan JavaScriptConvert, ada NullValueHandlingproperti yang bisa Anda atur untuk diabaikan.

Berikut ini contohnya:

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

Atau, seperti yang disarankan oleh @amit

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

Solusi alternatif menggunakan JsonPropertyatribut:

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

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

Seperti yang terlihat dalam dokumen online ini .

Mirip dengan jawaban @ sirthomas ini, JSON.NET juga menghormati para EmitDefaultValueproperti di DataMemberAttribute:

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

Ini mungkin diinginkan jika Anda sudah menggunakan [DataContract]dan [DataMember]dalam tipe model Anda dan tidak ingin menambahkan atribut JSON.NET-spesifik.

Kamu bisa menulis: [JsonProperty("property_name",DefaultValueHandling = DefaultValueHandling.Ignore)]

Ini juga menangani tidak membuat serialisasi properti dengan nilai default (tidak hanya nol). Ini bisa bermanfaat untuk enum misalnya.

Anda bisa melakukan ini untuk mengabaikan semua null di objek yang Anda serialkan, dan properti null apa pun tidak akan muncul di JSON

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

Seperti yang dapat dilihat di tautan ini di situs mereka (http://james.newtonking.com/archive/2009/10/23/efisien-json-with-json-net-netucing-serialized-json-size.aspx) I dukungan menggunakan [Default ()] untuk menentukan nilai default

Diambil dari tautan

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

Adaptasi untuk jawaban @ Mrchief's / @ amit, tetapi untuk orang yang menggunakan VB

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

Lihat: "Inisialisasi Objek: Tipe Bernama dan Anonim (Visual Basic)"

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

Di .Net Core ini jauh lebih mudah sekarang. Di startup.cs Anda cukup tambahkan opsi json dan Anda dapat mengonfigurasi pengaturan di sana.

public void ConfigureServices(IServiceCollection services)

....

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

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

Hasilnya adalah:

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

Dengan System.Text.Jsondan .NET Core 3.0 ini berfungsi untuk saya:

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

Untuk sedikit menguraikan jawaban GlennG yang sangat membantu (menerjemahkan sintaks dari C # ke VB.Net tidak selalu "jelas"), Anda juga dapat menghiasi properti kelas individu untuk mengelola bagaimana nilai-nilai nol ditangani. Jika Anda melakukan ini jangan gunakan global JsonSerializerSettings dari saran GlennG, jika tidak maka akan menimpa dekorasi individu. Ini sangat berguna jika Anda ingin item nol muncul di JSON sehingga konsumen tidak perlu melakukan penanganan khusus. Jika, misalnya, konsumen perlu mengetahui berbagai item opsional biasanya tersedia, tetapi saat ini kosong ... Dekorasi dalam deklarasi properti terlihat seperti ini:

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

Untuk properti yang Anda tidak ingin muncul sama sekali dalam perubahan JSON : = NullValueHandling.Termasuk ke : = NullValueHandling.Ignore . Ngomong-ngomong - Saya telah menemukan bahwa Anda dapat menghiasi properti untuk serialisasi XML dan JSON dengan baik (cukup letakkan di samping satu sama lain). Ini memberi saya pilihan untuk memanggil serializer XML di dotnet atau serializer NewtonSoft sesuka hati - keduanya bekerja berdampingan dan pelanggan saya memiliki opsi untuk bekerja dengan XML atau JSON. Ini licin karena ingus pada gagang pintu karena saya memiliki pelanggan yang membutuhkan keduanya!

Berikut ini opsi yang serupa, tetapi memberikan pilihan lain:

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

Lalu, saya menggunakannya seperti ini:

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

Perbedaannya di sini adalah:

• Mengurangi kode berulang dengan membuat instance dan mengkonfigurasi JsonSerializerSettingssetiap tempat yang digunakan.
• Menghemat waktu dalam mengonfigurasi setiap properti dari setiap objek yang akan diserialisasi.
• Masih memberi pengembang lain fleksibilitas dalam opsi serialisasi, daripada memiliki properti yang secara eksplisit ditentukan pada objek yang dapat digunakan kembali.
• Kasus penggunaan saya adalah bahwa kode tersebut adalah pustaka pihak ke-3 dan saya tidak ingin memaksakan opsi serialisasi pada pengembang yang ingin menggunakan kembali kelas saya.
• Kelemahan potensial adalah objek lain yang perlu diketahui pengembang lain, atau jika aplikasi Anda kecil dan pendekatan ini tidak masalah untuk serialisasi tunggal.

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