WPF DataTemplate-und Bindung

Ich weiterhin mein Verständnis von MVVC mit der code von MSDN und ich habe eine Frage.

In der .xaml-Sie haben eine Liste der Befehle auf dem Bildschirm angezeigt.

   <Border 
    Grid.Column="0" 
    Style="{StaticResource MainBorderStyle}"
    Width="170"
    >
    <HeaderedContentControl
      Content="{Binding Path=Commands}"
      ContentTemplate="{StaticResource CommandsTemplate}"
      Header="Control Panel"
      Style="{StaticResource MainHCCStyle}"
      />
  </Border>

Von hier, ich verstehe, dass der DataContext gesetzt ist (hier nicht gezeigt) und es zeigt die Sammlung der Befehle. Was ich nicht verstehe, ist die CommandsTemplate, die Sie unten sehen können:

<DataTemplate x:Key="CommandsTemplate">
<ItemsControl IsTabStop="False" ItemsSource="{Binding}" Margin="6,2">
  <ItemsControl.ItemTemplate>
    <DataTemplate>
      <TextBlock Margin="2,6">pou
        <Hyperlink Command="{Binding Path=Command}">
          <TextBlock Text="{Binding Path=DisplayName}" />
        </Hyperlink>
      </TextBlock>
    </DataTemplate>
  </ItemsControl.ItemTemplate>
</ItemsControl>
</DataTemplate>

Wie funktioniert die Bindung geschaffen wird? Wie dieser code sagen, um zu überprüfen, die Eigenschaft "Befehl" und "DisplayName" aus dem Objekt in die Sammlung? Ist es von der ItemsSource? Wenn ja, verstehe ich nicht, warum es nur bei {Binding}. Wer kann mir erklären bitte, wie das DataTemplate, bindearbeiten von einem ContentTemplate?

InformationsquelleAutor Patrick Desjardins | 2009-07-15

.net-3.5 c#data-binding templates wpf

9

Als Sie sagte: der DataContext gesetzt ist, um die ViewModel-Klasse, also das Steuerelement, das Sie erwähnten in XAML wird in der Lage sein, um Zugriff auf die öffentlichen Eigenschaften des ViewModel.

Beispiel:
```
private ObservableCollection<Commander> commands = new ObservableCollection<Commander>();

    public ObservableCollection<Commander> Commands {
        get { return commands; }
        set { commands = value; }
    }
```
Die Struktur der Commander-Klasse.
```
public class Commander {
    public ICommand Command { get; set; }
    public string DisplayName { get; set; }
}
```
VM hat die Eigenschaft, die man als Befehle, die möglicherweise ObservableCollection. Diese Eigenschaft zugegriffen werden kann von XAML.

Können Sie sich vorstellen, dass HeaderedContentControl ist ein container. Die Inhalte, die HeaderedContentControl ist ein DataTemplate "CommandsTemplate", die ein ItemsControl und binden die Befehle Eigentum des VM.

Content="{Binding Path=Befehle}"

Dann können Sie zu binden, ItemControl mit Befehlen wieder, aber die ItemControl ist innen die Inhalte, die Bindung an Befehle. So brauchen Sie nicht, um den Pfad wieder. Sie können einfach verwenden Sie
```
 ItemsSource="{Binding}" instead of ItemsSource="{Binding Commands}".
```
Zwei textblocks innerhalb ItemControl Sie sind also auf der gleichen Ebene wie der Commander-Klasse von Befehlen ObservableCollection. Das ist, warum Sie zugreifen können Text="{Binding Path=DisplayName}" direkt.

Hoffe, es hilft.

InformationsquelleAutor Michael Sync
1

Die ItemsSource-Bindung zu {Binding} - bindet direkt an den DataContext des ItemsControl (das Aussehen der Kette, bis es findet einen Satz DataContext). In diesem Fall ist es in der HeaderedContentControl

Jedes Element im inneren ItemsControl wird, dann haben die DataContext gesetzt, um ein element in der Liste.

Den <ItemsControl.ItemTemplate> ist die Einstellung der Vorlage für jedes Element in der Liste nicht für das ItemsControl selbst. So, dass {Binding Path=Command} und {Binding Path=DisplayName} schauen sich diese Eigenschaften auf die Elemente innerhalb der Liste.
- Wenn es bindet direkt an den DataContext sollte es sein, gebunden an den Kontext der Liste und nicht das element von der Liste?
- Das gilt sogar für das ItemsControl, aber jeder Element im ItemsControl wird ein element der Liste für seine DataContext.
- Okay, also mit {Binding} suchen ein DataContext innerhalb dieser Sammlung Recht?
- Ich verstehe nicht, was du fragst dort. {Binding} von selbst immer binden an den DataContext. Also, wenn Sie in dem ItemTemplate dann bindet es sich an ein element in der Sammlung.
- Okay, klingt nicht sehr offensichtlich für mich, die {Binding} - binden sich an die DataContext innerhalb der Kollektion. Für mich sieht es so aus naturaly, um auf den aktuellen datacontext, das ist die Liste. Aber jetzt verstehe ich, danke.
InformationsquelleAutor Ray

Beispiel:

XAML

<Window x:Class="WpfApplication2.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300" Loaded="Window_Loaded">
    <Window.Resources>
        <DataTemplate x:Key="CommandsTemplate">
            <ItemsControl IsTabStop="False" ItemsSource="{Binding}" Margin="6,2">
                <ItemsControl.ItemTemplate>
                    <DataTemplate>
                        <TextBlock Margin="2,6">pou
                            <Hyperlink Command="{Binding Path=Command}">
                                <TextBlock Text="{Binding Path=DisplayName}" />
                            </Hyperlink>
                        </TextBlock>
                    </DataTemplate>
                </ItemsControl.ItemTemplate>
            </ItemsControl>
        </DataTemplate>
    </Window.Resources>
    <Grid>
        <Border Width="170">
            <HeaderedContentControl
                Content="{Binding Path=Commands}"
                ContentTemplate="{StaticResource CommandsTemplate}"
                Header="Control Panel"/>
        </Border>
    </Grid>
</Window>

///<summary>
///Interaction logic for Window1.xaml
///</summary>
public partial class Window1 : Window {
    public Window1() {
        InitializeComponent();

        Commands.Add(new Commander() { DisplayName = "DN1" });
        Commands.Add(new Commander() { DisplayName = "DN2" });
        Commands.Add(new Commander() { DisplayName = "DN3" });

        this.DataContext = this;
    }

    private void Window_Loaded(object sender, RoutedEventArgs e) {

    }

    private ObservableCollection<Commander> commands = new ObservableCollection<Commander>();

    public ObservableCollection<Commander> Commands {
        get { return commands; }
        set { commands = value; }
    }
}

public class Commander {
    public ICommand Command { get; set; }
    public string DisplayName { get; set; }
}

InformationsquelleAutor Michael Sync

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.