Using JsonConvert.DeserializeObject to dynamically choose class

Question

So I am making an api call and I need to use JsonConvert.DeserializeObject to convert it to a class. The Json structure comes back as the following

{
    "fcResponse": {
        "responseData": {
            "fcRequest": {
                "mail": "Emails",
                "outlookMail": "Outlook Emails",
                 (etc.)
            }
        }
    }
}

The problem is that the values that come back inside "fcRequest" varies based on the parameters I am sending.

The class structure is as follows so far

    public class GetSubModulesResponse : BaseResponse
    {
        [JsonProperty("fcResponse")]
        public SubModuleResponse Response { get; set; }
    }

    public class SubModuleResponse
    {
        [JsonProperty("responseData")]
        public SubModuleData Data { get; set; }
    }

    public class SubModuleData
    {
        [JsonProperty("fcRequest")]
        public SubModuleFIMRequest RequestFIM { get; set; }

        [JsonProperty("fcRequest")]
        public SubModuleFSRequest RequestFS { get; set; }
    }

And this is the basic call structure

GetSubModulesResponse subModuleResponse = new GetSubModulesResponse();
var response = SubmitAPICall();
subModuleResponse = JsonConvert.DeserializeObject<GetSubModulesResponse>(response);

Now I know I obviously can't have the same JsonProperty on both RequestFIM and RequestFS, but what I'm trying to do is somehow find a way to switch which one of those two properties I should use based on a variable.

Does your API that you are dealing with have a `SDK`? Most of the time they do. — Patrick Mcvay, Jul 08 '20 at 16:46
@PatrickMcvay not that I am aware of, and the structure I have at the moment is that the fcRequest comes back as two different types, but I don't know if thats the best way or not — Xyloking17, Jul 08 '20 at 17:10
I would say that is not the best way. It would require too much guess work and is just asking for problems. You should probably return both types every time and just make one of them null, if you have control over that. — Patrick Mcvay, Jul 08 '20 at 17:44

score 0 · Answer 1 · answered Jul 08 '20 at 20:48

If you're in control of the Json being returned, I'd highly recommend returning each object under it's own property and set whatever's not needed to null.

If that's not an option, another thing that could work is deserializing "fcRequest" to dynamic and then try casting to the types it may be or casting based on another property name. That's not very clean.

Another interesting approach in a different Json lib (Jil) is Unions. "Jil has limited support for "unions" (fields on JSON objects that may contain one of several types), provided that they can be distiguished by their first character."

sunside · Accepted Answer · 2020-07-10T09:32:23.637

One option is to go with a custom (de-)serializer for the element. This way, you can still least benefit from automatic deserialization in most spots and get the flexibility where you need it. I'm assuming you're using Newtonsoft JSON / JSON.NET.

Let's introduce a base class for the fcRequest elements first.

public enum ResponseType
{
    FIM, FS
}

public abstract class ResponseBase
{
    [JsonIgnore]
    public abstract ResponseType ResponseType { get; }
}

By adding a ResponseType here you can simplify consuming code; if you can use type based pattern matching, you may not even need it.

I obviously have no idea what your domain entities are, but for the sake of the argument, the SubModuleFIMRequest is now going to contain the mail addresses. In addition, it also derives from said ResponseBase:

public class SubModuleFIMRequest : ResponseBase
{
    public override ResponseType ResponseType => ResponseType.FIM;

    [JsonProperty("mail")]
    public string Mail { get; set; }

    [JsonProperty("outlookMail")]
    public string OutlookMail { get; set; }
}

Next, you'd implement a JsonConverter<ResponseBase>; to make life easy, it can deserialize the responseData content into a JObject first. In doing so, you'll be able to introspect the properties of the element, which in turn (hopefully) allows you to come up with a heuristic to determine the element's actual type.

Once you know the type, you convert the JObject to a concrete instance. Here's an example:

public class ResponseDataConverter : JsonConverter<ResponseBase>
{
    /// <inheritdoc />
    public override bool CanWrite => false;

    /// <inheritdoc />
    public override ResponseBase ReadJson(JsonReader reader, Type objectType, ResponseBase existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        var jObject = serializer.Deserialize<JObject>(reader);

        // Now, decide tye type by matching patterns.
        if (jObject.TryGetValue("mail", out var mailToken))
        {
            return jObject.ToObject<SubModuleFIMRequest>();
        }

        // TODO: Add more types as needed

        // If nothing matches, you may choose to throw an exception,
        // return a catchall type (e.g. wrapping the JObject), or just
        // return a default value as a last resort.
        throw new JsonSerializationException();
    }

    /// <inheritdoc />
    public override void WriteJson(JsonWriter writer, ResponseBase value, JsonSerializer serializer) => throw new NotImplementedException();
}

Note that the serializer doesn't need to write, so we're just throwing in WriteJson.

What's left is to annotate the SubModuleData's fcProperty property with a JsonConverter attribute pointing to the converter type:

public class SubModuleData
{
    [JsonProperty("fcRequest")]
    [JsonConverter(typeof(ResponseDataConverter))]
    public ResponseBase FcRequest { get; set; }
}

I hope that gets you started. As was mentioned in other comments and answers: If you can influence the API returning the JSON in the first place, try changing that instead.

This really helped out. The API comes from a franchise connection tool for work that I have no control over, and my first thought was that it wasn't coming back in the best format to handle. But this seems like a good solution — Xyloking17, Jul 09 '20 at 17:11

Using JsonConvert.DeserializeObject to dynamically choose class

2 Answers2