WPF如何以结构化方式展示单个复杂对象的层级数据？

TreeView完全能搞定这个需求——它不仅能绑定集合，只要把单个复杂对象转换成可遍历的树节点结构，就能实现层级钻取。下面是具体实现步骤：

1. 创建通用树节点类 #

先定义一个通用的TreeNode类，统一包装对象的属性、值和子节点，适配TreeView的数据源结构：

public class TreeNode
{
    public string Name { get; set; }
    public string Value { get; set; }
    public List<TreeNode> Children { get; set; } = new List<TreeNode>();
    public bool IsExpandable => Children.Any();
}

2. 编写对象转树节点的递归方法 #

写一个递归工具方法，自动遍历复杂对象的属性，区分基本类型、嵌套对象和数组/集合，转换成TreeNode集合：

public static class ObjectToTreeConverter
{
    public static List<TreeNode> ConvertObjectToTree(object obj, string rootName = "Root")
    {
        var tree = new List<TreeNode>();
        if (obj == null)
        {
            tree.Add(new TreeNode { Name = rootName, Value = "null" });
            return tree;
        }

        var rootNode = new TreeNode { Name = rootName };
        ProcessObject(obj, rootNode);
        tree.Add(rootNode);
        return tree;
    }

    private static void ProcessObject(object obj, TreeNode parentNode)
    {
        var type = obj.GetType();

        // 处理数组或集合（排除字符串）
        if (typeof(IEnumerable).IsAssignableFrom(type) && type != typeof(string))
        {
            var enumerable = (IEnumerable)obj;
            int index = 0;
            foreach (var item in enumerable)
            {
                var itemNode = new TreeNode { Name = $"[{index}]" };
                index++;
                if (item == null)
                {
                    itemNode.Value = "null";
                    parentNode.Children.Add(itemNode);
                    continue;
                }

                var itemType = item.GetType();
                if (IsBasicType(itemType))
                {
                    itemNode.Value = item.ToString();
                    parentNode.Children.Add(itemNode);
                }
                else
                {
                    ProcessObject(item, itemNode);
                    parentNode.Children.Add(itemNode);
                }
            }
            return;
        }

        // 处理基本类型（字符串、数值、布尔、日期等）
        if (IsBasicType(type))
        {
            parentNode.Value = obj.ToString();
            return;
        }

        // 处理复杂对象的属性
        foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            var propValue = prop.GetValue(obj);
            var propNode = new TreeNode { Name = prop.Name };

            if (propValue == null)
            {
                propNode.Value = "null";
                parentNode.Children.Add(propNode);
                continue;
            }

            var propType = propValue.GetType();
            if (IsBasicType(propType))
            {
                propNode.Value = propValue.ToString();
                parentNode.Children.Add(propNode);
            }
            else
            {
                ProcessObject(propValue, propNode);
                parentNode.Children.Add(propNode);
            }
        }
    }

    // 判断是否为可直接显示的基础类型
    private static bool IsBasicType(Type type)
    {
        return type.IsValueType || type == typeof(string) || type == typeof(DateTime);
    }
}

3. XAML中配置TreeView #

在XAML里设置TreeView的层级模板，绑定TreeNode的属性，实现结构化展示：

<TreeView ItemsSource="{Binding ObjectTree}">
    <TreeView.ItemTemplate>
        <HierarchicalDataTemplate ItemsSource="{Binding Children}">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Name}" FontWeight="Bold" Margin="0 0 5 0"/>
                <TextBlock Text="{Binding Value}" Foreground="Gray"/>
            </StackPanel>
        </HierarchicalDataTemplate>
    </TreeView.ItemTemplate>
</TreeView>

4. 在ViewModel中使用 #

把你解析好的复杂对象转换成TreeView数据源，绑定到界面：

public class MainViewModel : INotifyPropertyChanged
{
    private List<TreeNode> _objectTree;
    public List<TreeNode> ObjectTree
    {
        get => _objectTree;
        set
        {
            _objectTree = value;
            OnPropertyChanged();
        }
    }

    public MainViewModel()
    {
        // 替换成你实际解析后的复杂对象
        var myComplexObj = ParseJsonToObject();
        ObjectTree = ObjectToTreeConverter.ConvertObjectToTree(myComplexObj, "My Complex Object");
    }

    // 模拟JSON解析逻辑
    private MyComplexObject ParseJsonToObject()
    {
        // 这里可以用Newtonsoft.Json或System.Text.Json解析你的JSON字符串
        return new MyComplexObject
        {
            Name = "Sample Data",
            Description = "Nested complex object example",
            Details = new Detail
            {
                Id = 123,
                Tags = new List<string> { "WPF", "TreeView", "JSON" },
                Nested = new NestedItem { Value = "Deep nested value" }
            }
        };
    }

    // INotifyPropertyChanged实现
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}

// 示例复杂对象模型（替换成你自己的模型类）
public class MyComplexObject
{
    public string Name { get; set; }
    public string Description { get; set; }
    public Detail Details { get; set; }
}

public class Detail
{
    public int Id { get; set; }
    public List<string> Tags { get; set; }
    public NestedItem Nested { get; set; }
}

public class NestedItem
{
    public string Value { get; set; }
}

额外优化建议 #

• 给TreeNode添加Type属性，根据数据类型设置不同的显示样式（比如数组用蓝色标识）
• 支持读取属性的DisplayName特性，让节点名称更友好
• 添加循环引用检测，避免转换时栈溢出
• 控制默认展开/折叠状态，比如默认展开前两层节点

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