¿Cómo obtengo el formato JSON en .NET usando C #?

Estoy usando el analizador .NET JSON y me gustaría serializar mi archivo de configuración para que sea legible. Entonces, en lugar de:

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

Me gustaría algo más agradable como:

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

Mi código es algo como esto:

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

Tendrá dificultades para lograr esto con JavaScriptSerializer.

Prueba JSON.Net .

Con modificaciones menores del ejemplo de 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" } 

Documentación: serializar un objeto

Un código de muestra más corto para la biblioteca Json.Net

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

Si tiene una cadena JSON y desea “embellecerla”, pero no desea serializarla hacia y desde un tipo de C # conocido, entonces lo siguiente es el truco (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(); } } } 

Versión más corta para embellecer JSON existente: (editar: usando 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()"} ] } }} 

Salida:

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

Para imprimir bastante un objeto:

 JToken.FromObject(myObject).ToString() 

Newtonsoft.Json con Newtonsoft.Json :

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

Puede usar el siguiente método estándar para obtener Json formateado

JsonReaderWriterFactory.CreateJsonWriter (Stream stream, encoding de encoding, bool ownsStream, bool indent, string indentChars)

Solo establece “sangría == verdadero”

Pruebe algo como esto

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

Presta atención a las líneas

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

Debe usar InvariantCulture para evitar excepciones durante la deserialización en las computadoras con diferentes configuraciones regionales. Por ejemplo, el formato inválido de double o DateTime a veces los causa.

Para deserializar

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

¡Gracias!

Primero, quería agregar un comentario en Duncan Smart post, pero desafortunadamente aún no tengo suficiente reputación como para dejar comentarios. Así que lo intentaré aquí.

Solo quiero advertir sobre los efectos secundarios.

JsonTextReader internamente analiza json en JTokens tipeados y luego los serializa de nuevo.

Por ejemplo, si su JSON original era

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

Después de embellecer, obtienes

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

Por supuesto, ambas cadenas json son equivalentes y se deserializarán para objetos estructuralmente iguales, pero si necesita preservar los valores de cadena originales, debe tener esto en cuenta.