Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Important
Le TableView contrôle est disponible à partir de SDK d'application Windows 2.5.4-experimental. Les API sont marquées expérimentales et peuvent changer ou être supprimées dans une version ultérieure. Ne les utilisez pas dans les applications de production.
Utilisez le contrôle expérimental TableView pour afficher une collection d’éléments dans des lignes et des colonnes. Chaque ligne représente un élément de votre source de données et vous définissez les colonnes qui affichent les valeurs de l’élément. TableView prend en charge le tri, le filtrage, le regroupement, le redimensionnement des colonnes, les colonnes de début figées, la sélection à une seule ligne et la modification des cellules sur activation. Les lignes sont virtualisées. Par conséquent, le contrôle crée l’interface utilisateur uniquement pour les lignes situées dans et près de la zone visible.
Pour essayer le contrôle, installez le package SDK d'application Windows 2.5.4-experimental et le runtime correspondant. Pour obtenir des liens de téléchargement et des informations d’installation, consultez Les derniers téléchargements SDK d'application Windows.
Est-ce le contrôle approprié ?
Utilisez un TableView lorsque vous souhaitez :
- Afficher les enregistrements qui partagent les mêmes champs, tels que les commandes, les fichiers ou les clients, dans des colonnes alignées.
- Permettre aux utilisateurs de comparer des valeurs entre les éléments et de modifier l’ordre des lignes par colonne.
- Filtrez ou regroupez les lignes affichées sans modifier votre collection sous-jacente.
- Permettre aux utilisateurs de modifier des valeurs individuelles en place.
Dans SDK d'application Windows version 2.5.4 expérimentale, TableView présente les limitations suivantes :
- Les utilisateurs ne peuvent sélectionner qu’une seule ligne à la fois.
- Les utilisateurs peuvent trier d’une colonne à la fois et les en-têtes de colonne ne prennent pas en charge le tri à partir du clavier.
- Les lignes peuvent être regroupées par un seul niveau.
- Les utilisateurs ne peuvent pas réorganiser les colonnes et le contrôle n’affiche pas d’en-têtes de ligne.
- Seules les premières colonnes peuvent être gelées.
- Les colonnes ne sont pas virtualisées. Le contrôle est conçu pour les tables avec environ 5 à 50 colonnes.
- TableView n’est pas un remplacement DataGrid et ne fournit pas d’interaction de style feuille de calcul.
Tenez compte de ces alternatives :
| Scenario | Consider |
|---|---|
| Votre application utilise une version stable SDK d'application Windows. | ItemsView ou ListView avec un modèle d’élément en colonnes ou un contrôle de grille tiers pris en charge. Pour obtenir des conseils, consultez Afficher les données tabulaires dans une application WinUI. |
| Les éléments ont besoin d’une carte, d’une vignette ou d’une disposition personnalisée au lieu de colonnes alignées. | ItemsView ou ListView et GridView. |
| Vous avez besoin de fonctionnalités que cette version n’inclut pas, telles que la sélection multiple ou la réorganisation des colonnes. | Contrôle de grille tiers pris en charge. |
Le projet communautaire WinUI.TableView est un contrôle open source distinct distribué en tant que package NuGet WinUI.TableView. Il ne fait pas partie de la SDK d'application Windows, et son API est différente de l'API décrite par cet article. Le code et le balisage que vous écrivez pour un contrôle ne fonctionnent pas avec l’autre sans modification.
Ajouter TableView à votre application
![]()
L’application Galerie WinUI 3 inclut des exemples interactifs de contrôles et de fonctionnalités WinUI. Obtenez l’application à partir du Microsoft Store ou parcourez le code source sur GitHub.
La galerie WinUI 3 inclut un exemple TableView expérimental commençant par la version 3.0.4. Vous pouvez également afficher l’exemple de code source TableView sur GitHub.
TableView nécessite des ressources de thème qui ne sont pas incluses dans XamlControlsResources. Dans App.xaml, fusionnez TabularControlsResources dans vos ressources d’application après XamlControlsResources:
<Application.Resources>
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
<TabularControlsResources xmlns="using:Microsoft.UI.Xaml.Controls.Tabular" />
</ResourceDictionary.MergedDictionaries>
</ResourceDictionary>
</Application.Resources>
Si vous ne fusionnez pas ces ressources, votre application lève une exception d’analyse XAML lors de la première présentation d’une TableView. Le message d’exception inclut Cannot find a Resource with the Name/Key, suivi du nom d’une ressource TableView. Il ne mentionne pas TabularControlsResources.
Si vous remplacez les ressources TableView dans vos propres dictionnaires fusionnés, ajoutez ces dictionnaires après TabularControlsResources.
Tip
À compter de SDK d'application Windows 2.6.6-experimental, si TabularControlsResources n'est pas fusionné lorsqu'un TableView est créé, TableView écrit un message commençant par TableView setup: dans la fenêtre Sortie de Visual Studio. Le message affiche l’entrée à ajouter à App.xaml. Pour le voir, déboguez-le avec le débogage en mode natif ou en mode mixte. Dans un projet C#, sélectionnez Activer le débogage de code natif dans le profil de lancement de débogage du projet.
Pour utiliser TableView dans le balisage, déclarez le namespace Microsoft.UI.Xaml.Controls.Tabular. Les exemples de cet article utilisent le tabular préfixe de cet espace de noms et le local préfixe de l’espace de noms de l’application :
xmlns:tabular="using:Microsoft.UI.Xaml.Controls.Tabular"
Dans les fichiers de code C#, ajoutez using Microsoft.UI.Xaml.Controls.Tabular;.
Note
Étant donné que les API sont expérimentales, le compilateur C# signale l’avertissement CS8305 et l’avertissement du compilateur XAML WMC1501 lorsque vous les utilisez. Ces avertissements sont attendus. Pour supprimer CS8305 dans un projet que vous utilisez pour l’évaluation, ajoutez-le à la propriété NoWarn dans votre fichier projet.
Créer une table
TableView ne génère pas de colonnes à partir de vos données. Ajoutez une colonne pour chaque valeur que vous souhaitez afficher. Sans colonnes, TableView n’affiche aucune cellule.
Utilisez TableViewTextColumn pour afficher une valeur sous forme de texte. Définissez sa propriété Binding sur une extension de balisage {Binding} qui nomme la propriété à afficher, et définissez Header sur le texte de l’en-tête de colonne. La propriété Binding prend un objet Binding, donc utilisez {Binding} au lieu de {x:Bind} pour cette propriété.
L’exemple suivant crée un tableau avec quatre colonnes de texte :
<tabular:TableView
x:Name="ItemsTable"
Height="280"
AutomationProperties.Name="Inventory items"
ItemsSource="{x:Bind Items}">
<tabular:TableView.Columns>
<tabular:TableViewTextColumn Binding="{Binding Id}" Header="ID" Width="80" />
<tabular:TableViewTextColumn Binding="{Binding Name}" Header="Name" Width="*" />
<tabular:TableViewTextColumn Binding="{Binding Category}" Header="Category" Width="180" />
<tabular:TableViewTextColumn Binding="{Binding Value}" Header="Value" Width="Auto" />
</tabular:TableView.Columns>
</tabular:TableView>
Columns est la propriété de contenu de TableView. Vous pouvez donc également ajouter des colonnes directement à l’intérieur de l’élément TableView.
La page expose les éléments sous la forme d’un ObservableCollection<T>, de sorte que le tableau se met à jour lorsque vous ajoutez ou supprimez des éléments :
using System.Collections.ObjectModel;
using Microsoft.UI.Xaml.Controls;
public sealed partial class InventoryPage : Page
{
public ObservableCollection<TableViewSampleItem> Items { get; } =
[
new(1, "Item 1", "Alpha", 25),
new(2, "Item 2", "Beta", 80),
new(3, "Item 3", "Gamma", 50),
new(4, "Item 4", "Alpha", 100),
new(5, "Item 5", "Beta", 10),
];
public InventoryPage()
{
InitializeComponent();
}
}
La classe d’élément implémente INotifyPropertyChanged, de sorte que les cellules se mettent à jour lorsqu’une valeur change, par exemple après qu’un utilisateur modifie une cellule :
using System.ComponentModel;
using System.Runtime.CompilerServices;
public sealed partial class TableViewSampleItem(int id, string name, string category, int value)
: INotifyPropertyChanged
{
private string _name = name;
private string _category = category;
public event PropertyChangedEventHandler? PropertyChanged;
public int Id { get; } = id;
public int Value { get; } = value;
public string Name
{
get => _name;
set => SetProperty(ref _name, value);
}
public string Category
{
get => _category;
set => SetProperty(ref _category, value);
}
private bool SetProperty(ref string field, string value, [CallerMemberName] string? propertyName = null)
{
if (field == value)
{
return false;
}
field = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
return true;
}
}
L’image suivante montre le tableau de cet exemple :
Tip
Si vous publiez votre application avec le découpage ou L’AOT natif, marquez vos classes d’éléments et classes de comparateur en tant que partial. C#/WinRT nécessite le modificateur partial pour générer le code d’interopérabilité pour les classes qu’il transmet aux API Windows Runtime.
Définir des largeurs de colonne
Définissez la propriété Width de chaque colonne sur l’une des valeurs suivantes :
| Largeur | Behavior |
|---|---|
Un certain nombre de pixels, comme 80 |
La colonne a une largeur fixe. La largeur par défaut est de 120 pixels. |
Auto |
La colonne s’adapte à l’en-tête ou à la cellule la plus large qui est actuellement affiché. Étant donné que les lignes sont virtualisées, la largeur peut changer à mesure que l’utilisateur défile. |
Valeur d’étoile, telle que * ou 2* |
La colonne partage la largeur restante avec d’autres colonnes de taille étoile, en proportion de sa valeur en étoile. |
Utilisez MinWidth et MaxWidth pour limiter la largeur d’une colonne. La largeur minimale par défaut est de 20 pixels. Pour obtenir la largeur actuelle d’une colonne, lisez ActualWidth.
Configurer les en-têtes de colonne
Utilisez des chaînes de caractères pour Header si possible. TableView utilise des en-têtes textuels pour donner un nom aux cellules à l’intention des technologies d’assistance et annoncer les modifications de tri. Pour personnaliser l’apparence d’un en-tête, définissez HeaderTemplate et conservez une chaîne Header. Le modèle d’en-tête reçoit la valeur Header en tant que contenu.
Pour masquer une colonne, définissez sa Visibility propriété sur Collapsed.
Afficher du contenu personnalisé avec des colonnes de modèle
Utilisez un TableViewTemplateColumn lorsqu’une cellule a besoin de plus que du texte, comme une barre de progression, une image ou plusieurs valeurs. Définissez la propriété CellTemplate de la colonne sur un DataTemplate. Les données de chaque cellule sont l’élément de cette ligne. Vous pouvez donc utiliser {x:Bind} avec x:DataType dans le modèle.
La colonne suivante affiche chaque valeur sous la forme d’une barre de progression et d’un nombre :
<tabular:TableViewTemplateColumn Header="Value" SortMemberPath="Value" Width="220">
<tabular:TableViewTemplateColumn.CellTemplate>
<DataTemplate x:DataType="local:TableViewSampleItem">
<Grid Padding="12,0" ColumnSpacing="12">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<ColumnDefinition Width="32" />
</Grid.ColumnDefinitions>
<ProgressBar
VerticalAlignment="Center"
AutomationProperties.AccessibilityView="Raw"
IsHitTestVisible="False"
Maximum="100"
Value="{x:Bind Value}" />
<TextBlock
Grid.Column="1"
HorizontalAlignment="Right"
VerticalAlignment="Center"
Text="{x:Bind Value}" />
</Grid>
</DataTemplate>
</tabular:TableViewTemplateColumn.CellTemplate>
</tabular:TableViewTemplateColumn>
Une colonne de modèle n’a aucune liaison par laquelle TableView peut trier. Pour rendre la colonne triable, définissez SortMemberPath sur le nom de la propriété à utiliser pour le tri, comme dans l’exemple précédent, ou définissez un comparateur personnalisé. Pour plus d’informations, consultez Trier les lignes.
TableView réutilise les éléments de cellule à mesure que les lignes entrent et sortent de l’affichage. Liez chaque valeur du modèle à l’élément au lieu de définir des valeurs sur des éléments de cellule individuels dans le code. La barre de progression de l’exemple répète le nombre dans le bloc de texte. Elle est donc marquée avec AutomationProperties.AccessibilityView="Raw" pour empêcher les technologies d’assistance de signaler la valeur deux fois.
Fournir des données avec TableViewSource
Vous pouvez définir ItemsSource directement à une collection, comme dans l’exemple précédent, et les utilisateurs peuvent toujours trier par colonne. Pour filtrer, trier ou regrouper des lignes à partir du code, encapsulez plutôt la collection dans un TableViewSource et définissez plutôt ItemsSource sur la source. TableViewSource modifie uniquement les lignes affichées par TableView. Il ne modifie pas le contenu ou l’ordre de votre collection.
Appelez TableViewSource.From pour créer la source et liez ItemsSource à celle-ci :
public TableViewSource TableSource { get; }
public InventoryPage()
{
TableSource = TableViewSource.From(Items);
InitializeComponent();
}
<tabular:TableView
x:Name="ItemsTable"
Height="280"
AutomationProperties.Name="Inventory items"
ItemsSource="{x:Bind TableSource}">
<!-- Columns -->
</tabular:TableView>
Les méthodes de filtrage, de tri et de regroupement retournent le même TableViewSource. Vous pouvez donc chaîner des appels :
TableSource
.Filter(item => ((TableViewSampleItem)item).Value >= 25)
.Sort("Name", SortDirection.Ascending);
Gardez ces comportements à l’esprit lorsque vous utilisez une TableViewSource :
-
Fromaccepte une collection telle qu’unObservableCollection<T>ou unList<T>. Elle lève une exception si vous passeznullou un objet qui n’est pas une collection. - Lorsque votre collection déclenche des notifications de modification de collection, par exemple lorsque vous ajoutez un élément à un objet
ObservableCollection<T>, TableView applique le filtre, le tri et le regroupement actuels à la modification. - Une modification de propriété sur un élément ne filtre, ne trie ni ne regroupe à nouveau cet élément. Par exemple, lorsqu’un utilisateur modifie une valeur dans la colonne triée, la ligne conserve sa position. Les lignes sont remodelées la prochaine fois que la collection change ou que vous appliquez à nouveau un filtre, un tri ou un regroupement.
- Utilisez la source et sa collection uniquement sur le thread d’interface utilisateur et déclenchez des notifications de modification de la collection sur le thread d’interface utilisateur.
- Un TableViewSource peut être utilisé par un seul TableView à la fois. Pour l’utiliser avec un autre TableView, définissez d’abord le
ItemsSourcedu TableView d’origine sur une valeur différente. - TableView identifie les lignes par identité d’objet, que vous utilisiez ou non une TableViewSource. Le même objet ne peut pas apparaître dans la collection plusieurs fois. La sélection suit un élément lorsque les lignes sont remodelées, mais pas lorsque vous remplacez l’élément par un nouvel objet.
Sélectionner des lignes
Les utilisateurs sélectionnent une ligne en cliquant ou en appuyant dessus, ou en s’y déplaçant au clavier. Pour contrôler la sélection, définissez SelectionMode sur l’une des valeurs suivantes :
-
Single(valeur par défaut) : les utilisateurs peuvent sélectionner une ligne à la fois. -
None: les utilisateurs ne peuvent pas sélectionner de lignes. Le fait de définir cette valeur efface la sélection actuelle.
Les propriétés SelectedItem et SelectedIndex sont en lecture seule. Pour modifier la sélection à partir du code, appelez Select, Deselectou DeselectAll. Pour vérifier si une ligne est sélectionnée, appelez IsSelected.
// Select the first displayed row.
ItemsTable.Select(0);
Les membres basés sur l’index utilisent la position de la ligne dans l’ordre affiché, après application du filtrage, du tri et du regroupement. Lorsque les lignes sont regroupées, les lignes d’en-tête de groupe occupent également des positions, mais elles ne peuvent pas être sélectionnées.
Select n’a aucun effet si ItemsSource n’est pas défini ou si SelectionMode est None.
Pour répondre lorsque la sélection change, gérez l’événement SelectionChanged :
<tabular:TableView
x:Name="ItemsTable"
AutomationProperties.Name="Inventory items"
ItemsSource="{x:Bind Items}"
SelectionChanged="ItemsTable_SelectionChanged">
<!-- Columns -->
</tabular:TableView>
<TextBlock x:Name="SelectionStatusText" AutomationProperties.LiveSetting="Polite" Text="No row selected." />
private void ItemsTable_SelectionChanged(TableView sender, SelectionChangedEventArgs args)
{
SelectionStatusText.Text = sender.SelectedItem is TableViewSampleItem item
? $"Selected: {item.Name} (ID {item.Id})."
: "No row selected.";
}
La sélection suit l’élément sélectionné lorsque les lignes sont triées à nouveau ou que les éléments sont insérés. La suppression de l’élément sélectionné de la collection, son masquage avec un filtre ou la définition d’un nouveau ItemsSource efface la sélection. Les utilisateurs peuvent désélectionner la ligne sélectionnée en appuyant sur Ctrl et en cliquant dessus, ou en appuyant sur Ctrl+Espace.
Trier les lignes
Par défaut, les utilisateurs peuvent trier les lignes en cliquant ou en appuyant sur un en-tête de colonne. L’en-tête affiche un indicateur qui affiche le sens du tri. Le tri d’une colonne efface le tri de n’importe quelle autre colonne.
Une colonne de texte trie selon la propriété de son Binding. Une colonne de modèle a besoin d’un SortMemberPath ou d’un comparateur personnalisé avant de pouvoir être triée. Pour empêcher les utilisateurs de trier par n’importe quelle colonne, définissez CanUserSortColumns sur False. Pour empêcher le tri par une colonne spécifique, définissez la propriété False de cette colonne sur CanSort.
Choisir un cycle de tri
La propriété SortCycle d’une colonne contrôle l’ordre des directions lorsqu’un utilisateur clique sur son en-tête à plusieurs reprises :
| Value | Directions |
|---|---|
AscendingDescending (valeur par défaut) |
Croissant, puis décroissant. |
AscendingDescendingNone |
Croissant, décroissant, puis l’ordre d’origine de la source. |
DescendingAscending |
Décroissant, puis croissant. |
DescendingAscendingNone |
Décroissant, croissant, puis l’ordre d’origine de la source. |
Lorsqu’un utilisateur remet une colonne dans son ordre d’origine, TableView efface tout tri, y compris le tri que vous avez appliqué avec TableViewSource.
L’exemple suivant, basé sur l’exemple de galerie WinUI 3, empêche le tri par ID, permet aux utilisateurs de renvoyer la colonne Name à l’ordre d’origine et trie d’abord les valeurs de la plus élevée à la plus basse :
<tabular:TableView.Columns>
<tabular:TableViewTextColumn
Binding="{Binding Id}"
CanSort="False"
Header="ID"
Width="80" />
<tabular:TableViewTextColumn
x:Name="NameColumn"
Binding="{Binding Name}"
Header="Name"
SortCycle="AscendingDescendingNone"
Width="220" />
<tabular:TableViewTextColumn
Binding="{Binding Value}"
Header="Value"
SortCycle="DescendingAscendingNone"
Width="140" />
</tabular:TableView.Columns>
L’image suivante montre cette table triée par la colonne Valeur dans l’ordre décroissant, la première direction du cycle de tri de cette colonne. L’en-tête Valeur affiche un indicateur de tri.
Trier par code
Appelez SortByColumn, ToggleSortDirection ou ClearSort. Chaque méthode retourne true si le tri a changé. Le tri à partir du code fonctionne même lorsque CanUserSortColumns est False.
// Sort by name in ascending order.
ItemsTable.SortByColumn(NameColumn, SortDirection.Ascending);
// Move the Name column to the next direction in its sort cycle.
ItemsTable.ToggleSortDirection(NameColumn);
// Remove sorting from all columns.
ItemsTable.ClearSort();
Pour lire la direction actuelle d’une colonne, utilisez sa propriété SortDirection en lecture seule.
Répondre aux modifications de tri
TableView déclenche l’événement Sorting avant d’appliquer un tri et l’événement Sorted après l’application du tri. Les deux événements signalent la colonne et le nouveau sens. Lorsque vous appelez ClearSort, la colonne est null et la direction est None.
Pour empêcher un tri, définissez Cancel sur true dans le gestionnaire d’événements Sorting. TableView conserve ensuite l’ordre actuel et les indicateurs de tri et ne déclenche pas Sorted.
<tabular:TableView
x:Name="ItemsTable"
AutomationProperties.Name="Inventory items"
ItemsSource="{x:Bind Items}"
Sorted="ItemsTable_Sorted"
Sorting="ItemsTable_Sorting">
<!-- Columns -->
</tabular:TableView>
<TextBlock x:Name="SortStatusText" AutomationProperties.LiveSetting="Polite" Text="Rows are in source order." />
// Set to true while the app loads data.
private bool _isLoading;
private void ItemsTable_Sorting(TableView sender, TableViewSortingEventArgs args)
{
// Keep the current order while the app is still loading data.
if (_isLoading)
{
args.Cancel = true;
}
}
private void ItemsTable_Sorted(TableView sender, TableViewSortedEventArgs args)
{
SortStatusText.Text = args.Direction == SortDirection.None
? "Rows are in source order."
: $"Sorted by {args.Column.Header}, {args.Direction.ToString().ToLowerInvariant()}.";
}
Lorsque vous définissez un nouveau ItemsSource, TableView efface le tri sans déclencher Sorting ou Sorted.
Trier avec un comparateur personnalisé
Pour contrôler l’ordre de tri d’une colonne, implémentez ITableViewSortComparer et affectez-le à la propriété CustomSortComparer de la colonne. Un comparateur personnalisé prend le pas sur SortMemberPath et la liaison de la colonne.
La Compare méthode reçoit deux éléments de données et définit l’ordre croissant. TableView inverse l’ordre pour un tri décroissant. Retournez un résultat cohérent pour la même paire d’éléments et ne lèvez pas d’exceptions. TableView traite comme égale une comparaison qui lève une exception.
using Microsoft.UI.Xaml.Controls.Tabular;
public sealed partial class NameLengthComparer : ITableViewSortComparer
{
public int Compare(object left, object right)
{
string leftName = ((TableViewSampleItem)left).Name;
string rightName = ((TableViewSampleItem)right).Name;
// Shorter names first. Names of equal length sort in ordinal order.
int result = leftName.Length.CompareTo(rightName.Length);
return result != 0 ? result : string.CompareOrdinal(leftName, rightName);
}
}
Vous pouvez déclarer le comparateur en tant que ressource et le référencer dans le balisage :
<Page.Resources>
<local:NameLengthComparer x:Key="NameLengthComparer" />
</Page.Resources>
<tabular:TableViewTextColumn
Binding="{Binding Name}"
CustomSortComparer="{StaticResource NameLengthComparer}"
Header="Name"
Width="220" />
Ou l’affecter par code :
NameColumn.CustomSortComparer = new NameLengthComparer();
Trier avec TableViewSource
Lorsque ItemsSource est une TableViewSource, vous pouvez également trier en appelant TableViewSource.Sort. Contrairement au tri d’en-tête, cette méthode peut trier par plusieurs propriétés. Le premier tri que vous ajoutez est le tri principal, et chaque tri ultérieur trie les éléments qui sont égaux dans les tris précédents.
// Sort by category, and then by name within each category.
TableSource
.Sort("Category", SortDirection.Ascending)
.Sort("Name", SortDirection.Ascending);
Préférez la surcharge qui prend un chemin de propriété. TableView peut correspondre au chemin d’accès à une colonne et afficher l’indicateur de tri de cette colonne. Le tri par le même chemin remplace à nouveau ce tri en place et SortDirection.None le supprime. La surcharge qui prend un sélecteur de clé trie par une valeur calculée, et TableView efface tous les indicateurs de tri de colonne lorsque vous l’utilisez.
Un tri que vous appliquez avec TableViewSource et un tri qu’un utilisateur applique à partir d’un en-tête de colonne se remplacent mutuellement. Le dernier élément appliqué détermine l’ordre. Pour supprimer tous les tris de la source, appelez ClearSort.
TableView ne déclenche pas Sorting pour un tri que vous appliquez avec TableViewSource, vous ne pouvez donc pas l’annuler à partir du gestionnaire d’événements. Une fois que TableView met à jour les indicateurs de tri de colonne pour qu’ils correspondent au nouveau tri, il déclenche Sorted. Si aucune colonne ne correspond au tri principal, par exemple parce que vous avez trié avec un sélecteur de clé, l’événement signale la colonne null et une direction de None.
Filtrer les lignes
Pour afficher uniquement les lignes qui correspondent à une condition, appelez TableViewSource.Filter avec un prédicat qui retourne true pour chaque élément à conserver. Chaque appel remplace le filtre précédent. Pour supprimer le filtre, appelez ClearFilter.
L’exemple suivant, à partir de l’exemple de galerie WinUI 3, filtre les lignes à mesure que l’utilisateur saisit :
<TextBox
x:Name="FilterBox"
Header="Filter by name or category"
TextChanged="FilterBox_TextChanged" />
private void FilterBox_TextChanged(object sender, TextChangedEventArgs e)
{
string text = FilterBox.Text.Trim();
if (text.Length == 0)
{
TableSource.ClearFilter();
return;
}
TableSource.Filter(item => item is TableViewSampleItem sampleItem &&
(sampleItem.Name.Contains(text, StringComparison.CurrentCultureIgnoreCase) ||
sampleItem.Category.Contains(text, StringComparison.CurrentCultureIgnoreCase)));
}
Le filtre s’exécute avant le tri et le regroupement. Si le prédicat lève une exception pour un élément, TableViewSource exclut cet élément.
Lorsqu’aucune ligne ne correspond, TableView affiche le contenu de sa EmptyTemplate propriété. TableView affiche également ce modèle lorsque ItemsSource est null ou vide.
<tabular:TableView.EmptyTemplate>
<DataTemplate>
<TextBlock
Margin="24"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Text="No items match the filter." />
</DataTemplate>
</tabular:TableView.EmptyTemplate>
Regrouper des lignes
Pour regrouper des lignes, appelez TableViewSource.GroupBy avec un sélecteur de clé. TableView affiche une ligne d’en-tête pour chaque groupe, et les utilisateurs peuvent déplier ou replier chaque groupe. Pour supprimer le regroupement, appelez ClearGroupBy.
// Group the rows by category.
TableSource.GroupBy(item => ((TableViewSampleItem)item).Category);
Pour personnaliser le contenu des en-têtes de groupe, définissez GroupHeaderTemplate. Les données du modèle sont un TableViewGroupInfo objet. TableView met à jour cet objet en place. Utilisez donc Mode=OneWay dans vos liaisons. Le modèle remplace uniquement la zone de contenu de l’en-tête. TableView continue d’afficher le glyphe de développement et de réduction.
<tabular:TableView.GroupHeaderTemplate>
<DataTemplate x:DataType="tabular:TableViewGroupInfo">
<TextBlock>
<Run FontWeight="SemiBold" Text="{x:Bind KeyText, Mode=OneWay}" />
<Run Text="{x:Bind ItemCountText, Mode=OneWay}" />
</TextBlock>
</DataTemplate>
</tabular:TableView.GroupHeaderTemplate>
KeyText est la clé de groupe sous forme de texte et ItemCountText correspond au nombre d’éléments du groupe mis en forme pour l’affichage.
L’image suivante montre les éléments regroupés par catégorie avec ce modèle d’en-tête :
Pour développer ou réduire chaque groupe à partir du code, appelez ExpandAllGroups ou CollapseAllGroups. Ces méthodes n’ont aucun effet lorsque les lignes ne sont pas regroupées.
private void ExpandAllGroups_Click(object sender, RoutedEventArgs e)
{
ItemsTable.ExpandAllGroups();
}
private void CollapseAllGroups_Click(object sender, RoutedEventArgs e)
{
ItemsTable.CollapseAllGroups();
}
Choisissez les clés de groupe
Le sélecteur de clé doit retourner une clé pour chaque élément, et la clé ne peut pas être null ou une chaîne vide. Sinon, TableViewSource lève une exception. Retourne une valeur d’espace réservé pour les éléments qui n’ont pas de clé :
// Items without a category are grouped under "(None)".
TableSource.GroupBy(item =>
((TableViewSampleItem)item).Category is { Length: > 0 } category ? category : "(None)");
TableViewSource peut identifier les clés de type String, Int32, Int64, Guid, Boolean, et les types d’énumération. Pour d’autres types de clés, tels qu’un objet personnalisé, utilisez la surcharge GroupBy qui prend également un TableViewIdentitySelector. Le sélecteur d’identité reçoit une clé et retourne une chaîne non vide qui identifie de façon unique son groupe.
Combiner le tri et le regroupement
L’ordre dans lequel vous appelez des méthodes TableViewSource détermine la façon dont le tri et le regroupement sont combinés. Les tris que vous ajoutez avant GroupBy ordonnent les groupes. Les tris que vous ajoutez après GroupBy ordonnent les lignes au sein de chaque groupe.
// Order the groups by category, and order the rows in each group by value.
TableSource
.Sort("Category", SortDirection.Ascending)
.GroupBy(item => ((TableViewSampleItem)item).Category)
.Sort("Value", SortDirection.Descending);
Redimensionner et figer les colonnes
Les utilisateurs peuvent redimensionner une colonne en faisant glisser le bord de son en-tête. Un redimensionnement définit la Width de la colonne à une valeur en pixels dans son MinWidth et MaxWidth. Pour annuler un redimensionnement lors du glissement, appuyez sur Échap.
Pour empêcher les utilisateurs de redimensionner n’importe quelle colonne, définissez CanUserResizeColumns sur False. Pour empêcher le redimensionnement d’une colonne spécifique, définissez sa propriété CanResize sur False.
Pour conserver une colonne visible lorsque les utilisateurs défilent horizontalement, définissez sa propriété FrozenEdge sur Leading. Seul un ensemble continu de colonnes commençant par la première colonne peut être figé. TableView ignore Leading sur n’importe quelle colonne qui vient après une colonne qui n’est pas figée. L’énumération TableViewFrozenEdge définit également une Trailing valeur, qui est réservée et n’est pas implémentée dans cette version.
<tabular:TableView.Columns>
<tabular:TableViewTextColumn
x:Name="IdColumn"
Binding="{Binding Id}"
CanResize="False"
FrozenEdge="Leading"
Header="ID"
Width="80" />
<tabular:TableViewTextColumn
Binding="{Binding Name}"
Header="Name"
MaxWidth="400"
MinWidth="120"
Width="220" />
</tabular:TableView.Columns>
Vous pouvez également changer FrozenEdge dans le code. L’exemple de galerie WinUI 3 utilise un ToggleSwitch pour figer la première colonne :
private void FreezeFirstColumnToggle_Toggled(object sender, RoutedEventArgs e)
{
IdColumn.FrozenEdge = FreezeFirstColumnToggle.IsOn
? TableViewFrozenEdge.Leading
: TableViewFrozenEdge.None;
}
Modifier les cellules
Les cellules sont en lecture seule par défaut. Pour permettre aux utilisateurs de modifier des cellules, définissez la propriété False du TableView sur IsReadOnly. Pour conserver une colonne spécifique en lecture seule, définissez la propriété True de cette colonne sur IsReadOnly. Marquez comme étant en lecture seule les colonnes qui affichent des propriétés en lecture seule, telles que Id dans l’exemple suivant.
<tabular:TableView
x:Name="EditingTable"
AutomationProperties.Name="Editable items"
BeginningEdit="EditingTable_BeginningEdit"
CellEditEnding="EditingTable_CellEditEnding"
IsReadOnly="False"
ItemsSource="{x:Bind Items}">
<tabular:TableView.Columns>
<tabular:TableViewTextColumn Binding="{Binding Id}" Header="ID" IsReadOnly="True" Width="80" />
<tabular:TableViewTextColumn Binding="{Binding Name}" Header="Name" Width="180" />
<tabular:TableViewTextColumn Binding="{Binding Category}" Header="Category" Width="180" />
</tabular:TableView.Columns>
</tabular:TableView>
<TextBlock x:Name="EditStatusText" AutomationProperties.LiveSetting="Polite" />
Les utilisateurs modifient une cellule de cette façon :
- Pour commencer à modifier, double-cliquez ou appuyez deux fois sur la cellule, ou appuyez sur F2. F2 modifie la cellule de la ligne active et dans la colonne sur laquelle l’utilisateur a cliqué ou appuyé la dernière fois. Si l’utilisateur n’a pas cliqué sur une cellule, F2 modifie la première colonne modifiable visible.
- Pour valider la modification, appuyez sur Entrée ou déplacez le focus hors de l’éditeur. Pour annuler la modification, appuyez sur Échap.
- Pendant que l’éditeur est ouvert, il reçoit les touches de direction et de navigation, et la sélection ne change pas.
Une colonne de texte modifie sa valeur dans une TextBox qui utilise la Binding de la colonne. Lorsque l’utilisateur valide la modification, TableView écrit la nouvelle valeur à l’élément. Les modifications sont validées une cellule à la fois. Il n’y a pas de validation au niveau des lignes ou d’annulation dans cette version. Par conséquent, l’annulation d’une modification restaure uniquement la cellule en cours de modification.
L’image suivante montre l’éditeur de la cellule Nom dans la première ligne :
Pour valider ou annuler la modification actuelle à partir du code, appelez CommitEdit ou CancelEdit. Par exemple, validez toute modification en attente avant d’enregistrer des données. Les deux méthodes retournent true lorsqu’elles ferment l’éditeur. Ils retournent false lorsqu’aucune édition n’est ouverte ou quand l’édition reste ouverte, car un gestionnaire d’événements a annulé la modification ou la validation a échoué. Pour vérifier si un éditeur est ouvert, lisez IsEditing.
Répondre aux événements de modification
TableView déclenche BeginningEdit avant d’ouvrir un éditeur. Pour empêcher la modification, définissez Cancel sur true:
private void EditingTable_BeginningEdit(TableView sender, TableViewBeginningEditEventArgs args)
{
// Only allow edits to items in the Alpha category.
if (args.Item is TableViewSampleItem item && item.Category != "Alpha")
{
args.Cancel = true;
}
}
TableView déclenche CellEditEnding lorsqu’une modification est sur le point d’être validée ou annulée. La EditAction propriété vous indique laquelle. Pour que l’éditeur reste ouvert, définissez Cancel sur true. Définissez Cancel avant le retour du gestionnaire, car ces événements ne prennent pas en charge les reports.
TableView déclenche CellEditEnding avant d’écrire la valeur dans l’élément. Pour exécuter du code après la validation de la valeur, mettez le travail en file d’attente sur la file d’attente du répartiteur, comme le fait l’exemple de la galerie WinUI 3 :
private void EditingTable_CellEditEnding(TableView sender, TableViewCellEditEndingEventArgs args)
{
if (args.EditAction == TableViewEditAction.Cancel || args.Item is not TableViewSampleItem item)
{
return;
}
// CellEditEnding is raised before TableView writes the value to the item.
// Queue work that needs the committed value.
sender.DispatcherQueue.TryEnqueue(() =>
{
if (!sender.IsEditing)
{
EditStatusText.Text = $"Saved {item.Name}.";
}
});
}
Fournir un éditeur personnalisé
Pour utiliser un autre éditeur, définissez la propriété CellEditingTemplate de la colonne. Sur une colonne de texte, ce modèle remplace la valeur par défaut TextBox. Une colonne de modèle est modifiable uniquement lorsque vous définissez CellEditingTemplate.
Dans le modèle d’édition, liez la valeur modifiée avec {Binding}, Mode=TwoWayet UpdateSourceTrigger=Explicit. TableView met à jour la source de cette liaison lorsque l’utilisateur valide la modification. Il recherche des liaisons sur ces propriétés : TextBox.Text, ToggleSwitch.IsOn, AutoSuggestBox.Text, ToggleButton.IsChecked, Selector.SelectedItem, Selector.SelectedIndex, Selector.SelectedValue, Slider.Value et NumberBox.Value. TableView ne peut pas trouver les liaisons {x:Bind}. S’il ne trouve pas de binding à mettre à jour, la validation échoue et l’éditeur reste ouvert.
L’exemple suivant modifie la catégorie avec un ComboBox:
<tabular:TableViewTextColumn Binding="{Binding Category}" Header="Category" Width="180">
<tabular:TableViewTextColumn.CellEditingTemplate>
<DataTemplate x:DataType="local:TableViewSampleItem">
<ComboBox
AutomationProperties.Name="Category"
ItemsSource="{x:Bind local:TableViewSampleItem.Categories}"
SelectedItem="{Binding Category, Mode=TwoWay, UpdateSourceTrigger=Explicit}" />
</DataTemplate>
</tabular:TableViewTextColumn.CellEditingTemplate>
</tabular:TableViewTextColumn>
L’exemple utilise une propriété statique sur la classe d’élément pour la liste des catégories :
public static IReadOnlyList<string> Categories { get; } = ["Alpha", "Beta", "Gamma"];
Valider les modifications
Si l’élément implémente INotifyDataErrorInfo, TableView vérifie les erreurs sur la propriété en cours de modification après avoir écrit la valeur. Si la propriété a des erreurs, TableView restaure la valeur précédente et maintient l’éditeur ouvert, afin que l’utilisateur puisse corriger la valeur ou appuyer sur Échap pour annuler. Si le setter de la propriété lève une exception, l’éditeur reste également ouvert.
La classe d’éléments suivante, à partir de l’exemple de galerie WinUI 3, nécessite un nom :
using System;
using System.Collections;
using System.ComponentModel;
using System.Runtime.CompilerServices;
public sealed partial class TableViewSampleItem : INotifyPropertyChanged, INotifyDataErrorInfo
{
private string _name;
private string _category;
private string? _nameError;
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler<DataErrorsChangedEventArgs>? ErrorsChanged;
public int Id { get; }
public int Value { get; }
public bool HasErrors => _nameError is not null;
public string Name
{
get => _name;
set
{
string normalizedValue = value ?? string.Empty;
if (SetProperty(ref _name, normalizedValue))
{
string? error = string.IsNullOrWhiteSpace(normalizedValue) ? "Name is required." : null;
if (_nameError != error)
{
_nameError = error;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(HasErrors)));
ErrorsChanged?.Invoke(this, new DataErrorsChangedEventArgs(nameof(Name)));
}
}
}
}
public string Category
{
get => _category;
set => SetProperty(ref _category, value ?? string.Empty);
}
public TableViewSampleItem(int id, string name, string category, int value)
{
ArgumentException.ThrowIfNullOrWhiteSpace(name);
Id = id;
_name = name;
_category = category;
Value = value;
}
public IEnumerable GetErrors(string? propertyName)
{
if ((string.IsNullOrEmpty(propertyName) || propertyName == nameof(Name)) && _nameError is not null)
{
yield return _nameError;
}
}
private bool SetProperty(ref string field, string value, [CallerMemberName] string? propertyName = null)
{
if (field == value)
{
return false;
}
field = value;
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
return true;
}
}
TableView n’affiche pas le message d’erreur. Pour indiquer aux utilisateurs pourquoi la valeur n’a pas été acceptée, affichez le message vous-même. Par exemple, l’exemple de galerie WinUI 3 gère l’événement ErrorsChanged de l’élément modifié et affiche le message dans un InfoBar.
Personnaliser l’apparence
Utilisez ces propriétés pour modifier l’apparence d’un TableView :
| Propriété | Description |
|---|---|
Density |
Définit la hauteur minimale de ligne et le remplissage dans les cellules et les en-têtes de colonne. Les valeurs sont Compact, Standard (par défaut) et Comfortable. |
GridLinesVisibility |
Affiche All (par défaut), Horizontal, Vertical ou None des lignes de grille. |
HeadersVisibility |
Affiche les en-têtes de colonne (Columnpar défaut) ou les masque (None). |
RowBackground, AlternatingRowBackground |
Définissez l’arrière-plan des lignes et des lignes alternées. Lorsque ces propriétés sont null, les lignes utilisent l’arrière-plan du thème. |
EmptyTemplate |
Définit le contenu à afficher lorsqu’il n’y a pas de lignes. |
Si vous masquez les en-têtes de colonne, les utilisateurs ne peuvent pas trier ou redimensionner les colonnes à l’aide des en-têtes.
L’exemple suivant, basé sur l’exemple galerie WinUI 3, affiche des lignes compactes avec des lignes de grille horizontale et des arrière-plans de lignes alternés :
<tabular:TableView
Height="320"
AlternatingRowBackground="{ThemeResource SubtleFillColorSecondaryBrush}"
AutomationProperties.Name="Compact items"
Density="Compact"
GridLinesVisibility="Horizontal"
ItemsSource="{x:Bind Items}"
RowBackground="{ThemeResource CardBackgroundFillColorDefaultBrush}">
<tabular:TableView.EmptyTemplate>
<DataTemplate>
<StackPanel
Padding="32"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Spacing="8">
<FontIcon AutomationProperties.AccessibilityView="Raw" FontSize="32" Glyph="" />
<TextBlock
HorizontalAlignment="Center"
AutomationProperties.HeadingLevel="Level3"
Style="{ThemeResource SubtitleTextBlockStyle}"
Text="No items" />
</StackPanel>
</DataTemplate>
</tabular:TableView.EmptyTemplate>
<tabular:TableView.Columns>
<tabular:TableViewTextColumn Binding="{Binding Id}" Header="ID" Width="80" />
<tabular:TableViewTextColumn Binding="{Binding Name}" Header="Name" Width="180" />
</tabular:TableView.Columns>
</tabular:TableView>
L’image suivante montre ce tableau avec cinq éléments :
Afficher les info-bulles
Pour afficher une info-bulle pour les cellules d’une colonne, définissez la propriété CellToolTipBinding de la colonne sur un {Binding}. TableView évalue la liaison de données pour chaque ligne. Si la valeur est null ou vide, la cellule n’affiche pas d’info-bulle. Pour calculer le texte de l’info-bulle, utilisez un convertisseur dans la liaison.
Pour afficher une info-bulle pour un en-tête de colonne, définissez la propriété HeaderToolTip de la colonne sur une chaîne ou un autre contenu. Si vous utilisez un élément d’interface utilisateur comme contenu d’info-bulle, attribuez à chaque colonne sa propre instance.
TableView crée l'ToolTip pour vous. Définissez donc le contenu de l’info-bulle, tel qu’une chaîne, plutôt qu’un objet ToolTip. Si la valeur est un ToolTip, TableView n’affiche pas d’info-bulle.
La colonne de modèle suivante, basée sur l’exemple galerie WinUI 3, affiche le nom de l’élément en tant qu’info-bulle de cellule et décrit la colonne dans une info-bulle d’en-tête :
<tabular:TableViewTemplateColumn
CellToolTipBinding="{Binding Name}"
Header="Item"
HeaderToolTip="The item's name and category"
SortMemberPath="Name"
Width="200">
<tabular:TableViewTemplateColumn.CellTemplate>
<DataTemplate x:DataType="local:TableViewSampleItem">
<StackPanel Padding="12,6" Orientation="Horizontal" Spacing="12">
<PersonPicture
Width="32"
Height="32"
AutomationProperties.AccessibilityView="Raw"
DisplayName="{x:Bind Name, Mode=OneWay}" />
<StackPanel VerticalAlignment="Center">
<TextBlock Style="{ThemeResource BodyStrongTextBlockStyle}" Text="{x:Bind Name, Mode=OneWay}" />
<TextBlock Style="{ThemeResource CaptionTextBlockStyle}" Text="{x:Bind Category, Mode=OneWay}" />
</StackPanel>
</StackPanel>
</DataTemplate>
</tabular:TableViewTemplateColumn.CellTemplate>
</tabular:TableViewTemplateColumn>
Les info-bulles s’affichent lorsque l’utilisateur pointe vers une cellule ou un en-tête de colonne. Les info-bulles de cellule n’apparaissent pas pour le focus clavier, car le focus clavier se déplace entre les lignes, et non les cellules. Lorsque le contenu d’info-bulle d’une cellule ou d’un en-tête de colonne est une chaîne, TableView l’expose également aux technologies d’assistance en tant que texte d’aide. Le contenu qui n’est pas une chaîne n’est pas exposé. Utilisez donc un convertisseur qui retourne du texte lorsque vous devez calculer une info-bulle de cellule.
Prise en charge de l’accessibilité et du clavier
TableView fournit une prise en charge de l’automatisation de l’interface utilisateur pour ses composants :
- La table est exposée sous forme de grille de données. Il prend en charge les modèles de conception Grille et Table, afin que les technologies d’assistance puissent signaler ses lignes et ses colonnes. Quand ce n’est pas le cas pour
SelectionMode,Noneil prend également en charge le modèle de sélection. - Quand
SelectionModece n’est pasNonele cas, les lignes prennent en charge le modèle SelectionItem. - Les en-têtes de colonne sont exposés en tant qu’éléments d’en-tête. Lorsque les utilisateurs peuvent trier par une colonne, son en-tête prend en charge le modèle de contrôle Invoke, qui trie par cette colonne et son texte d’aide signale l’état de tri. Le texte d’aide d’un en-tête inclut également l’info-bulle de la colonne, si l’info-bulle est une chaîne.
- Les cellules prennent en charge les modèles GridItem et TableItem. Le nom de chaque cellule combine l’en-tête de colonne et la valeur de la cellule, par exemple « Nom, Élément 1 ». L’en-tête est inclus uniquement lorsqu’il s’agit d’une chaîne. Les cellules de texte que les utilisateurs peuvent modifier avec l’éditeur par défaut prennent également en charge le modèle Valeur.
- Les en-têtes de groupe prennent en charge le modèle ExpandCollapse.
- Lorsque l’ordre de tri change ou qu’un utilisateur redimensionne une colonne, TableView déclenche une notification que les technologies d’assistance peuvent annoncer.
Pour rendre votre table accessible :
- Définissez
AutomationProperties.Namesur chaque TableView pour décrire son contenu. - Utilisez des valeurs de chaîne pour les en-têtes de colonne.
- Dans les modèles de cellule, marquez les éléments décoratifs avec
AutomationProperties.AccessibilityView="Raw"et donnez aux éléments interactifs un nom accessible. Testez les colonnes de modèle avec un outil d’accessibilité, tel que Accessibility Insights pour Windows, pour vérifier ce que les technologies d’assistance indiquent pour chaque cellule. - Évitez de définir explicitement
Foregroundsur le texte dans les modèles de cellule. Une couleur de premier plan explicite remplace les couleurs utilisées par TableView pour les lignes sélectionnées et les thèmes à contraste élevé. Si vous la définissez, vérifiez ces statuts. - Les utilisateurs ne peuvent pas trier à partir du clavier à l’aide d’en-têtes de colonne dans cette version. Si le tri est important dans votre application, fournissez un autre moyen accessible au clavier de trier, tel qu’un menu ou un
ComboBoxqui appelleSortByColumn. - TableView n’annonce pas quand une modification démarre ou se termine. Signalez vous-même le résultat d’une modification lorsque cela importe pour l’utilisateur, par exemple dans un élément
TextBlockdontAutomationProperties.LiveSettingest défini surPolite.
TableView prend en charge ces interactions au clavier :
| Clé | Action |
|---|---|
| Flèche vers le haut, flèche vers le bas | Déplacez le focus sur la ligne précédente ou suivante, puis sélectionnez-la. |
| Accueil, Fin | Déplacez le focus sur la première ou la dernière ligne et sélectionnez-la. |
| Page précédente, Page suivante | Déplacez le focus vers le haut ou le bas d’environ une page de lignes et sélectionnez la ligne. |
| Ctrl + une touche de navigation | Déplacez le focus sans modifier la sélection. |
| Space | Sélectionnez la ligne active. |
| Ctrl+Espace | Sélectionnez la ligne active ou désélectionnez-la si elle est déjà sélectionnée. |
| Entrée ou Espace sur un en-tête de groupe | Développez ou repliez le groupe. |
| Flèche droite, flèche gauche sur un en-tête de groupe | Développez ou repliez le groupe. Les touches sont inversées dans les configurations de droite à gauche. |
| Tab | Déplacez le focus vers et entre les en-têtes des colonnes redimensionnables. |
| Flèche gauche, flèche droite sur un en-tête de colonne | Redimensionnez la colonne. Maintenez la touche Maj enfoncée pour redimensionner en étapes plus grandes. |
| F2 | Commencez à modifier une cellule dans la ligne active. |
| Entrez | Enregistrez la modification en cours. |
| Échap | Annulez la modification actuelle ou annulez un redimensionnement de colonne pendant le déplacement. |
Pour plus d’informations, consultez Accessibilité au clavier et vue d’ensemble de l’accessibilité.
Contenu connexe
- espace de noms Microsoft.UI.Xaml.Controls.Tabular
- Notes de publication de SDK d'application Windows 2.5.4 - version expérimentale
- Spécification de l’API TableView
- Afficher des données tabulaires dans une application WinUI
- Vue des éléments
- Affichage liste et affichage grille
- Vue d’ensemble de la liaison de données
Windows developer