Serialization Newtonsoft.json JsonConvert.SerializeObject-仅序列化第一级-MaxDepth不'；我不适合序列化

我只需要通过JsonConvert.SerializeObject序列化对象的第一级。我尝试了MaxDepth=1，但此属性仅用于反序列化

所需的行为（属性栏缺失或为空）：

我应该如何设置JsonConvert.SerializeObject以忽略序列化中的子非基本对象？非常感谢。

我找到了解决办法

我制作了一个自定义JsonConverter：

    public class OnlyPrimitiveJsonConverter : JsonConverter
    {
        private readonly Type[] _types;

        public OnlyPrimitiveJsonConverter(params Type[] types)
        {
            _types = types;
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken t = JToken.FromObject(value, new JsonSerializer()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            });

            if (t.Type != JTokenType.Object)
            {
                t.WriteTo(writer);
            }
            else
            {
                JObject o = (JObject)t;

                var propertiesToRemove = new List<string>();

                foreach (var prop in value.GetType().GetProperties())
                {
                    if (
                        !prop.PropertyType.IsPrimitive &&
                        !prop.PropertyType.IsValueType &&
                        prop.PropertyType != typeof(string)
                        )
                    {
                        propertiesToRemove.Add(prop.Name);
                    }
                }

                foreach (var propToRemove in propertiesToRemove)
                {
                    o.Remove(propToRemove);
                }

                o.WriteTo(writer);
            }
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            throw new NotImplementedException("Unnecessary because CanRead is false. The type will skip the converter.");
        }

        public override bool CanRead
        {
            get { return false; }
        }

        public override bool CanConvert(Type objectType)
        {
            return _types.Any(t => t == objectType);
        }
    }

仅公共类PrimitiveJSONConverter:JsonConverter
{
私有只读类型[]\u类型；
仅公共PrimitiveJSONConverter（参数类型[]类型）
{
_类型=类型；
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
JToken t=JToken.FromObject（值，新的JsonSerializer（）
{
ReferenceLoopHandling=ReferenceLoopHandling.Ignore
});
if（t.Type！=JTokenType.Object）
{
t、 书面（作者）；
}
其他的
{
JObject o=（JObject）t；
var propertiesToRemove=新列表（）；
foreach（value.GetType（）.GetProperties（）中的var prop）
{
如果(
！prop.PropertyType.IsPrimitive&&
！prop.PropertyType.IsValueType&&
prop.PropertyType！=typeof（字符串）
)
{
propertiesToRemove.Add（属性名称）；
}
}
foreach（propertiesToRemove中的var propToRemove）
{
o、 移除（支撑物移除）；
}
o、 书面（作者）；
}
}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
抛出new NotImplementedException（“不必要，因为CanRead为false。该类型将跳过转换器。”）；
}
公共覆盖布尔可读取
{
获取{return false；}
}
公共覆盖布尔CanConvert（类型objectType）
{
返回_types.Any（t=>t==objectType）；
}
}

---

我并不宣称它是完美的，但它对我来说是有效的。它只是删除非原语和非值类型。

您可以创建一个自定义JsonConverter。这样，您就可以完全控制要序列化的内容。Json.NET是一个基于协定的序列化程序，它为要序列化的每个类型创建协定，然后根据协定进行序列化。基本上，你需要一个不同的合同，这取决于合同的深度，而这并不是设计的目的。有关一种可能的方法，请参阅。

    public class OnlyPrimitiveJsonConverter : JsonConverter
    {
        private readonly Type[] _types;

        public OnlyPrimitiveJsonConverter(params Type[] types)
        {
            _types = types;
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            JToken t = JToken.FromObject(value, new JsonSerializer()
            {
                ReferenceLoopHandling = ReferenceLoopHandling.Ignore
            });

            if (t.Type != JTokenType.Object)
            {
                t.WriteTo(writer);
            }
            else
            {
                JObject o = (JObject)t;

                var propertiesToRemove = new List<string>();

                foreach (var prop in value.GetType().GetProperties())
                {
                    if (
                        !prop.PropertyType.IsPrimitive &&
                        !prop.PropertyType.IsValueType &&
                        prop.PropertyType != typeof(string)
                        )
                    {
                        propertiesToRemove.Add(prop.Name);
                    }
                }

                foreach (var propToRemove in propertiesToRemove)
                {
                    o.Remove(propToRemove);
                }

                o.WriteTo(writer);
            }
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            throw new NotImplementedException("Unnecessary because CanRead is false. The type will skip the converter.");
        }

        public override bool CanRead
        {
            get { return false; }
        }

        public override bool CanConvert(Type objectType)
        {
            return _types.Any(t => t == objectType);
        }
    }