blocks|key|1780801|text|更简单的是我刚刚写的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1780802|public+class+JsonFormatter
{
++++public+static+string+Indent+=+"++++";

++++public+static+string+PrettyPrint(string+input)
++++{
++++++++var+output+=+new+StringBuilder(input.Length+*+2);
++++++++char?+quote+=+null;
++++++++int+depth+=+0;

++++++++for(int+i=0;+i<input.Length;+%2B%2Bi)
++++++++{
++++++++++++char+ch+=+input[i];

++++++++++++switch+(ch)
++++++++++++{
++++++++++++++++case+'{':
++++++++++++++++case+'[':
++++++++++++++++++++output.Append(ch);
++++++++++++++++++++if+(!quote.HasValue)
++++++++++++++++++++{
++++++++++++++++++++++++output.AppendLine();
++++++++++++++++++++++++output.Append(Indent.Repeat(%2B%2Bdepth));
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+'}':
++++++++++++++++case+']':
++++++++++++++++++++if+(quote.HasValue)++
++++++++++++++++++++++++output.Append(ch);
++++++++++++++++++++else
++++++++++++++++++++{
++++++++++++++++++++++++output.AppendLine();
++++++++++++++++++++++++output.Append(Indent.Repeat(--depth));
++++++++++++++++++++++++output.Append(ch);
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+'"':
++++++++++++++++case+'\'':
++++++++++++++++++++output.Append(ch);
++++++++++++++++++++if+(quote.HasValue)
++++++++++++++++++++{
++++++++++++++++++++++++if+(!output.IsEscaped(i))
++++++++++++++++++++++++++++quote+=+null;
++++++++++++++++++++}
++++++++++++++++++++else+quote+=+ch;
++++++++++++++++++++break;
++++++++++++++++case+',':
++++++++++++++++++++output.Append(ch);
++++++++++++++++++++if+(!quote.HasValue)
++++++++++++++++++++{
++++++++++++++++++++++++output.AppendLine();
++++++++++++++++++++++++output.Append(Indent.Repeat(depth));
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+':':
++++++++++++++++++++if+(quote.HasValue)+output.Append(ch);
++++++++++++++++++++else+output.Append("+:+");
++++++++++++++++++++break;
++++++++++++++++default:
++++++++++++++++++++if+(quote.HasValue+%7C%7C+!char.IsWhiteSpace(ch))+
++++++++++++++++++++++++output.Append(ch);
++++++++++++++++++++break;
++++++++++++}
++++++++}

++++++++return+output.ToString();
++++}
}|code-block|syntax|javascript|1780803|必要的扩展：|1780804|++++public+static+string+Repeat(this+string+str,+int+count)
++++{
++++++++return+new+StringBuilder().Insert(0,+str,+count).ToString();
++++}

++++public+static+bool+IsEscaped(this+string+str,+int+index)
++++{
++++++++bool+escaped+=+false;
++++++++while+(index+>+0+&&+str[--index]+==+'\\')+escaped+=+!escaped;
++++++++return+escaped;
++++}

++++public+static+bool+IsEscaped(this+StringBuilder+str,+int+index)
++++{
++++++++return+str.ToString().IsEscaped(index);
++++}|1780805|示例输出：|1780806|{
++++"status"+:+"OK",
++++"results"+:+[
++++++++{
++++++++++++"types"+:+[
++++++++++++++++"locality",
++++++++++++++++"political"
++++++++++++],
++++++++++++"formatted_address"+:+"New+York,+NY,+USA",
++++++++++++"address_components"+:+[
++++++++++++++++{
++++++++++++++++++++"long_name"+:+"New+York",
++++++++++++++++++++"short_name"+:+"New+York",
++++++++++++++++++++"types"+:+[
++++++++++++++++++++++++"locality",
++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
++++++++++++++++{
++++++++++++++++++++"long_name"+:+"New+York",
++++++++++++++++++++"short_name"+:+"New+York",
++++++++++++++++++++"types"+:+[
++++++++++++++++++++++++"administrative_area_level_2",
++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
++++++++++++++++{
++++++++++++++++++++"long_name"+:+"New+York",
++++++++++++++++++++"short_name"+:+"NY",
++++++++++++++++++++"types"+:+[
++++++++++++++++++++++++"administrative_area_level_1",
++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
++++++++++++++++{
++++++++++++++++++++"long_name"+:+"United+States",
++++++++++++++++++++"short_name"+:+"US",
++++++++++++++++++++"types"+:+[
++++++++++++++++++++++++"country",
++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++}
++++++++++++],
++++++++++++"geometry"+:+{
++++++++++++++++"location"+:+{
++++++++++++++++++++"lat"+:+40.7143528,
++++++++++++++++++++"lng"+:+-74.0059731
++++++++++++++++},
++++++++++++++++"location_type"+:+"APPROXIMATE",
++++++++++++++++"viewport"+:+{
++++++++++++++++++++"southwest"+:+{
++++++++++++++++++++++++"lat"+:+40.5788964,
++++++++++++++++++++++++"lng"+:+-74.2620919
++++++++++++++++++++},
++++++++++++++++++++"northeast"+:+{
++++++++++++++++++++++++"lat"+:+40.8495342,
++++++++++++++++++++++++"lng"+:+-73.7498543
++++++++++++++++++++}
++++++++++++++++},
++++++++++++++++"bounds"+:+{
++++++++++++++++++++"southwest"+:+{
++++++++++++++++++++++++"lat"+:+40.4773990,
++++++++++++++++++++++++"lng"+:+-74.2590900
++++++++++++++++++++},
++++++++++++++++++++"northeast"+:+{
++++++++++++++++++++++++"lat"+:+40.9175770,
++++++++++++++++++++++++"lng"+:+-73.7002720
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++]
}|1780807|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Even simpler one that I just wrote:

<pre><code>public class JsonFormatter
{
 public static string Indent = " ";

 public static string PrettyPrint(string input)
 {
 var output = new StringBuilder(input.Length * 2);
 char? quote = null;
 int depth = 0;

 for(int i=0; i&lt;input.Length; ++i)
 {
 char ch = input[i];

 switch (ch)
 {
 case '{':
 case '[':
 output.Append(ch);
 if (!quote.HasValue)
 {
 output.AppendLine();
 output.Append(Indent.Repeat(++depth));
 }
 break;
 case '}':
 case ']':
 if (quote.HasValue) 
 output.Append(ch);
 else
 {
 output.AppendLine();
 output.Append(Indent.Repeat(--depth));
 output.Append(ch);
 }
 break;
 case '"':
 case '\'':
 output.Append(ch);
 if (quote.HasValue)
 {
 if (!output.IsEscaped(i))
 quote = null;
 }
 else quote = ch;
 break;
 case ',':
 output.Append(ch);
 if (!quote.HasValue)
 {
 output.AppendLine();
 output.Append(Indent.Repeat(depth));
 }
 break;
 case ':':
 if (quote.HasValue) output.Append(ch);
 else output.Append(" : ");
 break;
 default:
 if (quote.HasValue || !char.IsWhiteSpace(ch)) 
 output.Append(ch);
 break;
 }
 }

 return output.ToString();
 }
}
</code></pre>

Necessary extensions:

<pre><code> public static string Repeat(this string str, int count)
 {
 return new StringBuilder().Insert(0, str, count).ToString();
 }

 public static bool IsEscaped(this string str, int index)
 {
 bool escaped = false;
 while (index &gt; 0 &amp;&amp; str[--index] == '\\') escaped = !escaped;
 return escaped;
 }

 public static bool IsEscaped(this StringBuilder str, int index)
 {
 return str.ToString().IsEscaped(index);
 }
</code></pre>

Sample output:

<pre><code>{
 "status" : "OK",
 "results" : [
 {
 "types" : [
 "locality",
 "political"
 ],
 "formatted_address" : "New York, NY, USA",
 "address_components" : [
 {
 "long_name" : "New York",
 "short_name" : "New York",
 "types" : [
 "locality",
 "political"
 ]
 },
 {
 "long_name" : "New York",
 "short_name" : "New York",
 "types" : [
 "administrative_area_level_2",
 "political"
 ]
 },
 {
 "long_name" : "New York",
 "short_name" : "NY",
 "types" : [
 "administrative_area_level_1",
 "political"
 ]
 },
 {
 "long_name" : "United States",
 "short_name" : "US",
 "types" : [
 "country",
 "political"
 ]
 }
 ],
 "geometry" : {
 "location" : {
 "lat" : 40.7143528,
 "lng" : -74.0059731
 },
 "location_type" : "APPROXIMATE",
 "viewport" : {
 "southwest" : {
 "lat" : 40.5788964,
 "lng" : -74.2620919
 },
 "northeast" : {
 "lat" : 40.8495342,
 "lng" : -73.7498543
 }
 },
 "bounds" : {
 "southwest" : {
 "lat" : 40.4773990,
 "lng" : -74.2590900
 },
 "northeast" : {
 "lat" : 40.9175770,
 "lng" : -73.7002720
 }
 }
 }
 }
 ]
}
</code></pre>

blocks|key|1994652|text|我更新了旧版本，现在它应该支持无引号的值，如整数和布尔值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1994653|我重构了之前的版本，得到了最终的版本:代码更短、更干净。只需要一个扩展方法。最重要的是:修复了一些bug。|1994654|class+JsonHelper
{
++++private+const+string+INDENT_STRING+=+"++++";
++++public+static+string+FormatJson(string+str)
++++{
++++++++var+indent+=+0;
++++++++var+quoted+=+false;
++++++++var+sb+=+new+StringBuilder();
++++++++for+(var+i+=+0;+i+<+str.Length;+i%2B%2B)
++++++++{
++++++++++++var+ch+=+str[i];
++++++++++++switch+(ch)
++++++++++++{
++++++++++++++++case+'{':
++++++++++++++++case+'[':
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++if+(!quoted)
++++++++++++++++++++{
++++++++++++++++++++++++sb.AppendLine();
++++++++++++++++++++++++Enumerable.Range(0,+%2B%2Bindent).ForEach(item+=>+sb.Append(INDENT_STRING));
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+'}':
++++++++++++++++case+']':
++++++++++++++++++++if+(!quoted)
++++++++++++++++++++{
++++++++++++++++++++++++sb.AppendLine();
++++++++++++++++++++++++Enumerable.Range(0,+--indent).ForEach(item+=>+sb.Append(INDENT_STRING));
++++++++++++++++++++}
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++break;
++++++++++++++++case+'"':
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++bool+escaped+=+false;
++++++++++++++++++++var+index+=+i;
++++++++++++++++++++while+(index+>+0+&&+str[--index]+==+'\\')
++++++++++++++++++++++++escaped+=+!escaped;
++++++++++++++++++++if+(!escaped)
++++++++++++++++++++++++quoted+=+!quoted;
++++++++++++++++++++break;
++++++++++++++++case+',':
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++if+(!quoted)
++++++++++++++++++++{
++++++++++++++++++++++++sb.AppendLine();
++++++++++++++++++++++++Enumerable.Range(0,+indent).ForEach(item+=>+sb.Append(INDENT_STRING));
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+':':
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++if+(!quoted)
++++++++++++++++++++++++sb.Append("+");
++++++++++++++++++++break;
++++++++++++++++default:
++++++++++++++++++++sb.Append(ch);
++++++++++++++++++++break;
++++++++++++}
++++++++}
++++++++return+sb.ToString();
++++}
}

static+class+Extensions
{
++++public+static+void+ForEach<T>(this+IEnumerable<T>+ie,+Action<T>+action)
++++{
++++++++foreach+(var+i+in+ie)
++++++++{
++++++++++++action(i);
++++++++}
++++}
}|code-block|syntax|javascript|1994655|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I updated the old version, now it should support unquoted values such as integers and booleans.

I refactored the previous version and got the final version:
The code is shorter and cleaner. Only require one extension method. The most important: fixed some bugs.

<pre><code>class JsonHelper
{
 private const string INDENT_STRING = " ";
 public static string FormatJson(string str)
 {
 var indent = 0;
 var quoted = false;
 var sb = new StringBuilder();
 for (var i = 0; i &lt; str.Length; i++)
 {
 var ch = str[i];
 switch (ch)
 {
 case '{':
 case '[':
 sb.Append(ch);
 if (!quoted)
 {
 sb.AppendLine();
 Enumerable.Range(0, ++indent).ForEach(item =&gt; sb.Append(INDENT_STRING));
 }
 break;
 case '}':
 case ']':
 if (!quoted)
 {
 sb.AppendLine();
 Enumerable.Range(0, --indent).ForEach(item =&gt; sb.Append(INDENT_STRING));
 }
 sb.Append(ch);
 break;
 case '"':
 sb.Append(ch);
 bool escaped = false;
 var index = i;
 while (index &gt; 0 &amp;&amp; str[--index] == '\\')
 escaped = !escaped;
 if (!escaped)
 quoted = !quoted;
 break;
 case ',':
 sb.Append(ch);
 if (!quoted)
 {
 sb.AppendLine();
 Enumerable.Range(0, indent).ForEach(item =&gt; sb.Append(INDENT_STRING));
 }
 break;
 case ':':
 sb.Append(ch);
 if (!quoted)
 sb.Append(" ");
 break;
 default:
 sb.Append(ch);
 break;
 }
 }
 return sb.ToString();
 }
}

static class Extensions
{
 public static void ForEach&lt;T&gt;(this IEnumerable&lt;T&gt; ie, Action&lt;T&gt; action)
 {
 foreach (var i in ie)
 {
 action(i);
 }
 }
}
</code></pre>

blocks|key|1994751|text|您需要跳过PrettyPrint()中的\r和\n。输出看起来很滑稽，因为有一些crlf已经存在(或者说源代码已经格式化)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1994752|entityMap^0|5|D|K|2|N|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|O|8|@]|D|@]|E|$]]]|G|$]]

You need to skip <code>\r</code> and <code>\n</code> in <code>PrettyPrint()</code>. The output looks funny of there are some crlf's already present (or the source was already formatted).

blocks|key|1994814|text|这是我喜欢使用的公认答案的变体。注释部分的结果是我认为更具可读性的格式(您需要注释掉相邻的代码才能看到区别)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1994815|public+class+JsonHelper
{
++++private+const+int+INDENT_SIZE+=+4;

++++public+static+string+FormatJson(string+str)
++++{
++++++++str+=+(str+??+"").Replace("{}",+@"\{\}").Replace("[]",+@"\[\]");

++++++++var+inserts+=+new+List<int[]>();
++++++++bool+quoted+=+false,+escape+=+false;
++++++++int+depth+=+0/*-1*/;

++++++++for+(int+i+=+0,+N+=+str.Length;+i+<+N;+i%2B%2B)
++++++++{
++++++++++++var+chr+=+str[i];

++++++++++++if+(!escape+&&+!quoted)
++++++++++++++++switch+(chr)
++++++++++++++++{
++++++++++++++++++++case+'{':
++++++++++++++++++++case+'[':
++++++++++++++++++++++++inserts.Add(new[]+{+i,+%2B1,+0,+INDENT_SIZE+*+%2B%2Bdepth+});
++++++++++++++++++++++++//int+n+=+(i+==+0+%7C%7C+"{[,".Contains(str[i+-+1]))+?+0+:+-1;
++++++++++++++++++++++++//inserts.Add(new[]+{+i,+n,+INDENT_SIZE+*+%2B%2Bdepth+*+-n,+INDENT_SIZE+-+1+});
++++++++++++++++++++++++break;
++++++++++++++++++++case+',':
++++++++++++++++++++++++inserts.Add(new[]+{+i,+%2B1,+0,+INDENT_SIZE+*+depth+});
++++++++++++++++++++++++//inserts.Add(new[]+{+i,+-1,+INDENT_SIZE+*+depth,+INDENT_SIZE+-+1+});
++++++++++++++++++++++++break;
++++++++++++++++++++case+'}':
++++++++++++++++++++case+']':
++++++++++++++++++++++++inserts.Add(new[]+{+i,+-1,+INDENT_SIZE+*+--depth,+0+});
++++++++++++++++++++++++//inserts.Add(new[]+{+i,+-1,+INDENT_SIZE+*+depth--,+0+});
++++++++++++++++++++++++break;
++++++++++++++++++++case+':':
++++++++++++++++++++++++inserts.Add(new[]+{+i,+0,+1,+1+});
++++++++++++++++++++++++break;
++++++++++++++++}

++++++++++++quoted+=+(chr+==+'"')+?+!quoted+:+quoted;
++++++++++++escape+=+(chr+==+'\\')+?+!escape+:+false;
++++++++}

++++++++if+(inserts.Count+>+0)
++++++++{
++++++++++++var+sb+=+new+System.Text.StringBuilder(str.Length+*+2);

++++++++++++int+lastIndex+=+0;
++++++++++++foreach+(var+insert+in+inserts)
++++++++++++{
++++++++++++++++int+index+=+insert[0],+before+=+insert[2],+after+=+insert[3];
++++++++++++++++bool+nlBefore+=+(insert[1]+==+-1),+nlAfter+=+(insert[1]+==+%2B1);

++++++++++++++++sb.Append(str.Substring(lastIndex,+index+-+lastIndex));

++++++++++++++++if+(nlBefore)+sb.AppendLine();
++++++++++++++++if+(before+>+0)+sb.Append(new+String('+',+before));

++++++++++++++++sb.Append(str[index]);

++++++++++++++++if+(nlAfter)+sb.AppendLine();
++++++++++++++++if+(after+>+0)+sb.Append(new+String('+',+after));

++++++++++++++++lastIndex+=+index+%2B+1;
++++++++++++}

++++++++++++str+=+sb.ToString();
++++++++}

++++++++return+str.Replace(@"\{\}",+"{}").Replace(@"\[\]",+"[]");
++++}
}|code-block|syntax|javascript|1994816|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is a variant of the accepted answer that I like to use. The commented parts result in what I consider a more readable format (you would need to comment out the adjacent code to see the difference):

<pre><code>public class JsonHelper
{
 private const int INDENT_SIZE = 4;

 public static string FormatJson(string str)
 {
 str = (str ?? "").Replace("{}", @"\{\}").Replace("[]", @"\[\]");

 var inserts = new List&lt;int[]&gt;();
 bool quoted = false, escape = false;
 int depth = 0/*-1*/;

 for (int i = 0, N = str.Length; i &lt; N; i++)
 {
 var chr = str[i];

 if (!escape &amp;&amp; !quoted)
 switch (chr)
 {
 case '{':
 case '[':
 inserts.Add(new[] { i, +1, 0, INDENT_SIZE * ++depth });
 //int n = (i == 0 || "{[,".Contains(str[i - 1])) ? 0 : -1;
 //inserts.Add(new[] { i, n, INDENT_SIZE * ++depth * -n, INDENT_SIZE - 1 });
 break;
 case ',':
 inserts.Add(new[] { i, +1, 0, INDENT_SIZE * depth });
 //inserts.Add(new[] { i, -1, INDENT_SIZE * depth, INDENT_SIZE - 1 });
 break;
 case '}':
 case ']':
 inserts.Add(new[] { i, -1, INDENT_SIZE * --depth, 0 });
 //inserts.Add(new[] { i, -1, INDENT_SIZE * depth--, 0 });
 break;
 case ':':
 inserts.Add(new[] { i, 0, 1, 1 });
 break;
 }

 quoted = (chr == '"') ? !quoted : quoted;
 escape = (chr == '\\') ? !escape : false;
 }

 if (inserts.Count &gt; 0)
 {
 var sb = new System.Text.StringBuilder(str.Length * 2);

 int lastIndex = 0;
 foreach (var insert in inserts)
 {
 int index = insert[0], before = insert[2], after = insert[3];
 bool nlBefore = (insert[1] == -1), nlAfter = (insert[1] == +1);

 sb.Append(str.Substring(lastIndex, index - lastIndex));

 if (nlBefore) sb.AppendLine();
 if (before &gt; 0) sb.Append(new String(' ', before));

 sb.Append(str[index]);

 if (nlAfter) sb.AppendLine();
 if (after &gt; 0) sb.Append(new String(' ', after));

 lastIndex = index + 1;
 }

 str = sb.ToString();
 }

 return str.Replace(@"\{\}", "{}").Replace(@"\[\]", "[]");
 }
}
</code></pre>

blocks|key|1781113|text|json.net库的较短示例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781114|using+Newtonsoft.Json;

private+static+string+format_json(string+json)
{
++++dynamic+parsedJson+=+JsonConvert.DeserializeObject(json);
++++return+JsonConvert.SerializeObject(parsedJson,+Formatting.Indented);
}|code-block|syntax|javascript|1781115|PS:您可以使用标签将格式化的json文本包装起来，以便像在html页面上一样打印。|1781116|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Shorter sample for json.net library.

<pre><code>using Newtonsoft.Json;

private static string format_json(string json)
{
 dynamic parsedJson = JsonConvert.DeserializeObject(json);
 return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
}
</code></pre>

PS: You can wrap the formatted json text with tag to print as it is on the html page.

blocks|key|1781174|text|这是一个JSON美化器的精简版本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781175|private+const+string+INDENT_STRING+=+"++++";

static+string+FormatJson(string+json)+{

++++int+indentation+=+0;
++++int+quoteCount+=+0;
++++var+result+=+
++++++++from+ch+in+json
++++++++let+quotes+=+ch+==+'"'+?+quoteCount%2B%2B+:+quoteCount
++++++++let+lineBreak+=+ch+==+','+&&+quotes+%25+2+==+0+?+ch+%2B+Environment.NewLine+%2B++String.Concat(Enumerable.Repeat(INDENT_STRING,+indentation))+:+null
++++++++let+openChar+=+ch+==+'{'+%7C%7C+ch+==+'['+?+ch+%2B+Environment.NewLine+%2B+String.Concat(Enumerable.Repeat(INDENT_STRING,+%2B%2Bindentation))+:+ch.ToString()
++++++++let+closeChar+=+ch+==+'}'+%7C%7C+ch+==+']'+?+Environment.NewLine+%2B+String.Concat(Enumerable.Repeat(INDENT_STRING,+--indentation))+%2B+ch+:+ch.ToString()
++++++++select+lineBreak+==+null++++
++++++++++++++++++++?+openChar.Length+>+1+
++++++++++++++++++++++++?+openChar+
++++++++++++++++++++++++:+closeChar
++++++++++++++++++++:+lineBreak;

++++return+String.Concat(result);
}|code-block|syntax|javascript|1781176|输出：|1781177|+{
++++"status":"OK",
+++++"results":[
+++++++++{
++++++++++++"types":[
+++++++++++++++++"locality",
+++++++++++++++++"political"
++++++++++++],
+++++++++++++"formatted_address":"New+York,+NY,+USA",
+++++++++++++"address_components":[
+++++++++++++++++{
++++++++++++++++++++"long_name":"New+York",
+++++++++++++++++++++"short_name":"New+York",
+++++++++++++++++++++"types":[
+++++++++++++++++++++++++"locality",
+++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
+++++++++++++++++{
++++++++++++++++++++"long_name":"New+York",
+++++++++++++++++++++"short_name":"New+York",
+++++++++++++++++++++"types":[
+++++++++++++++++++++++++"administrative_area_level_2",
+++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
+++++++++++++++++{
++++++++++++++++++++"long_name":"New+York",
+++++++++++++++++++++"short_name":"NY",
+++++++++++++++++++++"types":[
+++++++++++++++++++++++++"administrative_area_level_1",
+++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++},
+++++++++++++++++{
++++++++++++++++++++"long_name":"United+States",
+++++++++++++++++++++"short_name":"US",
+++++++++++++++++++++"types":[
+++++++++++++++++++++++++"country",
+++++++++++++++++++++++++"political"
++++++++++++++++++++]
++++++++++++++++}
++++++++++++],
+++++++++++++"geometry":{
++++++++++++++++"location":{
++++++++++++++++++++"lat":40.7143528,
+++++++++++++++++++++"lng":-74.0059731
++++++++++++++++},
+++++++++++++++++"location_type":"APPROXIMATE",
+++++++++++++++++"viewport":{
++++++++++++++++++++"southwest":{
++++++++++++++++++++++++"lat":40.5788964,
+++++++++++++++++++++++++"lng":-74.2620919
++++++++++++++++++++},
+++++++++++++++++++++"northeast":{
++++++++++++++++++++++++"lat":40.8495342,
+++++++++++++++++++++++++"lng":-73.7498543
++++++++++++++++++++}
++++++++++++++++},
+++++++++++++++++"bounds":{
++++++++++++++++++++"southwest":{
++++++++++++++++++++++++"lat":40.4773990,
+++++++++++++++++++++++++"lng":-74.2590900
++++++++++++++++++++},
+++++++++++++++++++++"northeast":{
++++++++++++++++++++++++"lat":40.9175770,
+++++++++++++++++++++++++"lng":-73.7002720
++++++++++++++++++++}
++++++++++++++++}
++++++++++++}
++++++++}
++++]
}|1781178|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's a compact version of a JSON beautifier.

<pre><code>private const string INDENT_STRING = " ";

static string FormatJson(string json) {

 int indentation = 0;
 int quoteCount = 0;
 var result = 
 from ch in json
 let quotes = ch == '"' ? quoteCount++ : quoteCount
 let lineBreak = ch == ',' &amp;&amp; quotes % 2 == 0 ? ch + Environment.NewLine + String.Concat(Enumerable.Repeat(INDENT_STRING, indentation)) : null
 let openChar = ch == '{' || ch == '[' ? ch + Environment.NewLine + String.Concat(Enumerable.Repeat(INDENT_STRING, ++indentation)) : ch.ToString()
 let closeChar = ch == '}' || ch == ']' ? Environment.NewLine + String.Concat(Enumerable.Repeat(INDENT_STRING, --indentation)) + ch : ch.ToString()
 select lineBreak == null 
 ? openChar.Length &gt; 1 
 ? openChar 
 : closeChar
 : lineBreak;

 return String.Concat(result);
}
</code></pre>

Outputs:

<pre><code> {
 "status":"OK",
 "results":[
 {
 "types":[
 "locality",
 "political"
 ],
 "formatted_address":"New York, NY, USA",
 "address_components":[
 {
 "long_name":"New York",
 "short_name":"New York",
 "types":[
 "locality",
 "political"
 ]
 },
 {
 "long_name":"New York",
 "short_name":"New York",
 "types":[
 "administrative_area_level_2",
 "political"
 ]
 },
 {
 "long_name":"New York",
 "short_name":"NY",
 "types":[
 "administrative_area_level_1",
 "political"
 ]
 },
 {
 "long_name":"United States",
 "short_name":"US",
 "types":[
 "country",
 "political"
 ]
 }
 ],
 "geometry":{
 "location":{
 "lat":40.7143528,
 "lng":-74.0059731
 },
 "location_type":"APPROXIMATE",
 "viewport":{
 "southwest":{
 "lat":40.5788964,
 "lng":-74.2620919
 },
 "northeast":{
 "lat":40.8495342,
 "lng":-73.7498543
 }
 },
 "bounds":{
 "southwest":{
 "lat":40.4773990,
 "lng":-74.2590900
 },
 "northeast":{
 "lat":40.9175770,
 "lng":-73.7002720
 }
 }
 }
 }
 ]
}
</code></pre>

blocks|key|1994955|text|示例|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1994956|++++public+static+string+JsonFormatter(string+json)
++++{
++++++++StringBuilder+builder+=+new+StringBuilder();

++++++++bool+quotes+=+false;

++++++++bool+ignore+=+false;

++++++++int+offset+=+0;

++++++++int+position+=+0;

++++++++if+(string.IsNullOrEmpty(json))
++++++++{
++++++++++++return+string.Empty;
++++++++}

++++++++json+=+json.Replace(Environment.NewLine,+"").Replace("\t",+"");

++++++++foreach+(char+character+in+json)
++++++++{
++++++++++++switch+(character)
++++++++++++{
++++++++++++++++case+'"':
++++++++++++++++++++if+(!ignore)
++++++++++++++++++++{
++++++++++++++++++++++++quotes+=+!quotes;
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++++++case+'\'':
++++++++++++++++++++if+(quotes)
++++++++++++++++++++{
++++++++++++++++++++++++ignore+=+!ignore;
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++}

++++++++++++if+(quotes)
++++++++++++{
++++++++++++++++builder.Append(character);
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++switch+(character)
++++++++++++++++{
++++++++++++++++++++case+'{':
++++++++++++++++++++case+'[':
++++++++++++++++++++++++builder.Append(character);
++++++++++++++++++++++++builder.Append(Environment.NewLine);
++++++++++++++++++++++++builder.Append(new+string('+',+%2B%2Boffset+*+4));
++++++++++++++++++++++++break;
++++++++++++++++++++case+'}':
++++++++++++++++++++case+']':
++++++++++++++++++++++++builder.Append(Environment.NewLine);
++++++++++++++++++++++++builder.Append(new+string('+',+--offset+*+4));
++++++++++++++++++++++++builder.Append(character);
++++++++++++++++++++++++break;
++++++++++++++++++++case+',':
++++++++++++++++++++++++builder.Append(character);
++++++++++++++++++++++++builder.Append(Environment.NewLine);
++++++++++++++++++++++++builder.Append(new+string('+',+offset+*+4));
++++++++++++++++++++++++break;
++++++++++++++++++++case+':':
++++++++++++++++++++++++builder.Append(character);
++++++++++++++++++++++++builder.Append('+');
++++++++++++++++++++++++break;
++++++++++++++++++++default:
++++++++++++++++++++++++if+(character+!=+'+')
++++++++++++++++++++++++{
++++++++++++++++++++++++++++builder.Append(character);
++++++++++++++++++++++++}
++++++++++++++++++++++++break;
++++++++++++++++}

++++++++++++++++position%2B%2B;
++++++++++++}
++++++++}

++++++++return+builder.ToString().Trim();
++++}|code-block|syntax|javascript|1994957|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Example

<pre><code> public static string JsonFormatter(string json)
 {
 StringBuilder builder = new StringBuilder();

 bool quotes = false;

 bool ignore = false;

 int offset = 0;

 int position = 0;

 if (string.IsNullOrEmpty(json))
 {
 return string.Empty;
 }

 json = json.Replace(Environment.NewLine, "").Replace("\t", "");

 foreach (char character in json)
 {
 switch (character)
 {
 case '"':
 if (!ignore)
 {
 quotes = !quotes;
 }
 break;
 case '\'':
 if (quotes)
 {
 ignore = !ignore;
 }
 break;
 }

 if (quotes)
 {
 builder.Append(character);
 }
 else
 {
 switch (character)
 {
 case '{':
 case '[':
 builder.Append(character);
 builder.Append(Environment.NewLine);
 builder.Append(new string(' ', ++offset * 4));
 break;
 case '}':
 case ']':
 builder.Append(Environment.NewLine);
 builder.Append(new string(' ', --offset * 4));
 builder.Append(character);
 break;
 case ',':
 builder.Append(character);
 builder.Append(Environment.NewLine);
 builder.Append(new string(' ', offset * 4));
 break;
 case ':':
 builder.Append(character);
 builder.Append(' ');
 break;
 default:
 if (character != ' ')
 {
 builder.Append(character);
 }
 break;
 }

 position++;
 }
 }

 return builder.ToString().Trim();
 }
</code></pre>

blocks|key|1781225|text|正如benjymous所指出的，您可以将Newtonsoft.Json与临时对象一起使用，并对其进行反序列化/序列化。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1781226|var+obj+=+JsonConvert.DeserializeObject(jsonString);+
var+formatted+=+JsonConvert.SerializeObject(obj,+Formatting.Indented);|code-block|syntax|javascript|1781227|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/1073843/benjymous|1|http://www.newtonsoft.com/json^0|2|9|0|K|F|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

As <a href="https://stackoverflow.com/users/1073843/benjymous">benjymous</a> pointed out, you can use <a href="http://www.newtonsoft.com/json" rel="nofollow noreferrer">Newtonsoft.Json</a> with a temporary object and deserialize/serialize.

<pre><code>var obj = JsonConvert.DeserializeObject(jsonString); 
var formatted = JsonConvert.SerializeObject(obj, Formatting.Indented);
</code></pre>

blocks|key|1781270|text|这将把每个项目放在一个新的行上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781271|VB.NET|1781272|mytext+=+responseFromServer.Replace("{",+vbNewLine+%2B+"{")|code-block|syntax|javascript|1781273|C#|1781274|mytext+=+responseFromServer.Replace("{",+Environment.NewLine+%2B+"{");|1781275|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

This will put each item on a new line
VB.NET
<pre><code>mytext = responseFromServer.Replace(&quot;{&quot;, vbNewLine + &quot;{&quot;)
</code></pre>
C#
<pre><code>mytext = responseFromServer.Replace(&quot;{&quot;, Environment.NewLine + &quot;{&quot;);
</code></pre>

blocks|key|1995183|text|编写自己的函数的主要原因是JSON框架通常会将字符串解析为.net类型，然后再将其转换回字符串，这可能会导致丢失原始字符串。例如，0.0002变成了2E-4|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1995184|我没有发布我的函数(它与这里的其他函数非常相似)，但这里是测试用例|1995185|using+System.IO;

using+Newtonsoft.Json;

using+NUnit.Framework;

namespace+json_formatter.tests
{
++++[TestFixture]
++++internal+class+FormatterTests
++++{
++++++++[Test]
++++++++public+void+CompareWithNewtonsofJson()
++++++++{
++++++++++++string+file+=+Path.Combine(TestContext.CurrentContext.TestDirectory,+"json",+"minified.txt");

++++++++++++string+json+=+File.ReadAllText(file);

++++++++++++string+newton+=+JsonPrettify(json);
++++++++++++//+Double+space+are+indent+symbols+which+newtonsoft+framework+uses
++++++++++++string+my+=+new+Formatter("++").Format(json);

++++++++++++Assert.AreEqual(newton,+my);
++++++++}

++++++++[Test]
++++++++public+void+EmptyArrayMustNotBeFormatted()
++++++++{
++++++++++++var+input+=+"{\"na{me\":+[]}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\":+[]\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+EmptyObjectMustNotBeFormatted()
++++++++{
++++++++++++var+input+=+"{\"na{me\":+{}}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\":+{}\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustAddLinebreakAfterBraces()
++++++++{
++++++++++++var+input+=+"{\"name\":+\"value\"}";
++++++++++++var+expected+=+"{\r\n\t\"name\":+\"value\"\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustFormatNestedObject()
++++++++{
++++++++++++var+input+=+"{\"na{me\":\"val}ue\",+\"name1\":+{\"name2\":\"value\"}}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\":+\"val}ue\",\r\n\t\"name1\":+{\r\n\t\t\"name2\":+\"value\"\r\n\t}\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustHandleArray()
++++++++{
++++++++++++var+input+=+"{\"name\":+\"value\",+\"name2\":[\"a\",+\"b\",+\"c\"]}";
++++++++++++var+expected+=+"{\r\n\t\"name\":+\"value\",\r\n\t\"name2\":+[\r\n\t\t\"a\",\r\n\t\t\"b\",\r\n\t\t\"c\"\r\n\t]\r\n}";
++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustHandleArrayOfObject()
++++++++{
++++++++++++var+input+=+"{\"name\":+\"value\",+\"name2\":[{\"na{me\":\"val}ue\"},+{\"nam\\\"e2\":\"val\\\\\\\"ue\"}]}";
++++++++++++var+expected+=
++++++++++++++++"{\r\n\t\"name\":+\"value\",\r\n\t\"name2\":+[\r\n\t\t{\r\n\t\t\t\"na{me\":+\"val}ue\"\r\n\t\t},\r\n\t\t{\r\n\t\t\t\"nam\\\"e2\":+\"val\\\\\\\"ue\"\r\n\t\t}\r\n\t]\r\n}";
++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustHandleEscapedString()
++++++++{
++++++++++++var+input+=+"{\"na{me\":\"val}ue\",+\"name1\":+{\"nam\\\"e2\":\"val\\\\\\\"ue\"}}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\":+\"val}ue\",\r\n\t\"name1\":+{\r\n\t\t\"nam\\\"e2\":+\"val\\\\\\\"ue\"\r\n\t}\r\n}";
++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+MustIgnoreEscapedQuotesInsideString()
++++++++{
++++++++++++var+input+=+"{\"na{me\\\"\":+\"val}ue\"}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\\\"\":+\"val}ue\"\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[TestCase("+")]
++++++++[TestCase("\"")]
++++++++[TestCase("{")]
++++++++[TestCase("}")]
++++++++[TestCase("[")]
++++++++[TestCase("]")]
++++++++[TestCase(":")]
++++++++[TestCase(",")]
++++++++public+void+MustIgnoreSpecialSymbolsInsideString(string+symbol)
++++++++{
++++++++++++string+input+=+"{\"na"+%2B+symbol+%2B+"me\":+\"val"+%2B+symbol+%2B+"ue\"}";
++++++++++++string+expected+=+"{\r\n\t\"na"+%2B+symbol+%2B+"me\":+\"val"+%2B+symbol+%2B+"ue\"\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++[Test]
++++++++public+void+StringEndsWithEscapedBackslash()
++++++++{
++++++++++++var+input+=+"{\"na{me\\\\\":+\"val}ue\"}";
++++++++++++var+expected+=+"{\r\n\t\"na{me\\\\\":+\"val}ue\"\r\n}";

++++++++++++Assert.AreEqual(expected,+new+Formatter().Format(input));
++++++++}

++++++++private+static+string+PrettifyUsingNewtosoft(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();
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1995186|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The main reason of writing your own function is that JSON frameworks usually perform parsing of strings into .net types and converting them back to string, which may result in losing original strings. For example 0.0002 becomes 2E-4

I do not post my function (it's pretty same as other here) but here are the test cases

<pre><code>using System.IO;

using Newtonsoft.Json;

using NUnit.Framework;

namespace json_formatter.tests
{
 [TestFixture]
 internal class FormatterTests
 {
 [Test]
 public void CompareWithNewtonsofJson()
 {
 string file = Path.Combine(TestContext.CurrentContext.TestDirectory, "json", "minified.txt");

 string json = File.ReadAllText(file);

 string newton = JsonPrettify(json);
 // Double space are indent symbols which newtonsoft framework uses
 string my = new Formatter(" ").Format(json);

 Assert.AreEqual(newton, my);
 }

 [Test]
 public void EmptyArrayMustNotBeFormatted()
 {
 var input = "{\"na{me\": []}";
 var expected = "{\r\n\t\"na{me\": []\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void EmptyObjectMustNotBeFormatted()
 {
 var input = "{\"na{me\": {}}";
 var expected = "{\r\n\t\"na{me\": {}\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustAddLinebreakAfterBraces()
 {
 var input = "{\"name\": \"value\"}";
 var expected = "{\r\n\t\"name\": \"value\"\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustFormatNestedObject()
 {
 var input = "{\"na{me\":\"val}ue\", \"name1\": {\"name2\":\"value\"}}";
 var expected = "{\r\n\t\"na{me\": \"val}ue\",\r\n\t\"name1\": {\r\n\t\t\"name2\": \"value\"\r\n\t}\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustHandleArray()
 {
 var input = "{\"name\": \"value\", \"name2\":[\"a\", \"b\", \"c\"]}";
 var expected = "{\r\n\t\"name\": \"value\",\r\n\t\"name2\": [\r\n\t\t\"a\",\r\n\t\t\"b\",\r\n\t\t\"c\"\r\n\t]\r\n}";
 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustHandleArrayOfObject()
 {
 var input = "{\"name\": \"value\", \"name2\":[{\"na{me\":\"val}ue\"}, {\"nam\\\"e2\":\"val\\\\\\\"ue\"}]}";
 var expected =
 "{\r\n\t\"name\": \"value\",\r\n\t\"name2\": [\r\n\t\t{\r\n\t\t\t\"na{me\": \"val}ue\"\r\n\t\t},\r\n\t\t{\r\n\t\t\t\"nam\\\"e2\": \"val\\\\\\\"ue\"\r\n\t\t}\r\n\t]\r\n}";
 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustHandleEscapedString()
 {
 var input = "{\"na{me\":\"val}ue\", \"name1\": {\"nam\\\"e2\":\"val\\\\\\\"ue\"}}";
 var expected = "{\r\n\t\"na{me\": \"val}ue\",\r\n\t\"name1\": {\r\n\t\t\"nam\\\"e2\": \"val\\\\\\\"ue\"\r\n\t}\r\n}";
 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void MustIgnoreEscapedQuotesInsideString()
 {
 var input = "{\"na{me\\\"\": \"val}ue\"}";
 var expected = "{\r\n\t\"na{me\\\"\": \"val}ue\"\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [TestCase(" ")]
 [TestCase("\"")]
 [TestCase("{")]
 [TestCase("}")]
 [TestCase("[")]
 [TestCase("]")]
 [TestCase(":")]
 [TestCase(",")]
 public void MustIgnoreSpecialSymbolsInsideString(string symbol)
 {
 string input = "{\"na" + symbol + "me\": \"val" + symbol + "ue\"}";
 string expected = "{\r\n\t\"na" + symbol + "me\": \"val" + symbol + "ue\"\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 [Test]
 public void StringEndsWithEscapedBackslash()
 {
 var input = "{\"na{me\\\\\": \"val}ue\"}";
 var expected = "{\r\n\t\"na{me\\\\\": \"val}ue\"\r\n}";

 Assert.AreEqual(expected, new Formatter().Format(input));
 }

 private static string PrettifyUsingNewtosoft(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();
 }
 }
 }
}
</code></pre>

blocks|key|1995504|text|所有的功劳都归于弗兰克·查纳比蒂斯。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1995505|using+Newtonsoft.Json;
using+Newtonsoft.Json.Linq;

++++...
++++try
++++{
++++++++return+JToken.Parse(jsonString).ToString(Formatting.Indented);
++++}
++++catch
++++{
++++++++return+jsonString;|code-block|syntax|javascript|1995506|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

All credits are to Frank Tzanabetis. However this is the shortest direct example, that also survives in case of empty string or broken original JSON string:
<pre><code>using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

 ...
 try
 {
 return JToken.Parse(jsonString).ToString(Formatting.Indented);
 }
 catch
 {
 return jsonString;
</code></pre>

blocks|key|1781763|text|这里已经有一堆使用Newtonsoft.JSON的很好的答案，但这里还有一个结合使用JObject.Parse和ToString()的答案，因为还没有提到：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1781764|var+jObj+=+Newtonsoft.Json.Linq.JObject.Parse(json);
var+formatted+=+jObj.ToString(Newtonsoft.Json.Formatting.Indented);|code-block|syntax|javascript|1781765|entityMap|0|LINK|mutability|MUTABLE|url|https://www.newtonsoft.com/json^0|16|D|1K|A|9|F|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

There are already a bunch of great answers here that use <a href="https://www.newtonsoft.com/json" rel="noreferrer">Newtonsoft.JSON</a>, but here's one more that uses <code>JObject.Parse</code> in combination with <code>ToString()</code>, since that hasn't been mentioned yet:

<pre><code>var jObj = Newtonsoft.Json.Linq.JObject.Parse(json);
var formatted = jObj.ToString(Newtonsoft.Json.Formatting.Indented);
</code></pre>

blocks|key|1995646|text|这个版本生成的JSON更紧凑，在我看来更具可读性，因为您可以同时看到更多内容。它通过格式化最深层的内联或类似于紧凑的数组结构来实现这一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1995647|代码没有依赖项，但更复杂。|1995648|{+
++"name":"Seller",+
++"schema":"dbo",
++"CaptionFields":["Caption","Id"],
++"fields":[+
++++{"name":"Id","type":"Integer","length":"10","autoincrement":true,"nullable":false},+
++++{"name":"FirstName","type":"Text","length":"50","autoincrement":false,"nullable":false},+
++++{"name":"LastName","type":"Text","length":"50","autoincrement":false,"nullable":false},+
++++{"name":"LotName","type":"Text","length":"50","autoincrement":false,"nullable":true},+
++++{"name":"LotDetailsURL","type":"Text","length":"255","autoincrement":false,"nullable":true}+
++]
}|code-block|syntax|javascript|1995649|代码如下|1995650|private+class+IndentJsonInfo
{
++++public+IndentJsonInfo(string+prefix,+char+openingTag)
++++{
++++++++Prefix+=+prefix;
++++++++OpeningTag+=+openingTag;
++++++++Data+=+new+List<string>();
++++}
++++public+string+Prefix;
++++public+char+OpeningTag;
++++public+bool+isOutputStarted;
++++public+List<string>+Data;
}
internal+static+string+IndentJSON(string+jsonString,+int+startIndent+=+0,+int+indentSpaces+=+2)
{
++++if+(String.IsNullOrEmpty(jsonString))
++++++++return+jsonString;

++++try
++++{
++++++++var+jsonCache+=+new+List<IndentJsonInfo>();
++++++++IndentJsonInfo+currentItem+=+null;

++++++++var+sbResult+=+new+StringBuilder();

++++++++int+curIndex+=+0;
++++++++bool+inQuotedText+=+false;

++++++++var+chunk+=+new+StringBuilder();

++++++++var+saveChunk+=+new+Action(()+=>
++++++++{
++++++++++++if+(chunk.Length+==+0)
++++++++++++++++return;
++++++++++++if+(currentItem+==+null)
++++++++++++++++throw+new+Exception("Invalid+JSON:+No+container.");
++++++++++++currentItem.Data.Add(chunk.ToString());
++++++++++++chunk+=+new+StringBuilder();
++++++++});

++++++++while+(curIndex+<+jsonString.Length)
++++++++{
++++++++++++var+cChar+=+jsonString[curIndex];
++++++++++++if+(inQuotedText)
++++++++++++{
++++++++++++++++//+Get+the+rest+of+quoted+text.
++++++++++++++++chunk.Append(cChar);

++++++++++++++++//+Determine+if+the+quote+is+escaped.
++++++++++++++++bool+isEscaped+=+false;
++++++++++++++++var+excapeIndex+=+curIndex;
++++++++++++++++while+(excapeIndex+>+0+&&+jsonString[--excapeIndex]+==+'\\')+isEscaped+=+!isEscaped;

++++++++++++++++if+(cChar+==+'"'+&&+!isEscaped)
++++++++++++++++++++inQuotedText+=+false;
++++++++++++}
++++++++++++else+if+(Char.IsWhiteSpace(cChar))
++++++++++++{
++++++++++++++++//+Ignore+all+whitespace+outside+of+quotes.
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++//+Outside+of+Quotes.
++++++++++++++++switch+(cChar)
++++++++++++++++{
++++++++++++++++++++case+'"':
++++++++++++++++++++++++chunk.Append(cChar);
++++++++++++++++++++++++inQuotedText+=+true;
++++++++++++++++++++++++break;
++++++++++++++++++++case+',':
++++++++++++++++++++++++chunk.Append(cChar);
++++++++++++++++++++++++saveChunk();
++++++++++++++++++++++++break;
++++++++++++++++++++case+'{':
++++++++++++++++++++case+'[':
++++++++++++++++++++++++currentItem+=+new+IndentJsonInfo(chunk.ToString(),+cChar);
++++++++++++++++++++++++jsonCache.Add(currentItem);
++++++++++++++++++++++++chunk+=+new+StringBuilder();
++++++++++++++++++++++++break;
++++++++++++++++++++case+'}':
++++++++++++++++++++case+']':
++++++++++++++++++++++++saveChunk();
++++++++++++++++++++++++for+(int+i+=+0;+i+<+jsonCache.Count;+i%2B%2B)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++var+item+=+jsonCache[i];
++++++++++++++++++++++++++++var+isLast+=+i+==+jsonCache.Count+-+1;
++++++++++++++++++++++++++++if+(!isLast)
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++if+(!item.isOutputStarted)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++sbResult.AppendLine(
++++++++++++++++++++++++++++++++++++++++"".PadLeft((startIndent+%2B+i)+*+indentSpaces)+%2B
++++++++++++++++++++++++++++++++++++++++item.Prefix+%2B+item.OpeningTag);
++++++++++++++++++++++++++++++++++++item.isOutputStarted+=+true;
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++var+newIndentString+=+"".PadLeft((startIndent+%2B+i+%2B+1)+*+indentSpaces);
++++++++++++++++++++++++++++++++foreach+(var+listItem+in+item.Data)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++sbResult.AppendLine(newIndentString+%2B+listItem);
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++item.Data+=+new+List<string>();
++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++else+//+If+Last
++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++if+(!(
++++++++++++++++++++++++++++++++++++(item.OpeningTag+==+'{'+&&+cChar+==+'}')+%7C%7C
++++++++++++++++++++++++++++++++++++(item.OpeningTag+==+'['+&&+cChar+==+']')
+++++++++++++++++++++++++++++++++++))
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++throw+new+Exception("Invalid+JSON:+Container+Mismatch,+Open+'"+%2B+item.OpeningTag+%2B+"',+Close+'"+%2B+cChar+%2B+"'.");
++++++++++++++++++++++++++++++++}

++++++++++++++++++++++++++++++++string+closing+=+null;
++++++++++++++++++++++++++++++++if+(item.isOutputStarted)
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++var+newIndentString+=+"".PadLeft((startIndent+%2B+i+%2B+1)+*+indentSpaces);
++++++++++++++++++++++++++++++++++++foreach+(var+listItem+in+item.Data)
++++++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++++++sbResult.AppendLine(newIndentString+%2B+listItem);
++++++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++++++closing+=+cChar.ToString();
++++++++++++++++++++++++++++++++}
++++++++++++++++++++++++++++++++else
++++++++++++++++++++++++++++++++{
++++++++++++++++++++++++++++++++++++closing+=
++++++++++++++++++++++++++++++++++++++++item.Prefix+%2B+item.OpeningTag+%2B
++++++++++++++++++++++++++++++++++++++++String.Join("",+currentItem.Data.ToArray())+%2B
++++++++++++++++++++++++++++++++++++++++cChar;
++++++++++++++++++++++++++++++++}

++++++++++++++++++++++++++++++++jsonCache.RemoveAt(i);
++++++++++++++++++++++++++++++++currentItem+=+(jsonCache.Count+>+0)+?+jsonCache[jsonCache.Count+-+1]+:+null;
++++++++++++++++++++++++++++++++chunk.Append(closing);
++++++++++++++++++++++++++++}
++++++++++++++++++++++++}
++++++++++++++++++++++++break;
++++++++++++++++++++default:
++++++++++++++++++++++++chunk.Append(cChar);
++++++++++++++++++++++++break;
++++++++++++++++}
++++++++++++}
++++++++++++curIndex%2B%2B;
++++++++}

++++++++if+(inQuotedText)
++++++++++++throw+new+Exception("Invalid+JSON:+Incomplete+Quote");
++++++++else+if+(jsonCache.Count+!=+0)
++++++++++++throw+new+Exception("Invalid+JSON:+Incomplete+Structure");
++++++++else
++++++++{
++++++++++++if+(chunk.Length+>+0)
++++++++++++++++sbResult.AppendLine("".PadLeft(startIndent+*+indentSpaces)+%2B+chunk);
++++++++++++var+result+=+sbResult.ToString();
++++++++++++return+result;
++++++++}
++++}
++++catch+(Exception+ex)
++++{
++++++++throw;++//+Comment+out+to+return+unformatted+text+if+the+format+failed.
++++++++//+Invalid+JSON,+skip+the+formatting.
++++++++return+jsonString;
++++}
}|1995651|该函数允许您指定缩进的起始点，因为我将此作为组装非常大的JSON格式备份文件的过程的一部分。|1995652|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This version produces JSON that is more compact and in my opinion more readable since you can see more at one time. It does this by formatting the deepest layer inline or like a compact array structure.

The code has no dependencies but is more complex.

<pre><code>{ 
 "name":"Seller", 
 "schema":"dbo",
 "CaptionFields":["Caption","Id"],
 "fields":[ 
 {"name":"Id","type":"Integer","length":"10","autoincrement":true,"nullable":false}, 
 {"name":"FirstName","type":"Text","length":"50","autoincrement":false,"nullable":false}, 
 {"name":"LastName","type":"Text","length":"50","autoincrement":false,"nullable":false}, 
 {"name":"LotName","type":"Text","length":"50","autoincrement":false,"nullable":true}, 
 {"name":"LotDetailsURL","type":"Text","length":"255","autoincrement":false,"nullable":true} 
 ]
}
</code></pre>

The code follows

<pre><code>private class IndentJsonInfo
{
 public IndentJsonInfo(string prefix, char openingTag)
 {
 Prefix = prefix;
 OpeningTag = openingTag;
 Data = new List&lt;string&gt;();
 }
 public string Prefix;
 public char OpeningTag;
 public bool isOutputStarted;
 public List&lt;string&gt; Data;
}
internal static string IndentJSON(string jsonString, int startIndent = 0, int indentSpaces = 2)
{
 if (String.IsNullOrEmpty(jsonString))
 return jsonString;

 try
 {
 var jsonCache = new List&lt;IndentJsonInfo&gt;();
 IndentJsonInfo currentItem = null;

 var sbResult = new StringBuilder();

 int curIndex = 0;
 bool inQuotedText = false;

 var chunk = new StringBuilder();

 var saveChunk = new Action(() =&gt;
 {
 if (chunk.Length == 0)
 return;
 if (currentItem == null)
 throw new Exception("Invalid JSON: No container.");
 currentItem.Data.Add(chunk.ToString());
 chunk = new StringBuilder();
 });

 while (curIndex &lt; jsonString.Length)
 {
 var cChar = jsonString[curIndex];
 if (inQuotedText)
 {
 // Get the rest of quoted text.
 chunk.Append(cChar);

 // Determine if the quote is escaped.
 bool isEscaped = false;
 var excapeIndex = curIndex;
 while (excapeIndex &gt; 0 &amp;&amp; jsonString[--excapeIndex] == '\\') isEscaped = !isEscaped;

 if (cChar == '"' &amp;&amp; !isEscaped)
 inQuotedText = false;
 }
 else if (Char.IsWhiteSpace(cChar))
 {
 // Ignore all whitespace outside of quotes.
 }
 else
 {
 // Outside of Quotes.
 switch (cChar)
 {
 case '"':
 chunk.Append(cChar);
 inQuotedText = true;
 break;
 case ',':
 chunk.Append(cChar);
 saveChunk();
 break;
 case '{':
 case '[':
 currentItem = new IndentJsonInfo(chunk.ToString(), cChar);
 jsonCache.Add(currentItem);
 chunk = new StringBuilder();
 break;
 case '}':
 case ']':
 saveChunk();
 for (int i = 0; i &lt; jsonCache.Count; i++)
 {
 var item = jsonCache[i];
 var isLast = i == jsonCache.Count - 1;
 if (!isLast)
 {
 if (!item.isOutputStarted)
 {
 sbResult.AppendLine(
 "".PadLeft((startIndent + i) * indentSpaces) +
 item.Prefix + item.OpeningTag);
 item.isOutputStarted = true;
 }
 var newIndentString = "".PadLeft((startIndent + i + 1) * indentSpaces);
 foreach (var listItem in item.Data)
 {
 sbResult.AppendLine(newIndentString + listItem);
 }
 item.Data = new List&lt;string&gt;();
 }
 else // If Last
 {
 if (!(
 (item.OpeningTag == '{' &amp;&amp; cChar == '}') ||
 (item.OpeningTag == '[' &amp;&amp; cChar == ']')
 ))
 {
 throw new Exception("Invalid JSON: Container Mismatch, Open '" + item.OpeningTag + "', Close '" + cChar + "'.");
 }

 string closing = null;
 if (item.isOutputStarted)
 {
 var newIndentString = "".PadLeft((startIndent + i + 1) * indentSpaces);
 foreach (var listItem in item.Data)
 {
 sbResult.AppendLine(newIndentString + listItem);
 }
 closing = cChar.ToString();
 }
 else
 {
 closing =
 item.Prefix + item.OpeningTag +
 String.Join("", currentItem.Data.ToArray()) +
 cChar;
 }

 jsonCache.RemoveAt(i);
 currentItem = (jsonCache.Count &gt; 0) ? jsonCache[jsonCache.Count - 1] : null;
 chunk.Append(closing);
 }
 }
 break;
 default:
 chunk.Append(cChar);
 break;
 }
 }
 curIndex++;
 }

 if (inQuotedText)
 throw new Exception("Invalid JSON: Incomplete Quote");
 else if (jsonCache.Count != 0)
 throw new Exception("Invalid JSON: Incomplete Structure");
 else
 {
 if (chunk.Length &gt; 0)
 sbResult.AppendLine("".PadLeft(startIndent * indentSpaces) + chunk);
 var result = sbResult.ToString();
 return result;
 }
 }
 catch (Exception ex)
 {
 throw; // Comment out to return unformatted text if the format failed.
 // Invalid JSON, skip the formatting.
 return jsonString;
 }
}
</code></pre>

The function allows you to specify a starting point for the indentation because I use this as part of a process that assembles very large JSON formatted backup files.

blocks|key|1781874|text|这对我在.Net+Core3.1中使用System.Text.Json很有效|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1781875|+public+string+PrettyJson(string+unPrettyJson)
+{
+++++var+options+=+new+JsonSerializerOptions(){
+++++++++WriteIndented+=+true
+++++};

+++++var+jsonElement+=+JsonSerializer.Deserialize<JsonElement>(unPrettyJson);

+++++return+JsonSerializer.Serialize(jsonElement,+options);
+}|code-block|syntax|javascript|1781876|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This worked for me using System.Text.Json in .Net Core 3.1
<pre><code> public string PrettyJson(string unPrettyJson)
 {
 var options = new JsonSerializerOptions(){
 WriteIndented = true
 };

 var jsonElement = JsonSerializer.Deserialize&lt;JsonElement&gt;(unPrettyJson);

 return JsonSerializer.Serialize(jsonElement, options);
 }
</code></pre>

blocks|key|1995729|text|使用一个简单的方法扩展：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1995730|using+Newtonsoft.Json;

namespace+Example
{
++++public+static+class+StringExtensions
++++{
++++++++public+static+string+BeautifyJson(this+string+str)
++++++++{
++++++++++++var+obj+=+JsonConvert.DeserializeObject(str);
++++++++++++string+json+=+JsonConvert.SerializeObject(obj,+Formatting.Indented);
++++++++++++return+json;
++++++++}
++++}
}|code-block|syntax|javascript|1995731|并像这样使用它：|1995732|string+jsonFormatted+=+json.BeautifyJson();|1995733|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Using a simple Method Extension:
<pre><code>using Newtonsoft.Json;

namespace Example
{
 public static class StringExtensions
 {
 public static string BeautifyJson(this string str)
 {
 var obj = JsonConvert.DeserializeObject(str);
 string json = JsonConvert.SerializeObject(obj, Formatting.Indented);
 return json;
 }
 }
}
</code></pre>
and using it like:
<pre><code>string jsonFormatted = json.BeautifyJson();
</code></pre>

Looking for a function that will take a <code>string</code> of Json as input and format it with line breaks and indentations. Validation would be a bonus, but isn't necessary, and I don't need to parse it into an object or anything.

Anyone know of such a library?

<hr>

Sample input:

<pre><code>{"status":"OK", "results":[ {"types":[ "locality", "political"], "formatted_address":"New York, NY, USA", "address_components":[ {"long_name":"New York", "short_name":"New York", "types":[ "locality", "political"]}, {"long_name":"New York", "short_name":"New York", "types":[ "administrative_area_level_2", "political"]}, {"long_name":"New York", "short_name":"NY", "types":[ "administrative_area_level_1", "political"]}, {"long_name":"United States", "short_name":"US", "types":[ "country", "political"]}], "geometry":{"location":{"lat":40.7143528, "lng":-74.0059731}, "location_type":"APPROXIMATE", "viewport":{"southwest":{"lat":40.5788964, "lng":-74.2620919}, "northeast":{"lat":40.8495342, "lng":-73.7498543}}, "bounds":{"southwest":{"lat":40.4773990, "lng":-74.2590900}, "northeast":{"lat":40.9175770, "lng":-73.7002720}}}}]} 
</code></pre>

JSON formatter in C#?

JSON

寻找一个函数，它将接受Json的string作为输入，并使用换行符和缩进对其进行格式化。验证将是额外的，但不是必需的，并且我不需要将其解析为对象或任何东西。有没有人知道这样的库？示例输入：{"status":"OK", "results":[ {"types":[ "locality", "political"], "...

问C#中的JSON格式化程序？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的JSON格式化程序？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C#中的JSON格式化程序？
EN