Visual Studio中WPF前端树结构与后端数据传递实现难题

我在WPF前端用以下树形结构类在列表框展示数据：

public class Root
{
    public string Name;
    public List<Root> Children;
    public Root(string name)
    {
        Name = name;
        Children = new List<Root>();
    }

    public void AddChild(Root rootObject)
    {
        Children.Add(rootObject);
    }
}

public class Unit : Root { }
public class SubUnit : Root { }
public class Platoon : Root { }
public class Section : Root { }

其中SubUnit和Platoon还有额外唯一值字段（示例已省略），当前前端展示逻辑正常，但需要从后端填充这个树形列表：希望后端通过递归方法遍历自身结构，生成前端树结构后返回给前端展示。

后端结构如下（可按需调整，唯一值字段已省略）：

public class BackendUnit 
{
    public BackEndSubUnit SubUnit;
} 

public class BackEndSubUnit
{
    public List<BackEndPlatoon> MyPlatoonns;
    public List<BackEndSubUnit> MySubUnits;
}

public class BackEndPlatoon
{
    public List<BackEndSection> MySections;
}

public class BackEndSection
{
}

设计原则是前端无需知晓后端结构，目前的难题是：如何让后端识别前端的树结构类，从而递归填充后返回给前端？

核心思路是通过共享模型层（或DTO层）实现前后端模型解耦，后端依赖共享层的模型而非直接引用前端类，同时编写递归转换逻辑完成后端到前端模型的映射。

1. 定义共享模型层 #

把前端的Root及其子类抽离到独立类库（如Shared.Models），前后端项目都引用这个类库。这样后端能直接使用这些模型，前端也无需接触后端结构。

补全字段后的共享模型示例：

public class Root
{
    public string Name { get; set; }
    public List<Root> Children { get; set; } = new List<Root>();

    protected Root(string name)
    {
        Name = name;
    }
}

public class Unit : Root
{
    public Unit(string name) : base(name) { }
}

public class SubUnit : Root
{
    public string UniqueId { get; set; } // 示例唯一值字段
    public SubUnit(string name, string uniqueId) : base(name)
    {
        UniqueId = uniqueId;
    }
}

public class Platoon : Root
{
    public int PlatoonNumber { get; set; } // 示例唯一值字段
    public Platoon(string name, int platoonNumber) : base(name)
    {
        PlatoonNumber = platoonNumber;
    }
}

public class Section : Root
{
    public Section(string name) : base(name) { }
}

2. 编写递归转换方法 #

在后端创建转换类（如TreeModelConverter），实现后端实体到共享前端模型的递归转换：

public static class TreeModelConverter
{
    // 入口：转换BackendUnit到前端Unit模型
    public static Unit ConvertToFrontendUnit(BackendUnit backendUnit)
    {
        if (backendUnit == null || backendUnit.SubUnit == null)
            return null;

        var frontendUnit = new Unit("主单位");
        var subUnitModel = ConvertToFrontendSubUnit(backendUnit.SubUnit);
        if (subUnitModel != null)
            frontendUnit.Children.Add(subUnitModel);
        
        return frontendUnit;
    }

    // 转换BackEndSubUnit到前端SubUnit模型
    private static SubUnit ConvertToFrontendSubUnit(BackEndSubUnit backendSubUnit)
    {
        if (backendSubUnit == null)
            return null;

        // 假设后端SubUnit有Name和UniqueId字段，按需调整
        var frontendSubUnit = new SubUnit(backendSubUnit.Name, backendSubUnit.UniqueId);

        // 递归转换子SubUnit
        if (backendSubUnit.MySubUnits != null)
        {
            foreach (var sub in backendSubUnit.MySubUnits)
            {
                var childSub = ConvertToFrontendSubUnit(sub);
                if (childSub != null)
                    frontendSubUnit.Children.Add(childSub);
            }
        }

        // 转换下属Platoon
        if (backendSubUnit.MyPlatoonns != null)
        {
            foreach (var platoon in backendSubUnit.MyPlatoonns)
            {
                var platoonModel = ConvertToFrontendPlatoon(platoon);
                if (platoonModel != null)
                    frontendSubUnit.Children.Add(platoonModel);
            }
        }

        return frontendSubUnit;
    }

    // 转换BackEndPlatoon到前端Platoon模型
    private static Platoon ConvertToFrontendPlatoon(BackEndPlatoon backendPlatoon)
    {
        if (backendPlatoon == null)
            return null;

        // 假设后端Platoon有Name和PlatoonNumber字段
        var frontendPlatoon = new Platoon(backendPlatoon.Name, backendPlatoon.PlatoonNumber);

        // 转换下属Section
        if (backendPlatoon.MySections != null)
        {
            foreach (var section in backendPlatoon.MySections)
            {
                var sectionModel = new Section(section.Name);
                frontendPlatoon.Children.Add(sectionModel);
            }
        }

        return frontendPlatoon;
    }
}

3. 后端接口返回转换后的模型 #

后端API调用转换方法，直接返回共享模型给前端：

[ApiController]
[Route("api/tree")]
public class TreeController : ControllerBase
{
    [HttpGet]
    public IActionResult GetUnitTree()
    {
        // 从数据源获取后端实体
        var backendUnit = GetBackendUnitFromDataSource();
        
        // 转换为前端模型
        var frontendTree = TreeModelConverter.ConvertToFrontendUnit(backendUnit);
        
        return Ok(frontendTree);
    }

    // 模拟数据获取逻辑
    private BackendUnit GetBackendUnitFromDataSource()
    {
        return new BackendUnit
        {
            SubUnit = new BackEndSubUnit
            {
                Name = "一级子单位",
                UniqueId = "SU001",
                MySubUnits = new List<BackEndSubUnit>
                {
                    new BackEndSubUnit { Name = "二级子单位", UniqueId = "SU002" }
                },
                MyPlatoonns = new List<BackEndPlatoon>
                {
                    new BackEndPlatoon
                    {
                        Name = "一排",
                        PlatoonNumber = 1,
                        MySections = new List<BackEndSection>
                        {
                            new BackEndSection { Name = "一班" },
                            new BackEndSection { Name = "二班" }
                        }
                    }
                }
            }
        };
    }
}

4. 前端接收数据并展示 #

前端WPF项目引用共享模型类库，调用接口获取数据后直接绑定（原有展示逻辑无需修改）：

private async Task LoadTreeData()
{
    using var httpClient = new HttpClient();
    var response = await httpClient.GetFromJsonAsync<Unit>("https://your-api-url/api/tree");
    // 将数据绑定到列表框
    treeListBox.ItemsSource = response.Children;
}

替代方案：用AutoMapper简化转换 #

若不想手动写递归代码，可使用AutoMapper配置映射规则：

1. 安装AutoMapper NuGet包到后端项目
2. 配置映射规则：

public class MappingProfile : Profile
{
    public MappingProfile()
    {
        CreateMap<BackEndSubUnit, SubUnit>()
            .ForMember(dest => dest.Children, opt => opt.MapFrom(src => 
                src.MySubUnits.Cast<object>().Concat(src.MyPlatoonns.Cast<object>())));
        
        CreateMap<BackEndPlatoon, Platoon>()
            .ForMember(dest => dest.Children, opt => opt.MapFrom(src => src.MySections));
        
        CreateMap<BackEndSection, Section>();
        
        CreateMap<BackendUnit, Unit>()
            .ForMember(dest => dest.Children, opt => opt.MapFrom(src => new List<Root> { src.SubUnit }));
    }
}

3. 初始化并使用：

var config = new MapperConfiguration(cfg => cfg.AddProfile<MappingProfile>());
var mapper = new Mapper(config);
var frontendTree = mapper.Map<Unit>(backendUnit);

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