C #을 사용하여 .NET에서 JSON 형식을 지정하려면 어떻게합니까?

.NET JSON 파서를 사용하고 있으며 읽을 수 있도록 구성 파일을 직렬화하고 싶습니다. 따라서 대신 :

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

나는 더 좋은 것을 원합니다 :

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

내 코드는 다음과 같습니다

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

JavaScriptSerializer 로이 작업을 수행하는 데 어려움을 겪을 것입니다.

JSON.Net을 사용해보십시오 .

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

결과

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

설명서 : 객체 직렬화

Json.Net 라이브러리의 더 짧은 샘플 코드

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

JSON 문자열이 있고 "prettify"하고 싶지만 알려진 C # 유형과 직렬화하지 않으려면 다음이 트릭을 수행합니다 (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();
        }
    }
}

기존 JSON 을 확인하는 가장 짧은 버전 : (JSON.net 사용)

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

입력:

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

산출:

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

객체 를 예쁘게 인쇄 하려면 :

JToken.FromObject(myObject).ToString()

사용하는 Oneliner Newtonsoft.Json.Linq:

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

Json 형식화를 위해 다음 표준 방법을 사용할 수 있습니다.

JsonReaderWriterFactory.CreateJsonWriter (스트림 스트림, 인코딩 인코딩, bool ownsStream, bool 들여 쓰기, 문자열 indentChars)

"indent == true" 만 설정

이런 식으로 해보십시오

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

라인에주의를 기울이십시오

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

일부 종류의 xml-serializer의 경우 InvariantCulture 를 사용 하여 지역 설정이 다른 컴퓨터에서 deserialization하는 동안 예외를 피해야합니다. 예를 들어, double 또는 DateTime 형식이 올바르지 않은 경우가 있습니다.

역 직렬화

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

감사!

이 모든 것은 한 줄로 이루어질 수 있습니다 :

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

다음은 Microsoft의 System.Text.Json 라이브러리를 사용하는 솔루션입니다 .

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

먼저 Duncan Smart 게시물에 의견을 추가하고 싶었지만 안타깝게도 아직 의견을 남길만한 명성이 없습니다. 그래서 나는 여기서 시도 할 것입니다.

부작용에 대해서만 경고하고 싶습니다.

JsonTextReader는 내부적으로 json을 유형이 지정된 JToken으로 구문 분석 한 후 다시 직렬화합니다.

예를 들어 원래 JSON이

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

prettify 후 얻을

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

물론 두 json 문자열은 동일하며 구조적으로 동일한 객체로 직렬화 해제되지만 원래 문자열 값을 유지 해야하는 경우 이것을 조정해야합니다.

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

이것은 나를 위해 일했습니다. 누군가 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

아래 코드는 저에게 효과적입니다.

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