Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Important
Das TableView Steuerelement ist ab Windows App SDK 2.5.4-experimental verfügbar. Die APIs sind als experimentell gekennzeichnet und können in einer zukünftigen Version geändert oder entfernt werden. Verwenden Sie sie nicht in Produktions-Apps.
Verwenden Sie das experimentelle TableView Steuerelement, um eine Sammlung von Elementen in Zeilen und Spalten anzuzeigen. Jede Zeile stellt ein Element aus Der Datenquelle dar, und Sie definieren die Spalten, die die Werte des Elements anzeigen. TableView unterstützt das Sortieren, Filtern, Gruppieren, Ändern der Größe von Spalten, fixierte führende Spalten, Auswahl einer einzelnen Zeile und optionale Zellbearbeitung. Zeilen werden virtualisiert, sodass das Steuerelement nur ui für die Zeilen in und in der Nähe des sichtbaren Bereichs erstellt.
Um das Steuerelement zu testen, installieren Sie das Windows App SDK 2.5.4-experimental-Paket und die entsprechende Laufzeit. Downloadlinks und Setupinformationen finden Sie unter Neueste Windows App SDK Downloads.
Ist dies das richtige Steuerelement?
Verwenden Sie eine TableView, wenn Sie möchten:
- Zeigen Sie Datensätze mit denselben Feldern, z. B. Bestellungen, Dateien oder Kunden, in ausgerichteten Spalten an.
- Ermöglichen Sie Benutzern, Werte über Elemente hinweg zu vergleichen und die Zeilenreihenfolge nach Spalte zu ändern.
- Filtern oder gruppieren Sie die angezeigten Zeilen, ohne die zugrunde liegende Sammlung zu ändern.
- Zulassen, dass Benutzer einzelne Werte direkt bearbeiten können.
In Windows App SDK 2.5.4-experimentell hat TableView folgende Einschränkungen:
- Benutzer können jeweils nur eine Zeile auswählen.
- Benutzer können jeweils nach einer Spalte sortieren, und Spaltenüberschriften unterstützen die Sortierung nicht über die Tastatur.
- Zeilen können nur auf einer Ebene gruppiert werden.
- Benutzer können Spalten nicht neu anordnen, und das Steuerelement zeigt keine Zeilenüberschriften an.
- Nur führende Spalten können fixiert werden.
- Spalten werden nicht virtualisiert. Das Steuerelement ist für Tabellen mit ca. 5 bis 50 Spalten ausgelegt.
- TableView ist kein DataGrid-Ersatz und bietet keine Interaktion im Tabellenkalkulationsstil.
Berücksichtigen Sie diese Alternativen:
| Scenario | Storm oder Flink |
|---|---|
| Ihre App verwendet eine stabile Version des Windows App SDK. | ItemsView oder ListView mit einer Spaltenelementvorlage oder einem unterstützten Rastersteuerelement eines Drittanbieters. Anleitungen finden Sie unter Anzeigen von tabellarischen Daten in einer WinUI-App. |
| Elemente benötigen eine Karte, Kachel oder ein benutzerdefiniertes Layout anstelle von ausgerichteten Spalten. | ItemsView oder ListView und GridView. |
| Sie benötigen Features, die diese Version nicht enthält, z. B. Mehrfachauswahl oder Spaltenumordnung. | Ein unterstütztes Grid-Steuerelement eines Drittanbieters. |
Das Community-Projekt WinUI.TableView ist ein separates Open-Source-Steuerelement, das als WinUI.TableView NuGet-Paket verteilt wird. Es ist nicht Teil des Windows App SDK, und seine API unterscheidet sich von der API, die in diesem Artikel beschrieben wird. Code und Markup, die Sie für ein Steuerelement schreiben, funktionieren nicht ohne Änderungen mit dem anderen.
TableView zu Ihrer App hinzufügen
![]()
Die WinUI 3 Gallery-App enthält interaktive Beispiele für WinUI-Steuerelemente und -Features. Rufen Sie die App aus dem Microsoft Store ab, oder durchsuchen Sie den Quellcode auf GitHub.
Der WinUI 3-Katalog enthält ein experimentelles TableView-Beispiel ab Version 3.0.4. Sie können auch den TableView-Beispielquellcode auf GitHub anzeigen.
TableView erfordert Designressourcen, die in XamlControlsResources nicht enthalten sind. Fügen Sie in TabularControlsResources nach XamlControlsResources in die App-Ressourcen Ihrer App ein:
<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>
Wenn Sie diese Ressourcen nicht zusammenführen, löst Ihre App eine XAML-Analyseausnahme aus, wenn sie zum ersten Mal eine TableView anordnet. Die Ausnahmemeldung enthält Cannot find a Resource with the Name/Key gefolgt vom Namen einer TableView-Ressource. Es wird TabularControlsResources nicht erwähnt.
Wenn Sie TableView-Ressourcen in Ihren eigenen zusammengeführten Wörterbüchern überschreiben, fügen Sie diese Wörterbücher nach TabularControlsResources hinzu.
Tip
Ab Windows App SDK 2.6.6-experimental schreibt TableView eine Nachricht, die mit beginnt, in das Visual Studio-TabularControlsResourcesfenster, wenn TableView setup: beim Erstellen einer TableView nicht zusammengeführt ist. Die Meldung zeigt den Eintrag an, der zu App.xaml hinzugefügt werden soll. Um es anzuzeigen, debuggen Sie mit systemeigenem oder gemischtem Debugging. Wählen Sie in einem C#-Projekt die Option "Systemeigenes Codedebugging aktivieren " im Debugstartprofil des Projekts aus.
Um TableView im Markup zu verwenden, deklarieren Sie den Microsoft.UI.Xaml.Controls.Tabular Namespace. Die Beispiele in diesem Artikel verwenden das tabular Präfix für diesen Namespace und das local Präfix für den eigenen Namespace der App:
xmlns:tabular="using:Microsoft.UI.Xaml.Controls.Tabular"
Fügen Sie using Microsoft.UI.Xaml.Controls.Tabular; in C#-Codedateien ein.
Note
Da die APIs experimentell sind, meldet der C#-Compiler die Warnung CS8305 und der XAML-Compiler meldet Warnungen WMC1501, wenn Sie sie verwenden. Diese Warnungen werden erwartet. Um CS8305 in einem Projekt zu unterdrücken, das Sie zur Auswertung verwenden, fügen Sie es der Eigenschaft NoWarn in Ihrer Projektdatei hinzu.
Eine Tabelle erstellen
TableView generiert keine Spalten aus Ihren Daten. Fügen Sie eine Spalte für jeden Wert hinzu, den Sie anzeigen möchten. Ohne Spalten zeigt TableView keine Zellen an.
Verwenden Sie eine TableViewTextColumn , um einen Wert als Text anzuzeigen. Legen Sie die Binding Eigenschaft auf eine {Binding} Markuperweiterung fest, die die anzuzeigende Eigenschaft benennt, und legen Sie Header auf den Text für die Spaltenüberschrift fest. Die Binding Eigenschaft akzeptiert ein Binding Objekt. Verwenden Sie {Binding} daher anstelle von {x:Bind} für diese Eigenschaft.
Im folgenden Beispiel wird eine Tabelle mit vier Textspalten erstellt:
<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 ist die Inhaltseigenschaft von TableView, sodass Sie spalten direkt innerhalb des TableView Elements hinzufügen können.
Die Seite stellt die Elemente als ObservableCollection<T> bereit, sodass die Tabelle aktualisiert wird, wenn Sie Elemente hinzufügen oder entfernen:
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();
}
}
Die Elementklasse implementiert INotifyPropertyChanged, sodass Zellen aktualisiert werden, wenn sich ein Wert ändert, z. B. nachdem ein Benutzer eine Zelle bearbeitet hat:
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;
}
}
Die folgende Abbildung zeigt die Tabelle aus diesem Beispiel:
Tip
Wenn Sie Ihre App mit Trimming oder nativem AOT veröffentlichen, markieren Sie Ihre Elementklassen und Comparerklassen als partial. C#/WinRT erfordert den partial Modifizierer, um den Interoperabilitätscode für Klassen zu generieren, die an Windows-Runtime-APIs übergeben werden.
Festlegen von Spaltenbreiten
Legen Sie die Width Eigenschaft jeder Spalte auf einen der folgenden Werte fest:
| Breite | Behavior |
|---|---|
Eine Anzahl von Pixeln, z. B. 80 |
Die Spalte weist eine feste Breite auf. Die Standardbreite beträgt 120 Pixel. |
Auto |
Die Spalte passt sich der breitesten Kopfzeile oder Zelle an, die derzeit realisiert ist. Da Zeilen virtualisiert sind, kann sich die Breite ändern, während der Benutzer scrollt. |
Ein Sternwert, z. B. * oder 2* |
Die Spalte teilt die verbleibende Breite mit anderen Spalten mit Sternbreite im Verhältnis zu ihrem Sternwert. |
Verwenden Sie MaxWidth und MinWidth, um die Breite einer Spalte zu beschränken. Die Standard-Mindestbreite beträgt 20 Pixel. Um die aktuelle Breite einer Spalte abzurufen, lesen Sie ActualWidth.
Spaltenüberschriften festlegen
Verwenden Sie, wenn möglich, Zeichenfolgenwerte für Header. TableView verwendet Zeichenfolgen-Kopfzeilen, um Zellen für Hilfstechnologien zu benennen und Sortierungsänderungen anzukündigen. Zum Anpassen des Aussehens einer Kopfzeile legen Sie Header fest und behalten eine Zeichenfolge HeaderTemplate bei. Die Kopfzeilenvorlage empfängt den Header Wert als Inhalt.
Um eine Spalte auszublenden, legen Sie ihre Visibility-Eigenschaft auf Collapsed fest.
Anzeigen benutzerdefinierter Inhalte mit Vorlagenspalten
Verwenden Sie TableViewTemplateColumn, wenn eine Zelle mehr als Text benötigt, z. B. eine Statusanzeige, ein Bild oder mehrere Werte. Legen Sie die Eigenschaft CellTemplate der Spalte auf DataTemplate fest. Die Daten jeder Zelle sind das Element für diese Zeile, sodass Sie {x:Bind} mit x:DataType in der Vorlage verwenden können.
In der folgenden Spalte werden die einzelnen Werte als Fortschrittsbalken und eine Zahl angezeigt:
<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>
Eine Vorlagenspalte hat keine Bindung, nach der TableView sortieren kann. Um die Spalte sortierbar zu machen, setzen Sie SortMemberPath auf den Namen der Eigenschaft, nach der sortiert werden soll, wie im vorherigen Beispiel, oder legen Sie einen benutzerdefinierten Vergleich fest. Weitere Informationen finden Sie unter Sortieren von Zeilen.
TableView verwendet Zellenelemente wieder, wenn Zeilen in die und aus der Ansicht gescrollt werden. Binden Sie jeden Wert in der Vorlage an das Element, anstatt Werte für einzelne Zellelemente im Code festzulegen. Die Statusanzeige im Beispiel wiederholt die Zahl im Textblock, daher ist sie mit AutomationProperties.AccessibilityView="Raw" markiert, um zu verhindern, dass Hilfstechnologien den Wert zweimal melden.
Bereitstellen von Daten mit TableViewSource
Sie können ItemsSource wie im vorherigen Beispiel direkt auf eine Sammlung festlegen, und Benutzer können weiterhin nach Spalten sortieren. Um Zeilen aus Code zu filtern, zu sortieren oder zu gruppieren, umschließen Sie die Auflistung mit einem TableViewSource und setzen Sie ItemsSource stattdessen auf die Quelle. TableViewSource ändert nur die Zeilen, die TableView anzeigt. Sie ändert nicht den Inhalt oder die Reihenfolge Ihrer Sammlung.
Rufen Sie TableViewSource.From auf, um die Quelle zu erstellen und ItemsSource daran zu binden:
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>
Die Filter-, Sortier- und Gruppierungsmethoden geben dasselbe TableViewSourcezurück, sodass Sie Aufrufe verketten können:
TableSource
.Filter(item => ((TableViewSampleItem)item).Value >= 25)
.Sort("Name", SortDirection.Ascending);
Beachten Sie diese Verhaltensweisen, wenn Sie eine TableViewSource verwenden:
-
Fromakzeptiert eine Auflistung, z. B. eineObservableCollection<T>oder eineList<T>. Es löst eine Ausnahme aus, wenn Sienulloder ein Objekt übergeben, das keine Auflistung ist. - Wenn Ihre Sammlung Benachrichtigungen über Sammlungsänderungen auslöst, z. B. wenn Sie einem
ObservableCollection<T>ein Element hinzufügen, wendet TableView den aktuellen Filter, die Sortierung und die Gruppierung auf die Änderung an. - Eine Eigenschaftsänderung an einem Element führt nicht dazu, dass dieses Element erneut gefiltert, sortiert oder gruppiert wird. Wenn ein Benutzer beispielsweise einen Wert in der sortierten Spalte bearbeitet, behält die Zeile die Position bei. Die Zeilen werden beim nächsten Ändern der Sammlung oder beim erneuten Anwenden eines Filters, einer Sortierung oder einer Gruppierung neu angeordnet.
- Verwenden Sie die Quelle und deren Sammlung nur im UI-Thread, und lösen Sie Benachrichtigungen zu Sammlungsänderungen im UI-Thread aus.
- Eine TableViewSource kann jeweils nur von einer TableView verwendet werden. Um es mit einer anderen TableView zu verwenden, legen Sie zunächst
ItemsSourceder ursprünglichen TableView auf einen anderen Wert fest. - TableView identifiziert Zeilen nach Objektidentität, unabhängig davon, ob Sie eine TableViewSource verwenden. Dasselbe Objekt kann nicht mehr als einmal in der Auflistung enthalten sein. Die Auswahl folgt einem Element, wenn die Zeilen umgestaltet werden, aber nicht, wenn Sie das Element durch ein neues Objekt ersetzen.
Zeilen auswählen
Benutzer wählen eine Zeile aus, indem sie darauf klicken oder tippen oder mit der Tastatur darauf wechseln. Legen Sie zum Steuern der Auswahl SelectionMode einen der folgenden Werte fest:
-
Single(Standard): Benutzer können jeweils eine Zeile auswählen. -
None: Benutzer können keine Zeilen auswählen. Durch Festlegen dieses Werts wird die aktuelle Auswahl gelöscht.
Die SelectedItem und SelectedIndex Eigenschaften sind schreibgeschützt. Um die Auswahl per Code zu ändern, rufen Sie Select, Deselect oder DeselectAll auf. Um zu prüfen, ob eine Zeile ausgewählt ist, rufen Sie IsSelected auf.
// Select the first displayed row.
ItemsTable.Select(0);
Indexbasierte Member verwenden die Position der Zeile in der angezeigten Reihenfolge, nachdem Filterung, Sortierung und Gruppierung angewendet wurden. Wenn Zeilen gruppiert sind, belegen Gruppenkopfzeilen auch Positionen, können aber nicht ausgewählt werden.
Select hat keine Auswirkung, wenn ItemsSource nicht festgelegt ist oder SelectionModeNone ist.
Um zu reagieren, wenn sich die Auswahl ändert, behandeln Sie das SelectionChanged Ereignis:
<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.";
}
Die Auswahl folgt dem ausgewählten Element, wenn Zeilen erneut sortiert werden oder Elemente eingefügt werden. Wenn Sie das ausgewählte Element aus der Sammlung entfernen, es mit einem Filter ausblenden oder ein neues ItemsSource festlegen, wird die Auswahl aufgehoben. Benutzer können die Auswahl der ausgewählten Zeile aufheben, indem Sie STRG drücken und darauf klicken oder STRG+LEERTASTE drücken.
Zeilen sortieren
Standardmäßig können Benutzer die Zeilen sortieren, indem sie auf eine Spaltenüberschrift klicken oder tippen. Die Kopfzeile zeigt einen Indikator an, der die Sortierrichtung anzeigt. Beim Sortieren einer Spalte wird die Sortierung aus allen anderen Spalten gelöscht.
Eine Textspalte wird nach der Eigenschaft in ihrem Binding sortiert. Eine Vorlagenspalte benötigt einen SortMemberPath oder einen benutzerdefinierten Comparer, bevor sie sortiert werden kann. Um zu verhindern, dass Benutzer nach einer beliebigen Spalte sortieren, setzen Sie CanUserSortColumns auf False. Um die Sortierung nach einer bestimmten Spalte zu verhindern, legen Sie die CanSort-Eigenschaft dieser Spalte auf False.
Sortierzyklus auswählen
Die Eigenschaft SortCycle einer Spalte steuert die Reihenfolge der Richtungen, wenn ein Benutzer wiederholt auf deren Kopfzeile klickt:
| Wert | Wegbeschreibungen |
|---|---|
AscendingDescending (Standardwert) |
Aufsteigend, dann absteigend. |
AscendingDescendingNone |
Aufsteigend, absteigend und dann die ursprüngliche Reihenfolge der Quelle. |
DescendingAscending |
Absteigend, dann aufsteigend. |
DescendingAscendingNone |
Absteigend, aufsteigend und dann die ursprüngliche Reihenfolge der Quelle. |
Wenn ein Benutzer eine Spalte in die ursprüngliche Reihenfolge zurückgibt, löscht TableView alle Sortierungen, einschließlich der Sortierung, die Sie mit TableViewSource angewendet haben.
Das folgende Beispiel, das auf dem WinUI 3-Katalogbeispiel basiert, verhindert die Sortierung nach ID, ermöglicht es Benutzern, die Spalte „Name“ in die ursprüngliche Reihenfolge zurückzusetzen, und sortiert Werte zuerst vom höchsten zum niedrigsten:
<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>
Die folgende Abbildung zeigt diese Tabelle, sortiert nach der Spalte "Wert" in absteigender Reihenfolge, der ersten Richtung im Sortierzyklus dieser Spalte. Die Wertüberschrift zeigt einen Sortierindikator an.
Nach Code sortieren
Rufen Sie SortByColumn, ToggleSortDirection oder ClearSort an. Jede Methode gibt zurück true , wenn die Sortierung geändert wurde. Das Sortieren aus Code funktioniert auch dann, wenn CanUserSortColumns den Wert False aufweist.
// 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();
Verwenden Sie die schreibgeschützte SortDirection Eigenschaft, um die aktuelle Richtung einer Spalte zu lesen.
Reagieren auf Sortieränderungen
TableView löst das Sorting Ereignis aus, bevor es eine Sortierung anwendet, und das Sorted Ereignis, nachdem es die Sortierung angewendet hat. Beide Ereignisse melden die Spalte und die neue Richtung. Wenn Sie ClearSort aufrufen, ist die Spalte null und die Richtung ist None.
Um eine Sortierung zu verhindern, legen Sie Sorting im true-Ereignishandler auf Cancel fest. TableView behält dann die aktuelle Reihenfolge und Sortierindikatoren bei und löst Sorted nicht aus.
<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()}.";
}
Wenn Sie eine neue ItemsSource festlegen, löscht TableView die Sortierung, ohne Sorting oder Sorted auszulösen.
Sortieren mit einem benutzerdefinierten Comparer
Um die Sortierreihenfolge einer Spalte zu steuern, implementieren Sie ITableViewSortComparer und weisen Sie sie der CustomSortComparer-Eigenschaft der Spalte zu. Ein benutzerdefiniertes Vergleichsobjekt hat Vorrang vor SortMemberPath und der Bindung der Spalte.
Die Compare Methode empfängt zwei Datenelemente und definiert die aufsteigende Reihenfolge. TableView kehrt die Reihenfolge für eine absteigende Sortierung um. Gibt ein konsistentes Ergebnis für dasselbe Elementpaar zurück und löst keine Exceptions aus. TableView behandelt einen Vergleich, der eine Ausnahme auslöst, als gleich.
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);
}
}
Sie können den Comparer als Ressource deklarieren und im Markup darauf verweisen:
<Page.Resources>
<local:NameLengthComparer x:Key="NameLengthComparer" />
</Page.Resources>
<tabular:TableViewTextColumn
Binding="{Binding Name}"
CustomSortComparer="{StaticResource NameLengthComparer}"
Header="Name"
Width="220" />
Oder weisen Sie sie im Code zu:
NameColumn.CustomSortComparer = new NameLengthComparer();
Sortieren mit TableViewSource
Wenn es sich bei ItemsSource um eine TableViewSource handelt, können Sie auch durch Aufrufen von TableViewSource.Sort sortieren. Im Gegensatz zur Headersortierung kann diese Methode nach mehreren Eigenschaften sortieren. Die erste Sortierung, die Sie hinzufügen, ist die primäre Sortierung, und jede spätere Sortierung ordnet Elemente, die in den vorherigen Sortierungen gleich sind.
// Sort by category, and then by name within each category.
TableSource
.Sort("Category", SortDirection.Ascending)
.Sort("Name", SortDirection.Ascending);
Bevorzugen Sie die Überladung, die einen Eigenschaftspfad annimmt. TableView kann mit dem Pfad zu einer Spalte übereinstimmen und den Sortierindikator dieser Spalte anzeigen. Wenn Sie erneut nach demselben Pfad sortieren, wird diese Sortierung direkt ersetzt, und SortDirection.None entfernt sie. Die Überladung, die einen Key-Selector verwendet, sortiert nach einem berechneten Wert, und TableView löscht alle Spaltensortierungsindikatoren, wenn Sie sie verwenden.
Eine Sortierung, die Sie mit TableViewSource anwenden, und eine Sortierung, die ein Benutzer über eine Spaltenüberschrift anwendet, ersetzen einander. Was zuletzt angewendet wird, bestimmt die Reihenfolge. Um alle Sortierungen aus der Quelle zu entfernen, rufen Sie ClearSort auf.
TableView löst Sorting nicht für eine Sortierung aus, die Sie mit TableViewSource anwenden, sodass Sie sie nicht vom Ereignishandler abbrechen können. Nachdem TableView die Spaltensortierungsindikatoren aktualisiert hat, um der neuen Sortierung zu entsprechen, löst es Sorted aus. Wenn keine Spalte mit der primären Sortierung übereinstimmt, z. B. weil Sie mit einem Schlüsselselektor sortiert haben, meldet das Ereignis eine null Spalte und eine Richtung von None.
Zeilen filtern
Um nur die Zeilen anzuzeigen, die einer Bedingung entsprechen, rufen Sie TableViewSource.Filter mit einem Prädikat auf, das für jedes zu behaltende Element true zurückgibt. Jeder Aufruf ersetzt den vorherigen Filter. Um den Filter zu entfernen, rufen Sie ClearFilter auf.
Im folgenden Beispiel aus dem WinUI 3 Gallery-Beispiel werden die Zeilen gefiltert, während der Benutzer tippt:
<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)));
}
Der Filter wird vor dem Sortieren und Gruppieren ausgeführt. Wenn das Prädikat eine Ausnahme für ein Element auslöst, schließt TableViewSource dieses Element aus.
Wenn keine Zeilen übereinstimmen, zeigt TableView den Inhalt seiner EmptyTemplate Eigenschaft an. TableView zeigt diese Vorlage auch an, wenn ItemsSourcenull ist oder leer ist.
<tabular:TableView.EmptyTemplate>
<DataTemplate>
<TextBlock
Margin="24"
HorizontalAlignment="Center"
VerticalAlignment="Center"
Text="No items match the filter." />
</DataTemplate>
</tabular:TableView.EmptyTemplate>
Gruppieren von Zeilen
Zum Gruppieren von Zeilen rufen Sie TableViewSource.GroupBy mit einem Schlüsselselektor auf. TableView zeigt eine Kopfzeile für jede Gruppe an, und Benutzer können jede Gruppe erweitern oder einklappen. Rufen Sie ClearGroupBy auf, um die Gruppierung zu entfernen.
// Group the rows by category.
TableSource.GroupBy(item => ((TableViewSampleItem)item).Category);
Um den Inhalt der Gruppenkopfzeilen anzupassen, legen Sie GroupHeaderTemplate fest. Die Daten für die Vorlage sind ein TableViewGroupInfo Objekt. TableView aktualisiert dieses Objekt direkt. Verwenden Sie also Mode=OneWay in Ihren Bindungen. Die Vorlage ersetzt nur den Inhaltsbereich der Kopfzeile. TableView zeigt weiterhin die Glyphe zum Erweitern und Einklappen an.
<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 ist der Gruppenschlüssel als Text und ItemCountText ist die Anzahl der Elemente in der Gruppe, die für die Anzeige formatiert sind.
Die folgende Abbildung zeigt die nach Kategorie gruppierten Elemente mit dieser Kopfzeilenvorlage:
Zum Erweitern oder Einklappen jeder Gruppe im Code ExpandAllGroups oder CollapseAllGroups aufrufen. Diese Methoden haben keine Auswirkung, wenn die Zeilen nicht gruppiert werden.
private void ExpandAllGroups_Click(object sender, RoutedEventArgs e)
{
ItemsTable.ExpandAllGroups();
}
private void CollapseAllGroups_Click(object sender, RoutedEventArgs e)
{
ItemsTable.CollapseAllGroups();
}
Gruppenschlüssel auswählen
Die Schlüsselauswahl muss für jedes Element einen Schlüssel zurückgeben, und der Schlüssel kann weder null noch eine leere Zeichenfolge sein. Andernfalls löst TableViewSource eine Ausnahme aus. Gibt einen Platzhalterwert für Elemente zurück, für die kein Schlüssel vorhanden ist:
// Items without a category are grouped under "(None)".
TableSource.GroupBy(item =>
((TableViewSampleItem)item).Category is { Length: > 0 } category ? category : "(None)");
TableViewSource kann Schlüssel vom Typ String, Int32, Int64, Guid, Boolean und Enumerationstypen identifizieren. Verwenden Sie für andere Schlüsseltypen, z. B. ein benutzerdefiniertes Objekt, die Überladung GroupBy, die auch ein TableViewIdentitySelector annimmt. Der Identitätsselektor empfängt einen Schlüssel und gibt eine nicht leere Zeichenfolge zurück, die seine Gruppe eindeutig identifiziert.
Kombinieren von Sortierung und Gruppierung
Die Reihenfolge, in der Sie TableViewSource-Methoden aufrufen, bestimmt, wie Sortierung und Gruppierung kombiniert werden. Sortierungen, die Sie vor GroupBy hinzufügen, legen die Reihenfolge der Gruppen fest. Sortierungen, die Sie nach GroupBy hinzufügen, ordnen die Zeilen innerhalb jeder Gruppe.
// 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);
Größe von Spalten ändern und Spalten fixieren
Benutzer können die Größe einer Spalte ändern, indem sie den Rand der Kopfzeile ziehen. Eine Größenänderung legt Width der Spalte auf einen Pixelwert innerhalb von MinWidth und MaxWidth fest. Um eine Größenänderung beim Ziehen abzubrechen, drücken Sie ESC.
Um zu verhindern, dass Benutzer die Größe einer Beliebigen Spalte ändern, legen Sie die CanUserResizeColumns Einstellung auf False. Um die Größenänderung einer bestimmten Spalte zu verhindern, legen Sie dessen CanResize Eigenschaft auf False.
Um eine Spalte sichtbar zu halten, während Benutzer horizontal scrollen, legen Sie deren FrozenEdge Eigenschaft auf Leading. Nur eine fortlaufende Gruppe von Spalten, die mit der ersten Spalte beginnen, kann fixiert werden. TableView ignoriert Leading bei jeder Spalte, die nach einer Spalte kommt, die nicht fixiert ist. Die TableViewFrozenEdge Enumeration definiert auch einen Trailing Wert, der reserviert ist und in dieser Version nicht implementiert ist.
<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>
Sie können FrozenEdge auch im Code ändern. Im Beispiel „WinUI 3 Gallery“ wird ein ToggleSwitch verwendet, um die erste Spalte zu fixieren:
private void FreezeFirstColumnToggle_Toggled(object sender, RoutedEventArgs e)
{
IdColumn.FrozenEdge = FreezeFirstColumnToggle.IsOn
? TableViewFrozenEdge.Leading
: TableViewFrozenEdge.None;
}
Bearbeiten von Zellen
Zellen sind standardmäßig schreibgeschützt. Um Benutzern das Bearbeiten von Zellen zu ermöglichen, legen Sie die Eigenschaft IsReadOnly der TableView auf False fest. Um eine bestimmte Spalte schreibgeschützt zu halten, legen Sie die Eigenschaft IsReadOnly dieser Spalte auf True fest. Markieren Sie Spalten, die schreibgeschützte Eigenschaften anzeigen, wie im folgenden Beispiel Id, als schreibgeschützt.
<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" />
Benutzer bearbeiten eine Zelle auf diese Weise:
- Um mit der Bearbeitung zu beginnen, doppelklicken oder doppeltippen Sie auf die Zelle, oder drücken Sie F2. F2 bearbeitet die Zelle in der fokussierten Zeile und in der Spalte, auf die der Benutzer zuletzt geklickt oder getippt hat. Wenn der Benutzer nicht auf eine Zelle geklickt hat, bearbeitet F2 die erste sichtbare bearbeitbare Spalte.
- Um die Änderung zu übernehmen, drücken Sie die EINGABETASTE, oder bewegen Sie den Fokus aus dem Editor heraus. Um die Bearbeitung abzubrechen, drücken Sie ESC.
- Während der Editor geöffnet ist, empfängt er die Pfeil- und Navigationstasten, und die Auswahl ändert sich nicht.
Eine Textspalte bearbeitet ihren Wert in einem TextBox, das Binding der Spalte verwendet. Wenn der Benutzer die Bearbeitung übernimmt, schreibt TableView den neuen Wert in das Element. Bearbeitungen werden Zelle für Zelle übernommen. In dieser Version gibt es kein Speichern oder Abbrechen auf Zeilenebene, sodass beim Abbrechen einer Bearbeitung nur die Zelle wiederhergestellt wird, die gerade bearbeitet wird.
Die folgende Abbildung zeigt den Editor für die Zelle "Name" in der ersten Zeile:
Rufen Sie zum Committen oder Abbrechen der aktuellen Bearbeitung per Code CommitEdit oder CancelEdit auf. Übernehmen Sie beispielsweise alle ausstehenden Bearbeitungen, bevor Sie Daten speichern. Beide Methoden geben true zurück, wenn sie den Editor schließen.
false wird zurückgegeben, wenn keine Bearbeitung geöffnet ist oder wenn die Bearbeitung geöffnet bleibt, da ein Ereignishandler die Änderung abgebrochen hat oder die Überprüfung fehlgeschlagen ist. Um zu überprüfen, ob ein Editor geöffnet ist, lesen Sie IsEditing.
Reagieren auf Bearbeitungsereignisse
TableView löst BeginningEdit aus, bevor ein Editor geöffnet wird. Um die Bearbeitung zu verhindern, setzen Sie Cancel auf 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 löst CellEditEnding aus, wenn eine Bearbeitung übernommen oder abgebrochen werden soll. Die Eigenschaft EditAction gibt an, was zutrifft. Um den Editor geöffnet zu halten, setzen Sie Cancel auf true fest. Legen Sie Cancel fest, bevor der Handler zurückgegeben wird, da diese Ereignisse keine Verzögerungen unterstützen.
TableView löst CellEditEnding aus, bevor der Wert in das Element geschrieben wird. Um Code auszuführen, nachdem der Wert übernommen wurde, reihen Sie die Arbeit in die Dispatcher-Warteschlange ein, wie es im WinUI 3-Katalogbeispiel der Fall ist:
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}.";
}
});
}
Bereitstellen eines benutzerdefinierten Editors
Wenn Sie einen anderen Editor verwenden möchten, legen Sie die CellEditingTemplate-Eigenschaft der Spalte fest. In einer Textspalte ersetzt diese Vorlage den Standardwert TextBox. Eine Vorlagenspalte kann nur bearbeitet werden, wenn Sie CellEditingTemplate festlegen.
Binden Sie in der Bearbeitungsvorlage den bearbeiteten Wert mit {Binding}, Mode=TwoWayund UpdateSourceTrigger=Explicit. TableView aktualisiert die Quelle dieser Bindung, wenn der Benutzer die Bearbeitung abschließt. Es findet Bindungen auf diesen Eigenschaften: TextBox.Text, AutoSuggestBox.Text, ToggleSwitch.IsOn, ToggleButton.IsChecked, Selector.SelectedItem, Selector.SelectedIndex, Selector.SelectedValue, Slider.Value und NumberBox.Value. TableView kann {x:Bind}-Bindungen nicht finden. Wenn keine Bindung zum Aktualisieren gefunden werden kann, schlägt der Commit fehl, und der Editor bleibt geöffnet.
Im folgenden Beispiel wird die Kategorie mit ComboBox bearbeitet:
<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>
Das Beispiel verwendet eine statische Eigenschaft für die Elementklasse für die Liste der Kategorien:
public static IReadOnlyList<string> Categories { get; } = ["Alpha", "Beta", "Gamma"];
Überprüfen von Bearbeitungen
Wenn das Element INotifyDataErrorInfo implementiert, sucht TableView nach dem Schreiben des Werts nach Fehlern in der bearbeiteten Eigenschaft. Wenn die Eigenschaft Fehler aufweist, stellt TableView den vorherigen Wert wieder her und behält den Editor geöffnet, sodass der Benutzer den Wert korrigieren oder ESC drücken kann, um den Vorgang abzubrechen. Wenn der Eigenschaftenseter eine Ausnahme auslöst, bleibt der Editor ebenfalls geöffnet.
Für die folgende Elementklasse aus dem WinUI 3 Gallery-Beispiel ist ein Name erforderlich:
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 zeigt die Fehlermeldung nicht an. Um Benutzern mitzuteilen, warum der Wert nicht akzeptiert wurde, zeigen Sie die Nachricht selbst an. Beispielsweise behandelt das WinUI 3 Gallery-Beispiel das ErrorsChanged-Ereignis des bearbeiteten Elements und zeigt die Meldung in einer InfoBar.
Anpassen der Darstellung
Verwenden Sie diese Eigenschaften, um zu ändern, wie eine TableView aussieht:
| Eigenschaft | Description |
|---|---|
Density |
Legt die minimale Zeilenhöhe und den Abstand in Zellen und Spaltenüberschriften fest. Werte sind Compact, Standard (Standard) und Comfortable. |
GridLinesVisibility |
Zeigt All (Standard), Horizontal, Vertical oder None der Rasterlinien an. |
HeadersVisibility |
Zeigt die Spaltenüberschriften (ColumnStandard) an oder blendet sie aus (None). |
RowBackground, AlternatingRowBackground |
Legen Sie den Hintergrund von Zeilen und abwechselnden Zeilen fest. Wenn diese Eigenschaften null sind, verwenden Zeilen den Designhintergrund. |
EmptyTemplate |
Legt den Anzuzeigenden Inhalt fest, wenn keine Zeilen vorhanden sind. |
Wenn Sie die Spaltenüberschriften ausblenden, können Benutzer Spalten nicht mithilfe der Überschriften sortieren oder in der Größe ändern.
Im folgenden Beispiel, basierend auf dem WinUI 3 Gallery-Beispiel, werden kompakte Zeilen mit horizontalen Gitternetzlinien und wechselnden Zeilenhintergründen angezeigt:
<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>
Die folgende Abbildung zeigt diese Tabelle mit fünf Elementen:
QuickInfos anzeigen
Wenn Sie eine QuickInfo für die Zellen in einer Spalte anzeigen möchten, legen Sie die CellToolTipBinding-Eigenschaft der Spalte auf eine {Binding} fest. TableView wertet das Binding für jede Zeile aus. Wenn der Wert null oder leer ist, zeigt die Zelle keine QuickInfo an. Verwenden Sie zum Berechnen des QuickInfo-Texts einen Konverter in der Bindung.
Wenn Sie eine QuickInfo für eine Spaltenüberschrift anzeigen möchten, legen Sie die HeaderToolTip-Eigenschaft der Spalte auf eine Zeichenfolge oder einen anderen Inhalt fest. Wenn Sie ein UI-Element als QuickInfo-Inhalt verwenden, geben Sie jeder Spalte eine eigene Instanz.
TableView erstellt das ToolTip für Sie; legen Sie also den QuickInfo-Inhalt fest, z. B. eine Zeichenfolge, statt ein ToolTip Objekt. Wenn der Wert ein ToolTipist, zeigt TableView keine QuickInfo an.
Die folgende Vorlagenspalte, basierend auf dem WinUI 3 Gallery-Beispiel, zeigt den Elementnamen als Zellen-QuickInfo an und beschreibt die Spalte in einer Kopfzeilen-QuickInfo:
<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>
QuickInfos werden angezeigt, wenn der Benutzer auf eine Zelle oder Spaltenüberschrift zeigt. QuickInfos für Zellen werden nicht für den Tastaturfokus angezeigt, da der Tastaturfokus zwischen Zeilen und nicht zwischen Zellen verschoben wird. Wenn der QuickInfo-Inhalt einer Zelle oder Spaltenüberschrift eine Zeichenfolge ist, macht TableView sie auch für Hilfstechnologien als Hilfetext verfügbar. Inhalte, die keine Zeichenfolge sind, werden nicht verfügbar gemacht. Verwenden Sie daher einen Konverter, der Text zurückgibt, wenn Sie eine QuickInfo für Zellen berechnen müssen.
Bedienungshilfen und Tastaturunterstützung
TableView bietet Benutzeroberflächenautomatisierung Unterstützung für seine Teile:
- Die Tabelle wird als Datenraster verfügbar gemacht. Sie unterstützt die Grid- und Table-Muster, sodass Hilfstechnologien ihre Zeilen und Spalten melden können. Wenn
SelectionModenichtNoneist, wird auch das Selection-Muster unterstützt. - Wenn
SelectionModenichtNoneist, unterstützen Zeilen das SelectionItem-Muster. - Spaltenüberschriften werden als Kopfzeilenelemente verfügbar gemacht. Wenn Benutzer nach einer Spalte sortieren können, unterstützt die Kopfzeile das Invoke-Muster, mit dem nach dieser Spalte sortiert wird, und der Hilfetext meldet den Sortierstatus. Der Hilfetext einer Kopfzeile enthält auch die QuickInfo der Spalte, wenn die QuickInfo eine Zeichenfolge ist.
- Zellen unterstützen die GridItem- und TableItem-Muster. Der Name jeder Zelle kombiniert die Spaltenüberschrift und den Zellwert, z. B. "Name, Element 1". Die Kopfzeile ist nur enthalten, wenn es sich um eine Zeichenfolge handelt. Textzellen, die Benutzer mit dem Standard-Editor bearbeiten können, unterstützen auch das Value-Muster.
- Gruppenkopfzeilen unterstützen das ExpandCollapse-Muster.
- Wenn sich die Sortierreihenfolge ändert oder ein Benutzer die Größe einer Spalte ändert, löst TableView eine Benachrichtigung aus, die von Hilfstechnologien angekündigt werden kann.
So machen Sie Ihre Tabelle barrierefrei:
- Legen Sie
AutomationProperties.Namebei jedem TableView fest, um dessen Inhalt zu beschreiben. - Verwenden Sie Zeichenfolgenwerte für Spaltenüberschriften.
- Markieren Sie in Zellenvorlagen dekorative Elemente mit
AutomationProperties.AccessibilityView="Raw", und geben Sie interaktiven Elementen einen barrierefreien Namen. Testen Sie Vorlagenspalten mit einem Barrierefreiheitstool wie Accessibility Insights for Windows, um zu überprüfen, was Hilfstechnologien für jede Zelle melden. - Vermeiden Sie,
Foregroundfür Text in Zellenvorlagen explizit festzulegen. Ein expliziter Vordergrund überschreibt die Farben, die TableView für ausgewählte Zeilen und Designs mit hohem Kontrast verwendet. Wenn Sie sie festlegen, überprüfen Sie diese Zustände. - Benutzer können in dieser Version nicht anhand von Spaltenüberschriften von der Tastatur sortieren. Wenn die Sortierung in Ihrer App wichtig ist, stellen Sie eine andere per Tastatur zugängliche Möglichkeit zum Sortieren bereit, z. B. ein Menü oder ein
ComboBox, dasSortByColumnaufruft. - TableView kündigt nicht an, wann eine Bearbeitung beginnt oder endet. Melden Sie das Ergebnis einer Bearbeitung selbst, wenn es für den Benutzer wichtig ist, zum Beispiel in einer
TextBlock, bei derAutomationProperties.LiveSettingaufPolitegesetzt ist.
TableView unterstützt diese Tastaturinteraktionen:
| Key | Action |
|---|---|
| Pfeil nach oben, Pfeil nach unten | Setzen Sie den Fokus auf die vorherige oder nächste Zeile und wählen Sie diese aus. |
| Pos1, Ende | Setzen Sie den Fokus auf die erste oder letzte Zeile, und wählen Sie diese aus. |
| BILD-AUF, BILD-AB | Bewegen Sie den Fokus um etwa eine Seite mit Zeilen nach oben oder unten, und wählen Sie die Zeile aus. |
| STRG + eine Navigationstaste | Fokus verschieben, ohne die Auswahl zu ändern. |
| Space | Auswählen der fokussierten Zeile. |
| STRG+LEERTASTE | Auswählen der fokussierten Zeile oder Aufheben der Auswahl, wenn sie bereits ausgewählt ist. |
| Enter oder Leertaste auf einem Gruppenkopf | Erweitern oder Reduzieren der Gruppe. |
| NACH-RECHTS-TASTE, NACH-LINKS-TASTE auf einer Gruppenkopfzeile | Erweitern oder Reduzieren der Gruppe. Die Tasten sind in Rechts-nach-links-Layouts vertauscht. |
| Tab | Verschieben Sie den Fokus auf und zwischen den Kopfzeilen von Spalten mit veränderbarer Größe. |
| NACH-LINKS- und NACH-RECHTS-TASTE auf einer Spaltenüberschrift | Ändern Sie die Größe der Spalte. Halten Sie die Umschalttaste gedrückt, um die Größe in größeren Schritten zu ändern. |
| F2 | Beginnen Sie mit der Bearbeitung einer Zelle in der fokussierten Zeile. |
| Eingeben | Übernehmen der aktuellen Bearbeitung. |
| Esc | Brechen Sie die aktuelle Bearbeitung ab, oder brechen Sie das Ändern der Spaltengröße beim Ziehen ab. |
Weitere Informationen finden Sie unter Tastaturbedienungshilfen und Übersicht über Barrierefreiheit.
Verwandte Inhalte
Windows developer