使用ItemsSource填充WPF ListBox-好主意? [英] Using ItemsSource to populate WPF ListBox - Good Idea?
问题描述
我是一位(相对)经验丰富的Cocoa/Objective-C编码器，并且正在自学C#和WPF框架.
I'm a (relatively) experienced Cocoa/Objective-C coder, and am teaching myself C# and the WPF framework.
在Cocoa中，填充NSTableView时，将委托和数据源分配给视图相对简单.然后使用这些委托/数据源方法填充表并确定其行为.
In Cocoa, when populating an NSTableView, it's relatively simply to assign a delegate and datasource to the view. Those delegate/datasource methods are then used to populate the table, and to determine its behavior.
我将一个简单的应用程序放在一起，该应用程序具有一个对象列表，让我们称它们为Dog对象，每个对象都有一个public string name.这是Dog.ToString()的返回值.
I'm putting together a simple application that has a list of objects, lets call them Dog objects, that each have a public string name. This is the return value of Dog.ToString().
对象将显示在ListBox中，我想使用与可可NSTableViewDataSource类似的样式填充该视图.当前似乎正在使用:
The objects will be displayed in a ListBox, and I would like to populate this view using a similar pattern to Cocoa's NSTableViewDataSource. It currently seems to be working using:
public partial class MainWindow : Window, IEnumerable<Dog>
{
public Pound pound = new Pound();
public MainWindow()
{
InitializeComponent();
Dog fido = new Dog();
fido.name = "Fido";
pound.AddDog(fido);
listBox1.ItemsSource = this;
Dog spot = new Dog();
spot.name = "Spot";
pound.AddDog(spot);
}
public IEnumerator<Dog> GetEnumerator()
{
return currentContext.subjects.GetEnumerator();
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
但是我想知道这是正确是什么.我实际上已经安装了Visual Studio不到一个小时，所以可以肯定地说我不知道自己在做什么.
But I'm wondering how correct this is. I've literally had Visual Studio installed for less than an hour, so it's safe to say I have no idea what I'm doing.
- 这是正确的模式吗?
- 将第二项添加到列表(
spot)似乎可以正确更新ListBox，但是我想知道是什么触发了更新? - 如果我在后台线程上更新
Pound会发生什么? - 如何手动要求
ListBox进行自我更新? (我什至需要吗?)
- Is this the proper pattern?
- Adding the second item to the list (
spot) seems to update theListBoxproperly, but I'm wondering what triggers the updates? - What happens if I update the
Poundon a background thread? - How can I manually ask the
ListBoxto update itself? (Do I even need to?)
我知道我需要做的
一项更改是将IEnumerable<Dog>实现重构为自己的类，例如DogListItemsSource，但是我想确保在完善它之前我有一个扎实的方法
One change that I know I need to make is refactoring the IEnumerable<Dog> implementation into its own class, like DogListItemsSource, but I want to make sure I have a solid approach before polishing it.
随意在评论中指出我应该解决或牢记的其他任何要点，无论大小.我想第一次学习正确的方法.
Feel free to point out, in comments, any other points I should address or keep in mind, big or small. I'd like to learn this the right way, the first time.
推荐答案
我的建议是在Window之外创建一个类，该类负责为您的ListBox提供数据. WPF是一种常见的方法，称为 MVVM ，它与任何模式一样都具有许多实现.
My suggestion would be to create a class besides your Window which would be responsible for providing the data to your ListBox. A common approach is WPF is called MVVM, which like any pattern has many implementations.
每个模型的基础知识(例如Pound和Dog)都将具有一个视图模型，该视图模型负责以易于与用户界面进行交互的方式来呈现模型.
The basics are each Model (e.g. Pound and Dog) would have a View Model responsible for presenting the model in a manner which is easy to interact with from the UI.
为使您入门，WPF提供了出色的课程， ObservableCollection<T> ，这是一个集合，在添加，移动或删除任何人时都会触发嘿，我改变了"事件.
To get you started, WPF provides an excellent class, ObservableCollection<T>, which is a collection that fires off a "Hey I Changed" event whenever anybody is added, moved, or removed.
下面是一个示例，它既不打算教您MVVM，也不打算使用任何MVVM框架.但是，如果您设置一些断点并使用它，您将了解绑定，命令，INotifyPropertyChanged和ObservableCollection.所有这些在WPF应用程序开发中都起着重要作用.
Below is an example that doesn't intend to teach you MVVM, nor does it use any framework for MVVM. However, if you set some breakpoints and play with it, you'll learn about bindings, commands, INotifyPropertyChanged, and ObservableCollection; all of which play a large role in WPF application development.
从MainWindow开始，您可以将DataContext设置为视图模型:
Starting in the MainWindow, you can set your DataContext to a View Model:
public class MainWindow : Window
{
// ...
public MainWindow()
{
// Assigning to the DataContext is important
// as all of the UIElement bindings inside the UI
// will be a part of this hierarchy
this.DataContext = new PoundViewModel();
this.InitializeComponent();
}
}
PoundViewModel用于管理DogViewModel对象的集合的地方:
Where the PoundViewModel manages a collection of DogViewModel objects:
public class PoundViewModel
{
// No WPF application is complete without at least 1 ObservableCollection
public ObservableCollection<DogViewModel> Dogs
{
get;
private set;
}
// Commands play a large role in WPF as a means of
// transmitting "actions" from UI elements
public ICommand AddDogCommand
{
get;
private set;
}
public PoundViewModel()
{
this.Dogs = new ObservableCollection<DogViewModel>();
// The Command takes a string parameter which will be provided
// by the UI. The first method is what happens when the command
// is executed. The second method is what is queried to find out
// if the command should be executed
this.AddDogCommand = new DelegateCommand<string>(
name => this.Dogs.Add(new DogViewModel { Name = name }),
name => !String.IsNullOrWhitespace(name)
);
}
}
在您的XAML中(请确保将xmlns:local映射为允许XAML使用您的视图模型):
And in your XAML (be sure to map xmlns:local to allow XAML to use your View Models):
<!-- <Window ...
xmlns:local="clr-namespace:YourNameSpace" -->
<!-- Binding the ItemsSource to Dogs, will use the Dogs property
-- On your DataContext, which is currently a PoundViewModel
-->
<ListBox x:Name="listBox1"
ItemsSource="{Binding Dogs}">
<ListBox.Resources>
<DataTemplate DataType="{x:Type local:DogViewModel}">
<Border BorderBrush="Black" BorderThickness="1" CornerRadius="5">
<TextBox Text="{Binding Name}" />
</Border>
</DataTemplate>
</ListBox.Resources>
</ListBox>
<GroupBox Header="New Dog">
<StackPanel>
<Label>Name:</Label>
<TextBox x:Name="NewDog" />
<!-- Commands are another big part of WPF -->
<Button Content="Add"
Command="{Binding AddDogCommand}"
CommandParameter="{Binding Text, ElementName=NewDog}" />
</StackPanel>
</GroupBox>
当然，您需要DogViewModel:
public class DogViewModel : INotifyPropertyChanged
{
private string name;
public string Name
{
get { return this.name; }
set
{
this.name = value;
// Needed to alert WPF to a change in the data
// which will then update the UI
this.RaisePropertyChanged("Name");
}
}
public event PropertyChangedHandler PropertyChanged;
private void RaisePropertyChanged(string propertyName)
{
var handler = this.PropertyChanged;
if (handler != null)
handler(this, new PropertyChangedEventArgs(propertyName));
}
}
最后，您将需要实现 DelegateCommand<T> :
Finally you'll need an implementation of DelegateCommand<T>:
public class DelegateCommand<T> : ICommand
{
private readonly Action<T> execute;
private readonly Func<T, bool> canExecute;
public event EventHandler CanExecuteChanged;
public DelegateCommand(Action<T> execute, Func<T, bool> canExecute)
{
if (execute == null) throw new ArgumentNullException("execute");
this.execute = execute;
this.canExecute = canExecute;
}
public bool CanExecute(T parameter)
{
return this.canExecute != null && this.canExecute(parameter);
}
bool ICommand.CanExecute(object parameter)
{
return this.CanExecute((T)parameter);
}
public void Execute(T parameter)
{
this.execute(parameter);
}
bool ICommand.Execute(object parameter)
{
return this.Execute((T)parameter);
}
}
这个答案绝不会让您鞭打沉浸式，完全绑定的WPF UI，但希望它能使您对UI如何与您的代码进行交互有一个了解！
This answer by no means will have you whipping up immersive, fully bound WPF UI's, but hopefully it'll give you a feel for how the UI can interact with your code!
这篇关于使用ItemsSource填充WPF ListBox-好主意?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
