Como serializar e desserializar JSON no .NETHow to serialize and deserialize JSON in .NET

Importante

A documentação de serialização JSON está em construção.The JSON serialization documentation is under construction. Este artigo não abrange todos os cenários.This article doesn't cover all scenarios. Para obter mais informações, examine os problemas de System. Text. JSON no repositório dotnet/Corefx no GitHub, especialmente aqueles rotulados como JSON-funcionalidade-doc.For more information, examine System.Text.Json issues in the dotnet/corefx repository on GitHub, especially those labeled json-functionality-doc.

Este artigo mostra como usar o namespace System.Text.Json para serializar e desserializar de e para o JavaScript Object Notation (JSON).This article shows how to use the System.Text.Json namespace to serialize and deserialize to and from JavaScript Object Notation (JSON). As direções e o código de exemplo usam a biblioteca diretamente, não por meio de uma estrutura como ASP.NET Core.The directions and sample code use the library directly, not through a framework such as ASP.NET Core.

NamespacesNamespaces

O namespace System.Text.Json contém todos os pontos de entrada e os tipos principais.The System.Text.Json namespace contains all the entry points and the main types. O namespace System.Text.Json.Serialization contém atributos e APIs para cenários avançados e personalização específicas para serialização e desserialização.The System.Text.Json.Serialization namespace contains attributes and APIs for advanced scenarios and customization specific to serialization and deserialization. Os exemplos de código mostrados neste artigo exigem using diretivas para um ou ambos os namespaces:The code examples shown in this article require using directives for one or both of these namespaces:

using System.Text.Json;
using System.Text.Json.Serialization;

Atualmente, não há suporte para atributos do namespace System.Runtime.Serialization no System.Text.Json.Attributes from the System.Runtime.Serialization namespace aren't currently supported in System.Text.Json.

Como gravar objetos .NET em JSON (Serialize)How to write .NET objects to JSON (serialize)

Para gravar JSON em uma cadeia de caracteres ou em um arquivo, chame o método JsonSerializer.Serialize.To write JSON to a string or to a file, call the JsonSerializer.Serialize method.

O exemplo a seguir cria JSON como uma cadeia de caracteres:The following example creates JSON as a string:

string json = JsonSerializer.Serialize(weatherForecast);

O exemplo a seguir usa código síncrono para criar um arquivo JSON:The following example uses synchronous code to create a JSON file:

File.WriteAllText(outputFileName, JsonSerializer.Serialize(weatherForecast));

O exemplo a seguir usa código assíncrono para criar um arquivo JSON:The following example uses asynchronous code to create a JSON file:

using (FileStream fs = File.Create(outputFileName))
{
    await JsonSerializer.SerializeAsync(fs, weatherForecast);
}

Os exemplos anteriores usam a inferência de tipos para o tipo que está sendo serializado.The preceding examples use type inference for the type being serialized. Uma sobrecarga de Serialize() usa um parâmetro de tipo genérico:An overload of Serialize() takes a generic type parameter:

string json = JsonSerializer.Serialize<WeatherForecast>(weatherForecast);

Exemplo de serializaçãoSerialization example

Aqui está um tipo de exemplo que contém coleções e classes aninhadas:Here's an example type that contains collections and nested classes:

public class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    public IList<DateTimeOffset> DatesAvailable { get; set;}
    public Dictionary<string, HighLowTemperatures> TemperatureRanges { get; set; }
    public string [] SummaryWords { get; set; }
}

public class HighLowTemperatures
{
    public Temperature High { get; set; }
    public Temperature Low { get; set; }
}

public class Temperature
{
    public int DegreesCelsius { get; set; }
}

A saída JSON da serialização de uma instância do tipo anterior é semelhante ao exemplo a seguir.The JSON output from serializing an instance of the preceding type looks like the following example. A saída JSON é reduzidos por padrão:The JSON output is minified by default:

{"Date":"2019-08-01T00:00:00-07:00","TemperatureC":25,"Summary":"Hot","DatesAvailable":["2019-08-01T00:00:00-07:00","2019-08-02T00:00:00-07:00"],"TemperatureRanges":{"Cold":{"High":{"DegreesCelsius":20},"Low":{"DegreesCelsius":-10}},"Hot":{"High":{"DegreesCelsius":60},"Low":{"DegreesCelsius":20}}},"SummaryWords":["Cool","Windy","Humid"]}

O exemplo a seguir mostra o mesmo JSON, formatado (ou seja, muito impresso com espaço em branco e recuo):The following example shows the same JSON, formatted (that is, pretty-printed with whitespace and indentation):

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "TemperatureRanges": {
    "Cold": {
      "High": {
        "DegreesCelsius": 20
      },
      "Low": {
        "DegreesCelsius": -10
      }
    },
    "Hot": {
      "High": {
        "DegreesCelsius": 60
      },
      "Low": {
        "DegreesCelsius": 20
      }
    }
  },
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}

Serializar para UTF-8Serialize to UTF-8

Para serializar para UTF-8, chame o método JsonSerializer.SerializeToUtf8Bytes:To serialize to UTF-8, call the JsonSerializer.SerializeToUtf8Bytes method:

byte[] jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes<WeatherForecast>(weatherForecast);

Uma sobrecarga de Serialize que usa uma Utf8JsonWriter também está disponível.A Serialize overload that takes a Utf8JsonWriter is also available.

A serialização para UTF-8 é de cerca de 5-10% mais rápida do que usar os métodos baseados em cadeia de caracteres.Serializing to UTF-8 is about 5-10% faster than using the string-based methods. A diferença é porque os bytes (como UTF-8) não precisam ser convertidos em cadeias de caracteres (UTF-16).The difference is because the bytes (as UTF-8) don't need to be converted to strings (UTF-16).

Comportamento de serializaçãoSerialization behavior

Os tipos com suporte incluem:Supported types include:

Você pode implementar conversores personalizados para lidar com tipos adicionais ou fornecer funcionalidade que não é suportada pelos conversores internos.You can implement custom converters to handle additional types or provide functionality that isn't supported by the built-in converters.

Como ler JSON em objetos .NET (desserializar)How to read JSON into .NET objects (deserialize)

Para desserializar de uma cadeia de caracteres ou de um arquivo, chame o método JsonSerializer.Deserialize.To deserialize from a string or a file, call the JsonSerializer.Deserialize method.

O exemplo a seguir lê JSON de uma cadeia de caracteres:The following example reads JSON from a string:

var weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString);

Para desserializar de um arquivo usando código síncrono, leia o arquivo em uma cadeia de caracteres, conforme mostrado no exemplo a seguir:To deserialize from a file by using synchronous code, read the file into a string, as shown in the following example:

string jsonString = File.ReadAllText(inputFileName);
weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString);

Para desserializar de um arquivo usando código assíncrono, chame o método DeserializeAsync:To deserialize from a file by using asynchronous code, call the DeserializeAsync method:

using (FileStream fs = File.OpenRead(inputFileName))
{
    weatherForecast = await JsonSerializer.DeserializeAsync<WeatherForecast>(fs);
}

Para obter um exemplo de tipo e JSON correspondente, consulte a seção exemplo de serialização .For an example type and corresponding JSON, see the Serialization example section.

Desserializar de UTF-8Deserialize from UTF-8

Para desserializar do UTF-8, chame uma sobrecarga de JsonSerializer.Deserialize que usa uma Utf8JsonReader ou uma ReadOnlySpan<byte>, conforme mostrado nos exemplos a seguir.To deserialize from UTF-8, call a JsonSerializer.Deserialize overload that takes a Utf8JsonReader or a ReadOnlySpan<byte>, as shown in the following examples. Os exemplos pressupõem que o JSON esteja em uma matriz de bytes chamada jsonUtf8Bytes.The examples assume the JSON is in a byte array named jsonUtf8Bytes.

var readOnlySpan = new ReadOnlySpan<byte>(jsonUtf8Bytes);
weatherForecast = JsonSerializer.Deserialize<WeatherForecastMin>(readOnlySpan);
var utf8Reader = new Utf8JsonReader(jsonUtf8Bytes);
weatherForecast = JsonSerializer.Deserialize<WeatherForecastMin>(ref utf8Reader);

Comportamento de desserializaçãoDeserialization behavior

Você pode implementar conversores personalizados para fornecer funcionalidade que não é suportada pelos conversores internos.You can implement custom converters to provide functionality that isn't supported by the built-in converters.

Serializar para JSON formatadoSerialize to formatted JSON

Para imprimir a saída JSON, defina JsonSerializerOptions.WriteIndented como true:To pretty-print the JSON output, set JsonSerializerOptions.WriteIndented to true:

var options = new JsonSerializerOptions
{
    WriteIndented = true,
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está um tipo de exemplo a ser serializado e a saída JSON bem impressa:Here's an example type to be serialized and pretty-printed JSON output:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot"
}

Personalizar nomes e valores JSONCustomize JSON names and values

Por padrão, os nomes de propriedade e as chaves de dicionário são inalterados na saída JSON, incluindo maiúsculas e minúsculas.By default, property names and dictionary keys are unchanged in the JSON output, including case. Os valores de enumeração são representados como números.Enum values are represented as numbers. Esta seção explica como:This section explains how to:

  • Personalizar nomes de propriedade individuaisCustomize individual property names
  • Converter todos os nomes de propriedade em camel caseConvert all property names to camel case
  • Implementar uma política de nomenclatura de propriedade personalizadaImplement a custom property naming policy
  • Converter chaves de dicionário em camel caseConvert dictionary keys to camel case
  • Converter enums em cadeias de caracteres e camel caseConvert enums to strings and camel case

Para outros cenários que exigem tratamento especial de valores e nomes de propriedade JSON, você pode implementar conversores personalizados.For other scenarios that require special handling of JSON property names and values, you can implement custom converters.

Personalizar nomes de propriedade individuaisCustomize individual property names

Para definir o nome de propriedades individuais, use o atributo [JsonPropertyName] .To set the name of individual properties, use the [JsonPropertyName] attribute.

Veja um exemplo de tipo para serializar e o JSON resultante:Here's an example type to serialize and resulting JSON:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    [JsonPropertyName("Wind")]
    public int WindSpeed { get; set; }
}
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot",
  "Wind": 35
}

O nome da propriedade definido por este atributo:The property name set by this attribute:

  • Aplica-se em ambas as direções, para serialização e desserialização.Applies in both directions, for serialization and deserialization.
  • Tem precedência sobre as políticas de nomenclatura de propriedade.Takes precedence over property naming policies.

Usar o camel case para todos os nomes de propriedade JSONUse camel case for all JSON property names

Para usar o camel case para todos os nomes de propriedade JSON, defina JsonSerializerOptions.PropertyNamingPolicy como JsonNamingPolicy.CamelCase, conforme mostrado no exemplo a seguir:To use camel case for all JSON property names, set JsonSerializerOptions.PropertyNamingPolicy to JsonNamingPolicy.CamelCase, as shown in the following example:

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está uma classe de exemplo para serializar e a saída JSON:Here's an example class to serialize and JSON output:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public string Summary { get; set; }
    [JsonPropertyName("Wind")]
    public int WindSpeed { get; set; }
}
{
  "date": "2019-08-01T00:00:00-07:00",
  "temperatureCelsius": 25,
  "summary": "Hot",
  "Wind": 35
}

A política de nomenclatura de Propriedade do camel case:The camel case property naming policy:

  • Aplica-se à serialização e desserialização.Applies to serialization and deserialization.
  • É substituído por [JsonPropertyName] atributos.Is overridden by [JsonPropertyName] attributes. É por isso que o nome da propriedade JSON Wind no exemplo não é o camel case.This is why the JSON property name Wind in the example is not camel case.

Usar uma política de nomenclatura de propriedade JSON personalizadaUse a custom JSON property naming policy

Para usar uma política de nomenclatura de propriedade JSON personalizada, crie uma classe derivada de JsonNamingPolicy e substitua o método ConvertName, conforme mostrado no exemplo a seguir:To use a custom JSON property naming policy, create a class that derives from JsonNamingPolicy and override the ConvertName method, as shown in the following example:

class UpperCaseNamingPolicy : JsonNamingPolicy
{
    public override string ConvertName(string name)
    {
        return name.ToUpper();
    }
}

Em seguida, defina a propriedade JsonSerializerOptions.PropertyNamingPolicy como uma instância da sua classe de política de nomenclatura:Then set the JsonSerializerOptions.PropertyNamingPolicy property to an instance of your naming policy class:

var options = new JsonSerializerOptions
{
    PropertyNamingPolicy = new UpperCaseNamingPolicy()
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está uma classe de exemplo para serializar e a saída JSON:Here's an example class to serialize and JSON output:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    [JsonPropertyName("Wind")]
    public int WindSpeed { get; set; }
}
{
  "DATE": "2019-08-01T00:00:00-07:00",
  "TEMPERATUREC": 25,
  "SUMMARY": "Hot",
  "Wind": 35
}

A política de nomenclatura de propriedade JSON:The JSON property naming policy:

  • Aplica-se à serialização e desserialização.Applies to serialization and deserialization.
  • É substituído por [JsonPropertyName] atributos.Is overridden by [JsonPropertyName] attributes. É por isso que o nome da propriedade JSON Wind no exemplo não é maiúscula.This is why the JSON property name Wind in the example is not upper case.

Chaves de dicionário do camel caseCamel case dictionary keys

Se uma propriedade de um objeto a ser serializado for do tipo Dictionary<string,TValue>, as chaves de string poderão ser convertidas em camel case.If a property of an object to be serialized is of type Dictionary<string,TValue>, the string keys can be converted to camel case. Para fazer isso, defina DictionaryKeyPolicy como JsonNamingPolicy.CamelCase, conforme mostrado no exemplo a seguir:To do that, set DictionaryKeyPolicy to JsonNamingPolicy.CamelCase, as shown in the following example:

var options = new JsonSerializerOptions
{
    DictionaryKeyPolicy = JsonNamingPolicy.CamelCase
};
json = JsonSerializer.Serialize(weatherForecast, options);

A serialização de um objeto com um dicionário chamado TemperatureRanges que tem pares chave-valor "ColdMinTemp", 20 e "HotMinTemp", 40 resultaria na saída JSON, como no exemplo a seguir:Serializing an object with a dictionary named TemperatureRanges that has key-value pairs "ColdMinTemp", 20 and "HotMinTemp", 40 would result in JSON output like the following example:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot",
  "TemperatureRanges": {
    "coldMinTemp": 20,
    "hotMinTemp": 40
  }
}

A política de nomenclatura do camel case para chaves de dicionário se aplica somente à serialização.The camel case naming policy for dictionary keys applies to serialization only. Se você desserializar um dicionário, as chaves corresponderão ao arquivo JSON mesmo se você especificar JsonNamingPolicy.CamelCase para o DictionaryKeyPolicy.If you deserialize a dictionary, the keys will match the JSON file even if you specify JsonNamingPolicy.CamelCase for the DictionaryKeyPolicy.

Enumerações como cadeias de caracteresEnums as strings

Por padrão, as enumerações são serializadas como números.By default, enums are serialized as numbers. Para serializar nomes de enumeração como cadeias de caracteres, use o JsonStringEnumConverter.To serialize enum names as strings, use the JsonStringEnumConverter.

Por exemplo, suponha que você precise serializar a seguinte classe que tem uma enumeração:For example, suppose you need to serialize the following class that has an enum:

class WeatherForecastWithEnum
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public Summary Summary { get; set; }
}

public enum Summary
{
    Cold, Cool, Warm, Hot
}

Se o resumo for Hot, por padrão, o JSON serializado terá o valor numérico 3:If the Summary is Hot, by default the serialized JSON has the numeric value 3:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": 3
}

O código de exemplo a seguir serializa os nomes de enumeração e os converte em camel case:The following sample code serializes the enum names instead, and converts them to camel case:

options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
jsonWithEnumsAsStrings = JsonSerializer.Serialize(weatherForecastWithEnum, options);

O JSON resultante é semelhante ao exemplo a seguir:The resulting JSON looks like the following example:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "hot"
}

O suporte a enums como cadeias de caracteres se aplica à desserialização também, conforme mostrado no exemplo a seguir:The support for enums as strings applies to deserialization also, as shown in the following example:

options = new JsonSerializerOptions();
options.Converters.Add(new JsonStringEnumConverter(JsonNamingPolicy.CamelCase));
weatherForecastWithEnum = JsonSerializer.Deserialize<WeatherForecastWithEnum>(jsonWithEnumsAsStrings, options);

Excluir propriedades da serializaçãoExclude properties from serialization

Por padrão, todas as propriedades públicas são serializadas.By default, all public properties are serialized. Se você não quiser que alguns deles apareçam na saída JSON, terá várias opções.If you don't want some of them to appear in the JSON output, you have several options. Esta seção explica como excluir:This section explains how to exclude:

  • Propriedades individuaisIndividual properties
  • Todas as propriedades somente leituraAll read-only properties
  • Todas as propriedades de valor nuloAll null-value properties

Excluir propriedades individuaisExclude individual properties

Para ignorar as propriedades individuais, use o atributo [JsonIgnore] .To ignore individual properties, use the [JsonIgnore] attribute.

Aqui está um tipo de exemplo para serializar e a saída JSON:Here's an example type to serialize and JSON output:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    [JsonIgnore]
    public int WindSpeed { get; set; }
}
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot"
}

Excluir todas as propriedades somente leituraExclude all read-only properties

Uma propriedade será somente leitura se ela contiver um getter público, mas não um setter público.A property is read-only if it contains a public getter but not a public setter. Para excluir todas as propriedades somente leitura, defina o JsonSerializerOptions.IgnoreReadOnlyProperties como true, conforme mostrado no exemplo a seguir:To exclude all read-only properties, set the JsonSerializerOptions.IgnoreReadOnlyProperties to true, as shown in the following example:

var options = new JsonSerializerOptions
{
    IgnoreReadOnlyProperties = true
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está um tipo de exemplo para serializar e a saída JSON:Here's an example type to serialize and JSON output:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    public int WindSpeed { get; private set; }
}
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot",
}

Essa opção se aplica somente à serialização.This option applies only to serialization. Durante a desserialização, as propriedades somente leitura são ignoradas por padrão.During deserialization, read-only properties are ignored by default.

Excluir todas as propriedades de valor nuloExclude all null value properties

Para excluir todas as propriedades de valor nulo, defina a propriedade IgnoreNullValues como true, conforme mostrado no exemplo a seguir:To exclude all null value properties, set the IgnoreNullValues property to true, as shown in the following example:

var options = new JsonSerializerOptions
{
    IgnoreNullValues = true
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está um objeto de exemplo para serializar e a saída JSON:Here's an example object to serialize and JSON output:

propriedadeProperty ValorValue
DateDate 8/1/2019 12:00:00 AM-07:008/1/2019 12:00:00 AM -07:00
TemperatureCTemperatureC 2525
ResumoSummary nulonull
{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25
}

Essa configuração se aplica à serialização e desserialização.This setting applies to serialization and deserialization. Para obter informações sobre o efeito na desserialização, consulte ignorar nulo ao desserializar.For information about its effect on deserialization, see Ignore null when deserializing.

Personalizar codificação de caracteresCustomize character encoding

Por padrão, o serializador escapa todos os caracteres não ASCII.By default, the serializer escapes all non-ASCII characters. Ou seja, ele os substitui por \uxxxx em que xxxxx é o código Unicode do caractere.That is, it replaces them with \uxxxx where xxxxx is the Unicode code of the character. Por exemplo, se a propriedade Summary for definida como cirílico жарко, o objeto WeatherForecast será serializado, conforme mostrado neste exemplo:For example, if the Summary property is set to Cyrillic жарко, the WeatherForecast object is serialized as shown in this example:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "\u0436\u0430\u0440\u043A\u043E"
}

Serializar conjuntos de caracteres de idiomaSerialize language character sets

Para serializar os conjuntos de caracteres de um ou mais idiomas, especifique intervalo (s) Unicode ao criar uma instância de System.Text.Encodings.Web.JavaScriptEncoder, conforme mostrado no exemplo a seguir:To serialize the character set(s) of one or more languages, specify Unicode range(s) when creating an instance of System.Text.Encodings.Web.JavaScriptEncoder, as shown in the following example:

using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Unicode;
var options = new JsonSerializerOptions
{
    Encoder = JavaScriptEncoder.Create(UnicodeRanges.Cyrillic, UnicodeRanges.GreekExtended)
};
json = JsonSerializer.Serialize(weatherForecast, options);

Esse código serializa os caracteres cirílico e grego.This code serializes Cyrillic and Greek characters. Os caracteres cirílicos são mostrados no exemplo a seguir:Cyrillic characters are shown in the following example:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "жарко",
}

Para especificar todos os idiomas, use UnicodeRanges.All.To specify all languages, use UnicodeRanges.All.

Serializar caracteres específicosSerialize specific characters

Uma alternativa é especificar os caracteres individuais que você deseja permitir sem ter escape.An alternative is to specify individual characters that you want to allow through without being escaped. O exemplo a seguir serializa apenas os dois primeiros caracteres de жарко:The following example serializes only the first two characters of жарко:

using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Unicode;
var encoderSettings = new TextEncoderSettings();
encoderSettings.AllowCharacters('\u0436', '\u0430');
options = new JsonSerializerOptions
{
    Encoder = JavaScriptEncoder.Create(encoderSettings)
};
json = JsonSerializer.Serialize(weatherForecast, options);

Aqui está um exemplo de JSON produzido pelo código anterior:Here's an example of JSON produced by the preceding code:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "жа\u0440\u043A\u043E"
}

Serializar todos os caracteresSerialize all characters

Para minimizar a saída, você pode usar JavaScriptEncoder.UnsafeRelaxedJsonEscaping, conforme mostrado no exemplo a seguir:To minimize escaping you can use JavaScriptEncoder.UnsafeRelaxedJsonEscaping, as shown in the following example:

using System.Text.Encodings.Web;
using System.Text.Json;
options = new JsonSerializerOptions
{
    Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
};
json = JsonSerializer.Serialize(weatherForecast, options);

Cuidado

Ao contrário do codificador padrão, o codificador de UnsafeRelaxedJsonEscaping:Unlike the default encoder, the UnsafeRelaxedJsonEscaping encoder:

  • Não sai de caracteres sensíveis a HTML, como <, >, &e '.Doesn't escape HTML-sensitive characters such as <, >, &, and '.
  • O não oferece nenhuma proteção adicional de defesa profunda contra ataques XSS ou de divulgação de informações, como aqueles que podem resultar do cliente e do servidor que desconcordem com o conjunto de caracteres.Doesn't offer any additional defense-in-depth protections against XSS or information disclosure attacks, such as those which might result from the client and server disagreeing on the charset.
  • É mais permissivo do que o codificador padrão no qual os caracteres têm permissão para passar sem escape.Is more permissive than the default encoder on which characters are allowed to pass through unescaped.

Use o codificador não seguro somente quando for conhecido que o cliente irá interpretar a carga resultante como JSON codificado em UTF-8.Use the unsafe encoder only when it's known that the client will be interpreting the resulting payload as UTF-8 encoded JSON. Por exemplo, você pode usá-lo se o servidor estiver enviando o cabeçalho de resposta Content-Type: application/json; charset=utf-8.For example, you can use it if the server is sending the response header Content-Type: application/json; charset=utf-8. Nunca permita que a saída de UnsafeRelaxedJsonEscaping bruta seja emitida em uma página HTML ou em um elemento <script>.Never allow the raw UnsafeRelaxedJsonEscaping output to be emitted into an HTML page or a <script> element.

Serializar Propriedades de classes derivadasSerialize properties of derived classes

Não há suporte para a serialização polimórfica quando você especifica no momento da compilação o tipo a ser serializado.Polymorphic serialization isn't supported when you specify at compile time the type to be serialized. Por exemplo, suponha que você tenha uma classe WeatherForecast e uma classe derivada WeatherForecastWithWind:For example, suppose you have a WeatherForecast class and a derived class WeatherForecastWithWind:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}
class WeatherForecastWithWind : WeatherForecast
{
    public int WindSpeed { get; set; }
}

E suponha que o argumento de tipo do método de Serialize em tempo de compilação seja WeatherForecast:And suppose the type argument of the Serialize method at compile time is WeatherForecast:

string json = JsonSerializer.Serialize<WeatherForecast>(weatherForecast);

Nesse cenário, a propriedade WindSpeed não é serializada, mesmo que o objeto weatherForecast seja, na verdade, um objeto WeatherForecastWithWind.In this scenario, the WindSpeed property is not serialized even if the weatherForecast object is actually a WeatherForecastWithWind object. Somente as propriedades da classe base são serializadas:Only the base class properties are serialized:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot"
}

Esse comportamento destina-se a ajudar a evitar a exposição acidental de dados em um tipo criado de tempo de execução derivado.This behavior is intended to help prevent accidental exposure of data in a derived runtime-created type.

Para serializar as propriedades do tipo derivado, use uma das seguintes abordagens:To serialize the properties of the derived type, use one of the following approaches:

  • Chame uma sobrecarga de Serialize que permite especificar o tipo em tempo de execução:Call an overload of Serialize that lets you specify the type at runtime:

    json = JsonSerializer.Serialize(weatherForecast, weatherForecast.GetType());
    
  • Declare o objeto a ser serializado como object.Declare the object to be serialized as object.

    json = JsonSerializer.Serialize<object>(weatherForecast);
    

No cenário de exemplo anterior, ambas as abordagens fazem com que a propriedade WindSpeed seja incluída na saída JSON:In the preceding example scenario, both approaches cause the WindSpeed property to be included in the JSON output:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": "Hot",
  "WindSpeed": 35
}

Para obter informações sobre desserialização polimórfica, consulte dar suporte à desserialização polimórfica.For information about polymorphic deserialization, see Support polymorphic deserialization.

Permitir comentários e vírgulas à direitaAllow comments and trailing commas

Por padrão, comentários e vírgulas à direita não são permitidos em JSON.By default, comments and trailing commas are not allowed in JSON. Para permitir comentários no JSON, defina a propriedade JsonSerializerOptions.ReadCommentHandling como JsonCommentHandling.Skip.To allow comments in the JSON, set the JsonSerializerOptions.ReadCommentHandling property to JsonCommentHandling.Skip. E para permitir vírgulas à direita, defina a propriedade JsonSerializerOptions.AllowTrailingCommas como true.And to allow trailing commas, set the JsonSerializerOptions.AllowTrailingCommas property to true. O exemplo a seguir mostra como permitir:The following example shows how to allow both:

var options = new JsonSerializerOptions
{
    ReadCommentHandling = JsonCommentHandling.Skip,
    AllowTrailingCommas = true
};
var weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(json);

Aqui está um exemplo de JSON com comentários e uma vírgula à direita:Here's example JSON with comments and a trailing comma:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25, // Fahrenheit 77
  "Summary": "Hot", /* Zharko */
}

Correspondência de propriedade que não diferencia maiúsculas de minúsculasCase-insensitive property matching

Por padrão, a desserialização procura as correspondências de nome de propriedade que diferenciam maiúsculas de minúsculas entre JSON e as propriedades do objeto de destino.By default, deserialization looks for case-sensitive property name matches between JSON and the target object properties. Para alterar esse comportamento, defina o JsonSerializerOptions.PropertyNameCaseInsensitive como true:To change that behavior, set the JsonSerializerOptions.PropertyNameCaseInsensitive to true:

var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true,
};
var weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(weatherForecast, options);

Aqui está um exemplo de JSON com nomes de Propriedade do camel case.Here's example JSON with camel case property names. Ele pode ser desserializado no seguinte tipo que tem nomes de propriedade de caso de Pascal.It can be deserialized into the following type that has Pascal case property names.

{
  "date": "2019-08-01T00:00:00-07:00",
  "temperatureC": 25,
  "summary": "Hot",
}
class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}

Processar JSON de estouroHandle overflow JSON

Durante a desserialização, você pode receber dados no JSON que não são representados pelas propriedades do tipo de destino.While deserializing, you might receive data in the JSON that is not represented by properties of the target type. Por exemplo, suponha que o tipo de destino seja o seguinte:For example, suppose your target type is this:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}

E o JSON a ser desserializado é o seguinte:And the JSON to be deserialized is this:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "temperatureC": 25,
  "Summary": "Hot",
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}

Se você desserializar o JSON mostrado no tipo mostrado, as propriedades DatesAvailable e SummaryWords ficarão em qualquer lugar e serão perdidas.If you deserialize the JSON shown into the type shown, the DatesAvailable and SummaryWords properties have nowhere to go and are lost. Para capturar dados adicionais, como essas propriedades, aplique o atributo JsonExtensionData a uma propriedade do tipo Dictionary<string,object> ou Dictionary<string,JsonElement>:To capture extra data such as these properties, apply the JsonExtensionData attribute to a property of type Dictionary<string,object> or Dictionary<string,JsonElement>:

class WeatherForecast
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
    [JsonExtensionData]
    public Dictionary<string, object> ExtensionData { get; set; }
}

Quando você desserializar o JSON mostrado anteriormente neste tipo de exemplo, os dados extras se tornarão pares chave-valor da propriedade ExtensionData:When you deserialize the JSON shown earlier into this sample type, the extra data becomes key-value pairs of the ExtensionData property:

propriedadeProperty ValorValue AnotaçõesNotes
DateDate 8/1/2019 12:00:00 AM-07:008/1/2019 12:00:00 AM -07:00
TemperatureCTemperatureC 00 Incompatibilidade de maiúsculas e minúsculas (temperatureC no JSON), portanto, a propriedade não está definida.Case-sensitive mismatch (temperatureC in the JSON), so the property isn't set.
ResumoSummary PontosHot
ExtensionDataExtensionData temperatureC: 25temperatureC: 25 Como o caso não corresponde, essa propriedade JSON é um extra e se torna um par chave-valor no dicionário.Since the case didn't match, this JSON property is an extra and becomes a key-value pair in the dictionary.
DatesAvailable:DatesAvailable:
8/1/2019 12:00:00 AM-07:008/1/2019 12:00:00 AM -07:00
8/2/2019 12:00:00 AM-07:008/2/2019 12:00:00 AM -07:00
A propriedade extra do JSON torna-se um par chave-valor, com uma matriz como o objeto de valor.Extra property from the JSON becomes a key-value pair, with an array as the value object.
SummaryWords:SummaryWords:
LegaisCool
VentoWindy
HumidHumid
A propriedade extra do JSON torna-se um par chave-valor, com uma matriz como o objeto de valor.Extra property from the JSON becomes a key-value pair, with an array as the value object.

Quando o objeto de destino é serializado, os pares de valor de chave de dados de extensão se tornam propriedades JSON, assim como no JSON de entrada:When the target object is serialized, the extension data key value pairs become JSON properties just as they were in the incoming JSON:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 0,
  "Summary": "Hot",
  "temperatureC": 25,
  "DatesAvailable": [
    "2019-08-01T00:00:00-07:00",
    "2019-08-02T00:00:00-07:00"
  ],
  "SummaryWords": [
    "Cool",
    "Windy",
    "Humid"
  ]
}

Observe que o nome da propriedade ExtensionData não aparece no JSON.Notice that the ExtensionData property name doesn't appear in the JSON. Esse comportamento permite que o JSON faça uma viagem de ida e volta sem perder nenhum dado extra que, de outra forma, não seria desserializado.This behavior lets the JSON make a round trip without losing any extra data that otherwise wouldn't be deserialized.

Ignorar nulo ao desserializarIgnore null when deserializing

Por padrão, se uma propriedade em JSON for nula, a propriedade correspondente no objeto de destino será definida como NULL.By default, if a property in JSON is null, the corresponding property in the target object is set to null. Em alguns cenários, a propriedade de destino pode ter um valor padrão e você não quer um valor nulo para substituir o padrão.In some scenarios, the target property might have a default value, and you don't want a null value to override the default.

Por exemplo, suponha que o código a seguir represente o objeto de destino:For example, suppose the following code represents your target object:

class WeatherForecastWithDefault
{
    public WeatherForecastWithDefault()
    {
        Summary = "No summary";
    }
    public DateTimeOffset Date { get; set; }
    public int TemperatureC { get; set; }
    public string Summary { get; set; }
}

E suponha que o JSON a seguir seja desserializado:And suppose the following JSON is deserialized:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureC": 25,
  "Summary": null,
}

Após a desserialização, a propriedade Summary do objeto WeatherForecastWithDefault é nula.After deserialization, the Summary property of the WeatherForecastWithDefault object is null.

Para alterar esse comportamento, defina JsonSerializerOptions.IgnoreNullValues como true, conforme mostrado no exemplo a seguir:To change this behavior, set JsonSerializerOptions.IgnoreNullValues to true, as shown in the following example:

var options = new JsonSerializerOptions
{
    IgnoreNullValues = true
};
weatherForecast = JsonSerializer.Deserialize<WeatherForecastWithDefault>(json, options);

Com essa opção, a propriedade Summary do objeto WeatherForecastWithDefault é o valor padrão "sem Resumo" após a desserialização.With this option, the Summary property of the WeatherForecastWithDefault object is the default value "No summary" after deserialization.

Os valores nulos no JSON serão ignorados somente se forem válidos.Null values in the JSON are ignored only if they are valid. Valores nulos para tipos de valores não anuláveis causam exceções.Null values for non-nullable value types cause exceptions. Para obter mais informações, consulte o problema em tipos de valores não anuláveis no repositório dotnet/Corefx no github.For more information, see the issue on non-nullable value types in the dotnet/corefx repository on GitHub.

Utf8JsonReader, Utf8JsonWriter e JsonDocumentUtf8JsonReader, Utf8JsonWriter, and JsonDocument

System.Text.Json.Utf8JsonReader é um leitor de alto desempenho, baixa alocação e somente para encaminhamento para texto JSON codificado em UTF-8, lido de um ReadOnlySpan<byte>.System.Text.Json.Utf8JsonReader is a high-performance, low allocation, forward-only reader for UTF-8 encoded JSON text, read from a ReadOnlySpan<byte>. O Utf8JsonReader é um tipo de baixo nível que pode ser usado para criar analisadores e desserializadores personalizados.The Utf8JsonReader is a low-level type that can be used to build custom parsers and deserializers. O método JsonSerializer.Deserialize usa Utf8JsonReader nos bastidores.The JsonSerializer.Deserialize method uses Utf8JsonReader under the covers.

System.Text.Json.Utf8JsonWriter é uma maneira de alto desempenho para escrever texto JSON codificado em UTF-8 de tipos comuns do .NET, como String, Int32e DateTime.System.Text.Json.Utf8JsonWriter is a high-performance way to write UTF-8 encoded JSON text from common .NET types like String, Int32, and DateTime. O gravador é um tipo de baixo nível que pode ser usado para criar serializadores personalizados.The writer is a low-level type that can be used to build custom serializers. O método JsonSerializer.Serialize usa Utf8JsonWriter nos bastidores.The JsonSerializer.Serialize method uses Utf8JsonWriter under the covers.

System.Text.Json.JsonDocument fornece a capacidade de criar um Modelo de Objeto do Documento (DOM) somente leitura usando Utf8JsonReader.System.Text.Json.JsonDocument provides the ability to build a read-only Document Object Model (DOM) by using Utf8JsonReader. O DOM fornece acesso aleatório aos dados em uma carga JSON.The DOM provides random access to data in a JSON payload. Os elementos JSON que compõem a carga podem ser acessados por meio do tipo de JsonElement.The JSON elements that compose the payload can be accessed via the JsonElement type. O JsonElement fornece enumeradores de matriz e de objeto juntamente com APIs para converter texto JSON em tipos .NET comuns.The JsonElement provides array and object enumerators along with APIs to convert JSON text to common .NET types. JsonDocument expõe uma propriedade RootElement.JsonDocument exposes a RootElement property.

As seções a seguir mostram como usar essas ferramentas para ler e gravar o JSON.The following sections show how to use these tools for reading and writing JSON.

Usar o JsonDocument para acessar dadosUse JsonDocument for access to data

O exemplo a seguir mostra como usar a classe JsonDocument para acesso aleatório aos dados:The following example shows how to use the JsonDocument class for random access to data:

double sum = 0;
int count = 0;

using (JsonDocument document = JsonDocument.Parse(jsonString))
{
    JsonElement root = document.RootElement;
    JsonElement studentsElement = root.GetProperty("Students");
    foreach (JsonElement student in studentsElement.EnumerateArray())
    {
        if (student.TryGetProperty("Grade", out JsonElement gradeElement))
        {
            sum += gradeElement.GetDouble();
        }
        else
        {
            sum += 70;
        }
        count++;
    }
}

double average = sum / count;
Console.WriteLine($"Average grade: {average}");

O código anterior:The preceding code:

  • Assume que o JSON a ser analisado está em uma cadeia de caracteres chamada jsonString.Assumes the JSON to analyze is in a string named jsonString.

  • Calcula uma classificação média para objetos em uma matriz de Students que têm uma propriedade Grade.Calculates an average grade for objects in a Students array that have a Grade property.

  • Atribui uma classificação padrão de 70 para alunos que não têm uma classificação.Assigns a default grade of 70 for students who don't have a grade.

  • Conta os alunos incrementando uma count variável com cada iteração.Counts students by incrementing a count variable with each iteration. Uma alternativa é chamar GetArrayLength:An alternative is to call GetArrayLength:

    count = studentsElement.GetArrayLength();
    

Veja um exemplo do JSON que esse código processa:Here's an example of the JSON that this code processes:

{
  "Class Name": "Science",
  "Teacher's Name": "Jane",
  "Semester": "2019-01-01",
  "Students": [
    {
      "Name": "John",
      "Grade": 94.3
    },
    {
      "Name": "James",
      "Grade": 81.0
    },
    {
      "Name": "Julia",
      "Grade": 91.9
    },
    {
      "Name": "Jessica",
      "Grade": 72.4
    },
    {
      "Name": "Johnathan"
    }
  ],
  "Final": true
}

Usar JsonDocument para gravar JSONUse JsonDocument to write JSON

O exemplo a seguir mostra como gravar JSON de um JsonDocument:The following example shows how to write JSON from a JsonDocument:

string jsonString = File.ReadAllText(inputFileName);

var writerOptions = new JsonWriterOptions { Indented = true };
var documentOptions = new JsonDocumentOptions { CommentHandling = JsonCommentHandling.Skip };

using (FileStream fs = File.Create(outputFileName))
using (var writer = new Utf8JsonWriter(fs, options: writerOptions))
using (JsonDocument document = JsonDocument.Parse(jsonString, documentOptions))
{
    JsonElement root = document.RootElement;

    if (root.ValueKind == JsonValueKind.Object)
    {
        writer.WriteStartObject();
    }
    else
    {
        return;
    }

    foreach (JsonProperty property in root.EnumerateObject())
    {
        property.WriteTo(writer);
    }

    writer.WriteEndObject();

    writer.Flush();
}

O código anterior:The preceding code:

  • Lê um arquivo JSON, carrega os dados em um JsonDocumente grava JSON formatado (bem impresso) em um arquivo.Reads a JSON file, loads the data into a JsonDocument, and writes formatted (pretty-printed) JSON to a file.
  • Usa JsonDocumentOptions para especificar que os comentários no JSON de entrada são permitidos, mas ignorados.Uses JsonDocumentOptions to specify that comments in the input JSON are allowed but ignored.
  • Quando terminar, o chamará Flush no gravador.When finished, calls Flush on the writer. Uma alternativa é deixar o gravador AutoFlush quando ele é Descartado.An alternative is to let the writer autoflush when it's disposed.

Aqui está um exemplo de entrada JSON a ser processada pelo código de exemplo:Here's an example of JSON input to be processed by the example code:

{"Class Name": "Science","Teacher's Name": "Jane","Semester": "2019-01-01","Students": [{"Name": "John","Grade": 94.3},{"Name": "James","Grade": 81.0},{"Name": "Julia","Grade": 91.9},{"Name": "Jessica","Grade": 72.4},{"Name": "Johnathan"}],"Final": true}

O resultado é a seguinte saída JSON bem impressa:The result is the following pretty-printed JSON output:

{
  "Class Name": "Science",
  "Teacher\u0027s Name": "Jane",
  "Semester": "2019-01-01",
  "Students": [
    {
      "Name": "John",
      "Grade": 94.3
    },
    {
      "Name": "James",
      "Grade": 81.0
    },
    {
      "Name": "Julia",
      "Grade": 91.9
    },
    {
      "Name": "Jessica",
      "Grade": 72.4
    },
    {
      "Name": "Johnathan"
    }
  ],
  "Final": true
}

Usar Utf8JsonWriterUse Utf8JsonWriter

O exemplo a seguir mostra como usar a classe Utf8JsonWriter:The following example shows how to use the Utf8JsonWriter class:

var options = new JsonWriterOptions
{
    Indented = true
};

using (var stream = new MemoryStream())
{
    using (var writer = new Utf8JsonWriter(stream, options))
    {
        writer.WriteStartObject();
        writer.WriteString("date", DateTimeOffset.UtcNow);
        writer.WriteNumber("temp", 42);
        writer.WriteEndObject();
    }

    string json = Encoding.UTF8.GetString(stream.ToArray());
    Console.WriteLine(json);
}

Usar Utf8JsonReaderUse Utf8JsonReader

O exemplo a seguir mostra como usar a classe Utf8JsonReader:The following example shows how to use the Utf8JsonReader class:

var options = new JsonReaderOptions
{
    AllowTrailingCommas = true,
    CommentHandling = JsonCommentHandling.Skip
};
Utf8JsonReader reader = new Utf8JsonReader(jsonUtf8, options);

while (reader.Read())
{
    Console.Write(reader.TokenType);

    switch (reader.TokenType)
    {
        case JsonTokenType.PropertyName:
        case JsonTokenType.String:
            {
                string text = reader.GetString();
                Console.Write(" ");
                Console.Write(text);
                break;
            }

        case JsonTokenType.Number:
            {
                int value = reader.GetInt32();
                Console.Write(" ");
                Console.Write(value);
                break;
            }

            // Other token types elided for brevity
    }

    Console.WriteLine();
}

O código anterior pressupõe que a variável jsonUtf8 é uma matriz de bytes que contém um JSON válido, codificado como UTF-8.The preceding code assumes that the jsonUtf8 variable is a byte array that contains valid JSON, encoded as UTF-8.

Filtrar dados usando Utf8JsonReaderFilter data using Utf8JsonReader

O exemplo a seguir mostra como ler um arquivo de forma síncrona e procurar um valor:The following example shows how to read a file synchronously and search for a value:

class Program
{
    private static readonly byte[] s_nameUtf8 = Encoding.UTF8.GetBytes("name");
    private static readonly byte[] s_universityUtf8 = Encoding.UTF8.GetBytes("University");

    private static void ReaderFromFileSync(string fileName)
    {
         string jsonString = File.ReadAllText(fileName);
         ReadOnlySpan<byte> jsonReadOnlySpan = Encoding.UTF8.GetBytes(jsonString);

        int count = 0;
        int total = 0;

        var json = new Utf8JsonReader(jsonReadOnlySpan, isFinalBlock: true, state: default);

        while (json.Read())
        {
            JsonTokenType tokenType = json.TokenType;

            switch (tokenType)
            {
                case JsonTokenType.StartObject:
                    total++;
                    break;
                case JsonTokenType.PropertyName:
                    if (json.ValueSpan.SequenceEqual(s_nameUtf8))
                    {
                        bool result = json.Read();

                        Debug.Assert(result);  // Assume valid JSON
                        Debug.Assert(json.TokenType == JsonTokenType.String);   // Assume known, valid JSON schema

                        if (json.ValueSpan.EndsWith(s_universityUtf8))
                        {
                            count++;
                        }
                    }
                    break;
            }
        }
        Console.WriteLine($"{count} out of {total} have names that end with 'University'");
    }
}

O código anterior:The preceding code:

  • Pressupõe que o arquivo é codificado como UTF-16 e o codifica em UTF-8.Assumes the file is encoded as UTF-16 and transcodes it into UTF-8. Um arquivo codificado como UTF-8 pode ser lido diretamente em um ReadOnlySpan<byte>, usando o seguinte código:A file encoded as UTF-8 can be read directly into a ReadOnlySpan<byte>, by using the following code:

    ReadOnlySpan<byte> jsonReadOnlySpan = File.ReadAllBytes(fileName); 
    
  • Assume que o JSON contém uma matriz de objetos e cada objeto pode conter uma propriedade "Name" do tipo cadeia de caracteres.Assumes the JSON contains an array of objects and each object may contain a "name" property of type string.

  • Conta objetos e name valores de propriedade que terminam com "University".Counts objects and name property values that end with "University".

Aqui está um exemplo de JSON que o código anterior pode ler.Here's a JSON sample that the preceding code can read. A mensagem de resumo resultante é "2 de 4 têm nomes que terminam com" University "":The resulting summary message is "2 out of 4 have names that end with 'University'":

[
  {
    "web_pages": [ "https://contoso.edu/" ],
    "alpha_two_code": "US",
    "state-province": null,
    "country": "United States",
    "domains": [ "contoso.edu" ],
    "name": "Contoso Community College"
  },
  {
    "web_pages": [ "http://fabrikam.edu/" ],
    "alpha_two_code": "US",
    "state-province": null,
    "country": "United States",
    "domains": [ "fabrikam.edu" ],
    "name": "Fabrikam Community College"
  },
  {
    "web_pages": [ "http://www.contosouniversity.edu/" ],
    "alpha_two_code": "US",
    "state-province": null,
    "country": "United States",
    "domains": [ "contosouniversity.edu" ],
    "name": "Contoso University"
  },
  {
    "web_pages": [ "http://www.fabrikamuniversity.edu/" ],
    "alpha_two_code": "US",
    "state-province": null,
    "country": "United States",
    "domains": [ "fabrikamuniversity.edu" ],
    "name": "Fabrikam University"
  }
]

Recursos adicionaisAdditional resources