Bagaimana cara saya mendapatkan JSON yang diformat di .NET menggunakan C #?

Saya menggunakan parser .NET JSON dan ingin membuat serial file config saya agar dapat dibaca. Jadi alih-alih:

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

Saya ingin sesuatu yang lebih baik seperti:

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

Kode saya kira-kira seperti ini:

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

Anda akan mengalami kesulitan menyelesaikan ini dengan JavaScriptSerializer.

Coba JSON.Net .

Dengan sedikit modifikasi dari contoh 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; }
    }
}

Hasil

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

Dokumentasi: Buat serialisasi sebuah Objek

Kode sampel yang lebih pendek untuk perpustakaan Json.Net

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

Jika Anda memiliki string JSON dan ingin "mem-prettify" itu, tetapi tidak ingin membuat cerita bersambung ke dan dari tipe C # yang dikenal, maka yang berikut melakukan trik (menggunakan 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();
        }
    }
}

Versi terpendek untuk membuat cantik JSON yang ada: (edit: using JSON.net)

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

Memasukkan:

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

Keluaran:

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

Untuk mencetak objek dengan cantik:

JToken.FromObject(myObject).ToString()

Oneliner menggunakan Newtonsoft.Json.Linq:

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

Anda dapat menggunakan metode standar berikut untuk mendapatkan format Json

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

Hanya setel "indent == true"

Coba sesuatu seperti ini

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

Perhatikan baris Anda

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

Untuk beberapa jenis xml-serializers Anda harus menggunakan InvariantCulture untuk menghindari pengecualian selama deserialisasi pada komputer dengan pengaturan Regional yang berbeda. Misalnya, format ganda atau DateTime yang tidak valid terkadang menyebabkan mereka.

Untuk deserialisasi

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

Terima kasih!

Semua ini dapat dilakukan dalam satu baris sederhana:

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

Berikut ini adalah solusi menggunakan perpustakaan System.Text.Json 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());
}

Pertama saya ingin menambahkan komentar di bawah posting Duncan Smart, tapi sayangnya saya belum punya reputasi yang cukup untuk meninggalkan komentar. Jadi saya akan mencobanya di sini.

Saya hanya ingin memperingatkan tentang efek samping.

JsonTextReader secara internal mem-parsing json ke dalam JTokens yang diketik dan kemudian membuat serial kembali.

Misalnya jika JSON asli Anda

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

Setelah cantik Anda dapatkan

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

Tentu saja kedua string json adalah setara dan akan deserialize ke objek yang sama secara struktural, tetapi jika Anda perlu mempertahankan nilai string asli, Anda harus mempertimbangkan ini.

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

Ini berhasil untuk saya. Dalam kasus seseorang mencari versi 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

Kode di bawah ini berfungsi untuk saya:

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