Garantir que as chaves json sejam minúsculas no .NET

Existe uma maneira simples de usar JSON no .NET para garantir que as chaves sejam enviadas em minúsculas?

No momento estou usando a biblioteca Json.NET da newtonsoft e simplesmente usando

string loginRequest = JsonConvert.SerializeObject(auth);

Neste caso authé apenas o seguinte objeto

public class Authority
{
    public string Username { get; set; }
    public string ApiToken { get; set; }
}

Isto resulta em

{"Username":"Mark","ApiToken":"xyzABC1234"}

Existe uma maneira de garantir que as chaves usernamee apitokensejam exibidas em minúsculas?

Não quero simplesmente repassá-lo, é String.ToLower()claro, porque os valores para usernamee apitokensão maiúsculas e minúsculas.

Sei que posso fazer isso programaticamente e criar a string JSON manualmente, mas preciso disso para aproximadamente 20 strings de dados JSON e estou vendo se consigo economizar algum tempo. Estou me perguntando se há alguma biblioteca já construída que permite que você aplique minúsculas para a criação de chaves.

Você pode criar um resolvedor de contratos personalizado para isso. O seguinte resolvedor de contratos converterá todas as chaves em minúsculas:

public class LowercaseContractResolver : DefaultContractResolver
{
    protected override string ResolvePropertyName(string propertyName)
    {
        return propertyName.ToLower();
    }
}

Uso:

var settings = new JsonSerializerSettings();
settings.ContractResolver = new LowercaseContractResolver();
var json = JsonConvert.SerializeObject(authority, Formatting.Indented, settings);

Resultará em:

{"username":"Mark","apitoken":"xyzABC1234"}

Se você sempre deseja serializar usando o LowercaseContractResolver, considere envolvê-lo em uma classe para evitar a repetição:

public class LowercaseJsonSerializer
{
    private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
    {
        ContractResolver = new LowercaseContractResolver()
    };

    public static string SerializeObject(object o)
    {
        return JsonConvert.SerializeObject(o, Formatting.Indented, Settings);
    }

    public class LowercaseContractResolver : DefaultContractResolver
    {
        protected override string ResolvePropertyName(string propertyName)
        {
            return propertyName.ToLower();
        }
    }
}

Que pode ser usado assim:

var json = LowercaseJsonSerializer.SerializeObject(new { Foo = "bar" });
// { "foo": "bar" }

ASP.NET MVC4 / WebAPI

Se você estiver usando ASP.NET MVC4 / WebAPI, você pode usar uma CamelCasePropertyNamesContractResolverbiblioteca de Newtonsoft.Json incluída por padrão.

protected void Application_Start() {
    JsonConfig.Configure();   
}

public static class JsonConfig
{
    public static void Configure(){
        var formatters = GlobalConfiguration.Configuration.Formatters;
        var jsonFormatter = formatters.JsonFormatter;
        var settings = jsonFormatter.SerializerSettings;

        settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
    }
}

No Json.NET 9.0.1 e posterior, é possível garantir que todos os nomes de propriedades sejam convertidos em minúsculas usando um personalizado NamingStrategy. Esta classe extrai a lógica para o remapeamento algorítmico de nomes de propriedades do resolvedor de contratos para um objeto leve e separado que pode ser definido emDefaultContractResolver.NamingStrategy . Isso evita a necessidade de criar um customizadoContractResolver e, portanto, pode ser mais fácil de integrar em estruturas que já têm seus próprios resolvedores de contrato.

Defina LowercaseNamingStrategyo seguinte:

public class LowercaseNamingStrategy : NamingStrategy
{
    protected override string ResolvePropertyName(string name)
    {
        return name.ToLowerInvariant();
    }
}

Em seguida, serialize da seguinte maneira:

var settings = new JsonSerializerSettings
{
    ContractResolver = new DefaultContractResolver { NamingStrategy = new LowercaseNamingStrategy() },
};
string loginRequest = JsonConvert.SerializeObject(auth, settings);

Notas -

• Usando string.ToLowerInvariant() garante que o mesmo contrato seja gerado em todos os locais.

• Para controlar se os nomes de propriedade substituídos, chaves de dicionário e nomes de dados de extensão estão em minúsculas, você pode definir NamingStrategy.OverrideSpecifiedNames, NamingStrategy.ProcessDictionaryKeysou NamingStrategy.ProcessExtensionDataNames(Json.NET 10.0.1 e posterior) paratrue .

• Você pode querer armazenar em cache o resolvedor de contratos para melhor desempenho .

• Se você não tiver acesso às configurações do serializador em sua estrutura, poderá aplicar um NamingStrategydiretamente ao seu objeto da seguinte maneira:

  [JsonObject(NamingStrategyType = typeof(LowercaseNamingStrategy))]
  public class Authority
  {
      public string Username { get; set; }
      public string ApiToken { get; set; }
  }

• Não modifique o NamingStrategyde CamelCasePropertyNamesContractResolver. Este resolvedor de contratos compartilha informações de tipo globalmente em todas as suas instâncias e, portanto, a modificação de qualquer instância pode ter efeitos colaterais inesperados.

você pode usar "JsonProperty":

Uso:

public class Authority
{
    [JsonProperty("userName")] // or [JsonProperty("username")]
    public string Username { get; set; }
    [JsonProperty("apiToken")] // or [JsonProperty("apitoken")]
    public string ApiToken { get; set; }
}

var json  = JsonConvert.SerializeObject(authority);

Para mim, usei uma combinação de algumas das outras respostas e terminei com esta

        return JsonConvert.SerializeObject(obj, Formatting.Indented, new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver()
        });

estava mais perto de uma solução para o que eu procurava, pois não procurava criar o meu próprio