Get stringa JSON grezzo in Newtonsoft.Json Biblioteca

Question

ho JSON come questo

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

e ho 2 oggetti come questo

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

io uso per analizzare JSON di opporsi Newtonsoft.NET biblioteca. E come posso ottenere JSON RAW in SomeObject, proprietà SomeDesct? In JSON "data.object ..." sono oggetti complessi e voglio ottenere solo la stringa JSON RAW su quelle proprietà. Mi potete aiutare ?

Answer 1

È necessario scrivere una classe di convertitore personalizzata (derivata da Newtonsoft.Json.JsonConverter) che indica al deserializzatore di leggere l'intero oggetto e restituire la stringa JSON per l'oggetto.

Quindi è necessario decorare la proprietà con l'attributo JsonConverter.

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

Ci sono buoni tutorial sul web su come creare convertitori personalizzati, ma - per comodità - il nucleo del vostro convertitore potrebbe assomigliare a questo:

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

Questo metodo legge un JSON completa oggetto ma restituisce la versione serializzata dell'oggetto come stringa. C'è un po 'di overhead perché l'oggetto è deserializzato su un JObject e poi serializzato di nuovo, ma per me è il modo più semplice per farlo. Forse hai un'idea migliore.

Answer 2

Se siete preoccupati per l'overhead perché l'oggetto viene deserializzato ad un JObject una e poi di nuovo serializzato (soluzione offerta da @fero) allora si può provare quanto segue.

Approccio 1: Creare il proprio personalizzato JsonConverter e override ReadJson

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

Per maggiori dettagli controlla il link Incremental JSON Parsing in C#

Approccio 2: leggere la stringa JSON e applicare funzioni di stringa o espressione regolare funzione per ottenere la stringa desiderata.

Answer 3

Nel tuo caso è possibile utilizzare direttamente il metodo statico dalla classe JsonConvert

PopulateObject (valore stringa, bersaglio oggetto, JsonSerializerSettings impostazioni);

Answer 4

Io uso questa implementazione del costume JsonConverter.

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

Non è necessario scrivere alcun convertitori, basta utilizzare il tipo di JRaw come segue:

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

Quindi è possibile accedere al valore grezzo controllando la proprietà .Value:

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

Se si desidera conservare la firma string, serializzare semplicemente JSON in un pr nascosto operty e avere invece la conversione di stringhe nella chiamata accessor.

Answer 6

Come chakrit suggested, si può fare qualcosa di simile per fornire una firma stringa per l'oggetto, durante l'utilizzo di JRaw per fare il vero lavoro.

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

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