Como usar um documento JSON em System.Text.Json (2023)

Este artigo mostra como usar umModelo de objeto de documento JSON (DOM)para acesso aleatório aos dados em uma carga JSON.

Opções JSON DOM

Trabalhar com um DOM é uma alternativa à desserialização comJsonSerializerquando:

• Você não tem um tipo para desserializar.
• O JSON que você recebe não possui um esquema fixo e deve ser inspecionado para saber o que ele contém.

System.Text.Jsonfornece duas maneiras de criar um JSON DOM:

• JsonDocumentNamefornece a capacidade de criar um DOM somente leitura usandoUtf8JsonReaderName. Os elementos JSON que compõem o payload podem ser acessados ​​por meio doJsonElementNametipo. OJsonElementNametype fornece enumeradores de matriz e objeto junto com APIs para converter texto JSON em tipos .NET comuns.JsonDocumentNameexpõe umRaizElementopropriedade. Para mais informações, vejaUsar JsonDocumentposteriormente neste artigo.

• JsonNodee as classes que dela derivam noSystem.Text.Json.Nodesnamespace fornecem a capacidade de criar um DOM mutável. Os elementos JSON que compõem o payload podem ser acessados ​​por meio doJsonNode,JsonObject,JsonArray,JsonValue, eJsonElementNametipos. Para mais informações, vejaUsar JsonNodeposteriormente neste artigo.

  (Video) 40% faster JSON serialization with Source Generators in .NET 6

Considere os seguintes fatores ao escolher entreJsonDocumentNameeJsonNode:

• OJsonNodeO DOM pode ser alterado depois de criado. OJsonDocumentNameDOM é imutável.
• OJsonDocumentNameO DOM fornece acesso mais rápido aos seus dados.

UsarJsonNode

O exemplo a seguir mostra como usarJsonNodee os outros tipos noSystem.Text.Json.Nodesespaço de nomes para:

• Crie um DOM a partir de uma string JSON
• Escreva JSON de um DOM.
• Obtenha um valor, objeto ou array de um DOM.

using System.Text.Json;using System.Text.Json.Nodes;namespace JsonNodeFromStringExample;public class Program{ public static void Main() { string jsonString =@"{ ""Date"": ""2019-08-01T00: 00:00"", ""Temperatura"": 25, ""Resumo"": ""Quente"", ""Datas disponíveis"": [ ""2019-08-01T00:00:00"", ""2019 -08-02T00:00:00"" ], ""Faixas de temperatura"": { ""Frio"": { ""Alto"": 20, ""Baixo"": -10 }, ""Quente"": { ""Alto"": 60, ""Baixo"": 20 } }}"; // Cria um DOM JsonNode a partir de uma string JSON. JsonNode forecastNode = JsonNode.Parse(jsonString)!; // Escreve JSON de um JsonNode var options = new JsonSerializerOptions { WriteIndented = true }; Console.WriteLine(forecastNode!.ToJsonString(opções)); // saída: //{ // "Data": "2019-08-01T00:00:00", // "Temperatura": 25, // "Resumo": "Quente", // "Datas disponíveis": [ // "2019-08-01T00:00:00", // "2019-08-02T00:00:00" // ], // "Temperature Ranges": { // "Frio": { // "Alto" : 20, // "Baixo": -10 // }, // "Quente": { // "Alto": 60, // "Baixo": 20 // } // } //} // Obter valor de um JsonNode. JsonNode temperatureNode = forecastNode!["Temperatura"]!; Console.WriteLine($"Type={temperatureNode.GetType()}"); Console.WriteLine($"JSON={temperatureNode.ToJsonString()}"); //output: //Type = System.Text.Json.Nodes.JsonValue`1[System.Text.Json.JsonElement] //JSON = 25 // Obtém um valor digitado de um JsonNode. int temperatureInt = (int)forecastNode!["Temperatura"]!; Console.WriteLine($"Value={temperatureInt}"); //output: //Value=25 // Obtém um valor digitado de um JsonNode usando GetValue. temperatureInt = forecastNode!["Temperatura"]!.GetValue(); Console.WriteLine($"TemperatureInt={temperatureInt}"); //output: //Value=25 // Obtém um objeto JSON de um JsonNode. JsonNode temperatureRanges = forecastNode!["TemperatureRanges"]!; Console.WriteLine($"Type={temperatureRanges.GetType()}"); Console.WriteLine($"JSON={temperatureRanges.ToJsonString()}"); //output: //Type = System.Text.Json.Nodes.JsonObject //JSON = { "Cold":{ "High":20,"Low":-10},"Hot":{ "High": 60,"Low":20} } // Obtém um array JSON de um JsonNode. JsonNode dateAvailable = forecastNode!["DatesDisponível"]!; Console.WriteLine($"Type={datesAvailable.GetType()}"); Console.WriteLine($"JSON={datesAvailable.ToJsonString()}"); //output: //datesAvailable Type = System.Text.Json.Nodes.JsonArray //datesAvailable JSON =["2019-08-01T00:00:00", "2019-08-02T00:00:00"] // Obtenha um valor de elemento de matriz de um JsonArray. JsonNode firstDateAvailable = dateAvailable[0]!; Console.WriteLine($"Type={firstDateAvailable.GetType()}"); Console.WriteLine($"JSON={firstDateAvailable.ToJsonString()}"); //output: //Type = System.Text.Json.Nodes.JsonValue`1[System.Text.Json.JsonElement] //JSON = "2019-08-01T00:00:00" // Obtém um valor digitado por encadeamento de referências. int coldHighTemperature = (int)forecastNode["Intervalos de temperatura"]!["Frio"]!["Alto"]!; Console.WriteLine($"TemperatureRanges.Cold.High={coldHighTemperature}"); //saída: //TemperatureRanges.Cold.High = 20 // Analisa um array JSON var dateNode = JsonNode.Parse(@"[""2019-08-01T00:00:00"",""2019-08-02T00 :00:00""]"); JsonNode firstDate = dateNode![0]!.GetValue(); Console.WriteLine($"firstDate={ firstDate}"); //output: //firstDate = "2019-08-01T00:00:00" }}

Crie um DOM JsonNode com inicializadores de objeto e faça alterações

O exemplo a seguir mostra como:

• Crie um DOM usando inicializadores de objeto.
• Faça alterações em um DOM.

using System.Text.Json;using System.Text.Json.Nodes;namespace JsonNodeFromObjectExample;public class Program{ public static void Main() { // Crie um novo JsonObject usando inicializadores de objeto. var forecastObject = new JsonObject { ["Date"] = new DateTime(2019, 8, 1), ["Temperature"] = 25, ["Summary"] = "Hot", ["DatesAvailable"] = new JsonArray( new DateTime(2019, 8, 1), new DateTime(2019, 8, 2)), ["TemperatureRanges"] = new JsonObject { ["Cold"] = new JsonObject { ["High"] = 20, ["Low" ] = -10 } }, ["SummaryWords"] = new JsonArray("Cool", "Windy", "Humid") }; // Adicionar um objeto. forecastObject!["TemperatureRanges"]!["Hot"] = new JsonObject { ["High"] = 60, ["Low"] = 20 }; // Remove uma propriedade. previsãoObject.Remove("SummaryWords"); // Altera o valor de uma propriedade. forecastObject["Date"] = new DateTime(2019, 8, 3); var opções = new JsonSerializerOptions { WriteIndented = true }; Console.WriteLine(forecastObject.ToJsonString(opções)); //saída: //{ // "Data": "2019-08-03T00:00:00", // "Temperatura": 25, // "Resumo": "Quente", // "Datas disponíveis": [ // "2019-08-01T00:00:00", // "2019-08-02T00:00:00" // ], // "Temperature Ranges": { // "Frio": { // "Alto" : 20, // "Baixo": -10 // }, // "Quente": { // "Alto": 60, // "Baixo": 20 // } // } //} }}

Desserializar subseções de uma carga JSON

O exemplo a seguir mostra como usarJsonNodepara navegar para uma subseção de uma árvore JSON e desserializar um único valor, um tipo personalizado ou uma matriz dessa subseção.

usando System.Text.Json;usando System.Text.Json.Nodes;namespace JsonNodePOCOExample;public class TemperatureRanges : Dictionary{}public class HighLowTemps{ public int High { get; definir; } public int Baixa { obter; definir; }}Programa de classe pública{ public static DateTime[]? Datas disponíveis { get; definir; } public static void Main() { string jsonString =@"{ ""Data"": ""2019-08-01T00:00:00"", ""Temperatura"": 25, ""Resumo"": "" Quente"", ""Datas disponíveis"": [ ""2019-08-01T00:00:00"", ""2019-08-02T00:00:00"" ], ""Temperature Ranges"": { ""Frio "": { ""Alta"": 20, ""Baixa"": -10 }, ""Quente"": { ""Alta"": 60, ""Baixa"": 20 } }}"; // Analisa todo o JSON. JsonNode forecastNode = JsonNode.Parse(jsonString)!; // Obtém um único valor int hotHigh = forecastNode["TemperatureRanges"]!["Hot"]!["High"]!.GetValue(); Console.WriteLine($"Hot.High={hotHigh}"); // output: //Hot.High=60 // Obtenha uma subseção e desserialize-a em um tipo personalizado. JsonObject temperatureRangesObject = forecastNode!["TemperatureRanges"]!.AsObject(); usando var stream = new MemoryStream(); usando var Writer = new Utf8JsonWriter(stream); temperatureRangesObject.WriteTo(escritor); escritor.Flush(); Faixas de temperatura? temperatureRanges = JsonSerializer.Deserialize(stream.ToArray()); Console.WriteLine($"Cold.Low={temperatureRanges!["Cold"].Baixo}, Hot.High={temperatureRanges["Hot"].Alto}"); // output: //Cold.Low=-10, Hot.High=60 // Obtenha uma subseção e desserialize-a em um array. JsonArray dateAvailable = forecastNode!["DatesAvailable"]!.AsArray()!; Console.WriteLine($"Datas disponíveis[0]={datas disponíveis[0]}"); // saída: //Datas disponíveis[0]=01/08/2019 12:00:00 }}

Exemplo de nota média JsonNode

O exemplo a seguir seleciona uma matriz JSON que possui valores inteiros e calcula um valor médio:

using System.Text.Json.Nodes;namespace JsonNodeAverageGradeExample;public class Program{ public static void Main() { string jsonString =@"{ ""Nome da turma"": ""Ciência"", ""Nome do professor"" : ""Jane"", ""Semestre"": ""01-01-2019"", ""Estudantes"": [ { ""Nome"": ""João"", ""Nota"": 94,3 }, { ""Nome"": ""James"", ""Nota"": 81,0 }, { ""Nome"": ""Julia"", ""Nota"": 91,9 }, { ""Nome "": ""Jessica"", ""Nota"": 72,4 }, { ""Nome"": ""Johnathan"" } ], ""Final"": verdadeiro}"; dupla soma = 0; contagem int = 0; documento JsonNode = JsonNode.Parse(jsonString)!; JsonNode root = document.Root; JsonArray alunosArray = root["Alunos"]!.AsArray(); contagem = alunosArray.Count; foreach (JsonNode? aluno em alunosArray) { if (aluno?["Nota"] é JsonNode notaNode) { soma += (duplo) notaNode; } else { soma += 70; } } média dupla = soma / contagem; Console.WriteLine($"Nota média: {média}"); }}// output://Nota média: 81,92

O código anterior:

• Calcula uma nota média para objetos em umAlunosmatriz que tem umNotapropriedade.
• Atribui uma nota padrão de 70 para os alunos que não têm nota.
• Obtém o número de alunos doContarpropriedade deJsonArray.

JsonNodecomJsonSerializerOptions

Você pode usarJsonSerializerpara serializar e desserializar uma instância deJsonNode. No entanto, se você usar uma sobrecarga que levaJsonSerializerOptions, a instância de opções é usada apenas para obter conversores personalizados. Outros recursos da instância de opções não são usados. Por exemplo, se você definirJsonSerializerOptions.DefaultIgnoreConditionparaWhenWritingNulle ligueJsonSerializercom uma sobrecarga que levaJsonSerializerOptions, as propriedades nulas não serão ignoradas.

A mesma limitação se aplica aoJsonNodemétodos que levam umJsonSerializerOptionsparâmetro:WriteTo(Utf8JsonWriter, JsonSerializerOptions)eToJsonString(JsonSerializerOptions). Essas APIs usamJsonSerializerOptionsapenas para obter conversores personalizados.

O exemplo a seguir ilustra o resultado do uso de métodos que usam umJsonSerializerOptionsparâmetro e serializar umJsonNodeinstância:

usando System.Text;usando System.Text.Json;usando System.Text.Json.Nodes;usando System.Text.Json.Serialization;namespace JsonNodeWithJsonSerializerOptions;public class Program{ public static void Main() { Person person = new Person { Nome = "Nancy" }; // Serialização padrão - Propriedade de endereço incluída no token nulo. // Output: {"Name":"Nancy","Address":null} string personJsonWithNull = JsonSerializer.Serialize(person); Console.WriteLine(pessoaJsonWithNull); // Serialize e ignore propriedades nulas - a propriedade de endereço nula é omitida // Saída: {"Name":"Nancy"} JsonSerializerOptions options = new() { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; string pessoaJsonWithoutNull = JsonSerializer.Serialize(pessoa, opções); Console.WriteLine(pessoaJsonWithoutNull); // Ignorar propriedades nulas não funciona ao serializar a instância JsonNode // usando JsonSerializer. // Output: {"Name":"Nancy","Address":null} var personJsonNode = JsonSerializer.Deserialize(personJsonWithNull); personJsonWithNull = JsonSerializer.Serialize(personJsonNode, opções); Console.WriteLine(pessoaJsonWithNull); // Ignorar propriedades nulas não funciona ao serializar a instância JsonNode // usando o método JsonNode.ToJsonString. // Output: {"Name":"Nancy","Address":null} personJsonWithNull = personJsonNode!.ToJsonString(options); Console.WriteLine(pessoaJsonWithNull); // Ignorar propriedades nulas não funciona ao serializar a instância JsonNode // usando o método JsonNode.WriteTo. // Output: {"Name":"Nancy","Address":null} using var stream = new MemoryStream(); usando var Writer = new Utf8JsonWriter(stream); personJsonNode!.WriteTo(escritor, opções); escritor.Flush(); personJsonWithNull = Encoding.UTF8.GetString(stream.ToArray()); Console.WriteLine(pessoaJsonWithNull); }}public class Person{ public string? Nome { obter; definir; } string pública? Endereço { obter; definir; }}

Se você precisa de recursos deJsonSerializerOptionsexceto conversores personalizados, useJsonSerializercom alvos fortemente tipados (como oPessoaclasse neste exemplo) em vez deJsonNode.

UsarJsonDocumentName

O exemplo a seguir mostra como usar oJsonDocumentNameclass para acesso aleatório aos dados em uma string JSON:

soma dupla = 0;contagem int = 0;usando (JsonDocument document = JsonDocument.Parse(jsonString)){ JsonElement root = document.RootElement; JsonElement StudentsElement = root.GetProperty("Estudantes"); foreach (JsonElement aluno em alunosElement.EnumerateArray()) { if (aluno.TryGetProperty("Grade", out JsonElement gradeElement)) { soma += gradeElement.GetDouble(); } else { soma += 70; } contagem++; }}dupla média = soma / contagem;Console.WriteLine($"Nota média : {média}");

Dim sum As Double = 0Dim count As Integer = 0Using document As JsonDocument = JsonDocument.Parse(jsonString) Dim root As JsonElement = document.RootElement Dim StudentsElement As JsonElement = root.GetProperty("Students") For Each student As JsonElement In StudentsElement. EnumerateArray() Dim gradeElement As JsonElement = Nothing If student.TryGetProperty("Grade", gradeElement) Then sum += gradeElement.GetDouble() Else sum += 70 End If count += 1 NextEnd UsingDim average As Double = sum / countConsole. WriteLine($"Nota média: {média}")

O código anterior:

• Assume que o JSON a ser analisado está em uma string chamadajsonString.
• Calcula uma nota média para objetos em umAlunosmatriz que tem umNotapropriedade.
• Atribui uma nota padrão de 70 para os alunos que não têm nota.
• Cria oJsonDocumentNameinstância em umusando declaraçãoporqueJsonDocumentNameimplementosIDisposable. Após umJsonDocumentNameinstância é descartada, você perde o acesso a todos os seusJsonElementNameinstâncias também. Para manter o acesso a umJsonElementNameexemplo, faça uma cópia antes que o paiJsonDocumentNameinstância é descartada. Para fazer uma cópia, ligueJsonElement.Clone. Para mais informações, vejaJsonDocument é IDisposable.

O código de exemplo anterior conta os alunos incrementando umcontarvariável a cada iteração. Uma alternativa é ligarGetArrayLength, conforme o exemplo a seguir:

soma dupla = 0;contagem int = 0;usando (JsonDocument document = JsonDocument.Parse(jsonString)){ JsonElement root = document.RootElement; JsonElement StudentsElement = root.GetProperty("Estudantes"); contagem = alunosElemento.GetArrayLength(); foreach (JsonElement aluno em alunosElement.EnumerateArray()) { if (aluno.TryGetProperty("Grade", out JsonElement gradeElement)) { soma += gradeElement.GetDouble(); } else { soma += 70; } }}dupla média = soma / contagem;Console.WriteLine($"Nota média : {média}");

Dim sum As Double = 0Dim count As Integer = 0Using document As JsonDocument = JsonDocument.Parse(jsonString) Dim root As JsonElement = document.RootElement Dim StudentsElement As JsonElement = root.GetProperty("Students") count = StudentsElement.GetArrayLength() For Cada aluno As JsonElement In StudentsElement.EnumerateArray() Dim gradeElement As JsonElement = Nothing If student.TryGetProperty("Grade", gradeElement) Then sum += gradeElement.GetDouble() Else sum += 70 End If NextEnd UsingDim average As Double = sum / countConsole.WriteLine($"Nota média: {média}")

Aqui está um exemplo do JSON que este código processa:

{ "Class Name": "Science", "Teacher\u0027s Name": "Jane", "Semestre": "2019-01-01", "Students": [ { "Name": "John", "Grade" : 94,3 }, { "Nome": "James", "Grade": 81,0 }, { "Nome": "Julia", "Grade": 91,9 }, { "Nome": "Jessica", "Grade": 72,4 }, { "Nome": "Johnathan" } ], "Final": verdadeiro}

Para um exemplo semelhante que usaJsonNodeem vez deJsonDocumentName, verExemplo de nota média JsonNode.

Como pesquisar um JsonDocument e JsonElement para subelementos

Pesquisas emJsonElementNameexigem uma pesquisa sequencial das propriedades e, portanto, são relativamente lentos (por exemplo, ao usarTryGetProperty).System.Text.Jsonfoi projetado para minimizar o tempo de análise inicial em vez do tempo de pesquisa. Portanto, use as seguintes abordagens para otimizar o desempenho ao pesquisar em umJsonDocumentNameobjeto:

• Use os enumeradores integrados (EnumerateArrayeEnumerateObject) em vez de fazer sua própria indexação ou loops.
• Não faça uma pesquisa sequencial como um todoJsonDocumentNameatravés de cada propriedade usandoRaizElemento. Em vez disso, pesquise objetos JSON aninhados com base na estrutura conhecida dos dados JSON. Por exemplo, os exemplos de código anteriores procuram umNotapropriedade emEstudanteobjetos percorrendo oEstudanteobjetos e obter o valor deNotapara cada um, em vez de procurar em todosJsonElementNameobjetos procurandoNotapropriedades. Fazer o último resultaria em passagens desnecessárias sobre os mesmos dados.

UsarJsonDocumentNameescrever JSON

O exemplo a seguir mostra como escrever JSON de umJsonDocumentName:

string jsonString = File.ReadAllText(inputFileName);var writerOptions = new JsonWriterOptions{ Indented = true};var documentOptions = new JsonDocumentOptions{ CommentHandling = JsonCommentHandling.Skip};usando FileStream fs = File.Create(outputFileName);usando var writer = novo Utf8JsonWriter(fs, opções: writerOptions);usando JsonDocument document = JsonDocument.Parse(jsonString, documentOptions);JsonElement root = document.RootElement;if (root.ValueKind == JsonValueKind.Object){ writer.WriteStartObject();}else{ return;}foreach (propriedade JsonProperty em root.EnumerateObject()){ property.WriteTo(writer);}writer.WriteEndObject();writer.Flush();

Dim jsonString As String = File.ReadAllText(inputFileName)Dim writerOptions As JsonWriterOptions = Novo JsonWriterOptions With { .Indented = True}Dim documentOptions As JsonDocumentOptions = Novo JsonDocumentOptions With { .CommentHandling = JsonCommentHandling.Skip}Dim fs As FileStream = File.Create( outputFileName)Dim writer As Utf8JsonWriter = New Utf8JsonWriter(fs, options:=writerOptions)Dim document As JsonDocument = JsonDocument.Parse(jsonString, documentOptions)Dim root As JsonElement = document.RootElementIf root.ValueKind = JsonValueKind.[Object] Then writer. WriteStartObject()Else ReturnEnd IfFor Each [property] As JsonProperty In root.EnumerateObject() [property].WriteTo(writer)Nextwriter.WriteEndObject()writer.Flush()

O código anterior:

• Lê um arquivo JSON, carrega os dados em umJsonDocumentName, e grava JSON formatado (impresso de forma bonita) em um arquivo.
• UsosJsonDocumentOptionspara especificar que os comentários no JSON de entrada são permitidos, mas ignorados.
• Quando terminar, chamaRuborno escritor. Uma alternativa é permitir que o gravador faça a descarga automática quando for descartado.

Aqui está um exemplo de entrada JSON a ser processada pelo código de exemplo:

{"Class Name": "Science","Teacher's Name": "Jane","Semestre": "2019-01-01","Students": [{"Name": "John","Grade": 94,3 },{"Name": "James","Grade": 81,0},{"Name": "Julia","Grade": 91,9},{"Name": "Jessica","Grade": 72,4}, {"Nome": "Johnathan"}],"Final": verdadeiro}

O resultado é a seguinte saída JSON bem impressa:

{ "Class Name": "Science", "Teacher\u0027s Name": "Jane", "Semestre": "2019-01-01", "Students": [ { "Name": "John", "Grade" : 94,3 }, { "Nome": "James", "Grade": 81,0 }, { "Nome": "Julia", "Grade": 91,9 }, { "Nome": "Jessica", "Grade": 72,4 }, { "Nome": "Johnathan" } ], "Final": verdadeiro}

JsonDocument é IDisposable

JsonDocumentNamecria uma exibição na memória dos dados em um buffer agrupado. Portanto, oJsonDocumentNametipo implementaIDisposablee precisa ser usado dentro de umusandobloquear.

Devolver apenas umJsonDocumentNameda sua API se quiser transferir a propriedade vitalícia e descartar a responsabilidade para o chamador. Na maioria dos cenários, isso não é necessário. Se o chamador precisar trabalhar com todo o documento JSON, retorne oClonedoRaizElemento, que é umJsonElementName. Se o chamador precisar trabalhar com um elemento específico no documento JSON, retorne oClonepor essaJsonElementName. Se você devolver oRaizElementoou um subelemento diretamente sem fazer umaClone, o autor da chamada não poderá acessar o retornoJsonElementNamedepois deJsonDocumentNameque o possui está disposto.

Aqui está um exemplo que requer que você faça umClone:

public JsonElement LookAndLoad(JsonElement source){ string json = File.ReadAllText(source.GetProperty("fileName").GetString()); using (JsonDocument doc = JsonDocument.Parse(json)) { return doc.RootElement.Clone(); }}

O código anterior espera umJsonElementNameque contém umnome do arquivopropriedade. Ele abre o arquivo JSON e cria umJsonDocumentName. O método assume que o chamador deseja trabalhar com o documento inteiro, então ele retorna oClonedoRaizElemento.

Se você receber umJsonElementNamee estão retornando um subelemento, não é necessário retornar umClonedo subelemento. O chamador é responsável por manter viva aJsonDocumentNameque o repassadoJsonElementNamepertence a. Por exemplo:

public JsonElement ReturnFileName(fonte JsonElement){ return source.GetProperty("fileName");}

JsonDocumentNamecomJsonSerializerOptions

Você pode usarJsonSerializerpara serializar e desserializar uma instância deJsonDocumentName. No entanto, a implementação para leitura e escritaJsonDocumentNameinstâncias usandoJsonSerializeré um invólucro sobre oJsonDocument.ParseValue(Utf8JsonReader)eJsonDocument.WriteTo(Utf8JsonWriter). Este wrapper não encaminha nenhumJsonSerializerOptions(recursos do serializador) paraUtf8JsonReaderNameouUtf8JsonWriterName. Por exemplo, se você definirJsonSerializerOptions.DefaultIgnoreConditionparaWhenWritingNulle ligueJsonSerializercom uma sobrecarga que levaJsonSerializerOptions, as propriedades nulas não serão ignoradas.

O exemplo a seguir ilustra o resultado do uso de métodos que usam umJsonSerializerOptionsparâmetro e serializar umJsonDocumentNameinstância:

usando System.Text;usando System.Text.Json;usando System.Text.Json.Nodes;usando System.Text.Json.Serialization;namespace JsonDocumentWithJsonSerializerOptions;public class Program{ public static void Main() { Person person = new Person { Nome = "Nancy" }; // Serialização padrão - Propriedade de endereço incluída no token nulo. // Output: {"Name":"Nancy","Address":null} string personJsonWithNull = JsonSerializer.Serialize(person); Console.WriteLine(pessoaJsonWithNull); // Serialize e ignore propriedades nulas - a propriedade de endereço nula é omitida // Saída: {"Name":"Nancy"} JsonSerializerOptions options = new() { DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull }; string pessoaJsonWithoutNull = JsonSerializer.Serialize(pessoa, opções); Console.WriteLine(pessoaJsonWithoutNull); // Ignorar propriedades nulas não funciona ao serializar a instância JsonDocument // usando JsonSerializer. // Output: {"Name":"Nancy","Address":null} var personJsonDocument = JsonSerializer.Deserialize(personJsonWithNull); personJsonWithNull = JsonSerializer.Serialize(personJsonDocument, opções); Console.WriteLine(pessoaJsonWithNull); }}public class Person{ public string? Nome { obter; definir; } string pública? Endereço { obter; definir; }}

Se você precisa de recursos deJsonSerializerOptions, usarJsonSerializercom alvos fortemente tipados (como oPessoaclasse neste exemplo) em vez deJsonDocumentName.

Veja também

• Visão geral do System.Text.Json
• Referência da API System.Text.Json
• Referência da API System.Text.Json.Serialization