Làm cách nào để có được định dạng JSON trong .NET bằng C #?

Tôi đang sử dụng trình phân tích cú pháp .NET JSON và muốn tuần tự hóa tệp cấu hình của mình để có thể đọc được. Vì vậy, thay vì:

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

Tôi muốn một cái gì đó đẹp hơn như:

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

Mã của tôi là một cái gì đó như thế này:

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

Bạn sẽ có một thời gian khó khăn để thực hiện điều này với JavaScriptSerializer.

Hãy thử JSON.Net .

Với các sửa đổi nhỏ từ ví dụ 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; }
    }
}

Các kết quả

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

Tài liệu: Nối tiếp một đối tượng

Mã mẫu ngắn hơn cho thư viện Json.Net

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

Nếu bạn có một chuỗi JSON và muốn "làm đẹp" nó, nhưng không muốn nối tiếp chuỗi đó đến và từ một loại C # đã biết thì sau đây sẽ thực hiện thủ thuật (sử dụng 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();
        }
    }
}

Phiên bản ngắn nhất để làm đẹp JSON hiện có: (chỉnh sửa: sử dụng JSON.net)

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

Đầu vào:

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

Đầu ra:

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

Để in đẹp một đối tượng:

JToken.FromObject(myObject).ToString()

Oneliner sử dụng Newtonsoft.Json.Linq:

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

Bạn có thể sử dụng phương pháp tiêu chuẩn sau để nhận được định dạng Json

JsonReaderWriterFactory.CreateJsonWriter (Luồng truyền phát, mã hóa mã hóa, bool ownStream, bool indent, chuỗi indentChars)

Chỉ đặt "thụt lề == true"

Hãy thử một cái gì đó như thế này

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

Chú ý đến các dòng

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

Đối với một số loại xml-serializer, bạn nên sử dụng InvariantCARM để tránh ngoại lệ trong quá trình khử lưu huỳnh trên các máy tính có cài đặt Vùng khác nhau. Ví dụ: định dạng kép không hợp lệ hoặc DateTime đôi khi gây ra chúng.

Để khử lưu huỳnh

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

Cảm ơn!

Tất cả điều này có thể được thực hiện trong một dòng đơn giản:

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

Đây là một giải pháp sử dụng thư viện System.Text.Json của 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());
}

Đầu tiên tôi muốn thêm bình luận dưới bài đăng của Duncan Smart, nhưng tiếc là tôi chưa có đủ danh tiếng để để lại bình luận. Vì vậy, tôi sẽ thử nó ở đây.

Tôi chỉ muốn cảnh báo về tác dụng phụ.

JsonTextReader phân tích nội bộ json thành JTokens đã gõ và sau đó nối tiếp chúng trở lại.

Ví dụ: nếu JSON gốc của bạn là

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

Sau khi làm đẹp bạn nhận được

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

Tất nhiên cả hai chuỗi json đều tương đương và sẽ giải tuần tự hóa các đối tượng có cấu trúc bằng nhau, nhưng nếu bạn cần giữ nguyên các giá trị chuỗi gốc, bạn cần đưa điều này vào trong concider

Sử dụng System.Text.Jsonbộ JsonSerializerOptions.WriteIndented = true:

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

netcor Ứng dụng3.1

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

Điều này làm việc cho tôi. Trong trường hợp ai đó đang tìm kiếm một phiên bản 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

Mã dưới đây hoạt động với tôi:

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