Question

我试图通过一个简单的例子来掌握WPF数据绑定的概念，但似乎我并没有完全明白所有这一点。

这个例子是级联下拉列表之一; XAML如下：

<Window x:Class="CascadingDropDown.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="496" Width="949" Loaded="Window_Loaded">
    <Grid>
        <ComboBox Name="comboBox1" ItemsSource="{Binding}" DisplayMemberPath="Key" SelectionChanged="comboBox1_SelectionChanged" />
        <ComboBox Name="comboBox2" ItemsSource="{Binding}" DisplayMemberPath="Name" />
    </Grid>
</Window>

这是表格的代码：

public partial class MainWindow : Window
{
    private ObservableCollection<ItemA> m_lstItemAContext = new ObservableCollection<ItemA>();
    private ObservableCollection<ItemB> m_lstItemBContext = new ObservableCollection<ItemB>();
    private IEnumerable<ItemB> m_lstAllItemB = null;

    public MainWindow()
    {
        InitializeComponent();

        this.comboBox1.DataContext = m_lstItemAContext;
        this.comboBox2.DataContext = m_lstItemBContext;
    }

    private void Window_Loaded(object sender, RoutedEventArgs e)
    {
        var lstItemA = new List<ItemA>() { new ItemA("aaa"), new ItemA("bbb"), new ItemA("ccc") };
        var lstItemB = new List<ItemB>() { new ItemB("aaa", "a11"), new ItemB("aaa", "a22"), new ItemB("bbb", "b11"), new ItemB("bbb", "b22") };

        initPicklists(lstItemA, lstItemB);
    }

    private void initPicklists(IEnumerable<ItemA> lstItemA, IEnumerable<ItemB> lstItemB)
    {
        this.m_lstAllItemB = lstItemB;

        this.m_lstItemAContext.Clear();
        lstItemA.ToList().ForEach(a => this.m_lstItemAContext.Add(a));
    }

    #region Control event handlers

    private void comboBox1_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        ComboBox ddlSender = (ComboBox)sender;
        ItemA itemaSelected = (ItemA)ddlSender.SelectedItem;

        var lstNewItemB = this.m_lstAllItemB.Where(b => b.KeyA == itemaSelected.Key);

        this.m_lstItemBContext.Clear();
        lstNewItemB.ToList().ForEach(b => this.m_lstItemBContext.Add(b));
    }

    private void comboBox2_?(object sender, ?EventArgs e)
    {
        // disable ComboBox  if empty
    }
    #endregion Control event handlers
}

这些是我的数据类：

class ItemA
{
    public string Key { get; set; }

    public ItemA(string sKey)
    {
        this.Key = sKey;
    }
}

class ItemB
{
    public string KeyA { get; set; }

    public string Name { get; set; }

    public ItemB(string sKeyA, string sName)
    {
        this.KeyA = sKeyA;
        this.Name = sName;
    }
}

因此，只要在comboBox1中选择了某个项目，就会在comboBox2中显示相应的项目。这是使用当前代码，但我不确定我重新填充相应的ObservableCollection的方式是否理想。

我无法实现的实际上是对comboBox2的基础集合中的更改作出反应，例如当列表为空时（即在comboBox1中选择“ccc”时）停用控件。

当然，我可以在ObservableCollection的CollectionChanged事件上使用事件处理程序，这可以在此示例中使用，但在更复杂的情况下，ComboBox的DataContext可能会更改为完全不同的对象（可能返回），这意味着双重依赖 - 我不仅要切换DataContext，还要来回切换事件处理程序。这对我来说似乎不对，但我可能只是在一个完全错误的轨道上。

基本上，我要找的是在控件而不是底层列表上触发的事件;不是ObservableCollection宣布“我的内容已经改变”，但是ComboBox告诉我“事情发生在我的项目上”。

我需要做什么，或者我需要在哪里纠正我对整个概念的看法？

Answer 1

基本上，我要找的是在控件而不是底层列表上触发的事件;不是ObservableCollection宣布“我的内容已经改变”，但ComboBox告诉我“事情发生在我的项目上”

如果您想使用MVVM模式，那么我会说不。不是控件应该提供信息，而是你的viewmodel应该。

首先采取ObservableCollection是一个很好的步骤。在你的specail情况下，我会考虑用ItemA创建一个列表，我会向ItemA添加一个类型为ItemB的新List属性。

class ItemA
{
public string Key { get; set; }

public ItemA(string sKey)
{
    this.Key = sKey;
}

public IEnumerable<ItemB> ListItemsB { get; set;}

}

我假设ItemA是父母？

class ItemB
{

public string Name { get; set; }

public ItemB(string sName)
{
    this.Name = sName;
}
}

你有一个ItemA集合，每个ItemA都有自己的依赖ItemB列表。

<ComboBox x:Name="cbo_itemA" ItemsSource="{Binding ListItemA}" DisplayMemberPath="Key"/>
<ComboBox ItemsSource="{Binding ElementName=cbo_itemA, Path=SelectedItem.ListItemsB}"
          DisplayMemberPath="Name" />

Answer 2

以下是更清洁（可能不是更优化）的方法来实现这一点，保持您的业务模式不变，并且只在可能的情况下使用ViewModel和XAML：

查看型号：

public class WindowViewModel : INotifyPropertyChanged
{
    private ItemA selectedItem;


    private readonly ObservableCollection<ItemA> itemsA = new ObservableCollection<ItemA>();
    private readonly ObservableCollection<ItemB> itemsB = new ObservableCollection<ItemB>();
    private readonly List<ItemB> internalItemsBList = new List<ItemB>();


    public WindowViewModel()
    {
        itemsA = new ObservableCollection<ItemA> { new ItemA("aaa"), new ItemA("bbb"), new ItemA("ccc") };
        InvokePropertyChanged(new PropertyChangedEventArgs("ItemsA"));

        internalItemsBList = new List<ItemB> { new ItemB("aaa", "a11"), new ItemB("aaa", "a22"), new ItemB("bbb", "b11"), new ItemB("bbb", "b22") };

    }

    public ObservableCollection<ItemA> ItemsA
    {
        get { return itemsA; }
    }

    public ItemA SelectedItem
    {
        get { return selectedItem; }

        set
        {
            selectedItem = value;

            ItemsB.Clear();
            var tmp = internalItemsBList.Where(b => b.KeyA == selectedItem.Key);
            foreach (var itemB in tmp)
            {
                ItemsB.Add(itemB);
            }


            InvokePropertyChanged(new PropertyChangedEventArgs("SelectedItem"));
        }
    }

    public ObservableCollection<ItemB> ItemsB
    {
        get { return itemsB; }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public void InvokePropertyChanged(PropertyChangedEventArgs e)
    {
        PropertyChangedEventHandler handler = PropertyChanged;
        if (handler != null) handler(this, e);
    }
}

代码背后：

public partial class Window1
{
    public Window1()
    {
        InitializeComponent();
        DataContext = new WindowViewModel();
    }
}

和XAML：

 <StackPanel>
    <ComboBox Name="comboBox1" ItemsSource="{Binding ItemsA}" DisplayMemberPath="Key" SelectedItem="{Binding SelectedItem, Mode=TwoWay}"  />
    <ComboBox Name="comboBox2" ItemsSource="{Binding ItemsB}" DisplayMemberPath="Name">
        <ComboBox.Style>
            <Style TargetType="{x:Type ComboBox}">
                <Setter Property="IsEnabled" Value="true"/>
                <Style.Triggers>
                    <DataTrigger Binding="{Binding ItemsB.Count}" Value="0">
                        <Setter Property="IsEnabled" Value="false"/>
                    </DataTrigger>
                </Style.Triggers>
            </Style>
        </ComboBox.Style>
    </ComboBox>
</StackPanel>

复制粘贴这应该有用。

几乎没有随意的想法：

1）在WPF中，尝试始终使用MVVM模式，并且永远不要将代码放在代码隐藏文件中以用于事件处理程序。对于用户操作（如按钮单击），请使用命令模式。对于没有命令的其他用户操作，请尽可能多地考虑“绑定方式”：您可以做很多事情，因为您可以从VM属性设置器中的视图中截取事件（在您的示例中，我使用{ {1}}属性设置器。）

2）尽可能多地使用XAML。 WPF框架提供了一个非常强大的绑定和触发器系统（在您的示例中，组合框的启用不需要任何C＃行）。

3）ObservableCollection通过绑定使视图模型暴露给视图。它们还可以与您可以在视图模型中处理的CollectionChanged事件一起使用。利用它（在你的例子中，我在VM中使用Observable集合，这将发生这种播放，并且集合中的任何更改都会通过DataBinding反映在视图中）。

希望这会有所帮助！

Answer 3

您需要Keys系列吗？如果不是，我建议通过CollectionView

分组从项目中动态创建它

private ObservableCollection<object> _Items = new ObservableCollection<object>()
{
    new { Key = "a", Name = "Item 1" },
    new { Key = "a", Name = "Item 2" },
    new { Key = "b", Name = "Item 3" },
    new { Key = "c", Name = "Item 4" },
};
public ObservableCollection<object> Items { get { return _Items; } }

<StackPanel>
    <StackPanel.Resources>
        <CollectionViewSource x:Key="ItemsSource" Source="{Binding Items}">
            <CollectionViewSource.GroupDescriptions>
                <PropertyGroupDescription PropertyName="Key"/>
            </CollectionViewSource.GroupDescriptions>
        </CollectionViewSource>
    </StackPanel.Resources>
    <StackPanel.Children>
        <ComboBox Name="keyCb" ItemsSource="{Binding Source={StaticResource ItemsSource}, Path=Groups}" DisplayMemberPath="Name"/>
        <ComboBox ItemsSource="{Binding ElementName=keyCb, Path=SelectedItem.Items}" DisplayMemberPath="Name"/>
    </StackPanel.Children>
</StackPanel>

第一个ComboBox显示通过Key - 属性分组生成的键，第二个键绑定到第一个ComboBox中所选项目的子项，显示项目的Name。

另请参阅CollectionViewGroup reference，在第一个CB中我使用Name中的Items。

当然，您也可以手动创建这些密钥组，方法是将项目嵌套在密钥对象中。

WPF数据绑定 - 我错过了什么？

3 个答案: