Como definir globalmente as opções padrão para System.Text.Json.JsonSerializer?

ATUALIZAÇÃO [2019-12-23]: em parte devido à contribuição da comunidade vocal , esse problema foi adicionado ao roteiro do .NET 5.0.

UPDATE [2019-10-10]: se estiver interessado em ver esse comportamento implementado paraSystem.Text.Json.JsonSerializervá para a edição aberta do GitHub, apontada por Chris Yungmann, e pesa.

Em vez disso:

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

Eu gostaria de fazer algo assim:

// 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); 

A esperança é não ter que passar uma instância dos casos JsonSerializerOptionsmais comuns e substituir a exceção, não a regra.

Conforme indicado nestas perguntas e respostas , esse é um recurso útil do Json.Net. Olhei na documentação para o System.Text.Jsonbem como este repo GitHub for .NET Core. E esse aqui .

Parece não haver um analógico para gerenciar padrões de serialização JSON no .NET Core 3. Ou estou ignorando isso?

Não, JsonSerializerOptionsnão expõe as opções padrão . Se você estiver usando uma estrutura da web específica, pode haver uma maneira de especificar as configurações de (des) serialização por meio disso. Caso contrário, sugiro criar seus próprios métodos de conveniência.

Veja também esta edição em aberto .

Você pode criar um método de extensão. Aqui está um exemplo

Eu uso métodos separados versus ter que criar configurações especiais, para que todas as configurações fiquem em um único local e facilmente reutilizáveis.

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);
    }
}

Em seguida, você o chama como um método em uma string, seja literal ou variável.

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

As opções padrão não são expostas no JsonSerializer.NET Core 3.1. No entanto, a partir de dezembro de 2019, isso foi adicionado ao roteiro do 5.0.

O lançamento do .NET 5.0 está previsto para novembro de 2020. Mas não há garantia de que esse problema específico seja solucionado a qualquer momento. Além de esperar, essas respostas sugerem soluções alternativas:

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

Uma solução alternativa foi proposta pelo usuário do GitHub andre-ss6 da seguinte maneira:

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

(Se você mudar para o Json.NET)

Prefiro e recomendo ser explícito e passar configurações para todas as chamadas, mas você pode definir padrões com DefaultSettings .

JsonConvert.DefaultSettings = () => MySuperJsonSerializerSettings;

e depois

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