Obtener cadena JSON sin procesar en Newtonsoft.Json Biblioteca

Question

tengo JSON como esto

{ 
    "name": "somenameofevent", 
    "type": "event", 
    "data": { 
     "object": { 
      "age": "18", 
      "petName": "18" 
     }, 
     "desct": { 
     } 
    } 
} 

y tengo 2 objetos como este

public class CustEvent 
{ 
    [JsonProperty("name")] 
    public string Name { get; set; } 
    [JsonProperty("type")] 
    public string EventType{ get; set; } 
    [JsonProperty("data")] 
    public SomeData Data{ get; set; } 
} 

public class SomeData 
{ 
    [JsonProperty("object")] 
    public String SomeObject { get; set;} 
    [JsonProperty("dsct")] 
    public String SomeDesct { get; set; } 
} 

utilizo para analizar JSON para objetar Newtonsoft.NET biblioteca. ¿Y cómo puedo obtener RAW JSON en SomeObject, propiedades de SomeDesct? En JSON "data.object ..." son objetos complejos y quiero obtener solo RAW JSON String para esas propiedades. Me puedes ayudar ?

Answer 1

Tiene que escribir una clase de convertidor personalizada (derivada de Newtonsoft.Json.JsonConverter) que indica al deserializador que lea todo el objeto y que devuelva la cadena JSON para el objeto.

Luego tiene que decorar la propiedad con el atributo JsonConverter.

[JsonConverter(typeof(YourCustomConverterClass))] 
public string SomeObject { get; set; } 

Hay buenos tutoriales en la web acerca de cómo crear convertidores personalizados, pero - para su conveniencia - el núcleo de su convertidor podría tener este aspecto:

public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
{ 
    return JObject.Load(reader).ToString(); 
} 

Este método lee un JSON completa objeto pero devuelve la versión serializada del objeto como cadena. Hay un poco de sobrecarga porque el objeto se deserializa a JObject y luego se serializa de nuevo, pero para mí es la forma más fácil de hacerlo. Quizás tengas una mejor idea.

Answer 2

Si usted está preocupado por la sobrecarga porque el objeto se deserializa a un JObject una y luego otra vez serializada (solución ofrecida por @fero) entonces puede intentar lo siguiente.

Enfoque 1: Cree su propia aduana JsonConverter y anular ReadJson

using(var jsonReader = new JsonTextReader(myTextReader)) 
{ 
    while(jsonReader.Read()){ 
    if(jsonReader.TokenType.PropertyName=="SomeDesct") 
    { 
     //do what you want 
    } 
    } 
} 

Para más detalles consultar el enlace Incremental JSON Parsing in C#

Enfoque 2: Lea la cadena JSON y aplicar funciones de cadenas o expresiones regulares función para obtener la cadena deseada.

Answer 3

En su caso se puede utilizar directamente el método estático de la clase JsonConvert

PopulateObject (cadena de valor, objetivo objeto, JsonSerializerSettings configuración);

Answer 4

Utilizo esta implementación del JsonConverter personalizado.

public class RawJsonConverter: JsonConverter 
{ 
    public override bool CanConvert(Type objectType) 
    { 
     return objectType == typeof(string); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     var sb = new StringBuilder(); 
     JsonToken previousToken = JsonToken.None; 

     if (reader.TokenType == JsonToken.StartObject) 
     { 
      sb.Append('{'); 
      int depth = 1; 
      while (depth > 0) 
      { 
       if (!reader.Read()) 
        break; 
       switch (reader.TokenType) 
       { 
        case JsonToken.PropertyName: 
         if (previousToken == JsonToken.Boolean || previousToken == JsonToken.Integer || previousToken == JsonToken.Float) 
          sb.Append(','); 
         sb.AppendFormat("\"{0}\":", reader.Value); 
         break; 
        case JsonToken.StartArray: 
         if (previousToken == JsonToken.EndArray) 
          sb.Append(','); 
         sb.Append('['); 
         break; 
        case JsonToken.Boolean: 
        case JsonToken.Integer: 
        case JsonToken.Float: 
         if (previousToken == JsonToken.Boolean || previousToken == JsonToken.Integer || previousToken == JsonToken.Float) 
          sb.Append(','); 
         sb.AppendFormat(System.Globalization.CultureInfo.InvariantCulture, "{0}", reader.Value); 
         break; 
        case JsonToken.EndArray: 
         sb.Append(']'); 
         break; 
        case JsonToken.StartObject: 
         sb.Append('{'); 
         depth++; 
         break; 
        case JsonToken.EndObject: 
         sb.Append('}'); 
         depth--; 
         break; 
       } 
       previousToken = reader.TokenType; 
      } 
     } 
     return sb.ToString(); 
    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     writer.WriteRawValue(value.ToString()); 
    } 

    public override bool CanWrite 
    { 
     get 
     { 
      return true; 
     } 
    } 
} 

Answer 5

No es necesario escribir ningún convertidores, sólo tiene que utilizar el tipo JRaw de la siguiente manera:

public class SomeData 
{ 
    [JsonProperty("object")] 
    public JRaw SomeObject { get; set;} 
    [JsonProperty("dsct")] 
    public JRaw SomeDesct { get; set; } 
} 

A continuación, se puede acceder al valor bruto comprobando la propiedad .Value:

var rawJsonDesct = (string)data.SomeDesct.Value; 

Si desea conservar la firma string, simplemente serialice el JSON a un pr oculto operty y tiene la conversión de cadena en la llamada de acceso en su lugar.

Answer 6

Como chakrit suggested, puede hacer algo como esto para proporcionar una firma de cadena para su objeto, mientras utiliza JRaw para hacer el trabajo real.

[JsonProperty("Data")] 
    public JRaw Raw { get; set; } 

    [JsonIgnore] 
    public string Data 
    { 
     get => Raw?.Value as string; 
     set => Raw = new JRaw(value); 
    }