Get Raw json string in Newtonsoft.Json Library

Question

I have json like this

{
    \"name\": \"somenameofevent\",
    \"type\": \"event\",
    \"data\": {
        \"object\": {
            \"age\": \"18\",
               


        

Answer 1

I use this implementation of the custom 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 2

You have to write a custom converter class (derived from Newtonsoft.Json.JsonConverter) which instructs the deserializer to read the whole object and to return the JSON string for the object.

Then you have to decorate the property with the JsonConverter attribute.

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

There are good tutorials on the web on how to create custom converters, but - for your convenience - the core of your converter might look like this:

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

This method reads a complete JSON object but returns the serialized version of the object as string. There is a bit of overhead because the object is deserialized to a JObject and then serialized again, but for me it's the easiest way to do this. Maybe you have a better idea.

Answer 3

As chakrit suggested, you can do something like this to provide a string signature for your object, while using JRaw to do the real work.

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

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

Answer 4

If you are worried about the overhead because the object is deserialized to a JObject a and then serialized again (solution offered by @fero ) then you can try the following.

Approach 1: Create your own custom JsonConverter and override ReadJson

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

For more detail check the link Incremental JSON Parsing in C#

Approach 2: Read the json string and apply string functions or regex function to get the desired string.

Answer 5

You don't need to write any converters, just use the JRaw type as follows:

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

Then you can access the raw value by checking the .Value property:

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

If you want to retain the string signature, just serialize the JSON to a hidden property and have the string conversion in the accessor call instead.

Answer 6

In your case you can directly use the static method from JsonConvert class

PopulateObject(string value, object target, JsonSerializerSettings settings);