Comment définir globalement les options par défaut pour System.Text.Json.JsonSerializer?

MISE À JOUR [2019-12-23]: En raison en partie de la contribution de la communauté vocale , ce problème a été ajouté à la feuille de route pour .NET 5.0.

MISE À JOUR [10/10/2019]: Si vous souhaitez voir ce comportement implémenté pourSystem.Text.Json.JsonSerializerdirigez-vous vers le problème ouvert de GitHub signalé par Chris Yungmann et pesez.

Au lieu de cela:

JsonSerializerOptions options = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    // etc.
};
JsonSerializer.Deserialize<SomeObject>(someJsonString, options);

Je voudrais faire quelque chose comme ça:

// This property is a pleasant fiction
JsonSerializer.DefaultSettings = new JsonSerializerOptions
{
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase
    // etc.
};

// This uses my options
JsonSerializer.Deserialize<SomeObject>(someJsonString); 

// And somewhere else in the same codebase...
// This also uses my options
JsonSerializer.Deserialize<SomeOtherObject>(someOtherJsonString); 

L'espoir est de ne pas avoir à passer une instance de JsonSerializerOptionspour nos cas les plus courants, et de passer outre à l'exception, pas à la règle.

Comme indiqué dans ces questions et réponses, il s'agit d'une fonctionnalité utile de Json.Net. J'ai regardé dans la documentation pour System.Text.Jsonainsi que ce dépôt GitHub pour .NET Core. Et celui-là .

Il ne semble pas y avoir d'analogue pour gérer les valeurs par défaut de sérialisation JSON dans .NET Core 3. Ou suis-je en train de l'ignorer?

Non, JsonSerializerOptionsn'expose pas les options par défaut . Si vous utilisez un cadre Web particulier, il peut y avoir un moyen de spécifier les paramètres de (dé-) sérialisation par ce biais. Sinon, je suggère de créer vos propres méthodes pratiques.

Voir aussi ce problème ouvert .

Vous pouvez créer une méthode d'extension. Voici un exemple

J'utilise des méthodes distinctes vs avoir à créer des paramètres spéciaux, de sorte que tous les paramètres soient au même endroit et facilement réutilisables.

public static class DeserializeExtensions
{
    private static JsonSerializerOptions defaultSerializerSettings = new JsonSerializerOptions();

    // set this up how you need to!
    private static JsonSerializerOptions featureXSerializerSettings = new JsonSerializerOptions();


    public static T Deserialize<T>(this string json)
    {       
        return JsonSerializer.Deserialize<T>(json, defaultSerializerSettings);
    }

    public static T DeserializeCustom<T>(this string json, JsonSerializerOptions settings)
    {
        return JsonSerializer.Deserialize<T>(json, settings);
    }

    public static T DeserializeFeatureX<T>(this string json)
    {
        return JsonSerializer.Deserialize<T>(json, featureXSerializerSettings);
    }
}

Ensuite, vous l'appelez comme méthode sur une chaîne, qu'elle soit littérale ou variable.

    Car result = @"{""Wheels"": 4, ""Doors"": 2}".DeserializeFeatureX<Car>();

Les options par défaut ne sont pas exposées dans JsonSerializer.NET Core 3.1. Cependant, en décembre 2019, cela a été ajouté à la feuille de route pour 5.0.

La sortie de .NET 5.0 est prévue pour novembre 2020. Mais il n'y a aucune garantie que ce problème particulier sera résolu à un moment donné. Outre l'attente, ces réponses suggèrent des solutions:

• https://stackoverflow.com/a/58331912/1011722
• https://stackoverflow.com/a/58959198/1011722

Une solution de contournement a été proposée par l'utilisateur GitHub andre-ss6 comme suit:

((JsonSerializerOptions)typeof(JsonSerializerOptions)
    .GetField("s_defaultOptions", 
        System.Reflection.BindingFlags.Static |
        System.Reflection.BindingFlags.NonPublic).GetValue(null))
    .PropertyNameCaseInsensitive = true;

(Si vous passez à utiliser Json.NET)

Je préfère et recommande d'être explicite et de transmettre les paramètres à tous les appels, mais vous pouvez définir des paramètres par défaut avec DefaultSettings .

JsonConvert.DefaultSettings = () => MySuperJsonSerializerSettings;

et alors

var json = JsonConvert.SerializeObject(o1);
var o2 = JsonConvert.DeserializeObject(x);