Asegurarse de que las claves json estén en minúsculas en .NET

¿Existe una forma sencilla de usar JSON en .NET para garantizar que las claves se envíen en minúsculas?

En este momento estoy usando la biblioteca Json.NET de newtonsoft y simplemente estoy usando

string loginRequest = JsonConvert.SerializeObject(auth);

En este caso authes solo el siguiente objeto

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

Esto resulta en

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

¿Hay alguna forma de garantizar que las teclas usernamey apitokenaparezcan en minúsculas?

No quiero simplemente ejecutarlo, por String.ToLower()supuesto, porque los valores de usernamey apitokenson mayúsculas y minúsculas.

Me doy cuenta de que puedo hacer esto programáticamente y crear la cadena JSON manualmente, pero necesito esto para aproximadamente 20 cadenas de datos JSON y estoy viendo si puedo ahorrarme algo de tiempo. Me pregunto si hay alguna biblioteca ya construida que le permita aplicar minúsculas para la creación de claves.

Puede crear un solucionador de contratos personalizado para esto. El siguiente solucionador de contratos convertirá todas las claves a 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);

Wil resultado en:

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

Si siempre desea serializar usando el LowercaseContractResolver, considere envolverlo en una clase para evitar repetirse:

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 se puede utilizar así:

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

ASP.NET MVC4 / WebAPI

Si está utilizando ASP.NET MVC4 / WebAPI, puede utilizar una CamelCasePropertyNamesContractResolverbiblioteca de Newtonsoft.Json que se incluye de forma predeterminada.

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

En Json.NET 9.0.1 y versiones posteriores, es posible asegurarse de que todos los nombres de propiedad se conviertan a minúsculas mediante el uso de un archivo NamingStrategy. Esta clase extrae la lógica para la reasignación algorítmica de los nombres de propiedad del solucionador de contratos a un objeto ligero separado en el que se puede configurar DefaultContractResolver.NamingStrategy. Al hacerlo, se evita la necesidad de crear una costumbreContractResolver y, por lo tanto, puede ser más fácil de integrar en marcos que ya tienen sus propios resolutores de contratos.

Defina LowercaseNamingStrategycomo sigue:

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

Luego serialice de la siguiente manera:

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

Notas -

• El uso string.ToLowerInvariant()asegura que se genere el mismo contrato en todas las configuraciones regionales.

• Para controlar si los nombres de las propiedades reemplazado, claves de un diccionario de datos y los nombres de extensión serán minúsculas, se puede establecer NamingStrategy.OverrideSpecifiedNames, NamingStrategy.ProcessDictionaryKeyso NamingStrategy.ProcessExtensionDataNames(Json.NET 10.0.1 y posteriores) a true.

• Es posible que desee almacenar en caché el solucionador de contratos para obtener el mejor rendimiento .

• Si no tiene acceso a la configuración del serializador en su marco, puede aplicar NamingStrategydirectamente a su objeto de la siguiente manera:

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

• No modifique el NamingStrategyde CamelCasePropertyNamesContractResolver. Este solucionador de contratos comparte información de tipo de forma global en todas sus instancias, por lo que modificar una instancia puede tener efectos secundarios inesperados.

puede utilizar "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 mí, utilicé una combinación de algunas de las otras respuestas y terminé con esta

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

estaba más cerca de una solución a lo que estaba buscando, ya que no estaba buscando crear mi propio