C#基类json反序列化为某个派生类，派生类属性不丢失

基类和派生类如下：

 /// <summary>
    /// 基类
    /// </summary>
    public class dataBase
    {
        public string name { get; set; }

        //这里插入的是派生类数据，如data1或data2
        public List<dataBase> children { get; set; }
    }

    /// <summary>
    /// 派生类1
    /// </summary>
    class data1 : dataBase
    {
        public string level { get; set; } = "1";

        public string subDevName { get; set; }
    }

    /// <summary>
    /// 派生类2
    /// </summary>
    class data2 : dataBase
    {
        public string level { get; set; } = "2";

        public string markName { get; set; }
    }

反序列化规则如下：

 public class DataConverter : DATACreationConverter<dataBase>
    {
        protected override dataBase Create(Type objectType, JObject jObject)
        {
            //第一种方法：判断属性值来确认是哪个派生类 
            if (FieldExists("level", jObject, out string level))
            {
                if (level == "1")
                {
                    return new data1();
                }
                else if (level == "2")
                {
                    return new data2();
                }
                else
                {
                    return new dataBase();
                }
            }
            else
            {
                return new dataBase();
            }

            //第二种方法：判断字段是否存在来确认是哪个派生类
            if (FieldExists("subDevName", jObject, out string subDevName))
            {
                return new data1();
            }
            else if (FieldExists("markName", jObject, out string markName))
            {
                return new data2();
            }
            else
            {
                return new dataBase();
            }  
        }

        private bool FieldExists(string fieldName, JObject jObject, out string entityName)
        {
            entityName = jObject[fieldName] == null ? "" : jObject[fieldName].ToString();
            return jObject[fieldName] != null;
        }
    }

    public abstract class DATACreationConverter<T> : JsonConverter
    {
        /// <summary>
        /// Create an instance of objectType, based properties in the JSON object
        /// </summary>
        /// <param name="objectType">type of object expected</param>
        /// <param name="jObject">
        /// contents of JSON object that will be deserialized
        /// </param>
        /// <returns></returns>
        protected abstract T Create(Type objectType, JObject jObject);

        public override bool CanConvert(Type objectType)
        {
            return typeof(T).IsAssignableFrom(objectType);
        }

        public override object ReadJson(JsonReader reader,
                                        Type objectType,
                                         object existingValue,
                                         JsonSerializer serializer)
        {
            // Load JObject from stream
            JObject jObject = JObject.Load(reader);

            // Create target object based on JObject
            T target = Create(objectType, jObject);

            // Populate the object properties
            serializer.Populate(jObject.CreateReader(), target);

            return target;
        }

        public override void WriteJson(JsonWriter writer,
                                       object value,
                                       JsonSerializer serializer)
        {
            throw new NotImplementedException();
        }
    }

调用如下：

//这里的json中只要包含派生类就会按照规则反序列化
//比如基类中有List<dataBase>类型的参数，并且里面插入的数据是派生类数据
//就可以用下列方法反序列化，派生类属性不会丢失
var result=JsonConvert.DeserializeObject<dataBase>(jsonStr, new DataConverter());