How to deserialize specific element with DataContractJsonSerializer

Question

I'm trying to deserialize json data with DataContractJsonSerializer class. a problem is how to set root element?

my json data is here.

{
   "delete":{
      "status":{
         "id":696142765093072896,
         "id_str":"696142765093072896",
         "user_id":2223183576,
         "user_id_str":"2223183576"
      },
      "timestamp_ms":"1454808363540"
   }
}

and I wrote class for deserialization like this. but it isn't works. my Status always null.

[DataContract(Name="delete")]
public class Delete
{
    [DataMember(Name="status")]
    public DeletedStatus Status { get; set; }
}

public class DeletedStatus
{
    [DataMember(Name = "id")]
    public long Id { get; set; }
    [DataMember(Name = "user_id")]
    public long UserId { get; set; }
}

how can I start parse json from specific element?

Answer 1

Based on what I can tell from the JSON, the deserialization appears to be failing because the root property of the object is the "delete" property. I don't believe this will work with the DataContractJsonSerializer simply because the given type will not match the Delete type. One other possible issue is that I see the DeleteStatus class is missing a [DataContract] attribute.

Long story short, there is no simple way of doing what you want to do. That being said, there is a short and sweet way of deserializing the JSON without adding a lot of extra headache. I suggest creating a data type that represents the JSON in its current state, and deserialize to that type instead.

I wrote a Unit Test that you can run from a Visual Studio test project. I hope this helps.

JsonDeserializationTests.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Runtime.Serialization.Json;
using System.IO;

namespace SerializationTests {
    [TestClass]
    public class JsonDeserializationTests {
        [TestMethod]
        public void Deserialize_Delete_Type_Success() {
            string json = string.Empty;
            //Set the DataContractJsonSerializer target type to our wrapper type.
            var ser = new DataContractJsonSerializer(typeof(DeleteWrapperJsonResult));
            //Create an instance of the wrapper that reflects the JSON  that you gave.
            //This will help me mock the data that you gave.
            var deleteWrapper = new DeleteWrapperJsonResult {
                delete = new DeleteJsonResult {
                    status = new DeletedStatusJsonResult {
                        id = 696142765093072896,
                        user_id = 2223183576
                    }
                }
            };
            //Convert the mock data to JSON to reflect the JSON that you gave.
            using (var serStream = new MemoryStream()) {
                using (var sr = new StreamReader(serStream)) {
                    ser.WriteObject(serStream, deleteWrapper);
                    serStream.Position = 0;
                    json = sr.ReadToEnd(); //Set the JSON string here.
                    //Output "{\"delete\":{\"status\":{\"id\":696142765093072896,\"id_str\":\"696142765093072896\",\"user_id\":2223183576,\"user_id_str\":\"2223183576\"}}}"
                }
            }
            //Prepeare to Deserialize the JSON.
            var deserialized = default(DeleteWrapperJsonResult);
            using (var deserStream = new MemoryStream()) {
                using (var sw = new StreamWriter(deserStream)) {
                    sw.Write(json); //Write the JSON to the MemoryStream
                    sw.Flush();
                    deserStream.Seek(0, SeekOrigin.Begin);
                    //Deserialize the JSON into an instance of our wrapper class.
                    //This works because of the structure of the JSON.
                    deserialized = (DeleteWrapperJsonResult)ser.ReadObject(deserStream);
                }
            }
            //Initialize the actual Delete instanace with what was deserialized.
            var delete = new Delete {
                Status = new DeletedStatus {
                    //These values were populated with the JSON values.
                    UserId = deserialized.delete.status.user_id,
                    Id = deserialized.delete.status.id
                }
            };
            //Write asserts around what was given and check for equality.
            Assert.AreEqual(delete.Status.UserId, deleteWrapper.delete.status.user_id);
            Assert.AreEqual(delete.Status.Id, deleteWrapper.delete.status.id);
            //Test Passes for Me
        }
    }
}

Delete.cs

using System.Runtime.Serialization;

namespace SerializationTests {
    [DataContract]
    [KnownType(typeof(Delete))]
    public class Delete {
        [DataMember]
        public DeletedStatus Status { get; set; }
    }

    [DataContract]
    [KnownType(typeof(DeletedStatus))]
    public class DeletedStatus {
        [DataMember]
        public long Id { get; set; }
        [DataMember]
        public long UserId { get; set; }

    }

    /**************************************************************
     These types below are what comprise our wrapper class so that we can
     use the JSON in its current state. The wrapper classes have properties that
     are synonymous with the JSON properties.
     **************************************************************/
    //This structure represents the object nesting as it appears currently in your example.
    [DataContract]
    [KnownType(typeof(DeleteJsonResult))]
    public class DeleteWrapperJsonResult {
        [DataMember]
        public DeleteJsonResult delete { get; set; }
    }

    [DataContract]
    [KnownType(typeof(DeleteJsonResult))]
    public class DeleteJsonResult {
        [DataMember]
        public DeletedStatusJsonResult status { get; set; }
    }

    [DataContract]
    [KnownType(typeof(DeletedStatusJsonResult))]
    public class DeletedStatusJsonResult {
        [DataMember]
        public long id { get; set; }
        [DataMember]
        public string id_str {
            get {
                return id.ToString();
            }
            set {
                return;
            }
        }
        [DataMember]
        public long user_id { get; set; }
        [DataMember]
        public string user_id_str {
            get {
                return user_id.ToString();
            }
            set {
                return;
            }
        }
    }
}

As of the time of this writing, my unit test is passing! Let me know if I can assist further.