如何动态反序列化 json 对象？

Question

I am trying to make my code more simpler and avoid redundant code. I have a function that will accept an object, and a json response from an API call. I want to pass in the object, and response, and have it deserialize dynamically. is this possible? i already have classes created for each of the Json files below.

private object ParseObject(object obj, string response)
{
     try
     {
         return JsonConvert.DeserializeObject<obj>(response);
     }
     catch (Exception ex)
     {
         return null;
     }
}

Different types of JSON Files

{
  "jobStatus": "4",
  "jobStatusDescription": "Job is complete",
  "resultSet": [
    {
      "equipmentInitial": "BNSF",
      "trainId": "S MEMSCO 1 15"
    }
  ],
  "rowCount": "1"
}

Second One

{
  "intermodalUnits": [
    {
      "attachedIntermodalUnits": [
        {}
      ],
      "carInitial": "INIT",
      "carKindCode": "K18 ",
      "carKindTypeCode": "K",
      "carNumber": "A1B2",
    }
  ]
}

Answer 1

To answer your question, first one needs to create types that match your JSON (please include this in your Minimal Reproduceable Example the next time.

public class Job
{
    public const string TestJson = @"
    {
      ""jobStatus"": ""4"",
      ""jobStatusDescription"": ""Job is complete"",
      ""resultSet"": [
        {
          ""equipmentInitial"": ""BNSF"",
          ""trainId"": ""S MEMSCO 1 15""
        }
      ],
      ""rowCount"": ""1""
    }";

    [JsonProperty("jobStatus")]
    public string JobStatus { get; set; }

    [JsonProperty("jobStatusDescription")]
    public string JobStatusDescription { get; set; }

    [JsonProperty("resultSet")]
    public List<ResultSet> ResultSet { get; set; }

    [JsonProperty("rowCount")]
    public string RowCount { get; set; }

}

public class ResultSet
{
    [JsonProperty("equipmentInitial")]
    public string EquipmentInitial { get; set; }

    [JsonProperty("trainId")]
    public string TrainId { get; set; }
}

and

public class IntermodalUnit
{
    public const string TestJson = @"
    {
      ""intermodalUnits"": [
        {
          ""attachedIntermodalUnits"": [
            {}
          ],
          ""carInitial"": ""INIT"",
          ""carKindCode"": ""K18 "",
          ""carKindTypeCode"": ""K"",
          ""carNumber"": ""A1B2""
        }
      ]
    }";

    [JsonProperty("intermodalUnits")]
    public List<InnerIntermodalUnit> IntermodalUnits { get; set; }
}

public class InnerIntermodalUnit
{
    [JsonProperty("attachedIntermodalUnits")]
    public List<object> AttachedIntermodalUnits { get; set; }

    [JsonProperty("carInitial")]
    public string CarInitial { get; set; }

    [JsonProperty("carKindCode")]
    public string CarKindCode { get; set; }

    [JsonProperty("carKindTypeCode")]
    public string CarKindTypeCode { get; set; }

    [JsonProperty("carNumber")]
    public string CarNumber { get; set; }

}

With that, to answer your question (as asked), I'd do something like this:

private static Lazy<MethodInfo> DeserializeGenericMethod = new Lazy<MethodInfo>(() =>
    typeof(JsonConvert).GetMethods().Where(m => m.Name == "DeserializeObject" && m.ContainsGenericParameters).FirstOrDefault());

private object ParseObject(object obj, string response)
{
    var deserializeSpecificMethod = DeserializeGenericMethod.Value.MakeGenericMethod(obj.GetType());

    try
    {
        return deserializeSpecificMethod.Invoke(null, new object[] { response });
    }
    catch (Exception)
    {
        return null;
    }
}

It uses reflection to invoke JsonConvert.DeserializeObject<T> for the type you specify.

You'd call the method something like this:

var result = ParseObject(new Job(), Job.TestJson);
var result2 = ParseObject(new IntermodalUnit(), IntermodalUnit.TestJson);

But a better solution would look like:

private object ParseObject(Type objType, string response)
{
    var deserializeSpecificMethod = DeserializeGenericMethod.Value.MakeGenericMethod(objType);
    // the rest of the method the same.

In that case, you'd call it like this:

var result3 = ParseObject(typeof(Job), Job.TestJson);
var result4 = ParseObject(typeof(IntermodalUnit), IntermodalUnit.TestJson);

Note that this way, you don't have to use a (possibly newly created) object that really is never used.

It would also make sense to make ParseObject a generic method:

private object ParseObject<T>(string response) where T : class
{
    var deserializeSpecificMethod = DeserializeGenericMethod.Value.MakeGenericMethod(typeof(T));
    // the rest of the method the same.

You might even keep both the version that takes the Type and the generic version (with one calling the other) to allow your users a choice

BUT

Neither of these is a good solution. As others have pointed out, all you are doing is swallowing the exception; your users will be left in the dark when something goes wrong.

Instead, consider a variation on the reasonably standard TryXxx pattern. Something like this:

private bool TryParseObject<T>(string response, out object obj) where T : class
{
    var deserializeSpecificMethod = DeserializeGenericMethod.Value.MakeGenericMethod(typeof(T));

    try
    {
        obj = deserializeSpecificMethod.Invoke(null, new object[] { response });
        return true;
    }
    catch (Exception ex)
    {
        obj = ex;
        return false;
    }
}

Note that now your users can check for errors. If there is no error, then the out parameter is the newly deserialized object. If there is an error, then the out parameter is the exception that was thrown.

Here's what calling this would look like:

var test1 = TryParseObject<Job>(Job.TestJson, out var result7);
var test2 = TryParseObject<IntermodalUnit>(IntermodalUnit.TestJson, out var result8);
var test3 = TryParseObject<IntermodalUnit>("badJson", out var result9);

BUT again...

None of this really buys you very much.

Postscript :
After I finished this, I realized that reflection isn't needed on the generic ( <T> ) versions of this code. But, I'll let you fix that...