如何移除嵌套类中的子属性？序列化前清理复杂类结构

当然可以搞定！不管你的类结构嵌套得有多深，都能在序列化前精准移除指定的子属性。你之前用ExpandoObject只处理了顶级属性，是因为没做递归遍历——咱们得逐层钻到对象的嵌套结构里，找到目标属性再动手。下面给你几种实用方案，结合你要移除OneOneOneOne属性的需求来举例：

先假设你的类结构大概是这样（如果和实际有出入，调整代码里的类型逻辑就行）：

public class RootClass
{
    public LevelOne One { get; set; }
}

public class LevelOne
{
    public LevelTwo OneOne { get; set; }
}

public class LevelTwo
{
    public LevelThree OneOneOne { get; set; }
}

public class LevelThree
{
    public string OneOneOneOne { get; set; }
    public string KeepThisProperty { get; set; }
}

方案一：递归反射遍历（无第三方库依赖） #

如果不想引入外部库，可以用反射递归遍历所有层级的属性，找到目标后移除（或者设为null，取决于你是否需要保留属性键但值为空）。

public static void RemoveNestedProperty(object obj, string targetPropertyName)
{
    if (obj == null) return;

    var type = obj.GetType();
    // 先检查当前对象是否有目标属性
    var targetProp = type.GetProperty(targetPropertyName);
    if (targetProp != null && targetProp.CanWrite)
    {
        // 如果是要彻底从序列化结构中移除，普通类无法直接删除属性，只能设为null
        // 若要完全移除键，建议转成字典处理（看方案三）
        targetProp.SetValue(obj, null);
        return;
    }

    // 递归遍历所有引用类型的子属性（跳过string这类特殊值类型）
    foreach (var prop in type.GetProperties().Where(p => p.PropertyType.IsClass && p.PropertyType != typeof(string)))
    {
        var childObj = prop.GetValue(obj);
        RemoveNestedProperty(childObj, targetPropertyName);
    }
}

调用方式：

var myRootObject = new RootClass { /* 初始化你的对象 */ };
RemoveNestedProperty(myRootObject, "OneOneOneOne");
// 之后序列化myRootObject即可，OneOneOneOne属性会被设为null

方案二：使用Json.NET自定义ContractResolver（推荐） #

如果项目里已经用了Newtonsoft.Json（Json.NET），这是最简洁高效的方法——不需要修改原对象，直接在序列化时跳过指定属性，不管嵌套层级多深都会生效。

public class ExcludeTargetPropertyResolver : DefaultContractResolver
{
    private readonly string _propertyToExclude;

    public ExcludeTargetPropertyResolver(string propertyToExclude)
    {
        _propertyToExclude = propertyToExclude;
    }

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        var property = base.CreateProperty(member, memberSerialization);
        // 匹配目标属性名，忽略大小写（可以根据需求改成严格匹配）
        if (property.PropertyName.Equals(_propertyToExclude, StringComparison.OrdinalIgnoreCase))
        {
            // 告诉序列化器不要序列化这个属性
            property.ShouldSerialize = _ => false;
        }
        return property;
    }
}

序列化时使用这个Resolver：

var serializerSettings = new JsonSerializerSettings
{
    ContractResolver = new ExcludeTargetPropertyResolver("OneOneOneOne")
};
var jsonResult = JsonConvert.SerializeObject(myRootObject, serializerSettings);
// 生成的JSON里完全不会出现OneOneOneOne属性

方案三：递归转字典移除属性（适配ExpandoObject场景） #

如果你更习惯用字典/ExpandoObject来操作，可以把整个嵌套对象转成字典，然后递归找到目标属性并移除，最后序列化字典。

// 将对象转成嵌套字典
public static IDictionary<string, object> ConvertObjectToNestedDict(object obj)
{
    var expandoDict = new ExpandoObject() as IDictionary<string, object>;
    foreach (var prop in obj.GetType().GetProperties())
    {
        var propValue = prop.GetValue(obj);
        if (propValue != null && prop.PropertyType.IsClass && prop.PropertyType != typeof(string))
        {
            // 递归转换子对象
            expandoDict.Add(prop.Name, ConvertObjectToNestedDict(propValue));
        }
        else
        {
            expandoDict.Add(prop.Name, propValue);
        }
    }
    return expandoDict;
}

// 递归移除目标属性
public static void RemovePropertyFromNestedDict(IDictionary<string, object> dict, string targetPropertyName)
{
    if (dict.ContainsKey(targetPropertyName))
    {
        dict.Remove(targetPropertyName);
        return;
    }

    // 遍历子字典，递归处理
    foreach (var kvp in dict.ToList()) // 用ToList避免遍历中修改集合导致异常
    {
        if (kvp.Value is IDictionary<string, object> childDict)
        {
            RemovePropertyFromNestedDict(childDict, targetPropertyName);
        }
    }
}

调用方式：

var rootDict = ConvertObjectToNestedDict(myRootObject);
RemovePropertyFromNestedDict(rootDict, "OneOneOneOne");
var jsonResult = JsonConvert.SerializeObject(rootDict);

内容的提问来源于stack exchange，提问作者Dan Hall