Hogyan használd a forrásgenerálást System.Text.Json

Ez a cikk bemutatja, hogyan használhatja a forrásgeneráció által támogatott System.Text.Json szerializációt az alkalmazásokban.

A különböző forrásgenerációs módokról további információt a Forrás-generációs módok című témakörben talál.

Forrásgenerálási alapértelmezett értékek használata

A forráslétrehozás használata az összes alapértelmezett beállítással (mindkét mód, alapértelmezett beállítás):

1. Hozzon létre egy részleges osztályt, amely a forrásból JsonSerializerContextszármazik.

2. Adja meg a szerializálni vagy deszerializálni kívánt típust a környezeti osztályra való alkalmazással JsonSerializableAttribute .

3. Hívjon meg egy JsonSerializer metódust, amely vagy:

   • A JsonTypeInfo<T> példányt vesz vagy
   • A JsonSerializerContext példányt vesz vagy
   • Egy JsonSerializerOptions példányt vesz, és annak JsonSerializerOptions.TypeInfoResolver tulajdonságát a környezettípus Default tulajdonságára állítja be.

Alapértelmezés szerint mindkét forrásgenerálási mód (metaadat-alapú és szerializálási optimalizálás) akkor használatos, ha nem ad meg egyet. A használni kívánt mód megadásáról a cikk későbbi részében, a forrásgenerálási mód megadása című témakörben talál további információt.

Az alábbi példákban használt típus:

public class WeatherForecast
{
    public DateTime Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public string? Summary { get; set; }
}

Az alábbi környezeti osztály úgy van konfigurálva, hogy forrást hozzon létre az előző WeatherForecast osztályhoz:

[JsonSourceGenerationOptions(WriteIndented = true)]
[JsonSerializable(typeof(WeatherForecast))]
internal partial class SourceGenerationContext : JsonSerializerContext { }

A WeatherForecast tagok típusait nem kell kifejezetten megadni attribútumokkal [JsonSerializable]. A szabály alól kivételt képező object deklarált tagok. Meg kell adni a deklarált object tag futtatókörnyezet-típusát. Tegyük fel például, hogy rendelkezik a következő osztállyal:

public class WeatherForecast
{
    public object? Data { get; set; }
    public List<object>? DataList { get; set; }
}

És tudja, hogy futásidőben lehet, hogy rendelkezik boolean és int objektumokkal:

WeatherForecast wf = new() { Data = true, DataList = [true, 1] };

Ezután boolean és int[JsonSerializable]-ként kell deklarálni:

[JsonSerializable(typeof(WeatherForecast))]
[JsonSerializable(typeof(bool))]
[JsonSerializable(typeof(int))]
public partial class WeatherForecastContext : JsonSerializerContext
{
}

A gyűjtemény forrásgenerációjának megadásához használja [JsonSerializable] a gyűjtemény típusát. Például: [JsonSerializable(typeof(List<WeatherForecast>))]

JsonSerializer forrásgenerálást használó metódusok

Az alábbi példákban a környezettípus statikus Default tulajdonsága a környezettípus egy példányát adja meg alapértelmezett beállításokkal. A kontextuspéldány olyan WeatherForecast tulajdonságot biztosít, amely egy JsonTypeInfo<WeatherForecast> példányt ad vissza. A tulajdonságnak eltérő nevet adhat meg a(z) TypeInfoPropertyName attribútum [JsonSerializable] tulajdonságának használatával.

Szerializálási példák

JsonTypeInfo<T> használata:

jsonString = JsonSerializer.Serialize(
    weatherForecast!, SourceGenerationContext.Default.WeatherForecast);

JsonSerializerContext használata:

jsonString = JsonSerializer.Serialize(
    weatherForecast, typeof(WeatherForecast), SourceGenerationContext.Default);

JsonSerializerOptions használata:

sourceGenOptions = new JsonSerializerOptions
{
    TypeInfoResolver = SourceGenerationContext.Default
};

jsonString = JsonSerializer.Serialize<WeatherForecast>(weatherForecast, sourceGenOptions);

Deszerializálási példák

JsonTypeInfo<T> használata:

weatherForecast = JsonSerializer.Deserialize(
    jsonString, SourceGenerationContext.Default.WeatherForecast);

JsonSerializerContext használata:

weatherForecast = JsonSerializer.Deserialize(
    jsonString, typeof(WeatherForecast), SourceGenerationContext.Default)
    as WeatherForecast;

JsonSerializerOptions használata:

var sourceGenOptions = new JsonSerializerOptions
{
    TypeInfoResolver = SourceGenerationContext.Default
};
weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString, sourceGenOptions);

Példa a teljes programra

A teljes programban az alábbi példákat mutatjuk be:

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

namespace BothModesNoOptions
{
    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    }

    [JsonSourceGenerationOptions(WriteIndented = true)]
    [JsonSerializable(typeof(WeatherForecast))]
    internal partial class SourceGenerationContext : JsonSerializerContext { }

    public class Program
    {
        public static void Main()
        {
            string jsonString = """
                {
                    "Date": "2019-08-01T00:00:00",
                    "TemperatureCelsius": 25,
                    "Summary": "Hot"
                }
                """;
            WeatherForecast? weatherForecast;

            weatherForecast = JsonSerializer.Deserialize(
                jsonString, SourceGenerationContext.Default.WeatherForecast);
            Console.WriteLine($"Date={weatherForecast?.Date}");
            // output:
            //Date=8/1/2019 12:00:00 AM

            weatherForecast = JsonSerializer.Deserialize(
                jsonString, typeof(WeatherForecast), SourceGenerationContext.Default)
                as WeatherForecast;
            Console.WriteLine($"Date={weatherForecast?.Date}");
            // output:
            //Date=8/1/2019 12:00:00 AM

            var sourceGenOptions = new JsonSerializerOptions
            {
                TypeInfoResolver = SourceGenerationContext.Default
            };
            weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(jsonString, sourceGenOptions);
            Console.WriteLine($"Date={weatherForecast?.Date}");
            // output:
            //Date=8/1/2019 12:00:00 AM

            jsonString = JsonSerializer.Serialize(
                weatherForecast!, SourceGenerationContext.Default.WeatherForecast);
            Console.WriteLine(jsonString);
            // output:
            //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}

            jsonString = JsonSerializer.Serialize(
                weatherForecast, typeof(WeatherForecast), SourceGenerationContext.Default);
            Console.WriteLine(jsonString);
            // output:
            //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}

            sourceGenOptions = new JsonSerializerOptions
            {
                TypeInfoResolver = SourceGenerationContext.Default
            };

            jsonString = JsonSerializer.Serialize<WeatherForecast>(weatherForecast, sourceGenOptions);
            Console.WriteLine(jsonString);
            // output:
            //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}
        }
    }
}

Forrásgenerálási mód megadása

Metaadat-alapú vagy szerializáció-optimalizálási módot is megadhat egy teljes környezethez, amely több típust is tartalmazhat. Vagy megadhatja az egyes típusokhoz tartozó módot. Ha mindkettőt megteszi, a típus módspecifikációja nyer.

• A teljes kontextushoz használja a JsonSourceGenerationOptionsAttribute.GenerationMode tulajdonságot.
• Egyéni típus esetén használja a tulajdonságot JsonSerializableAttribute.GenerationMode .

Példa a szerializálási optimalizálás (gyors elérési út) módra.

• Teljes környezet esetén:

  [JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Serialization)]
  [JsonSerializable(typeof(WeatherForecast))]
  internal partial class SerializeOnlyContext : JsonSerializerContext
  {
  }
  

• Egyéni típus esetén:

  [JsonSerializable(typeof(WeatherForecast), GenerationMode = JsonSourceGenerationMode.Serialization)]
  internal partial class SerializeOnlyWeatherForecastOnlyContext : JsonSerializerContext
  {
  }
  

• Példa a teljes programra

  using System.Text.Json;
  using System.Text.Json.Serialization;
  
  namespace SerializeOnlyNoOptions
  {
      public class WeatherForecast
      {
          public DateTime Date { get; set; }
          public int TemperatureCelsius { get; set; }
          public string? Summary { get; set; }
      }
  
      [JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Serialization)]
      [JsonSerializable(typeof(WeatherForecast))]
      internal partial class SerializeOnlyContext : JsonSerializerContext
      {
      }
      
      [JsonSerializable(typeof(WeatherForecast), GenerationMode = JsonSourceGenerationMode.Serialization)]
      internal partial class SerializeOnlyWeatherForecastOnlyContext : JsonSerializerContext
      {
      }
  
       public class Program
      {
          public static void Main()
          {
              string jsonString;
              WeatherForecast weatherForecast = new()
                  { Date = DateTime.Parse("2019-08-01"), TemperatureCelsius = 25, Summary = "Hot" };
  
              // Use context that selects Serialization mode only for WeatherForecast.
              jsonString = JsonSerializer.Serialize(weatherForecast,
                  SerializeOnlyWeatherForecastOnlyContext.Default.WeatherForecast);
              Console.WriteLine(jsonString);
              // output:
              //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}
  
              // Use a context that selects Serialization mode.
              jsonString = JsonSerializer.Serialize(weatherForecast,
                  SerializeOnlyContext.Default.WeatherForecast);
              Console.WriteLine(jsonString);
              // output:
              //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}
          }
      }
  }
  

Példa metaadatokon alapuló módra

• Teljes környezet esetén:

  [JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
  [JsonSerializable(typeof(WeatherForecast))]
  internal partial class MetadataOnlyContext : JsonSerializerContext
  {
  }
  

  jsonString = JsonSerializer.Serialize(
      weatherForecast, MetadataOnlyContext.Default.WeatherForecast);
  

  weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(
      jsonString, MetadataOnlyContext.Default.WeatherForecast);
  

• Egyéni típus esetén:

  [JsonSerializable(typeof(WeatherForecast), GenerationMode = JsonSourceGenerationMode.Metadata)]
  internal partial class MetadataOnlyWeatherForecastOnlyContext : JsonSerializerContext
  {
  }
  

  jsonString = JsonSerializer.Serialize(
      weatherForecast,
      MetadataOnlyWeatherForecastOnlyContext.Default.WeatherForecast);
  

  weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(
      jsonString, MetadataOnlyWeatherForecastOnlyContext.Default.WeatherForecast);
  

• Példa a teljes programra

  using System.Text.Json;
  using System.Text.Json.Serialization;
  
  namespace MetadataOnlyNoOptions
  {
      public class WeatherForecast
      {
          public DateTime Date { get; set; }
          public int TemperatureCelsius { get; set; }
          public string? Summary { get; set; }
      }
  
      [JsonSerializable(typeof(WeatherForecast), GenerationMode = JsonSourceGenerationMode.Metadata)]
      internal partial class MetadataOnlyWeatherForecastOnlyContext : JsonSerializerContext
      {
      }
  
      [JsonSourceGenerationOptions(GenerationMode = JsonSourceGenerationMode.Metadata)]
      [JsonSerializable(typeof(WeatherForecast))]
      internal partial class MetadataOnlyContext : JsonSerializerContext
      {
      }
  
      public class Program
      {
          public static void Main()
          {
              string jsonString = """
                  {
                    "Date": "2019-08-01T00:00:00",
                    "TemperatureCelsius": 25,
                    "Summary": "Hot"
                  }
                  """;
              WeatherForecast? weatherForecast;
  
              // Deserialize with context that selects metadata mode only for WeatherForecast only.
              weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(
                  jsonString, MetadataOnlyWeatherForecastOnlyContext.Default.WeatherForecast);
              Console.WriteLine($"Date={weatherForecast?.Date}");
              // output:
              //Date=8/1/2019 12:00:00 AM
  
              // Serialize with context that selects metadata mode only for WeatherForecast only.
              jsonString = JsonSerializer.Serialize(
                  weatherForecast,
                  MetadataOnlyWeatherForecastOnlyContext.Default.WeatherForecast);
              Console.WriteLine(jsonString);
              // output:
              //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}
  
              // Deserialize with context that selects metadata mode only.
              weatherForecast = JsonSerializer.Deserialize<WeatherForecast>(
                  jsonString, MetadataOnlyContext.Default.WeatherForecast);
              Console.WriteLine($"Date={weatherForecast?.Date}");
              // output:
              //Date=8/1/2019 12:00:00 AM
  
              // Serialize with context that selects metadata mode only.
              jsonString = JsonSerializer.Serialize(
                  weatherForecast, MetadataOnlyContext.Default.WeatherForecast);
              Console.WriteLine(jsonString);
              // output:
              //{"Date":"2019-08-01T00:00:00","TemperatureCelsius":25,"Summary":"Hot"}
          }
      }
  }
  

Forrásgenerációs támogatás a ASP.NET Core-ban

Blazor-alkalmazásokban használja a HttpClientJsonExtensions.GetFromJsonAsync és HttpClientJsonExtensions.PostAsJsonAsync bővítménymetódusok túlterheléseit, amelyek forrásgenerálási környezetet vagy TypeInfo<TValue> fogadnak.

A .NET 8-tól kezdve a HttpClientJsonExtensions.GetFromJsonAsAsyncEnumerable bővítési metódusok túlterheléseit is használhatja, amelyek elfogadják a forrásgeneráló környezetet vagy TypeInfo<TValue>.

A Razor Pages, az MVC, a SignalR és a Webes API-alkalmazásokban a JsonSerializerOptions.TypeInfoResolver tulajdonság használatával adja meg a környezetet.

[JsonSerializable(typeof(WeatherForecast[]))]
internal partial class MyJsonContext : JsonSerializerContext { }

var serializerOptions = new JsonSerializerOptions
{
    TypeInfoResolver = MyJsonContext.Default
};

services.AddControllers().AddJsonOptions(
    static options =>
        options.JsonSerializerOptions.TypeInfoResolverChain.Add(MyJsonContext.Default));

Feljegyzés

JsonSourceGenerationMode.Serialization, vagy a gyors elérési út szerializáció nem támogatott az aszinkron szerializáláshoz. Annak ellenére, hogy a streamelési szerializálás metaadat-alapú modelleket igényel, a gyors útvonalra esik vissza, ha a hasznos adatok elég kicsiek ahhoz, hogy elférjenek az előre meghatározott pufferméretben. További információ: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-8/#json.

Tükröződés alapértelmezett értékének letiltása

Mivel System.Text.Json alapértelmezés szerint tükröződést használ, egy alapszintű szerializálási módszer meghívása megszakíthatja a natív AOT-alkalmazásokat, ami nem támogatja az összes szükséges tükröződési API-t. Ezeket a töréseket nehéz diagnosztizálni, mivel kiszámíthatatlanok lehetnek, és az alkalmazásokat gyakran a CoreCLR-futtatókörnyezetben hibakereséssel végzik, ahol a tükröződés működik. Ehelyett, ha kifejezetten letiltja a tükröződésalapú szerializálást, a törések könnyebben diagnosztizálhatóak. A tükröződésalapú szerializálást használó kód egy leíró üzenetet fog eredményezni InvalidOperationException futásidőben.

Ha le szeretné tiltani az alapértelmezett tükröződést az alkalmazásban, állítsa be az JsonSerializerIsReflectionEnabledByDefault MSBuild tulajdonságot false a projektfájlba:

<PropertyGroup>
  <JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
</PropertyGroup>

• A tulajdonság viselkedése futásidőtől függetlenül konzisztens, akár CoreCLR, akár natív AOT.
• Ha nem adja meg ezt a tulajdonságot, és a PublishTrimmed engedélyezve van, a tükröződésalapú szerializálás automatikusan le lesz tiltva.

A tulajdonság használatával JsonSerializer.IsReflectionEnabledByDefault programozott módon ellenőrizheti, hogy a tükröződés le van-e tiltva. Az alábbi kódrészlet bemutatja, hogyan konfigurálhatja a szerializálót attól függően, hogy engedélyezve van-e a tükröződés:

static JsonSerializerOptions CreateDefaultOptions()
{
    return new()
    {
        TypeInfoResolver = JsonSerializer.IsReflectionEnabledByDefault
            ? new DefaultJsonTypeInfoResolver()
            : MyContext.Default
    };
}

Mivel a tulajdonság csatolási idő állandóként van kezelve, az előző metódus nem gyökerezteti a tükröződésalapú feloldót a natív AOT-ban futó alkalmazásokban.

Beállítások megadása

A .NET 8 és újabb verzióiban a legtöbb beállítás, amelyet a JsonSerializerOptions használatával állíthat be, az JsonSourceGenerationOptionsAttribute attribútummal is beállítható. Az attribútumon keresztüli beállítások beállításának előnye, hogy a konfiguráció fordításkor van megadva, ami biztosítja, hogy a létrehozott MyContext.Default tulajdonság előre konfigurálva legyen az összes vonatkozó beállításkészlettel.

Az alábbi kód bemutatja, hogyan állíthat be beállításokat az JsonSourceGenerationOptionsAttribute attribútum használatával.

[JsonSourceGenerationOptions(
    WriteIndented = true,
    PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
    GenerationMode = JsonSourceGenerationMode.Serialization)]
[JsonSerializable(typeof(WeatherForecast))]
internal partial class SerializationModeOptionsContext : JsonSerializerContext
{
}

JsonSourceGenerationOptionsAttribute Szerializálási beállítások megadásakor hívja meg a következő szerializálási módszerek egyikét:

• Egy JsonSerializer.Serialize metódus, amely egy TypeInfo<TValue>. Adja át a Default.<TypeName> tulajdonságot a környezeti osztályból:

  jsonString = JsonSerializer.Serialize(
      weatherForecast, SerializationModeOptionsContext.Default.WeatherForecast);
  

• Egy JsonSerializer.Serialize kontextust használó metódus. Adja át a Default környezeti osztály statikus tulajdonságát.

  jsonString = JsonSerializer.Serialize(
      weatherForecast, typeof(WeatherForecast), SerializationModeOptionsContext.Default);
  

Ha olyan metódust hív meg, amely lehetővé teszi, hogy a saját Utf8JsonWriter példányát adja át, az író Indented beállítása kerül előtérbe a JsonSourceGenerationOptionsAttribute.WriteIndented opció helyett.

Ha környezeti példányt hoz létre és használ egy példányt használó JsonSerializerOptions konstruktor meghívásával, a megadott példány lesz használva a megadott JsonSourceGenerationOptionsAttributebeállítások helyett.

Az alábbi kód egy teljes programban az előző példákat mutatja be:

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

namespace SerializeOnlyWithOptions
{
    public class WeatherForecast
    {
        public DateTime Date { get; set; }
        public int TemperatureCelsius { get; set; }
        public string? Summary { get; set; }
    }

    [JsonSourceGenerationOptions(
        WriteIndented = true,
        PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
        GenerationMode = JsonSourceGenerationMode.Serialization)]
    [JsonSerializable(typeof(WeatherForecast))]
    internal partial class SerializationModeOptionsContext : JsonSerializerContext
    {
    }
    public class Program
    {
        public static void Main()
        {
            string jsonString;
            WeatherForecast weatherForecast = new()
                { Date = DateTime.Parse("2019-08-01"),
                  TemperatureCelsius = 25,
                  Summary = "Hot" };

            // Serialize using TypeInfo<TValue> provided by the context
            // and options specified by [JsonSourceGenerationOptions].
            jsonString = JsonSerializer.Serialize(
                weatherForecast, SerializationModeOptionsContext.Default.WeatherForecast);
            Console.WriteLine(jsonString);
            // output:
            //{
            //  "date": "2019-08-01T00:00:00",
            //  "temperatureCelsius": 0,
            //  "summary": "Hot"
            //}

            // Serialize using Default context
            // and options specified by [JsonSourceGenerationOptions].
            jsonString = JsonSerializer.Serialize(
                weatherForecast, typeof(WeatherForecast), SerializationModeOptionsContext.Default);
            Console.WriteLine(jsonString);
            // output:
            //{
            //  "date": "2019-08-01T00:00:00",
            //  "temperatureCelsius": 0,
            //  "summary": "Hot"
            //}
        }
    }
}

Forrásgenerátorok egyesítése

Több forrásgenerált környezetből származó szerződéseket egyesíthet egyetlen JsonSerializerOptions példányban. JsonSerializerOptions.TypeInfoResolver A tulajdonság használatával több olyan környezetet is láncba rendezhet, amelyeket a JsonTypeInfoResolver.Combine(IJsonTypeInfoResolver[]) metódussal kombináltak.

var options = new JsonSerializerOptions
{
    TypeInfoResolver = JsonTypeInfoResolver.Combine(ContextA.Default, ContextB.Default, ContextC.Default),
};

A .NET 8-tól kezdődően, ha később egy másik környezetet szeretne előszedni vagy hozzáfűzni, ezt a JsonSerializerOptions.TypeInfoResolverChain tulajdonság használatával teheti meg. A lánc sorrendje jelentős: JsonSerializerOptions lekérdezi az egyes feloldókat a megadott sorrendben, és az első nem null eredményt adja vissza.

options.TypeInfoResolverChain.Add(ContextD.Default); // Append to the end of the list.
options.TypeInfoResolverChain.Insert(0, ContextE.Default); // Insert at the beginning of the list.

A TypeInfoResolverChain tulajdonságon végzett minden módosítás tükröződik TypeInfoResolver-en, és ez fordítva is igaz.

Enum mezők szerializálása karakterláncként

Alapértelmezés szerint a számokat számként szerializálja a rendszer. Ha egy adott enum mezőit sztringekként szeretné szerializálni a forráslétrehozás használatakor, jegyzetelje meg a JsonStringEnumConverter<TEnum> konverterrel. Vagy ha az összes enumeráláshoz egy keretszabályzatot szeretne beállítani, használja az JsonSourceGenerationOptionsAttribute attribútumot.

JsonStringEnumConverter<T> konverter

Az enum értékek sztringként való szerializálásához használja a JsonStringEnumConverter<TEnum> konvertert. (A natív AOT-futtatókörnyezet nem támogatja a nem általános JsonStringEnumConverter típust.)

Az enumerálási típus megjegyzése a konverterrel az JsonStringEnumConverter<TEnum>JsonConverterAttribute attribútum használatával:

public class WeatherForecastWithPrecipEnum
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public Precipitation? Precipitation { get; set; }
}

[JsonConverter(typeof(JsonStringEnumConverter<Precipitation>))]
public enum Precipitation
{
    Drizzle, Rain, Sleet, Hail, Snow
}

Hozzon létre egy osztályt JsonSerializerContext , és jegyzetelje meg az JsonSerializableAttribute attribútummal:

[JsonSerializable(typeof(WeatherForecastWithPrecipEnum))]
public partial class Context1 : JsonSerializerContext { }

A következő kód az enumerálási neveket szerializálja a számértékek helyett.

var weatherForecast = new WeatherForecastWithPrecipEnum
{
    Date = DateTime.Parse("2019-08-01"),
    TemperatureCelsius = 25,
    Precipitation = Precipitation.Sleet
};

var options = new JsonSerializerOptions
{
    WriteIndented = true,
    TypeInfoResolver = Context1.Default,
};
string? jsonString = JsonSerializer.Serialize(weatherForecast, options);

Az eredményként kapott JSON a következő példához hasonlóan néz ki:

{
  "Date": "2019-08-01T00:00:00-07:00",
  "TemperatureCelsius": 25,
  "Precipitation": "Sleet"
}

Átfogó politika

A JsonStringEnumConverter<TEnum> típus használata helyett alkalmazhat egy általános szabályt az enumok sztringként való szerializálására a JsonSourceGenerationOptionsAttribute. Hozzon létre egy osztályt JsonSerializerContext, és jegyzetelje meg az JsonSerializableAttribute és JsonSourceGenerationOptionsAttribute alábbi attribútumokkal:

[JsonSourceGenerationOptions(UseStringEnumConverter = true)]
[JsonSerializable(typeof(WeatherForecast2WithPrecipEnum))]
public partial class Context2 : JsonSerializerContext { }

Figyelje meg, hogy az enum nem tartalmazza a JsonConverterAttribute:

public class WeatherForecast2WithPrecipEnum
{
    public DateTimeOffset Date { get; set; }
    public int TemperatureCelsius { get; set; }
    public Precipitation2? Precipitation { get; set; }
}

public enum Precipitation2
{
    Drizzle, Rain, Sleet, Hail, Snow
}

Egyéni enumerálási tagnevek

A .NET 9-től kezdődően testre szabhatja az enumerálási tagok nevét a JsonStringEnumMemberName attribútummal. További információ: Egyéni felsorolási tagnevek.

Lásd még

• JSON szerializálás és deszerializálás a .NET-ben – áttekintés
• A kódtár használata