Comment obtenir du JSON formaté en .NET en utilisant C #?

J'utilise l'analyseur .NET JSON et je souhaite sérialiser mon fichier de configuration afin qu'il soit lisible. Donc au lieu de:

{"blah":"v", "blah2":"v2"}

J'aimerais quelque chose de plus agréable comme:

{
    "blah":"v", 
    "blah2":"v2"
}

Mon code est quelque chose comme ceci:

using System.Web.Script.Serialization; 

var ser = new JavaScriptSerializer();
configSz = ser.Serialize(config);
using (var f = (TextWriter)File.CreateText(configFn))
{
    f.WriteLine(configSz);
    f.Close();
}

Vous allez avoir du mal à accomplir cela avec JavaScriptSerializer.

Essayez JSON.Net .

Avec des modifications mineures de l'exemple JSON.Net

using System;
using Newtonsoft.Json;

namespace JsonPrettyPrint
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Product product = new Product
                {
                    Name = "Apple",
                    Expiry = new DateTime(2008, 12, 28),
                    Price = 3.99M,
                    Sizes = new[] { "Small", "Medium", "Large" }
                };

            string json = JsonConvert.SerializeObject(product, Formatting.Indented);
            Console.WriteLine(json);

            Product deserializedProduct = JsonConvert.DeserializeObject<Product>(json);
        }
    }

    internal class Product
    {
        public String[] Sizes { get; set; }
        public decimal Price { get; set; }
        public DateTime Expiry { get; set; }
        public string Name { get; set; }
    }
}

Résultats

{
  "Sizes": [
    "Small",
    "Medium",
    "Large"
  ],
  "Price": 3.99,
  "Expiry": "\/Date(1230447600000-0700)\/",
  "Name": "Apple"
}

Documentation: sérialiser un objet

Un exemple de code plus court pour la bibliothèque Json.Net

private static string FormatJson(string json)
{
    dynamic parsedJson = JsonConvert.DeserializeObject(json);
    return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
}

Si vous avez une chaîne JSON et que vous voulez la "raffiner", mais que vous ne voulez pas la sérialiser vers et depuis un type C # connu, alors ce qui suit fait l'affaire (en utilisant JSON.NET):

using System;
using System.IO;
using Newtonsoft.Json;

class JsonUtil
{
    public static string JsonPrettify(string json)
    {
        using (var stringReader = new StringReader(json))
        using (var stringWriter = new StringWriter())
        {
            var jsonReader = new JsonTextReader(stringReader);
            var jsonWriter = new JsonTextWriter(stringWriter) { Formatting = Formatting.Indented };
            jsonWriter.WriteToken(jsonReader);
            return stringWriter.ToString();
        }
    }
}

Version la plus courte pour embellir le JSON existant: (modifier: en utilisant JSON.net)

JToken.Parse("mystring").ToString()

Contribution:

{"menu": { "id": "file", "value": "File", "popup": { "menuitem": [ {"value": "New", "onclick": "CreateNewDoc()"}, {"value": "Open", "onclick": "OpenDoc()"}, {"value": "Close", "onclick": "CloseDoc()"} ] } }}

Production:

{
  "menu": {
    "id": "file",
    "value": "File",
    "popup": {
      "menuitem": [
        {
          "value": "New",
          "onclick": "CreateNewDoc()"
        },
        {
          "value": "Open",
          "onclick": "OpenDoc()"
        },
        {
          "value": "Close",
          "onclick": "CloseDoc()"
        }
      ]
    }
  }
}

Pour imprimer joliment un objet:

JToken.FromObject(myObject).ToString()

Oneliner utilisant Newtonsoft.Json.Linq:

string prettyJson = JToken.Parse(uglyJsonString).ToString(Formatting.Indented);

Vous pouvez utiliser la méthode standard suivante pour obtenir Json formaté

JsonReaderWriterFactory.CreateJsonWriter (Stream stream, Encoding encoding, bool ownsStream, bool indent, string indentChars)

Définissez uniquement "indent == true"

Essayez quelque chose comme ça

    public readonly DataContractJsonSerializerSettings Settings = 
            new DataContractJsonSerializerSettings
            { UseSimpleDictionaryFormat = true };

    public void Keep<TValue>(TValue item, string path)
    {
        try
        {
            using (var stream = File.Open(path, FileMode.Create))
            {
                //var currentCulture = Thread.CurrentThread.CurrentCulture;
                //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

                try
                {
                    using (var writer = JsonReaderWriterFactory.CreateJsonWriter(
                        stream, Encoding.UTF8, true, true, "  "))
                    {
                        var serializer = new DataContractJsonSerializer(type, Settings);
                        serializer.WriteObject(writer, item);
                        writer.Flush();
                    }
                }
                catch (Exception exception)
                {
                    Debug.WriteLine(exception.ToString());
                }
                finally
                {
                    //Thread.CurrentThread.CurrentCulture = currentCulture;
                }
            }
        }
        catch (Exception exception)
        {
            Debug.WriteLine(exception.ToString());
        }
    }

Faites attention aux lignes

    var currentCulture = Thread.CurrentThread.CurrentCulture;
    Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
    ....
    Thread.CurrentThread.CurrentCulture = currentCulture;

Pour certains types de sérialiseurs xml, vous devez utiliser InvariantCulture pour éviter les exceptions pendant la désérialisation sur les ordinateurs avec différents paramètres régionaux. Par exemple, un format non valide de double ou DateTime les provoque parfois.

Pour désérialiser

    public TValue Revive<TValue>(string path, params object[] constructorArgs)
    {
        try
        {
            using (var stream = File.OpenRead(path))
            {
                //var currentCulture = Thread.CurrentThread.CurrentCulture;
                //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

                try
                {
                    var serializer = new DataContractJsonSerializer(type, Settings);
                    var item = (TValue) serializer.ReadObject(stream);
                    if (Equals(item, null)) throw new Exception();
                    return item;
                }
                catch (Exception exception)
                {
                    Debug.WriteLine(exception.ToString());
                    return (TValue) Activator.CreateInstance(type, constructorArgs);
                }
                finally
                {
                    //Thread.CurrentThread.CurrentCulture = currentCulture;
                }
            }
        }
        catch
        {
            return (TValue) Activator.CreateInstance(typeof (TValue), constructorArgs);
        }
    }

Merci!

Tout cela peut se faire en une seule ligne:

string jsonString = JsonConvert.SerializeObject(yourObject, Formatting.Indented);

Voici une solution utilisant la bibliothèque System.Text.Json de Microsoft :

static string FormatJsonText(string jsonString)
{
    using var doc = JsonDocument.Parse(
        jsonString,
        new JsonDocumentOptions
        {
            AllowTrailingCommas = true
        }
    );
    MemoryStream memoryStream = new MemoryStream();
    using (
        var utf8JsonWriter = new Utf8JsonWriter(
            memoryStream,
            new JsonWriterOptions
            {
                Indented = true
            }
        )
    )
    {
        doc.WriteTo(utf8JsonWriter);
    }
    return new System.Text.UTF8Encoding()
        .GetString(memoryStream.ToArray());
}

J'ai d'abord voulu ajouter un commentaire sous Duncan Smart Post, mais malheureusement je n'ai pas encore assez de réputation pour laisser des commentaires. Je vais donc l'essayer ici.

Je veux juste mettre en garde contre les effets secondaires.

JsonTextReader analyse en interne json en JTokens typés puis les sérialise.

Par exemple, si votre JSON d'origine était

 { "double":0.00002, "date":"\/Date(1198908717056)\/"}

Après avoir joliment vous obtenez

{ 
    "double":2E-05,
    "date": "2007-12-29T06:11:57.056Z"
}

Bien sûr, les deux chaînes json sont équivalentes et se désérialisent en objets structurellement égaux, mais si vous devez conserver les valeurs de chaîne d'origine, vous devez prendre cela en considération.

Utilisation de l' System.Text.Jsonensemble JsonSerializerOptions.WriteIndented = true:

JsonSerializerOptions options = new JsonSerializerOptions { WriteIndented = true };
string json = JsonSerializer.Serialize<Type>(object, options);

netcoreapp3.1

var js = JsonSerializer.Serialize(obj, new JsonSerializerOptions {
             WriteIndented = true
         });

Cela a fonctionné pour moi. Dans le cas où quelqu'un cherche une version VB.NET.

@imports System
@imports System.IO
@imports Newtonsoft.Json

Public Shared Function JsonPrettify(ByVal json As String) As String
  Using stringReader = New StringReader(json)

    Using stringWriter = New StringWriter()
      Dim jsonReader = New JsonTextReader(stringReader)
      Dim jsonWriter = New JsonTextWriter(stringWriter) With {
          .Formatting = Formatting.Indented
      }
      jsonWriter.WriteToken(jsonReader)
      Return stringWriter.ToString()
    End Using
  End Using
End Function

Le code ci-dessous fonctionne pour moi:

JsonConvert.SerializeObject(JToken.Parse(yourobj.ToString()))