Meilleur DataGrid pour WPF ? Comparaison des composants intégrés et Xceed

J'y suis allé. Vous probablement aussi. Alors parlons de ce que DataGrid WPF Ce qu'il faut réellement faire dans une application réelle, lorsque le contrôle intégré atteint ses limites, et à quoi ressemblent les alternatives.

Que doit faire concrètement une grille de données WPF ?

Cela semble une question simple, n'est-ce pas ? Afficher des lignes et des colonnes. Mais pensez à ce que les utilisateurs attendent réellement d'un Grille WPF de nos jours

Ils veulent pouvoir cliquer sur l'en-tête d'une colonne pour la trier. La possibilité de faire glisser les colonnes devrait fonctionner nativement. En plus de cela, ils s'attendent à des filtres, à un regroupement par catégorie, et peut-être même à la possibilité d'étendre une ligne pour voir les données associées en dessous. L'application ne devrait pas se bloquer lors du chargement de 50 000 lignes. Et honnêtement ? Elle doit avoir l'apparence d'une application Windows moderne, pas de quelque chose qui date de 2008.

Le intégré System.Windows.Controls.DataGrid gère une partie de cela. Le tri de base fonctionne. Vous pouvez lier une collection. Mais c'est à peu près là que les bonnes nouvelles s'arrêtent.

Là où le DataGrid WPF intégré atteint ses limites

Je ne veux pas dénigrer le contrôle intégré trop durement — il est bon pour ce qu'il est. Cependant, voici ce que vous rencontrerez assez rapidement :

• Les performances se dégradent avec de grandes quantités de données. Essayez de charger quelques dizaines de milliers de lignes sans virtualisation appropriée. L'interface utilisateur se bloque, le défilement devient saccadé et vos utilisateurs commencent à se demander si l'application a planté. La grille intégrée offre une certaine virtualisation, mais elle est basique – pas de chargement asynchrone depuis des sources distantes, pas de mise en cache préemptive. Si vos données résident dans une base de données, vous êtes seul.
• Maître-détail n'existe pas. Vous avez besoin d'afficher les commandes avec leurs articles ? Les départements avec leurs employés ? La grille intégrée ne prend pas du tout en charge cela. Vous finirez par construire une solution personnalisée avec des grilles imbriquées (ce qui n'est... pas amusant) ou par utiliser un contrôle tiers.
• Le regroupement est limité. Vous pouvez techniquement regrouper, mais un regroupement multiniveau avec des résumés ? Des en-têtes de groupe personnalisés ? Cela représente beaucoup de travail manuel pour quelque chose qui devrait être simple.
• La personnalisation d'apparence semble bloquée en 2010. L'aspect par défaut est démodé. Pour qu'il corresponde à l'esthétique de Windows 10/11, il faut une quantité surprenante de personnalisation XAML. Et si votre designer demande le Material Design — bonne chance.
• Pas d'exportation, pas d'impression. Il n'y a pas d'exportation Excel, pas de CSV et pas de prise en charge d'impression intégrée. Par conséquent, vous devez le créer vous-même ou ajouter une autre bibliothèque.

Est-ce que cela vous dit quelque chose ?

Pourquoi la plupart finissent par utiliser Xceed DataGrid pour WPF

Je serai direct — il y a plusieurs tiers DataGrid WPF options disponibles. J'en ai essayé quelques-unes au fil des ans. Celle qui a séduit les utilisateurs est la nôtre Xceed DataGrid pour WPF.

Pourquoi ? En partie parce qu'il existe depuis plus de 13 ans et qu'il possède environ 185 fonctionnalités (leur affirmation, pas la mienne). Plus important encore, lorsque je l'ai intégré dans un projet, les choses ont simplement fonctionné sans avoir à y passer beaucoup de temps. Votre expérience peut varier, mais c'est la mienne.

Laissez-moi vous présenter les fonctionnalités avec du code fonctionnel pour que vous puissiez en juger par vous-même.

Commencer avec le Xceed WPF DataGrid

D'abord, attrapez le Package NuGet:

Install-Package Xceed.Products.Wpf.DataGrid.Full

Puis configurez votre clé de licence dans App.xaml.cs (vous obtenez une clé d'essai lors du téléchargement, ou une clé permanente avec une licence)

protected override void OnStartup(StartupEventArgs e)
{
    Xceed.Wpf.DataGrid.Licenser.LicenseKey = "YOUR-LICENSE-KEY";
    base.OnStartup(e);
}

Et c’est à peu près tout pour la configuration. (Xceed a plus de guide détaillé pour démarrer si vous voulez une image complète.) Ajoutez l'espace de noms à votre XAML et vous êtes prêt :

<Window xmlns:xcdg="http://schemas.xceed.com/wpf/xaml/datagrid">

    <xcdg:DataGridControl ItemsSource="{Binding Products}">
        <xcdg:DataGridControl.Columns>
            <xcdg:Column FieldName="Name" Title="Product Name" />
            <xcdg:Column FieldName="Price" Title="Price" />
            <xcdg:Column FieldName="Category" Title="Category" />
            <xcdg:Column FieldName="InStock" Title="In Stock" />
        </xcdg:DataGridControl.Columns>
    </xcdg:DataGridControl>

</Window>

Cela vous donne un entièrement fonctionnel DataGrid dans WPF — tri, filtrage, édition, le tout intégré. Aucune configuration supplémentaire n'est nécessaire pour les bases.

La vue Tableflow pour une grille WPF moderne

La vue de table par défaut est correcte, mais Xceed a une chose appelée Tableau fluide c'est honnêtement difficile de revenir en arrière une fois que vous l'avez utilisé. C'est une vue de tableau animée avec un défilement inertiel fluide, des en-têtes de groupe collants et un réordonnancement des colonnes par glisser-déposer.

Passer à cela est une propriété :

<xcdg:DataGridControl ItemsSource="{Binding Employees}">
    <xcdg:DataGridControl.View>
        <xcdg:TableflowView AllowColumnChooser="True"
                            IsAlternatingRowStyleEnabled="True" />
    </xcdg:DataGridControl.View>
</xcdg:DataGridControl>

Le AllowColumnChooser La propriété ajoute un petit bouton qui permet aux utilisateurs de choisir les colonnes qu'ils souhaitent voir. IsAlternatingRowStyleEnabled fait ce qu’on attend — alternance de couleurs de lignes pour la lisibilité. De petites choses, mais qui font la différence.

Il existe d'autres vues — TableView (la grille plate classique), TreeGridflow pour les données arborescentes hiérarchiques, et même une vue de cartes 3D si vous vous sentez aventureux. Je m'en tiens principalement à Tableflow cependant.

Regroupement du DataGrid dans WPF qui fonctionne réellement

C'est une de ces choses où la fonction intégrée DataGrid WPF prend techniquement en charge le regroupement mais vous oblige à faire trop de travail pour tout ce qui va au-delà des bases. Avec Xceed, vous utilisez leur DataGridCollectionView et ça marche, tout simplement :

var collectionView = new DataGridCollectionView(employees);
collectionView.GroupDescriptions.Add(
    new DataGridGroupDescription("Department"));

groupingGrid.ItemsSource = collectionView;

Cela vous donne des employés regroupés par département, avec des en-têtes de groupe repliables. Si vous souhaitez un regroupement à plusieurs niveaux, ajoutez simplement un autre DataGridGroupDescription. De même, si vous avez besoin de résumés (nombre, somme, moyenne) dans les en-têtes de groupe, Xceed prend également en charge cela. Il existe un tutoriel plus approfondi sur le regroupement et le tri si vous voulez voir plus d'exemples.

Le côté XAML reste propre :

<xcdg:DataGridControl x:Name="groupingGrid">
    <xcdg:DataGridControl.View>
        <xcdg:TableflowView IsAlternatingRowStyleEnabled="True" />
    </xcdg:DataGridControl.View>
</xcdg:DataGridControl>

Filtrer votre DataGrid WPF (style Excel)

Une chose qui m'a toujours dérangé avec le contrôle intégré est la quantité de travail nécessaire pour obtenir un filtrage décent. Xceed dispose d'un filtrage automatique intégré — ces filtres déroulants de style Excel dans les en-têtes de colonne. Vous l'activez sur le DataGridCollectionViewSource:

<Window.Resources>
    <xcdg:DataGridCollectionViewSource x:Key="cvs_products"
                                       Source="{Binding Products}"
                                       AutoFilterMode="And" />
</Window.Resources>

<xcdg:DataGridControl ItemsSource="{Binding Source={StaticResource cvs_products}}">
    <xcdg:DataGridControl.View>
        <xcdg:TableflowView />
    </xcdg:DataGridControl.View>
</xcdg:DataGridControl>

Fixer AutoFilterMode à "And" (tous les critères de filtre doivent correspondre) ou "Or" (n'importe quel critère correspond), et vous obtenez des listes déroulantes de filtres sur chaque colonne automatiquement. Vous pouvez également désactiver cette option pour des colonnes spécifiques avec AllowAutoFilter="False" si certaines colonnes n'ont pas de sens à filtrer. Le tutoriel de filtrage couvre des scénarios avancés tels que les valeurs distinctes personnalisées et la combinaison d'approches de filtrage.

Maître-détail dans le DataGrid WPF (le plus délicat)

Bon, j'admets que celui-ci m'a pris un peu de temps à comprendre. La fonctionnalité maître-détail dans Xceed fonctionne mieux lorsque vous lui fournissez une DataSet avec DataRelation objets — pensez-y comme à la définition d'une relation de clé étrangère que la grille peut comprendre et développer.

Voici la configuration côté C#. Il y a un peu plus de code que dans les autres exemples, mais soyez indulgents :

var dataSet = new DataSet();

// Master table: Orders
var ordersTable = new DataTable("Orders");
ordersTable.Columns.Add("OrderId", typeof(int));
ordersTable.Columns.Add("Customer", typeof(string));
ordersTable.Columns.Add("OrderDate", typeof(DateTime));
ordersTable.Columns.Add("Total", typeof(decimal));
ordersTable.PrimaryKey = new[] { ordersTable.Columns["OrderId"]! };

// Detail table: OrderDetails
var detailsTable = new DataTable("OrderDetails");
detailsTable.Columns.Add("DetailId", typeof(int));
detailsTable.Columns.Add("OrderId", typeof(int));
detailsTable.Columns.Add("Product", typeof(string));
detailsTable.Columns.Add("Quantity", typeof(int));
detailsTable.Columns.Add("UnitPrice", typeof(decimal));

dataSet.Tables.Add(ordersTable);
dataSet.Tables.Add(detailsTable);

// This is the key part — the DataRelation
dataSet.Relations.Add("OrderDetails",
    ordersTable.Columns["OrderId"]!,
    detailsTable.Columns["OrderId"]!);

L'important ici est que le DataRelation nom ("OrderDetails") doit correspondre à ce que vous avez mis dans votre XAML. DetailConfiguration. Puis vous l'enroulez dans un DataGridCollectionView:

var collectionView = new DataGridCollectionView(ordersTable.DefaultView);
masterDetailGrid.ItemsSource = collectionView;

Et le XAML :

<xcdg:DataGridControl x:Name="masterDetailGrid"
                      AutoCreateDetailConfigurations="True"
                      ReadOnly="True">
    <xcdg:DataGridControl.View>
        <xcdg:TableflowView />
    </xcdg:DataGridControl.View>
    <xcdg:DataGridControl.DetailConfigurations>
        <xcdg:DetailConfiguration RelationName="OrderDetails"
                                  Title="Order Details">
            <xcdg:DetailConfiguration.Columns>
                <xcdg:Column FieldName="OrderId" Visible="False" />
                <xcdg:Column FieldName="DetailId" Visible="False" />
            </xcdg:DetailConfiguration.Columns>
        </xcdg:DetailConfiguration>
    </xcdg:DataGridControl.DetailConfigurations>
</xcdg:DataGridControl>

Quelques pièges que j'ai rencontrés : AutoCreateDetailConfigurations par défaut false, donc tu avoir pour le régler à True ou vous n'aurez pas de boutons d'expansion et vous demanderez ce qui s'est mal passé. Et le RelationName sur le DetailConfiguration doit correspondre à DataRelation nom exact — il est sensible à la casse.

Mais une fois que ça fonctionne, c'est vraiment bien. Essentiellement, chaque ligne de commande obtient une flèche d'extension — cliquez dessus, et vous voyez les articles en ligne. Une seule barre de défilement pour le tout, pas de grille imbriquée inutile. Le documentation maître-détail a des exemples supplémentaires si vous avez besoin de hiérarchies plus profondes.

Prise en charge de MVVM et liaison de données

Si vous faites du développement WPF, il y a de fortes chances que vous utilisiez MVVM — et vous vous demandez probablement si la grille Xceed est compatible avec. Réponse courte : oui, elle l'est.

La grille se lie à ItemsSource tout comme n'importe quel autre contrôle WPF, donc votre standard ObservableCollection<T> et INotifyPropertyChanged les modèles fonctionnent comme prévu. Voici une configuration typique de ViewModel :

public class ProductViewModel : INotifyPropertyChanged
{
    public ObservableCollection<Product> Products { get; }

    public ProductViewModel()
    {
        Products = new ObservableCollection<Product>(
            LoadProductsFromDatabase());
    }

    public event PropertyChangedEventHandler? PropertyChanged;
}

<xcdg:DataGridControl ItemsSource="{Binding Products}" />

Rien d'inhabituel. La grille détecte automatiquement les changements de collection : ajoutez ou supprimez des éléments de la ObservableCollection et les mises à jour de l'interface utilisateur. De même, les changements de propriétés sur des éléments individuels se propagent à travers INotifyPropertyChanged comme on pouvait s'y attendre.

En outre, le DataGridCollectionView et DataGridCollectionViewSource suivre les mêmes modèles que ceux intégrés à WPF CollectionView / CollectionViewSource, donc si vous êtes déjà familier avec ceux-ci, vous vous sentirez comme chez vous.

Xceed expose aussi des propriétés de dépendance comme SelectedItemsSource et CurrentItem for two-way binding — the MVVM documentation covers this in detail.

Theming and appearance

Xceed ships with 18 themes. I’ve mostly been using the Windows 10 one because it fits naturally on modern Windows, but there’s also Aero, Windows 7, Windows 8, Zune (yes, Zune), Office 2007/2010 styles, and more.

Applying a theme in XAML:

<xcdg:DataGridControl ItemsSource="{Binding Products}">
    <xcdg:DataGridControl.View>
        <xcdg:TableflowView IsAlternatingRowStyleEnabled="True">
            <xcdg:TableflowView.Theme>
                <tp5:Windows10Theme />
            </xcdg:TableflowView.Theme>
        </xcdg:TableflowView>
    </xcdg:DataGridControl.View>
</xcdg:DataGridControl>

(You’ll need the namespace for the theme pack: xmlns:tp5="clr-namespace:Xceed.Wpf.DataGrid.ThemePack;assembly=Xceed.Wpf.DataGrid.ThemePack.5")

You can also switch themes at runtime in code-behind, which is handy if you want to let users pick their preferred look. Each theme is a separate assembly, so you only load the ones you actually use. Xceed also has a Pro Themes package that styles all standard WPF controls to match, not just the grid.

Performance and virtualization

I haven’t talked about this enough yet, and it’s probably the single most important reason to look beyond the built-in Grille WPF control. Xceed DataGrid has full UI virtualization (only visible rows get rendered), column virtualization (matters when you have wide grids), and — this is the big one — async data virtualization.

In practice, that means the grid can fetch data from a remote source in the background, cache it, and preemptively load nearby pages. As a result, your UI never freezes. The grid handles datasets with millions of rows, which is something the built-in WPF DataGrid simply can’t do without a lot of custom plumbing.

If you’re building anything that talks to a database or an API — honestly, any data source bigger than what fits comfortably in memory — this is the feature that matters most. There’s a practical walkthrough on rendering 1 million rows without freezing the UI if you want to see the details.

What else is in the box?

Beyond the features above, there are some things I haven’t covered in detail but are still worth mentioning:

• Editing. The grid auto-selects editors based on data type — text boxes for strings, date pickers for dates, checkboxes for booleans, numeric editors for numbers. It supports IDataErrorInfo et INotifyDataErrorInfo for validation. Masked input (phone numbers, SSNs) is built in too.
• Export. Excel (XLSX), CSV, and clipboard copy are all included. No extra NuGet packages, no third-party libraries. Same goes for print preview and printing.
• .NET support. Works on .NET Framework 4.0+, .NET Core 3.0+, and all the way up to .NET 8. Whether you’re maintaining a legacy app or starting fresh, it’s compatible.

Built-in WPF DataGrid vs. Xceed: feature comparison

Here’s the side-by-side, since I know that’s what a lot of people are looking for:

Pricing and licensing

Since people always ask — Xceed DataGrid for WPF is a commercial product. It’s not free, and it’s not open source. You can request a free 45-day trial to evaluate it, and licenses are per-developer (no runtime royalties). Pricing varies depending on whether you want just the DataGrid or the full Business Suite. Check the pricing page for current numbers.

If you’re looking for something free, the built-in DataGrid is obviously zero cost, and there are some open-source options on GitHub — though in my experience they tend to be much more limited in features and polish.

Choosing the right DataGrid for WPF

Look, the built-in DataGrid dans WPF is not a bad control. For simple stuff, it gets the job done. On the other hand, if you’re building something that real users depend on — something with big datasets, hierarchical data, grouping, export needs, or just a look that doesn’t feel a decade old — you’re going to hit its limits fast.

Xceed DataGrid pour WPF has been my go-to for these situations. Is it the only third-party grid out there? No. But the combination of Tableflow, master-detail, async virtualization, and the fact that it just works on .NET 8 without surprises — that’s why I keep reaching for it.

If you’re wrestling with the built-in grid or evaluating your options, it’s worth giving it a try. The NuGet package gets you up and running in about five minutes, and there are 28 sample applications covering pretty much every feature if you want to explore further.

Questions fréquemment posées

Is there a free DataGrid for WPF?

Yes — WPF ships with a built-in System.Windows.Controls.DataGrid that’s completely free. It covers basic sorting, column binding, and simple editing. However, for anything more advanced (master-detail, async virtualization, Excel export, theming), you’ll likely need a commercial DataGrid WPF component like Xceed.

How do I improve WPF DataGrid performance with large datasets?

The built-in grid supports basic UI virtualization. However, for truly large datasets you need async data virtualization — loading data on demand from the source without freezing the UI. Xceed DataGrid for WPF is the only Grille WPF that supports this natively. You can also improve performance by enabling column virtualization and using a TableflowView ou TableView instead of card-based views.

Does the WPF DataGrid support MVVM?

Le intégré DataGrid works with MVVM through standard ItemsSource binding, ObservableCollection<T>et INotifyPropertyChanged. Third-party grids like Xceed follow the same patterns — you bind to ItemsSource, and collection and property changes propagate automatically. Xceed’s DataGridCollectionViewSource also works as a XAML resource, similar to WPF’s built-in CollectionViewSource.

Can I export a WPF DataGrid to Excel?

Not with the built-in control — there’s no export functionality included. In contrast, Xceed DataGrid for WPF has built-in Excel (XLSX) and CSV export, plus clipboard copy support and print/print preview. No additional libraries needed.