BronParser

    public class BronParserException : Exception {
        public BronParserException(string message) : base(message) {
        }

        public BronParserException(string message, Exception innerException) : base(message, innerException) {
        }
    }

public static class BronParser {
    public static object MaakNestedDictionaryVanJObject(object reqObj) {
            switch (reqObj) {
                case JObject jObject:
                    return (
                        (IEnumerable<KeyValuePair<string, JToken>>)jObject)
                        .ToDictionary(j => j.Key, j => MaakNestedDictionaryVanJObject(j.Value)
                    );
                case JArray jArray:
                    return jArray.Select(MaakNestedDictionaryVanJObject).ToList();
                case JValue jValue:
                    return jValue.Value;
                default:
                    throw new BronParserException($"Dit type kan niet geparsed worden: {reqObj.GetType()}");
            }
        }

    public static T ParseCast<T>(object data, JSchema ValidatieSchema=null, bool toJsonFilterNulls=true) {

            var JSS = new JsonSerializer {
                NullValueHandling = NullValueHandling.Ignore,
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore // https://dotnetfiddle.net/frCSa3
            };

            JObject parsed_as_json = null;
            JObject parsed_as_obj = null;

            try {
                if (data.GetType() == typeof(string))
                    { parsed_as_json = JObject.Parse((string)data);
                }
            } catch(JsonReaderException) { }

            try {
                parsed_as_obj = JObject.FromObject(data, JSS);
            } catch (ArgumentException e) when (e.Message.Contains("JObject instance expected")) { }

            JObject parseResultaat = parsed_as_json is not null
                                     ? parsed_as_json
                                     : parsed_as_obj is not null
                                         ? parsed_as_obj
                                         : throw new BronParserException(
                                            "Kon de data niet parsen. " +
                                            "Indien je een JSON string wenst te parsen, " +
                                            "controleer of je JSON valid is."
                                           );

            if (ValidatieSchema is not null) {
                if (!parseResultaat.IsValid(ValidatieSchema)) {
                    throw new BronParserException(
                        "Het JSON object voldoet niet aan de voorwaarden " +
                        "opgelegd in het meegegeven schema."
                    );
                }
            }

            /**Optie 1 - omzetten naar json string**/
            if (typeof(T) == typeof(string)) {
                string filteredResultaat;

                if (toJsonFilterNulls) {
                    // Omweg (from+to) vereist aangezien anders nulls niet genegeerd worden
                    // (komt door JTokenType.Null)
                    // https://stackoverflow.com/questions/33027409/json-net-serialize-jobject-while-ignoring-null-properties
                    filteredResultaat = JObject.FromObject(
                                            parseResultaat.ToObject(typeof(object)),
                                            JSS
                                        ).ToString();
                } else {
                    filteredResultaat = parseResultaat.ToString();
                }

                return (T)Convert.ChangeType(filteredResultaat, typeof(T));

            /**Optie 2 - specifiek omzetten naar een object met type T **/
            } else if ((typeof(T) == typeof(JObject) || typeof(T).GetType().IsClass)
                        && typeof(T) != typeof(object)) {            // https://dotnetfiddle.net/puxB1a
                return (T)parseResultaat.ToObject(typeof(T));

            /**Optie 3 - generiek omzetten naar een "object" **/
            } else {
                return (T)parseResultaat.ToObject(typeof(object));
            }

            throw new BronParserException("Kon de data niet parsen.");
        }


}