Ordre des champs sérialisés en utilisant JSON.NET

la manière supportée est d'utiliser l'attribut JsonProperty sur les propriétés de classe pour lesquelles vous voulez définir l'ordre. lisez la documentation de commande de JsonPropertyAttribute pour plus d'information .

passer le JsonProperty un Order valeur et le serialiseur prendra soin du reste.

 [JsonProperty(Order = 1)]

ce qui est très similaire à la

 DataMember(Order = 1) 

des jours System.Runtime.Serialization .

vous pouvez effectivement contrôler l'ordre en implémentant IContractResolver ou en remplaçant la méthode DefaultContractResolver 's CreateProperties .

voici un exemple de mon implémentation simple de IContractResolver qui commande les propriétés par ordre alphabétique:

public class OrderedContractResolver : DefaultContractResolver
{
    protected override System.Collections.Generic.IList<JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization)
    {
        return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList();
    }
}

et ensuite définir les paramètres et sérialiser l'objet, et les champs JSON seront dans l'ordre alphabétique:

var settings = new JsonSerializerSettings()
{
    ContractResolver = new OrderedContractResolver()
};

var json = JsonConvert.SerializeObject(obj, Formatting.Indented, settings);

dans mon cas, la réponse de Mattias n'a pas fonctionné. La méthode CreateProperties n'a jamais été appelée.

après quelques déboguages de Newtonsoft.Json internes, j'ai trouvé une autre solution.

public class JsonUtility
{
    public static string NormalizeJsonString(string json)
    {
        // Parse json string into JObject.
        var parsedObject = JObject.Parse(json);

        // Sort properties of JObject.
        var normalizedObject = SortPropertiesAlphabetically(parsedObject);

        // Serialize JObject .
        return JsonConvert.SerializeObject(normalizedObject);
    }

    private static JObject SortPropertiesAlphabetically(JObject original)
    {
        var result = new JObject();

        foreach (var property in original.Properties().ToList().OrderBy(p => p.Name))
        {
            var value = property.Value as JObject;

            if (value != null)
            {
                value = SortPropertiesAlphabetically(value);
                result.Add(property.Name, value);
            }
            else
            {
                result.Add(property.Name, property.Value);
            }
        }

        return result;
    }
}

dans mon cas la solution de niaher n'a pas fonctionné parce qu'elle ne manipulait pas les objets dans les tableaux.

sur la base de sa solution c'est ce que j'ai trouvé

public static class JsonUtility
{
    public static string NormalizeJsonString(string json)
    {
        JToken parsed = JToken.Parse(json);

        JToken normalized = NormalizeToken(parsed);

        return JsonConvert.SerializeObject(normalized);
    }

    private static JToken NormalizeToken(JToken token)
    {
        JObject o;
        JArray array;
        if ((o = token as JObject) != null)
        {
            List<JProperty> orderedProperties = new List<JProperty>(o.Properties());
            orderedProperties.Sort(delegate(JProperty x, JProperty y) { return x.Name.CompareTo(y.Name); });
            JObject normalized = new JObject();
            foreach (JProperty property in orderedProperties)
            {
                normalized.Add(property.Name, NormalizeToken(property.Value));
            }
            return normalized;
        }
        else if ((array = token as JArray) != null)
        {
            for (int i = 0; i < array.Count; i++)
            {
                array[i] = NormalizeToken(array[i]);
            }
            return array;
        }
        else
        {
            return token;
        }
    }
}

comme Charlie l'a noté, vous pouvez quelque peu contrôler l'ordre des propriétés JSON en ordonnant les propriétés dans la classe elle-même. Malheureusement, cette approche ne fonctionne pas pour les propriétés héritées d'une classe de base. Les propriétés de la classe de base seront ordonnées comme elles sont présentées dans le code, mais apparaîtront avant les propriétés de la classe de base.

et pour ceux qui se demandent pourquoi vous pourriez vouloir classer les propriétés JSON par ordre alphabétique, c'est beaucoup plus facile de travailler avec JSON brut fichiers, en particulier pour les classes avec beaucoup de propriétés, si elles sont ordonnées.

la méthode récursive suivante utilise la réflexion pour trier la liste interne des tokens sur une instance JObject existante plutôt que de créer un tout nouveau graphe d'objet trié. Ce code repose sur des Json.NET détails de la mise en œuvre et ne doit pas être utilisé dans la production.

void SortProperties(JToken token)
{
    var obj = token as JObject;
    if (obj != null)
    {
        var props = typeof (JObject)
            .GetField("_properties",
                      BindingFlags.NonPublic | BindingFlags.Instance)
            .GetValue(obj);
        var items = typeof (Collection<JToken>)
            .GetField("items", BindingFlags.NonPublic | BindingFlags.Instance)
            .GetValue(props);
        ArrayList.Adapter((IList) items)
            .Sort(new ComparisonComparer(
                (x, y) =>
                {
                    var xProp = x as JProperty;
                    var yProp = y as JProperty;
                    return xProp != null && yProp != null
                        ? string.Compare(xProp.Name, yProp.Name)
                        : 0;
                }));
    }
    foreach (var child in token.Children())
    {
        SortProperties(child);
    }
}

en fait, puisque mon objet était déjà un objet de travail, j'ai utilisé la solution suivante:

public class SortedJObject : JObject
{
    public SortedJObject(JObject other)
    {
        var pairs = new List<KeyValuePair<string, JToken>>();
        foreach (var pair in other)
        {
            pairs.Add(pair);
        }
        pairs.OrderBy(p => p.Key).ForEach(pair => this[pair.Key] = pair.Value);
    }
}

et puis l'utiliser comme ceci:

string serializedObj = JsonConvert.SerializeObject(new SortedJObject(dataObject));

si vous contrôlez (c.-à-D. Écrivez) la classe, mettez les propriétés dans l'ordre alphabétique et ils serialiseront dans l'ordre alphabétique quand JsonConvert.SerializeObject() est appelé.

si vous souhaitez configurer globalement votre API avec des champs commandés, veuillez combiner la réponse de Mattias Nordberg:

public class OrderedContractResolver : DefaultContractResolver
{
    protected override System.Collections.Generic.IList<JsonProperty> CreateProperties(System.Type type, MemberSerialization memberSerialization)
    {
        return base.CreateProperties(type, memberSerialization).OrderBy(p => p.PropertyName).ToList();
    }
}

avec ma réponse ici:

comment forcer ASP.NET API Web pour toujours retourner JSON?

il n'y a pas d'ordre de champs dans le format JSON, donc définir un ordre n'a pas de sens.

{ id: 1, name: 'John' } est équivalent à { name: 'John', id: 1 } (tous deux représentent une instance d'objet strictement équivalente)