Como faço para obter formatado JSON no .net usando c #?

Eu estou usando o analisador .NET JSON e gostaria de serializar meu arquivo de configuração para que seja legível. Então, ao invés de:

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

Eu gostaria de algo mais legal como:

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

Meu código é algo assim:

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

Você vai ter dificuldade em realizar isso com JavaScriptSerializer.

Experimente o JSON.Net .

Com pequenas modificações do exemplo 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(json); } } internal class Product { public String[] Sizes { get; set; } public decimal Price { get; set; } public DateTime Expiry { get; set; } public string Name { get; set; } } } 

Resultados

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

Documentação: serializar um object

Um código de amostra mais curto para a biblioteca Json.Net

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

Se você tem uma string JSON e deseja “prettificá-la”, mas não quer serializá-la para e de um tipo conhecido de C #, o seguinte é o truque (usando 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(); } } } 

Versão mais curta para enfeitar o JSON existente: (edit: using JSON.net)

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

Entrada:

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

Saída:

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

Para imprimir bastante um object:

 JToken.FromObject(myObject).ToString() 

Oneliner usando Newtonsoft.Json :

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

Você pode usar o seguinte método padrão para obter o formato Json

JsonReaderWriterFactory.CreateJsonWriter (Fluxo de stream, Codificação de codificação, bool ownsStream, bool indent, string indentChars)

Apenas defina “recuo == verdadeiro”

Tente algo assim

  public readonly DataContractJsonSerializerSettings Settings = new DataContractJsonSerializerSettings { UseSimpleDictionaryFormat = true }; public void Keep(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()); } } 

Preste atenção nas linhas

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

Você deve usar InvariantCulture para evitar exceções durante a desserialização nos computadores com diferentes configurações regionais. Por exemplo, o formato inválido de double ou DateTime às vezes os causa.

Para desserializar

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

Obrigado!

Primeiro, gostaria de acrescentar comentários no post do Duncan Smart, mas infelizmente ainda não tenho reputação suficiente para deixar comentários. Então vou tentar aqui.

Eu só quero avisar sobre os efeitos colaterais.

JsonTextReader internamente analisa json em JTokens typescript e depois serializa-os de volta.

Por exemplo, se o seu JSON original foi

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

Depois de enfeitar você fica

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

É claro que ambas as strings do json são equivalentes e desserializam para estruturalmente objects iguais, mas se você precisa preservar os valores originais da string, você precisa levar isso em consideração.