Comment sérialiser et désérialiser du JSON avec C# - .NET

Exemples de code

Exemples de code de cet article :
Utilisez directement la bibliothèque, et non une infrastructure comme ASP.NET Core .
Utilisez la classe JsonSerializer avec des types personnalisés pour la sérialisation/désérialisation.
Pour plus d’informations sur la lecture et l’écriture de données JSON sans utiliser JsonSerializer , consultez Comment utiliser le DOM JSON , Comment utiliser Utf8JsonReader et Comment utiliser Utf8JsonWriter .
Utilisez l’option WriteIndented pour mettre en forme le JSON pour améliorer sa lisibilité lorsque cela est utile.
Pour une utilisation en production, vous acceptez généralement la valeur par défaut de false pour ce paramètre, car l’ajout d’espaces blancs inutiles peut avoir un impact négatif sur les performances et l’utilisation de la bande passante.
Reportez-vous à la classe suivante et ses variantes :

    public class WeatherForecast
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public string? Summary { get; set; }
    
     Public Class WeatherForecast
    Public Property [Date] As DateTimeOffset
    Public Property TemperatureCelsius As Integer
    Public Property Summary As String
End Class
     
      Espaces de noms
     
     
      L’espace de noms
      
       System.Text.Json
      
      contient tous les points d’entrée et les types principaux. L’espace de noms
      
       System.Text.Json.Serialization
      
      contient des attributs et des API pour les scénarios avancés, et la personnalisation spécifique à la sérialisation et à la désérialisation. Les exemples de code présentés dans cet article nécessitent des directives
      
       using
      
      pour l’un de ces espaces de noms ou les deux :
     
     using System.Text.Json;
using System.Text.Json.Serialization;
Imports System.Text.Json
Imports System.Text.Json.Serialization
Important
Les attributs de l’espace de noms System.Runtime.Serialization ne sont pas pris en charge par System.Text.Json.
System.SerializableAttribute et l’interface ISerializable ne sont pas pris en charge par System.Text.Json. Ces types sont utilisés uniquement pour la Sérialisation binaire et XML.
Comment écrire des objets .NET au format JSON (sérialisation)
Pour écrire du JSON dans une chaîne ou dans un fichier, appelez la méthode JsonSerializer.Serialize.
L’exemple suivant crée du JSON en tant que chaîne :
using System.Text.Json;
namespace SerializeBasic
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static void Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot"
            string jsonString = JsonSerializer.Serialize(weatherForecast);
            Console.WriteLine(jsonString);
// output:
//{"Date":"2019-08-01T00:00:00-07:00","TemperatureCelsius":25,"Summary":"Hot"}
Dim jsonString As String
La sortie JSON est réduite au minimum (les espaces blancs, la mise en retrait et les caractères de nouvelle ligne sont supprimés) par défaut.
L’exemple suivant utilise du code synchrone pour créer un fichier JSON :
using System.Text.Json;
namespace SerializeToFile
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static void Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot"
            string fileName = "WeatherForecast.json"; 
            string jsonString = JsonSerializer.Serialize(weatherForecast);
            File.WriteAllText(fileName, jsonString);
            Console.WriteLine(File.ReadAllText(fileName));
// output:
//{"Date":"2019-08-01T00:00:00-07:00","TemperatureCelsius":25,"Summary":"Hot"}
jsonString = JsonSerializer.Serialize(weatherForecast1)
File.WriteAllText(fileName, jsonString)
L’exemple suivant utilise du code asynchrone pour créer un fichier JSON :
using System.Text.Json;
namespace SerializeToFileAsync
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static async Task Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot"
            string fileName = "WeatherForecast.json";
            using FileStream createStream = File.Create(fileName);
            await JsonSerializer.SerializeAsync(createStream, weatherForecast);
            await createStream.DisposeAsync();
            Console.WriteLine(File.ReadAllText(fileName));
// output:
//{"Date":"2019-08-01T00:00:00-07:00","TemperatureCelsius":25,"Summary":"Hot"}
Dim createStream As FileStream = File.Create(fileName)
Await JsonSerializer.SerializeAsync(createStream, weatherForecast1)
Les exemples précédents utilisent l’inférence de type pour le type sérialisé. Une surcharge de Serialize() prend un paramètre de type générique :
using System.Text.Json;
namespace SerializeWithGenericParameter
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static void Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot"
            string jsonString = JsonSerializer.Serialize<WeatherForecast>(weatherForecast);
            Console.WriteLine(jsonString);
// output:
//{"Date":"2019-08-01T00:00:00-07:00","TemperatureCelsius":25,"Summary":"Hot"}
jsonString = JsonSerializer.Serialize(Of WeatherForecastWithPOCOs)(weatherForecast)
Exemple de sérialisation
Voici un exemple montrant comment une classe qui contient des propriétés de collection et un type défini par l’utilisateur est sérialisée :
using System.Text.Json;
namespace SerializeExtra
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
        public string? SummaryField;
        public IList<DateTimeOffset>? DatesAvailable { get; set; }
        public Dictionary<string, HighLowTemps>? TemperatureRanges { get; set; }
        public string[]? SummaryWords { get; set; }
    public class HighLowTemps
        public int High { get; set; }
        public int Low { get; set; }
    public class Program
        public static void Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot",
                SummaryField = "Hot",
                DatesAvailable = new List<DateTimeOffset>() 
                    { DateTime.Parse("2019-08-01"), DateTime.Parse("2019-08-02") },
                TemperatureRanges = new Dictionary<string, HighLowTemps>
                        ["Cold"] = new HighLowTemps { High = 20, Low = -10 },
                        ["Hot"] = new HighLowTemps { High = 60 , Low = 20 }
                SummaryWords = new[] { "Cool", "Windy", "Humid" }
            var options = new JsonSerializerOptions { WriteIndented = true };
            string jsonString = JsonSerializer.Serialize(weatherForecast, options);
            Console.WriteLine(jsonString);
// output:
//  "Date": "2019-08-01T00:00:00-07:00",
//  "TemperatureCelsius": 25,
//  "Summary": "Hot",
//  "DatesAvailable": [
//    "2019-08-01T00:00:00-07:00",
//    "2019-08-02T00:00:00-07:00"
//  ],
//  "TemperatureRanges": {
//    "Cold": {
//      "High": 20,
//      "Low": -10
//    },
//    "Hot": {
//    "High": 60,
//      "Low": 20
//    }
//  },
//  "SummaryWords": [
//    "Cool",
//    "Windy",
//    "Humid"
//  ]
Public Class WeatherForecastWithPOCOs
    Public Property [Date] As DateTimeOffset
    Public Property TemperatureCelsius As Integer
    Public Property Summary As String
    Public SummaryField As String
    Public Property DatesAvailable As IList(Of DateTimeOffset)
    Public Property TemperatureRanges As Dictionary(Of String, HighLowTemps)
    Public Property SummaryWords As String()
End Class
Public Class HighLowTemps
    Public Property High As Integer
    Public Property Low As Integer
End Class
' serialization output formatted (pretty-printed with whitespace and indentation):
'   "Date": "2019-08-01T00:00:00-07:00",
'   "TemperatureCelsius": 25,
'   "Summary": "Hot",
'   "DatesAvailable": [
'     "2019-08-01T00:00:00-07:00",
'     "2019-08-02T00:00:00-07:00"
'   ],
'   "TemperatureRanges": {
'     "Cold": {
'       "High": 20,
'       "Low": -10
'     },
'     "Hot": {
'       "High": 60,
'       "Low": 20
'     }
'   },
'   "SummaryWords": [
'     "Cool",
'     "Windy",
'     "Humid"
'   ]
Sérialiser vers UTF-8
La sérialisation vers un tableau d’octets UTF-8 est environ 5 à 10 % plus rapide que l’utilisation des méthodes basées sur des chaînes. La différence est que les octets (UTF-8) n’ont pas besoin d’être convertis en chaînes (UTF-16).
Pour sérialiser dans un tableau d’octets UTF-8, appelez la méthode JsonSerializer.SerializeToUtf8Bytes :
byte[] jsonUtf8Bytes =JsonSerializer.SerializeToUtf8Bytes(weatherForecast);
Dim jsonUtf8Bytes As Byte()
Dim options As JsonSerializerOptions = New JsonSerializerOptions With {
    .WriteIndented = True
jsonUtf8Bytes = JsonSerializer.SerializeToUtf8Bytes(weatherForecast1, options)
Une surcharge Serialize qui prend un Utf8JsonWriter est également disponible.
Comportements de sérialisation
Par défaut, l’ensemble des propriétés publiques sont sérialisées. Vous pouvez spécifier des propriétés à ignorer.
L’encodeur par défaut échappe les caractères non ASCII, les caractères HTML dans la plage ASCII et les caractères qui doivent être échappés selon la spécification JSON RFC 8259.
Par défaut, le JSON est minifié. Vous pouvez imprimer le JSON de façon élégante.
Par défaut, la casse des noms JSON correspond aux noms .NET. Vous pouvez personnaliser la casse de nom JSON.
Par défaut, les références circulaires sont détectées et des exceptions levées en conséquence. Vous pouvez conserver les références et gérer les références circulaires.
Par défaut, les champs sont ignorés. Vous pouvez inclure des champs.
Lorsque vous utilisez System.Text.Json indirectement dans une application ASP.NET Core, certains comportements par défaut sont différents. Pour plus d’informations, consultez Valeurs web par défaut pour JsonSerializerOptions.
Les types pris en charge comprennent les suivants :
Primitives .NET qui mappées sur des primitives JavaScript, comme les types numériques, les chaînes et les booléens.
Objets CLR traditionnels (OCT) définis par l’utilisateur.
Tableaux unidimensionnels et en escalier (T[][]).
Collections et dictionnaires des espaces de noms suivants.
System.Collections
System.Collections.Generic
System.Collections.Immutable
System.Collections.Concurrent
System.Collections.Specialized
System.Collections.ObjectModel
Pour plus d’informations, consultez Types de collection pris en charge dans System.Text.Json.
Vous pouvez implémenter des convertisseurs personnalisés pour gérer des types supplémentaires ou pour fournir des fonctionnalités qui ne sont pas prises en charge par les convertisseurs intégrés.
Comment lire du JSON en tant qu’objets .NET (désérialiser)
Une façon courante de désérialiser du JSON consiste à créer d’abord une classe avec des propriétés et des champs qui représentent une ou plusieurs des propriétés JSON. Ensuite, pour désérialiser à partir d’une chaîne ou d’un fichier, appelez la méthode JsonSerializer.Deserialize. Pour les surcharges génériques, vous transmettez le type de la classe que vous avez créée comme paramètre de type générique. Pour les surcharges non génériques, vous transmettez le type de la classe que vous avez créée en tant que paramètre de méthode. Vous pouvez désérialiser de façon synchrone ou asynchrone.
Toutes les propriétés JSON qui ne sont pas représentées dans votre classe sont ignorées par défaut. En outre, si des propriétés sur le type sont requises, mais qu’elles ne sont pas présentes dans la charge utile JSON, la désérialisation échoue.
L’exemple suivant montre comment désérialiser une chaîne JSON :
using System.Text.Json;
namespace DeserializeExtra
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
        public string? SummaryField;
        public IList<DateTimeOffset>? DatesAvailable { get; set; }
        public Dictionary<string, HighLowTemps>? TemperatureRanges { get; set; }
        public string[]? SummaryWords { get; set; }
    public class HighLowTemps
        public int High { get; set; }
        public int Low { get; set; }
    public class Program
        public static void Main()
            string jsonString =
  ""Date"": ""2019-08-01T00:00:00-07:00"",
  ""TemperatureCelsius"": 25,
  ""Summary"": ""Hot"",
  ""DatesAvailable"": [
    ""2019-08-01T00:00:00-07:00"",
    ""2019-08-02T00:00:00-07:00""
  ""TemperatureRanges"": {
                ""Cold"": {
                    ""High"": 20,
      ""Low"": -10
    ""Hot"": {
                    ""High"": 60,
      ""Low"": 20
  ""SummaryWords"": [
    ""Cool"",
    ""Windy"",
    ""Humid""
            WeatherForecast? weatherForecast = 
                JsonSerializer.Deserialize<WeatherForecast>(jsonString);
            Console.WriteLine($"Date: {weatherForecast?.Date}");
            Console.WriteLine($"TemperatureCelsius: {weatherForecast?.TemperatureCelsius}");
            Console.WriteLine($"Summary: {weatherForecast?.Summary}");
// output:
//Date: 8/1/2019 12:00:00 AM -07:00
//TemperatureCelsius: 25
//Summary: Hot
weatherForecast = JsonSerializer.Deserialize(Of WeatherForecastWithPOCOs)(jsonString)
Pour désérialiser à partir d’un fichier à l’aide de code synchrone, lisez le fichier dans une chaîne, comme illustré dans l’exemple suivant :




    

using System.Text.Json;
namespace DeserializeFromFile
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static void Main()
            string fileName = "WeatherForecast.json";
            string jsonString = File.ReadAllText(fileName);
            WeatherForecast weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString)!;
            Console.WriteLine($"Date: {weatherForecast.Date}");
            Console.WriteLine($"TemperatureCelsius: {weatherForecast.TemperatureCelsius}");
            Console.WriteLine($"Summary: {weatherForecast.Summary}");
// output:
//Date: 8/1/2019 12:00:00 AM -07:00
//TemperatureCelsius: 25
//Summary: Hot
jsonString = File.ReadAllText(fileName)
weatherForecast1 = JsonSerializer.Deserialize(Of WeatherForecast)(jsonString)
Pour désérialiser à partir d’un fichier à l’aide de code asynchrone, appelez la méthode DeserializeAsync :
using System.Text.Json;
namespace DeserializeFromFileAsync
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static async Task Main()
            string fileName = "WeatherForecast.json";
            using FileStream openStream = File.OpenRead(fileName);
            WeatherForecast? weatherForecast = 
                await JsonSerializer.DeserializeAsync<WeatherForecast>(openStream);
            Console.WriteLine($"Date: {weatherForecast?.Date}");
            Console.WriteLine($"TemperatureCelsius: {weatherForecast?.TemperatureCelsius}");
            Console.WriteLine($"Summary: {weatherForecast?.Summary}");
// output:
//Date: 8/1/2019 12:00:00 AM -07:00
//TemperatureCelsius: 25
//Summary: Hot
Dim openStream As FileStream = File.OpenRead(fileName)
weatherForecast1 = Await JsonSerializer.DeserializeAsync(Of WeatherForecast)(openStream)
Conseil
Si vous avez du JSON que vous souhaitez désérialiser et que vous n’avez pas la classe pour le désérialiser, vous avez d’autres options que la création manuelle de la classe dont vous avez besoin :
Désérialisez dans un DOM (modèle objet de document) JSON et extrayez ce dont vous avez besoin du DOM.
Le DOM vous permet d’accéder à une sous-section d’une charge utile JSON et de désérialiser une valeur unique, un type personnalisé ou un tableau. Pour plus d’informations sur le DOM JsonNode, consultez Désérialiser les sous-sections d’une charge utile JSON. Pour plus d’informations sur le DOM JsonDocument, consultez Comment rechercher des sous-éléments dans jsonDocument et JsonElement.
Utilisez Utf8JsonReader directement.
Utilisez Visual Studio 2022 pour générer automatiquement la classe dont vous avez besoin :
Copiez le JSON que vous devez désérialiser.
Créez un fichier de classe et supprimez le code du modèle.
Choisissez Modifier>Collage spécial>Coller le code JSON en tant que classes.
Le résultat est une classe que vous pouvez utiliser pour votre cible de désérialisation.
Désérialiser à partir d’UTF-8
Pour désérialiser à partir de UTF-8, appelez une surcharge de JsonSerializer.Deserialize qui prend un ReadOnlySpan<byte> ou un Utf8JsonReader, comme illustré dans les exemples suivants. Les exemples supposent que le JSON se trouve dans un tableau d’octets nommé jsonUtf8Bytes.
var readOnlySpan = new ReadOnlySpan<byte>(jsonUtf8Bytes);
WeatherForecast deserializedWeatherForecast = 
    JsonSerializer.Deserialize<WeatherForecast>(readOnlySpan)!;
Dim jsonString = Encoding.UTF8.GetString(jsonUtf8Bytes)
weatherForecast1 = JsonSerializer.Deserialize(Of WeatherForecast)(jsonString)
var utf8Reader = new Utf8JsonReader(jsonUtf8Bytes);
WeatherForecast deserializedWeatherForecast = 
    JsonSerializer.Deserialize<WeatherForecast>(ref utf8Reader)!;
' This code example doesn't apply to Visual Basic. For more information, go to the following URL:
' https://learn.microsoft.com/dotnet/standard/serialization/system-text-json-how-to#visual-basic-support
Comportement de désérialisation
Les comportements suivants s’appliquent lors de la désérialisation de JSON :
Par défaut, la correspondance de nom de propriété respecte la casse. Vous pouvez spécifier l’insensibilité à la casse.
Si le fichier JSON contient une valeur pour une propriété en lecture seule, la valeur est ignorée par défaut. Vous pouvez définir l’option PreferredObjectCreationHandling sur JsonObjectCreationHandling.Populate pour activer la désérialisation des propriétés en lecture seule.
Les constructeurs non publics sont ignorés par le sérialiseur.
La désérialisation vers des objets ou des propriétés immuables qui n’ont pas d’accesseurs publics set est prise en charge. Consultez Types et enregistrements immuables.
Par défaut, les énumérations sont prises en charge en tant que nombres. Vous pouvez sérialiser des noms d’énumération sous forme de chaînes.
Par défaut, les champs sont ignorés. Vous pouvez inclure des champs.
Par défaut, les commentaires ou les virgules de fin dans le JSON lèvent des exceptions. Vous pouvez autoriser les commentaires et les virgules de fin.
La profondeur maximale par défaut est de 64.
Lorsque vous utilisez System.Text.Json indirectement dans une application ASP.NET Core, certains comportements par défaut sont différents. Pour plus d’informations, consultez Valeurs web par défaut pour JsonSerializerOptions.
Par défaut, la correspondance de nom de propriété respecte la casse. Vous pouvez spécifier l’insensibilité à la casse.
Si le JSON contient une valeur pour une propriété en lecture seule, la valeur est ignorée et aucune exception n’est levée.
Les constructeurs non publics sont ignorés par le sérialiseur.
La désérialisation vers des objets ou des propriétés immuables qui n’ont pas d’accesseurs publics set est prise en charge. Consultez Types et enregistrements immuables.
Par défaut, les énumérations sont prises en charge en tant que nombres. Vous pouvez sérialiser des noms d’énumération sous forme de chaînes.
Par défaut, les champs sont ignorés. Vous pouvez inclure des champs.
Par défaut, les commentaires ou les virgules de fin dans le JSON lèvent des exceptions. Vous pouvez autoriser les commentaires et les virgules de fin.
La profondeur maximale par défaut est de 64.
Lorsque vous utilisez System.Text.Json indirectement dans une application ASP.NET Core, certains comportements par défaut sont différents. Pour plus d’informations, consultez Valeurs web par défaut pour JsonSerializerOptions.
Vous pouvez implémenter des convertisseurs personnalisés pour fournir des fonctionnalités qui ne sont pas prises en charge par les convertisseurs intégrés.
Sérialiser en JSON mis en forme
Pour imprimer élégamment la sortie JSON, définissez JsonSerializerOptions.WriteIndented sur true :
using System.Text.Json;
namespace SerializeWriteIndented
    public class WeatherForecast
        public DateTimeOffset Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    public class Program
        public static void Main()
            var weatherForecast = new WeatherForecast
                Date = DateTime.Parse("2019-08-01"),
                TemperatureCelsius = 25,
                Summary = "Hot"
            var options = new JsonSerializerOptions { WriteIndented = true };
            string jsonString = JsonSerializer.Serialize(weatherForecast, options);
            Console.WriteLine(jsonString);
// output:
//  "Date": "2019-08-01T00:00:00-07:00",
//  "TemperatureCelsius": 25,
//  "Summary": "Hot"
Dim options As JsonSerializerOptions = New JsonSerializerOptions With {
    .WriteIndented = True
jsonString = JsonSerializer.Serialize(weatherForecast, options)
Si vous utilisez JsonSerializerOptions plusieurs fois avec les mêmes options, ne créez pas d’instance de JsonSerializerOptions chaque fois que vous l’utilisez. Réutilisez la même instance pour chaque appel. Pour plus d’informations, consultez Réutiliser des instances de JsonSerializerOptions.
Inclure les champs
Utilisez le paramètre global JsonSerializerOptions.IncludeFields ou l’attribut [JsonInclude] pour inclure des champs lors de la sérialisation ou de la désérialisation, comme illustré dans l’exemple suivant :
using System.Text.Json;
using System.Text.Json.Serialization;
namespace Fields
    public class Forecast
        public DateTime Date;
        public int TemperatureC;
        public string? Summary;
    public class Forecast2
        [JsonInclude]
        public DateTime Date;
        [JsonInclude]
        public int TemperatureC;
        [JsonInclude]
        public string? Summary;
    public class Program
        public static void Main()
            var json =
                @"{""Date"":""2020-09-06T11:31:01.923395"",""TemperatureC"":-1,""Summary"":""Cold""} ";
            Console.WriteLine($"Input JSON: {json}");
            var options = new JsonSerializerOptions
                IncludeFields = true,
            var forecast = JsonSerializer.Deserialize<Forecast>(json, options)!;
            Console.WriteLine($"forecast.Date: {forecast.Date}");
            Console.WriteLine($"forecast.TemperatureC: {forecast.TemperatureC}");
            Console.WriteLine($"forecast.Summary: {forecast.Summary}");
            var roundTrippedJson =
                JsonSerializer.Serialize<Forecast>(forecast, options);
            Console.WriteLine($"Output JSON: {roundTrippedJson}");
            var forecast2 = JsonSerializer.Deserialize<Forecast2>(json)!;
            Console.WriteLine($"forecast2.Date: {forecast2.Date}");
            Console.WriteLine($"forecast2.TemperatureC: {forecast2.TemperatureC}");
            Console.WriteLine($"forecast2.Summary: {forecast2.Summary}");
            roundTrippedJson = JsonSerializer.Serialize<Forecast2>(forecast2);
            Console.WriteLine($"Output JSON: {roundTrippedJson}");
// Produces output like the following example:
//Input JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
//forecast.Date: 9/6/2020 11:31:01 AM
//forecast.TemperatureC: -1
//forecast.Summary: Cold
//Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
//forecast2.Date: 9/6/2020 11:31:01 AM
//forecast2.TemperatureC: -1
//forecast2.Summary: Cold
//Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
Imports System.Text.Json
Imports System.Text.Json.Serialization
Namespace Fields
    Public Class Forecast
        Public [Date] As Date
        Public TemperatureC As Integer
        Public Summary As String
    End Class
    Public Class Forecast2
        <JsonInclude>
        Public [Date] As Date
        <JsonInclude>
        Public TemperatureC As Integer
        <JsonInclude>
        Public Summary As String
    End Class
    Public NotInheritable Class Program
        Public Shared Sub Main()
            Dim json As String = "{""Date"":""2020-09-06T11:31:01.923395"",""TemperatureC"":-1,""Summary"":""Cold""}"
            Console.WriteLine($"Input JSON: {json}")
            Dim options As New JsonSerializerOptions With {
                .IncludeFields = True
            Dim forecast1 As Forecast = JsonSerializer.Deserialize(Of Forecast)(json, options)
            Console.WriteLine($"forecast.Date: {forecast1.[Date]}")
            Console.WriteLine($"forecast.TemperatureC: {forecast1.TemperatureC}")
            Console.WriteLine($"forecast.Summary: {forecast1.Summary}")
            Dim roundTrippedJson As String = JsonSerializer.Serialize(forecast1, options)
            Console.WriteLine($"Output JSON: {roundTrippedJson}")
            Dim forecast21 As Forecast2 = JsonSerializer.Deserialize(Of Forecast2)(json)
            Console.WriteLine($"forecast2.Date: {forecast21.[Date]}")
            Console.WriteLine($"forecast2.TemperatureC: {forecast21.TemperatureC}")
            Console.WriteLine($"forecast2.Summary: {forecast21.Summary}")
            roundTrippedJson = JsonSerializer.Serialize(forecast21)
            Console.WriteLine($"Output JSON: {roundTrippedJson}")
        End Sub
    End Class
End Namespace
' Produces output like the following example:
'Input JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
'forecast.Date: 9/6/2020 11:31:01 AM
'forecast.TemperatureC: -1
'forecast.Summary: Cold
'Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
'forecast2.Date: 9/6/2020 11:31:01 AM
'forecast2.TemperatureC: -1
'forecast2.Summary: Cold
'Output JSON: { "Date":"2020-09-06T11:31:01.923395","TemperatureC":-1,"Summary":"Cold"}
Pour ignorer les champs en lecture seule, utilisez le paramètre global JsonSerializerOptions.IgnoreReadOnlyFields.
Méthodes d’extension HttpClient et HttpContent
La sérialisation et la désérialisation des charges utiles JSON à partir du réseau sont des opérations courantes. Les méthodes d’extension sur HttpClient et HttpContent vous permettent d’effectuer ces opérations en une seule ligne de code. Ces méthodes d’extension utilisent des valeurs web par défaut pour JsonSerializerOptions.
L’exemple suivant illustre l’utilisation de HttpClientJsonExtensions.GetFromJsonAsync et HttpClientJsonExtensions.PostAsJsonAsync :
using System.Net.Http.Json;
namespace HttpClientExtensionMethods
    public class User
        public int Id { get; set; }
        public string? Name { get; set; }
        public string? Username { get; set; }
        public string? Email { get; set; }
    public class Program
        public static async Task Main()
            using HttpClient client = new()
                BaseAddress = new Uri("https://jsonplaceholder.typicode.com")
            // Get the user information.
            User? user = await client.GetFromJsonAsync<User>("users/1");
            Console.WriteLine($"Id: {user?.Id}");
            Console.WriteLine($"Name: {user?.Name}");
            Console.WriteLine($"Username: {user?.Username}");
            Console.WriteLine($"Email: {user?.Email}");
            // Post a new user.
            HttpResponseMessage response = await client.PostAsJsonAsync("users", user);
            Console.WriteLine(
                $"{(response.IsSuccessStatusCode ? "Success" : "Error")} - {response.StatusCode}");
// Produces output like the following example but with different names:
//Id: 1
//Name: Tyler King
//Username: Tyler
//Email: Tyler @contoso.com
//Success - Created
Imports System.Net.Http
Imports System.Net.Http.Json
Namespace HttpClientExtensionMethods
    Public Class User
        Public Property Id As Integer
        Public Property Name As String
        Public Property Username As String
        Public Property Email As String
    End Class
    Public Class Program
        Public Shared Async Function Main() As Task
            Using client As New HttpClient With {
                .BaseAddress = New Uri("https://jsonplaceholder.typicode.com")
                ' Get the user information.
                Dim user1 As User = Await client.GetFromJsonAsync(Of User)("users/1")
                Console.WriteLine($"Id: {user1.Id}")
                Console.WriteLine($"Name: {user1.Name}")
                Console.WriteLine($"Username: {user1.Username}")
                Console.WriteLine($"Email: {user1.Email}")
                ' Post a new user.
                Dim response As HttpResponseMessage = Await client.PostAsJsonAsync("users", user1)
                Console.WriteLine(
                $"{(If(response.IsSuccessStatusCode, "Success", "Error"))} - {response.StatusCode}")
            End Using
        End Function
    End Class
End Namespace
' Produces output like the following example but with different names:
'Id: 1
'Name: Tyler King
'Username: Tyler
'Email: Tyler @contoso.com
'Success - Created
Il existe également des méthodes d’extension pour System.Text.Json sur HttpContent.
Voir aussi
Vue d’ensemble de System.Text.Json