Wie bekomme ich JSON in .NET mit C # formatiert?

Ich verwende den .NET JSON-Parser und möchte meine Konfigurationsdatei serialisieren, damit sie lesbar ist. Also statt:

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

Ich hätte gerne etwas Schöneres wie:

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

Mein Code ist ungefähr so:

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

Mit JavaScriptSerializer wird es Ihnen schwer fallen, dies zu erreichen.

Versuchen Sie es mit JSON.Net .

Mit geringfügigen Änderungen aus dem JSON.Net-Beispiel

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

Ergebnisse

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

Dokumentation: Serialisieren Sie ein Objekt

Ein kürzerer Beispielcode für die Json.Net-Bibliothek

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

Wenn Sie eine JSON-Zeichenfolge haben und diese "verschönern" möchten, diese aber nicht zu und von einem bekannten C # -Typ serialisieren möchten, reicht Folgendes aus (mithilfe von 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();
        }
    }
}

Kürzeste Version, um vorhandenes JSON zu verschönern: (Bearbeiten: Verwenden von JSON.net)

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

Eingang:

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

Ausgabe:

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

So drucken Sie ein Objekt hübsch aus:

JToken.FromObject(myObject).ToString()

Oneliner mit Newtonsoft.Json.Linq:

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

Sie können die folgende Standardmethode verwenden, um Json zu formatieren

JsonReaderWriterFactory.CreateJsonWriter (Stream-Stream, Codierungscodierung, bool ownStream, bool indent, string indentChars)

Setzen Sie nur "indent == true"

Versuchen Sie so etwas

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

Achten Sie auf Linien

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

Für einige Arten von XML-Serialisierern sollten Sie InvariantCulture verwenden , um Ausnahmen während der Deserialisierung auf Computern mit unterschiedlichen regionalen Einstellungen zu vermeiden. Zum Beispiel ungültiges Format von double oder DateTime manchmal diese.

Zum Deserialisieren

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

Vielen Dank!

All dies kann in einer einfachen Zeile erfolgen:

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

Hier ist eine Lösung mit der System.Text.Json- Bibliothek von 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());
}

Zuerst wollte ich einen Kommentar unter Duncan Smart hinzufügen, aber leider habe ich noch nicht genug Ruf, um Kommentare zu hinterlassen. Also werde ich es hier versuchen.

Ich möchte nur vor Nebenwirkungen warnen.

JsonTextReader analysiert json intern in typisierte JTokens und serialisiert sie dann zurück.

Zum Beispiel, wenn Ihr ursprünglicher JSON war

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

Nach dem Verschönern bekommst du

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

Natürlich sind beide JSON-Zeichenfolgen gleichwertig und werden deserialisiert, um strukturell gleiche Objekte zu erhalten. Wenn Sie jedoch die ursprünglichen Zeichenfolgenwerte beibehalten müssen, müssen Sie dies berücksichtigen

Mit System.Text.Jsonset 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
         });

Das hat bei mir funktioniert. Für den Fall, dass jemand nach einer VB.NET-Version sucht.

@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

Der folgende Code funktioniert für mich:

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