WPF DataTemplate et de Liaison

Je continue ma compréhension de MVVC avec le code de MSDN et j'ai une question.

Dans le .xaml ils ont une liste de commandes affichées à l'écran.

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

À partir d'ici, je comprends que le DataContext est défini (non montré ici) et il affiche l'ensemble de Commandes. Ce que je ne comprends pas c'est la CommandsTemplate que vous pouvez voir ci-dessous:

<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>

Comment fonctionne la liaison est créé? Comment ce code indique de vérifier la propriété de Commande et d'Affichage de l'objet à l'intérieur de la collection? Est-il de la ItemsSource? Si oui, je ne comprends pas pourquoi c'est seulement à {Binding}. Quelqu'un peut m'expliquer s'il vous plaît comment le DataTemplate de liaison de travailler à partir d'une ContentTemplate?

OriginalL'auteur Patrick Desjardins | 2009-07-15

.net-3.5 c#data-binding templates wpf

9

Comme vous l'avez dit, le DataContext est défini pour la classe ViewModel de sorte que le contrôle que vous avez mentionné dans le code XAML sera en mesure d'accéder le public des propriétés de ce Dernier.

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

    public ObservableCollection<Commander> Commands {
        get { return commands; }
        set { commands = value; }
    }
```
La structure de Commandant de la classe.
```
public class Commander {
    public ICommand Command { get; set; }
    public string DisplayName { get; set; }
}
```
Que VM a la propriété de Commandes qui peut être ObservableCollection. Cette propriété peut être accessible à partir de XAML.

Vous pouvez imaginer que HeaderedContentControl est un conteneur. Le contenu de cette HeaderedContentControl est un DataTemplate "CommandsTemplate" qui a un ItemsControl et il se lier aux Commandes de la propriété de la VM.

Content="{Binding Path=Commandes}"

Et puis, vous pouvez lier itemcontrol sauf avec les Commandes, mais itemcontrol sauf est à l'intérieur du contenu qui se lient à des Commandes. Si vous n'avez pas besoin de spécifier le chemin d'accès de nouveau. Vous pouvez simplement utiliser
```
 ItemsSource="{Binding}" instead of ItemsSource="{Binding Commands}".
```
Deux textblocks sont à l'intérieur de itemcontrol sauf si ils sont au même niveau en tant que Commandant de la classe de Commandes ObservableCollection. C'est pourquoi vous pouvez accéder Text="{Binding Path=DisplayName}" directement.

Espère que cela aide.

OriginalL'auteur Michael Sync
1

La ItemsSource de liaison à {Binding} se lie directement à la DataContext de la ItemsControl (qui vont chercher la chaîne jusqu'à ce qu'il trouve un ensemble DataContext). Dans ce cas, il a été défini dans le HeaderedContentControl

Chaque élément à l'intérieur de la ItemsControl aura alors son DataContext ensemble à un élément dans la liste.

La <ItemsControl.ItemTemplate> est en définissant le modèle pour chaque Élément à l'intérieur de la liste, non pas pour le ItemsControl lui-même. De sorte que {Binding Path=Command} et {Binding Path=DisplayName} se penche sur ces propriétés sur les éléments à l'intérieur de la liste.

Si elle se lie directement à la DataContext il doit être appliqué au Contexte de la Liste et non pas l'élément de la liste?
C'est vrai pour le ItemsControl, mais chaque item dans le ItemsControl aura un élément de la liste pour son DataContext.
Bon, alors à l'aide de {Binding} recherchera un DataContext à l'intérieur de cette collection?
Je ne comprends pas ce que vous demandez là. {Binding} par elle-même sera toujours de se lier à la DataContext. Donc, si vous êtes à l'intérieur de l'ItemTemplate puis il va se lier à un élément dans la collection.
Bon, il ne semble pas que beaucoup d'évident pour moi que {Binding} se lier à la DataContext à l'intérieur de la collection. Pour moi, c'est bien sûr d'aller sur le datacontext qui est la Liste. Mais je comprends maintenant, merci.

OriginalL'auteur Ray

Exemple:

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; }
}

OriginalL'auteur Michael Sync

Vous devez vous connecter pour publier un commentaire.