如何在WPF ListView中分组显示多分支员工列表？

Great question! Manually flattening all employees into a single list works, but there's a much cleaner and more efficient approach that leverages your UI framework's built-in collection grouping capabilities—no need to duplicate or rearrange your original data structure.

Assuming you're using WPF (since you mentioned ListView), here's how to do it:

Step 1: Keep your original data structure #

First, you don't need to modify your Branch/Employee classes. Let's assume they look like this:

public class Branch
{
    public string BranchName { get; set; }
    public ObservableCollection<Employee> Employees { get; set; } = new();
}

public class Employee
{
    public string FullName { get; set; }
    // Add other employee properties here
}

Using ObservableCollection instead of List will let the UI automatically update if employees are added/removed later.

Step 2: Create a grouped view (no manual flattening!) #

Instead of merging all employees into one list, create a collection view that dynamically groups employees by their parent branch. Here's how to do it in your view model:

// Assume you have a collection of all branches
public ObservableCollection<Branch> AllBranches { get; set; } = new();

// Create a grouped view of employees
public ListCollectionView GroupedEmployeesView { get; private set; }

public YourViewModel()
{
    // Project each employee with their branch (deferred execution, no extra list upfront)
    var employeesWithBranch = AllBranches
        .SelectMany(branch => branch.Employees.Select(emp => new { Branch = branch, Employee = emp }));

    // Wrap in a ListCollectionView to enable grouping
    GroupedEmployeesView = new ListCollectionView(employeesWithBranch.ToList());
    
    // Add grouping by branch name
    GroupedEmployeesView.GroupDescriptions.Add(new PropertyGroupDescription("Branch.BranchName"));
}

The SelectMany projects each employee along with their branch, but since we use ToList() only once, it's efficient—no repeated enumeration of your original branches.

Step 3: Bind your ListView to the grouped view #

In XAML, set up your ListView to use the grouped view, and define a GroupStyle to show branch headers:

<ListView ItemsSource="{Binding GroupedEmployeesView}">
    <!-- Style for branch headers -->
    <ListView.GroupStyle>
        <GroupStyle>
            <GroupStyle.HeaderTemplate>
                <DataTemplate>
                    <TextBlock 
                        Text="{Binding Name}" 
                        FontWeight="Bold" 
                        FontSize="14" 
                        Margin="0,8,0,4"
                        Foreground="#2c3e50"/>
                </DataTemplate>
            </GroupStyle.HeaderTemplate>
        </GroupStyle>
    </ListView.GroupStyle>

    <!-- Template for individual employees -->
    <ListView.ItemTemplate>
        <DataTemplate>
            <StackPanel Margin="20,2,0,2">
                <TextBlock Text="{Binding Employee.FullName}"/>
                <!-- Add other employee details here -->
            </StackPanel>
        </DataTemplate>
    </ListView.ItemTemplate>
</ListView>

Why this is better than manual flattening: #

• Efficiency: You avoid creating a separate list of employees (unless you explicitly call ToList(), which is only done once). If your dataset is large, this saves memory and processing time.
• Maintainable: Your original data structure stays intact—no need to sync changes between the flattened list and your Branch objects.
• Dynamic Updates: If you use ObservableCollection for branches and employees, the grouped view will automatically update when employees are added/removed or branch names change.

For WinForms Users: #

If you're working with WinForms ListView, grouping is a bit trickier (since WinForms ListView doesn't have built-in grouping support like WPF). Instead, you can:

• Use a DataGridView with grouping (via BindingSource and PropertyDescriptor), or
• Use a third-party control like Telerik RadListView or DevExpress GridControl that supports out-of-the-box grouping.

Either way, the core idea is the same: leverage framework/control features to handle grouping instead of manual list merging.

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