Wie können Schaltflächen eingebunden und ihre Ereignisse in einer ListBox abgebildet werden?

Question

Ich habe eine Konzeptfrage, wie eine dynamische Liste durch ein Listenfeld angezeigt wird. Innerhalb des Listenfelds werden die Elemente in einem Stackpanel gespeichert. Innerhalb des Stack-Panels befindet sich eine Zeichenfolge und eine Schaltfläche. Wenn ich auf diese Schaltfläche klicke, wird diese Entität/dieses Element (sowohl die Schaltfläche als auch die Zeichenfolge) aus dem Listenfeld entfernt.

1) Wie erstelle ich neue Schaltflächen basierend auf der Anzahl der Entitäten in der Liste?
2) Wie verbinde ich die Idee, dass diese Schaltfläche mit diesem Element in der Listbox verbunden ist?
3) Ist das überhaupt möglich mit Bindung?

Tut mir leid, ich bin noch neu in WPF, aber ich beginne zu sehen, dass es ziemlich mächtig ist.

Wenn Sie auch ein kurzes/kurzes Beispiel angeben können, oder mich auf einen Link verweisen, der diesem ähnlich ist, wäre es sehr zu schätzen. Vielen Dank! :)

Answer 1

Ich denke, Sie müssen die Steuerelementvorlage und oder die Inhaltsvorlage des Steuerelements ändern. Sehen Sie sich die folgenden Links an http://mark-dot-net.blogspot.com/2007/07/creating-custom-wpf-button-template-in.htmlhttp://msdn.microsoft.com/en-us/magazine/cc163497.aspx

Hoffe, das hilft.

Answer 2

Dies ist ein einfaches Beispiel, wie Sie dies tun können. Zuerst die Quellklasse für die ListBox. Eine einfache Klasse, die die INotifyPropertyChanged-Schnittstelle und eine Zeichenfolgeneigenschaft implementiert.

public class MyClass : INotifyPropertyChanged 
{ 
    public MyClass(string myString) 
    { 
     MyString = myString; 
    } 
    private string m_myString; 
    public string MyString 
    { 
     get 
     { 
      return m_myString; 
     } 
     set 
     { 
      m_myString = value; 
      OnPropertyChanged("MyString"); 
     } 
    } 

    public event PropertyChangedEventHandler PropertyChanged; 
    private void OnPropertyChanged(string propertyName) 
    { 
     if (PropertyChanged != null) 
     { 
      PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); 
     } 
    } 
} 

Das MainWindow hat eine ObservableCollection von MyClass. Wir setzen den DataContext für das Fenster auf sich selbst (dies), damit ListBox den DataContext erbt, so dass wir seine ItemsSource an MyClasses binden können.

public partial class MainWindow : Window 
{ 
    public MainWindow() 
    { 
     InitializeComponent(); 
     MyClasses = new ObservableCollection<MyClass>(); 
     MyClasses.Add(new MyClass("My String 1")); 
     MyClasses.Add(new MyClass("My String 2")); 
     MyClasses.Add(new MyClass("My String 3")); 
     this.DataContext = this; 
    } 

    public ObservableCollection<MyClass> MyClasses 
    { 
     get; 
     private set; 
    } 
} 

In XAML haben wir die ListBox, die an MyClasses bindet. Das ItemTemplate ist für jedes ListBoxItem in der ListBox, jedes Element, das an seine Instanz von MyClass bindet, die MyString-Eigenschaft und einen "Remove Button". Der DataContext für jedes ListBoxItem ist eine Instanz von MyClass.

<ListBox ItemsSource="{Binding MyClasses}"> 
    <ListBox.ItemTemplate> 
     <DataTemplate> 
      <StackPanel Orientation="Horizontal"> 
       <TextBlock Text="{Binding MyString}" Margin="6"/> 
       <Button Content="Remove" 
         Click="RemoveListBoxItem_Click"/> 
      </StackPanel> 
     </DataTemplate> 
    </ListBox.ItemTemplate> 
</ListBox> 

Schließlich fügen wir den Code hinter EventHanlder für RemoveListBoxItem_Click in MainWindow.xaml.cs.

private void RemoveListBoxItem_Click(object sender, RoutedEventArgs e) 
{ 
    // The clicked Button 
    Button button = sender as Button; 
    // The DataContext of the Button will be its instance of MyClass 
    MyClass selectedItem = button.DataContext as MyClass; 
    if (selectedItem != null) 
    { 
     // Remove the MyClass item from the collection 
     MyClasses.Remove(selectedItem); 
    } 
}