Puede usar un JsonConverter personalizado para realizar una doble función en el manejo de los tipos de eventos polimórficos y los diferentes formatos JSON. A continuación se muestra un ejemplo. Funciona cargando los datos en un JObject , donde puede leer la propiedad $type e instanciar el tipo de evento correcto. A partir de ahí, intentará completar el objeto de evento desde el JSON. Si el Airport no puede deserializarse, intentará leer las propiedades heredadas del aeropuerto y completar una nueva instancia del Airport a partir de eso.

 class EventConverter : JsonConverter { public override bool CanConvert(Type objectType) { return typeof(BaseEvent).IsAssignableFrom(objectType); } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject obj = JObject.Load(reader); string type = (string)obj["$type"]; BaseEvent baseEvent; if (type.Contains(nameof(TakeoffEvent))) { baseEvent = new TakeoffEvent(); } else { baseEvent = new LandingEvent(); } serializer.Populate(obj.CreateReader(), baseEvent); if (baseEvent.Airport == null) { baseEvent.Airport = new Airport { Name = (string)obj["AirportName"], Runway = (string)obj["AirportRunway"] }; } return baseEvent; } public override bool CanWrite => false; public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { throw new NotImplementedException(); } }

Nota: esto supone que la estructura de su clase en realidad se ve así:

 class Airport { public string Name { get; set; } public string Runway { get; set; } } class BaseEvent { public Airport Airport { get; set; } } class TakeoffEvent : BaseEvent { public DateTime TimeOfTakeoff { get; set; } } class LandingEvent : BaseEvent { public DateTime TimeOfLanding { get; set; } }

Para usar el convertidor, agréguelo a la colección Converters en JsonSerializerSettings y pase la configuración a DeserializeObject() :

 var settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Objects, Converters = new List<JsonConverter> { new EventConverter() } }; var baseEvent = JsonConvert.DeserializeObject<BaseEvent>(json, settings);

Aquí hay una demostración funcional: https://dotnetfiddle.net/jSaq4T

Ver también: Adición de soporte de compatibilidad con versiones anteriores para una estructura JSON más antigua

Las clases cambian, este tipo de cadenas Json cambian y obtendrán funciones adicionales en futuras versiones. Seguirás ajustando tus declaraciones. Con Newtonsoft, puede agregar controladores personalizados para la herencia de clases variables y seguir usando la deserialización, pero tendrá que mantener ese código.

Para Json dinámico, me resulta más fácil usar JObject, JArray y JToken en su lugar, para analizar libremente una cadena Json. Especialmente si solo estás interesado en algunos de los campos.

Solo puedo darte un ejemplo, creo que esto está (un poco) relacionado con tu proyecto, pero no es la misma parte (smiley)

Utilizo el siguiente código para decodificar parte de un archivo de objeto 3d glTF producido por Blender en formato convertido a MSFS. Este formato similar a Json consta de secciones . Cada sección Json se parece a esto,

 "asset" : { "extensions" : { "ASOBO_normal_map_convention" : { "tangent_space_convention" : "DirectX" } }, "generator" : "Extended Khronos glTF Blender I/O v1.0.0", "version" : "2.0" },

.. pero estas secciones y sus campos son en su mayoría opcionales y en algunos GLtf no se completan. No es "serializable o deserializable" para las clases.

declaro algunos

 public JObject AssetObject;

.. completándolo desde Json string sJson de la siguiente manera:

 dynamic stuff = JObject.Parse(sJson); var pp = stuff.Children(); Dictionary<string, bool> d = new Dictionary<string, bool>(); foreach (JProperty jo in pp) d[jo.Name] = true; // all sections string cSection= "asset"; if (!d.ContainsKey(cSection)) { LogLine(98, "Warning: BPG Json has no " + cSection + " section."); return false; } else { AssetObject = (JObject)stuff[cSection]; ParseGLBAsset(); }

Observe el uso de una declaración dinámica al principio, una sección aterrizará en JObject a través de cast. Guardo las diversas partes de la sección en propiedades de cadena. El análisis en sí tiene lugar en ParseGLBAsset(), esta función tiene el siguiente aspecto:

 public void ParseGLBAsset() { foreach (JProperty jbp in AssetObject.Children()) if (jbp.Name == "generator") { GLBGenerator = jbp.Value.ToString(); } else if (jbp.Name == "extensions") { GLBAssetExtensions = jbp.Value.ToString(); LogLine(0, "Asset extensions: " + GLBAssetExtensions); } else if (jbp.Name == "version") { GLBVersion = jbp.Value.ToString(); } LogLine(1, "Found asset.generator=" + GLBGenerator); LogLine(1, "Found asset.version=" + GLBVersion); }