S'assurer que les clés Json sont en minuscules dans .NET

Existe-t-il un moyen simple d'utiliser JSON dans .NET pour s'assurer que les clés sont envoyées en minuscules?

En ce moment, j'utilise la bibliothèque Json.NET de newtonsoft et j'utilise simplement

string loginRequest = JsonConvert.SerializeObject(auth);

Dans ce cas authest juste l'objet suivant

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

Cela se traduit par

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

Existe-t-il un moyen de garantir que les touches usernameet apitokenapparaissent en minuscules?

Je ne veux pas simplement l'exécuter, String.ToLower()bien sûr, car les valeurs de usernameet apitokensont mixtes.

Je me rends compte que je peux le faire par programme et créer la chaîne JSON manuellement, mais j'en ai besoin pour environ 20 chaînes de données JSON et je vois si je peux gagner du temps. Je me demande s'il existe des bibliothèques déjà construites qui vous permettent d'appliquer des minuscules pour la création de clés.

Vous pouvez créer un résolveur de contrat personnalisé pour cela. Le résolveur de contrat suivant convertira toutes les clés en minuscules:

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

Usage:

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

Wil se traduit par:

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

Si vous souhaitez toujours sérialiser à l'aide de LowercaseContractResolver, envisagez de l'encapsuler dans une classe pour éviter de vous répéter:

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

Qui peut être utilisé comme ceci:

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

ASP.NET MVC4 / WebAPI

Si vous utilisez ASP.NET MVC4 / WebAPI, vous pouvez utiliser une CamelCasePropertyNamesContractResolverbibliothèque de Newtonsoft.Json incluse par défaut.

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

Dans Json.NET 9.0.1 et versions ultérieures, il est possible de garantir que tous les noms de propriété sont convertis en minuscules à l'aide d'un fichier NamingStrategy. Cette classe extrait la logique du remappage algorithmique des noms de propriété du résolveur de contrat vers un objet léger et distinct qui peut être défini DefaultContractResolver.NamingStrategy. Cela évite d'avoir à créer une coutumeContractResolver et peut donc être plus facile à intégrer dans des frameworks qui ont déjà leurs propres résolveurs de contrat.

Définissez LowercaseNamingStrategycomme suit:

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

Puis sérialisez comme suit:

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

Remarques -

• L'utilisation string.ToLowerInvariant()garantit que le même contrat est généré dans tous les paramètres régionaux.

• Pour contrôler si les noms de propriété surchargée, les clés de dictionnaire et les noms de données d'extension sont en minuscules, vous pouvez définir NamingStrategy.OverrideSpecifiedNames, NamingStrategy.ProcessDictionaryKeysou NamingStrategy.ProcessExtensionDataNames(Json.NET 10.0.1 et versions ultérieures) à true.

• Vous souhaiterez peut-être mettre en cache le résolveur de contrat pour de meilleures performances .

• Si vous n'avez pas accès aux paramètres du sérialiseur dans votre infrastructure, vous pouvez appliquer un NamingStrategydirectement à votre objet comme suit:

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

• Ne modifiez pas le NamingStrategyde CamelCasePropertyNamesContractResolver. Ce résolveur de contrat partage les informations de type globalement sur toutes ses instances, et ainsi la modification d'une seule instance peut avoir des effets secondaires inattendus.

vous pouvez utiliser "JsonProperty":

Usage:

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

Pour moi, j'ai utilisé une combinaison de certaines des autres réponses et j'ai fini avec ceci

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

était plus proche d'une solution à ce que je cherchais car je ne cherchais pas à créer la mienne