it-swarm.com.de

Wie kann ich JSON in .NET mit C # formatieren?

Ich verwende .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 sieht ungefähr so ​​aus:

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

Mit JavaScriptSerializer fällt es Ihnen schwer, dies zu erreichen.

Versuchen Sie 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: Objekt serialisieren

231
Sky Sanders

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

Wenn Sie über eine JSON-Zeichenfolge verfügen und diese "verschönern" möchten, diese aber nicht in einen bekannten C # -Typ serialisieren möchten, gilt Folgendes (unter Verwendung 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();
        }
    }
}
116
Duncan Smart

Kürzeste Version zu vorhandenes JSON hübsch machen: (edit: using 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()"
        }
      ]
    }
  }
}

Um ein Objekt hübsch zu drucken:

JToken.FromObject(myObject).ToString()
76
asherber

Oneliner mit Newtonsoft.Json.Linq:

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

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

JsonReaderWriterFactory.CreateJsonWriter (Stream-Stream, Codierung, bool ownsStream, 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;

Sie sollten InvariantCulture verwenden, um Ausnahmen während der Deserialisierung auf Computern mit unterschiedlichen Ländereinstellungen zu vermeiden. Beispielsweise kann ein ungültiges Format von double oder DateTime manchmal dazu führen.

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!

11
Makeman

Zuerst wollte ich einen Kommentar unter Duncan Smart posten, 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 anschließend zurück.

Zum Beispiel, wenn Ihre ursprüngliche 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 deserialisieren sich zu strukturell gleichen Objekten. Wenn Sie jedoch die ursprünglichen Zeichenfolgenwerte beibehalten müssen, müssen Sie dies berücksichtigen

2
Max Venediktov