Läsa JSON som .NET-objekt (deserialisera)

Artikel
09/25/2024

Den här artikeln visar hur du använder System.Text.Json namnområdet för att deserialisera från JavaScript Object Notation (JSON). Om du porterar befintlig kod från Newtonsoft.Jsonläser du Så här migrerar du tillSystem.Text.Json .

Ett vanligt sätt att deserialisera JSON är att ha (eller skapa) en .NET-klass med egenskaper och fält som representerar en eller flera av JSON-egenskaperna. Anropa sedan metoden för att deserialisera från en sträng eller en fil JsonSerializer.Deserialize . För de allmänna överlagringarna är den generiska typparametern .NET-klassen. För icke-generiska överlagringar skickar du klassens typ som en metodparameter. Du kan deserialisera synkront eller asynkront.

Dricks

Du kan använda AI-hjälp för att deserialisera en JSON-sträng med GitHub Copilot.

Alla JSON-egenskaper som inte representeras i klassen ignoreras som standard. Om några egenskaper för typen krävs men inte finns i JSON-nyttolasten misslyckas även deserialiseringen.

Exempel

I följande exempel visas hur du deserialiserar en JSON-sträng:

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)

Om du vill deserialisera från en fil med synkron kod läser du filen i en sträng, som du ser i följande exempel:

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)

Om du vill deserialisera från en fil med hjälp av asynkron kod anropar DeserializeAsync du metoden:

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)

Deserialiseringsbeteende

Följande beteenden gäller vid deserialisering av JSON:

Som standard är matchning av egenskapsnamn skiftlägeskänsligt. Du kan ange skiftlägeskänslighet.
Icke-offentliga konstruktorer ignoreras av serialiseraren.
Deserialisering till oföränderliga objekt eller egenskaper som inte har offentliga set accessorer stöds men är inte aktiverat som standard. Se Oföränderliga typer och poster.
Som standard stöds uppräkningar som tal. Du kan deserialisera stränguppräkningsfält.
Som standard ignoreras fälten. Du kan inkludera fält.
Som standard utlöser kommentarer eller avslutande kommatecken i JSON-undantagen. Du kan tillåta kommentarer och avslutande kommatecken.
Standardvärdet för maximalt djup är 64.

När du använder System.Text.Json indirekt i en ASP.NET Core-app skiljer sig vissa standardbeteenden åt. Mer information finns i Webbstandarder för JsonSerializerOptions.

Du kan implementera anpassade konverterare för att tillhandahålla funktioner som inte stöds av de inbyggda konverterarna.

Deserialisera utan en .NET-klass

Om du har JSON som du vill deserialisera, och du inte har klassen att deserialisera den till, har du andra alternativ än att manuellt skapa den klass som du behöver:

Använd Utf8JsonReader direkt.
Deserialisera till en JSON DOM (dokumentobjektmodell) och extrahera det du behöver från DOM.

MED DOM kan du navigera till ett underavsnitt av en JSON-nyttolast och deserialisera ett enda värde, en anpassad typ eller en matris. Information om DOM finns i JsonNode Deserialize underavsnitt av en JSON-nyttolast. Information om DOM finns i JsonDocument Så här söker du efter underelement i JsonDocument och JsonElement.
Använd Visual Studio 2022 för att automatiskt generera den klass du behöver:
- Kopiera den JSON som du behöver för att deserialisera.
- Skapa en klassfil och ta bort mallkoden.
- Välj Redigera>Klistra in special>klistra in JSON som klasser.
Resultatet är en klass som du kan använda för deserialiseringsmålet.

Deserialisera från UTF-8

Om du vill deserialisera från UTF-8 anropar du en JsonSerializer.Deserialize överlagring som tar en ReadOnlySpan<byte> eller en Utf8JsonReader, enligt följande exempel. Exemplen förutsätter att JSON finns i en bytematris med namnet 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

Använda GitHub Copilot för att deserialisera JSON

Du kan använda GitHub Copilot i din IDE för att generera kod som använder System.Text.Json för att deserialisera från JSON.

Om du använder Visual Studio 2022 version 17.8 eller senare kan du prova den AI-drivna GitHub Copilot i Visual Studio för att generera kod som använder System.Text.Json för att deserialisera JSON. Skicka din fråga som en uppmaning i Chattfönstret för Copilot, som i följande exempel. Du kan också skicka frågor med hjälp av infogad chatt i själva redigeringsfönstret.

Kommentar

GitHub Copilot drivs av AI, så överraskningar och misstag är möjliga. Kontrollera eventuell genererad kod eller förslag. Mer information om allmän användning av GitHub Copilot, produktpåverkan, mänsklig tillsyn och sekretess finns i Vanliga frågor och svar om GitHub Copilot.

Följande text visar en exempelfråga för Copilot Chat:

Generera kod som ska användas System.Text.Json för att deserialisera en JSON-sträng {"FirstName":"John","Efternamn":"Doe","Ålder":30} till ett motsvarande .NET-objekt. Mappa egenskapsnamn och värden. Ange exempelutdata.

Du kan anpassa uppmaningen så att den använder en JSON-sträng med egenskapsnamn och värden som passar dina behov.

Du kan använda chattfunktioner, till exempel snedstreckskommandon, referenser till filer, metoder eller klasser och trådar, för att ange avsikt och få bättre svar med begränsad kontext. För en befintlig klass i ett projekt som är öppet i IDE kan du fråga GitHub Copilot med /generate code to dserialize JSON to equivalent .NET object in #Filename.

Följande utdata visar ett exempel på Copilot Chat-svar:

Here's an example of how you can use `System.Text.Json` to deserialize a JSON string into a .NET object in C#:

using System;
using System.Text.Json;
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main()
    {
        string jsonString = "{\"FirstName\":\"John\",\"LastName\":\"Doe\",\"Age\":30}";
        Person person = JsonSerializer.Deserialize<Person>(jsonString);
        Console.WriteLine($"FirstName: {person.FirstName}");
        Console.WriteLine($"LastName: {person.LastName}");
        Console.WriteLine($"Age: {person.Age}");
    }
}

**Example Output**
FirstName: John
LastName: Doe
Age: 30

This code defines a Person class with properties that match the JSON string. It then uses `JsonSerializer.Deserialize` to convert the JSON string into a `Person` object and prints the properties to the console.

När Copilot returnerar ett kodblock innehåller svaret alternativ för att kopiera koden, infoga koden i en ny fil eller förhandsgranska kodutdata.

Kommentar

Dina resultat kan skilja sig från vad som visas i exempelsvaren. AI-modeller är icke-deterministiska, vilket innebär att de kan returnera olika svar när de får samma fråga. Detta kan bero på ytterligare inlärning och anpassning över tid, språkvariationer, ändringar i kontexten, till exempel din chatthistorik med mera.

Mer information finns i:

Dela via