Upewnienie się, że klucze JSON są małymi literami w .NET

Czy istnieje prosty sposób za pomocą JSON w .NET, aby upewnić się, że klucze są wysyłane małymi literami?

W tej chwili używam biblioteki Json.NET firmy Newtonsoft i po prostu używam

string loginRequest = JsonConvert.SerializeObject(auth);

W tym przypadku authjest to tylko następujący obiekt

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

To skutkuje

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

Czy istnieje sposób, aby upewnić się, że klawisze usernamei apitokensą zapisywane małymi literami?

Oczywiście nie chcę tego po prostu przeglądać, String.ToLower()ponieważ wartości dla usernamei apitokensą mieszane.

Zdaję sobie sprawę, że mogę to zrobić programowo i ręcznie utworzyć ciąg JSON, ale potrzebuję tego na około 20 ciągów danych JSON i widzę, czy mogę zaoszczędzić trochę czasu. Zastanawiam się, czy istnieją już zbudowane biblioteki, które pozwalają wymusić małe litery przy tworzeniu kluczy.

Możesz w tym celu utworzyć niestandardowy mechanizm rozpoznawania umów. Następujący program do rozpoznawania kontraktu konwertuje wszystkie klucze na małe litery:

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

Stosowanie:

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

Wynik Wil w:

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

Jeśli zawsze chcesz serializować przy użyciu rozszerzenia LowercaseContractResolver, rozważ umieszczenie go w klasie, aby uniknąć powtarzania się:

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

Które można wykorzystać w ten sposób:

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

ASP.NET MVC4 / WebAPI

Jeśli używasz ASP.NET MVC4 / WebAPI, możesz użyć CamelCasePropertyNamesContractResolverbiblioteki from Newtonsoft.Json, która jest dołączona domyślnie.

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

W Json.NET 9.0.1 i nowszych wersjach można upewnić się, że wszystkie nazwy właściwości są konwertowane na małe litery przy użyciu niestandardowego NamingStrategy. Ta klasa wyodrębnia logikę algorytmicznego ponownego mapowania nazw właściwości z mechanizmu rozpoznawania kontraktu do oddzielnego, lekkiego obiektu, który można ustawić DefaultContractResolver.NamingStrategy. W ten sposób unika się potrzeby tworzenia niestandardowego,ContractResolver a tym samym może być łatwiejsze do zintegrowania z platformami, które mają już własne programy do rozpoznawania kontraktów.

Zdefiniuj LowercaseNamingStrategyw następujący sposób:

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

Następnie serializuj w następujący sposób:

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

Uwagi -

• Użycie string.ToLowerInvariant()zapewnia, że ​​ten sam kontrakt jest generowany we wszystkich lokalizacjach.

• Aby określić, czy nazwy właściwości przesłonięte, klucze słownika i rozszerzenie nazwy danych są małe litery, można ustawić NamingStrategy.OverrideSpecifiedNames, NamingStrategy.ProcessDictionaryKeyslub NamingStrategy.ProcessExtensionDataNames(Json.NET 10.0.1 i nowsze) do true.

• Aby uzyskać najlepszą wydajność, możesz buforować program rozpoznawania umów .

• Jeśli nie masz dostępu do ustawień serializatora w swoim frameworku, możesz zastosować NamingStrategybezpośrednio do swojego obiektu w następujący sposób:

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

• Nie modyfikuj NamingStrategyz CamelCasePropertyNamesContractResolver. Ten program rozpoznawania kontraktu udostępnia globalnie informacje o typie we wszystkich swoich wystąpieniach, więc modyfikowanie dowolnego wystąpienia może mieć nieoczekiwane skutki uboczne.

możesz użyć „JsonProperty”:

Stosowanie:

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

Dla mnie użyłem kombinacji niektórych innych odpowiedzi i skończyło się na tym

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

był bliżej rozwiązania tego, czego szukałem, ponieważ nie chciałem tworzyć własnego