에서 JSON을 포맷하려면 어떻게 해야 하나요?C#을 사용한 NET?

에서 JSON을 포맷하려면 어떻게 해야 하나요?C#을 사용한 NET?

사용하고 있습니다.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을 시험해 보세요.그물

JSON에서 약간 수정했습니다.넷 예시

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의 짧은 샘플 코드입니다.넷 라이브러리

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

JSON 스트링이 있어 그것을 「프렛화」하고 싶지만, 기존의 C# 타입과 시리얼화하지 않는 경우는, 다음과 같이 합니다(JSON 사용).네트워크):

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

넷코어 앱

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

이 모든 것을 1개의 간단한 행으로 실행할 수 있습니다.

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

Microsoft 의 시스템을 사용한 솔루션을 다음에 나타냅니다.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());
}

Json을 포맷하려면 다음과 같은 표준 방법을 사용할 수 있습니다.

Json Reader Writer Factory 。CreateJsonWriter(스트림스트림, 인코딩, bool ownsStream, bool ind, string indChars)

"syslog==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의 경우 지역 설정이 다른 컴퓨터에서 역직렬화 중에 예외를 방지하려면 UniversentCulture를 사용해야 합니다.예를 들어 double 형식이나 Date Time 형식이 잘못되어 있는 경우가 있습니다.

역직렬화용

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

감사합니다!

사용.System.Text.Json세트JsonSerializerOptions.WriteIndented = true:

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

2023년 갱신

에서 JSON을 포맷하는 방법을 문의하는 고객용.C#을 사용하고 있는 NET 및 한 줄 애호가에게 즉시 사용하는 방법을 보고 싶다.들여쓰기된 JSON 문자열의 한 줄 코드를 다음에 나타냅니다.

시리얼화할 JSON 포메터 또는 파서는 다음 2가지가 있습니다.

뉴턴소프트 존슨.넷 버전:

using Newtonsoft.Json;

var jsonString = JsonConvert.SerializeObject(yourObj, Formatting.Indented);

---

.Net 7 버전:

using System.Text.Json;

var jsonString = JsonSerializer.Serialize(yourObj, new JsonSerializerOptions { WriteIndented = true });

using System.Text.Json;
...
var parsedJson = JsonSerializer.Deserialize<ExpandoObject>(json);
var options = new JsonSerializerOptions() { WriteIndented = true };
return JsonSerializer.Serialize(parsedJson, options);

처음에 Duncan Smart 포스트에 코멘트를 추가하고 싶었지만 안타깝게도 코멘트를 남길 만한 평판이 아직 없습니다.그래서 여기서 먹어볼게요.

부작용에 대해 경고하고 싶어요.

JsonTextReader는 내부적으로 json을 유형화된 JToken으로 해석하여 다시 시리얼화합니다.

예를 들어 원래 JSON이

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

예쁘게 꾸미고 나면 너는 받는다.

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

물론 두 json 문자열은 동일하며 구조적으로 동일한 객체로 역직렬화되지만 원래 문자열 값을 유지할 필요가 있는 경우 이 점을 고려해야 합니다.

아주 간단한 방법이 있습니다.다음 형식으로 json으로 변환되는 실제 객체를 입력으로 입력할 수 있습니다.

private static string GetJson<T> (T json)
{
    return JsonConvert.SerializeObject(json, Formatting.Indented);
}

이건 나한테 효과가 있었어.혹시 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

.NET 5 에서는, JSON 의 해석, 시리얼화, 역직렬화를 처리하기 위한 클래스가 짜넣어져 있습니다.Text.Json 네임스페이스다음으로 를 변환하는 시리얼라이저의 예를 나타냅니다.JSON 문자열에 대한 NET 개체,

using System.Text.Json;
using System.Text.Json.Serialization;

private string ConvertJsonString(object obj)
{
    JsonSerializerOptions options = new JsonSerializerOptions();
    options.WriteIndented = true; //Pretty print using indent, white space, new line, etc.
    options.NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals; //Allow NANs
    string jsonString = JsonSerializer.Serialize(obj, options);
    return jsonString;
}

아래 코드가 유효합니다.

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

를 사용하여 인코딩된 UTF8 JSON 파일의 경우.NET Core 3.1, 드디어 Microsoft의 정보를 바탕으로 Json Document를 사용할 수 있게 되었습니다.https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-how-to#utf8jsonreader-utf8jsonwriter-and-jsondocument

string allLinesAsOneString = string.Empty;
string [] lines = File.ReadAllLines(filename, Encoding.UTF8);
foreach(var line in lines)
    allLinesAsOneString += line;

JsonDocument jd = JsonDocument.Parse(Encoding.UTF8.GetBytes(allLinesAsOneString));
var writer = new Utf8JsonWriter(Console.OpenStandardOutput(), new JsonWriterOptions
{
    Indented = true
});
JsonElement root = jd.RootElement;
if( root.ValueKind == JsonValueKind.Object )
{
    writer.WriteStartObject();
}
foreach (var jp in root.EnumerateObject())
    jp.WriteTo(writer);
writer.WriteEndObject();

writer.Flush();

언급URL : https://stackoverflow.com/questions/2661063/how-do-i-get-formatted-json-in-net-using-c