Meilleures pratiques pour la mise à l’échelle du contrôle DataGridView Windows Forms

2025-05-07

Le DataGridView contrôle est conçu pour fournir une scalabilité maximale. Si vous avez besoin d’afficher de grandes quantités de données, vous devez suivre les instructions décrites dans cette rubrique pour éviter de consommer de grandes quantités de mémoire ou de dégrader la réactivité de l’interface utilisateur (IU). Cette rubrique traite des problèmes suivants :

Utilisation efficace des styles de cellule
Utilisation efficace des menus contextuels
Utilisation efficace du redimensionnement automatique
Utilisation efficace des collections de cellules, de lignes et de colonnes sélectionnées
Utilisation de lignes partagées
Empêcher les rangées de devenir non partagées

Si vous avez des besoins spéciaux en matière de performances, vous pouvez implémenter le mode virtuel et fournir vos propres opérations de gestion des données. Pour plus d’informations, consultez Modes d’affichage des données dans le contrôle DataGridView Windows Forms.

Utilisation efficace des styles de cellule

Chaque cellule, ligne et colonne peut avoir ses propres informations de style. Les informations de style sont stockées dans des DataGridViewCellStyle objets. La création d’objets de style de cellule pour de nombreux éléments individuels DataGridView peut être inefficace, en particulier lors de l’utilisation de grandes quantités de données. Pour éviter un impact sur les performances, utilisez les instructions suivantes :

Évitez de définir des propriétés de style de cellule pour des objets individuels, tels que DataGridViewCell ou DataGridViewRow. Cela inclut l’objet de ligne spécifié par la RowTemplate propriété. Chaque nouvelle ligne clonée à partir du modèle de ligne recevra sa propre copie de l'objet de style de cellule du modèle. Pour une scalabilité maximale, définissez les propriétés de style de cellule au DataGridView niveau. Par exemple, définissez la DataGridView.DefaultCellStyle propriété plutôt que la DataGridViewCell.Style propriété.
Si certaines cellules nécessitent une mise en forme autre que la mise en forme par défaut, utilisez la même DataGridViewCellStyle instance entre des groupes de cellules, de lignes ou de colonnes. Évitez de définir directement les propriétés de type DataGridViewCellStyle sur des cellules, des lignes et des colonnes individuelles. Pour obtenir un exemple de partage de style de cellule, consultez How to : Set Default Cell Styles for the Windows Forms DataGridView Control. Vous pouvez également éviter une pénalité de performances lors de la définition individuelle des styles de cellule en gérant le CellFormatting gestionnaire d’événements. Pour obtenir un exemple, consultez Comment : personnaliser la mise en forme des données dans le contrôle DataGridView Windows Forms.
Lorsque vous déterminez le style d’une cellule, utilisez la DataGridViewCell.InheritedStyle propriété plutôt que la DataGridViewCell.Style propriété. L’accès à la Style propriété crée une nouvelle instance de la DataGridViewCellStyle classe si la propriété n’a pas déjà été utilisée. De plus, cet objet peut ne pas contenir les informations de style complètes de la cellule si certains styles sont hérités de la ligne, de la colonne ou du contrôle. Pour plus d’informations sur l’héritage de style de cellule, consultez Styles de cellule dans le contrôle DataGridView Windows Forms.

Utilisation efficace des menus contextuels

Chaque cellule, ligne et colonne peut avoir son propre menu contextuel. Les menus contextuels dans le contrôle DataGridView sont représentés par les contrôles ContextMenuStrip. Tout comme avec les objets de style de cellule, la création de menus contextuels pour de nombreux éléments individuels DataGridView aura un impact négatif sur les performances. Pour éviter cette pénalité, utilisez les instructions suivantes :

Évitez de créer des menus contextuels pour des cellules et des lignes individuelles. Cela inclut le modèle de ligne, cloné avec son menu contextuel lorsque de nouvelles lignes sont ajoutées au contrôle. Pour une scalabilité maximale, utilisez uniquement la propriété du ContextMenuStrip contrôle pour spécifier un menu contextuel unique pour l’ensemble du contrôle.
Si vous avez besoin de plusieurs menus contextuels pour plusieurs lignes ou cellules, gérez les événements CellContextMenuStripNeeded ou RowContextMenuStripNeeded. Ces événements vous permettent de gérer vous-même les objets de menu contextuel, ce qui vous permet d’optimiser les performances.

Utilisation efficace du redimensionnement automatique

Les lignes, les colonnes et les en-têtes peuvent être redimensionnés automatiquement en tant que modifications de contenu de cellule afin que l’ensemble du contenu des cellules soit affiché sans découpage. La modification des modes de dimensionnement peut également redimensionner des lignes, des colonnes et des en-têtes. Pour déterminer la taille correcte, le DataGridView contrôle doit examiner la valeur de chaque cellule qu’il doit prendre en charge. Lorsque vous utilisez des jeux de données volumineux, cette analyse peut avoir un impact négatif sur les performances du contrôle lorsque le redimensionnement automatique se produit. Pour éviter les pénalités de performances, suivez les instructions suivantes :

Évitez d’utiliser le dimensionnement automatique sur un DataGridView contrôle avec un grand nombre de lignes. Si vous utilisez le dimensionnement automatique, redimensionnez uniquement en fonction des lignes affichées. Utilisez uniquement les lignes affichées en mode virtuel.
- Pour les lignes et les colonnes, utilisez le champ DisplayedCells ou DisplayedCellsExceptHeaders des énumérations DataGridViewAutoSizeRowsMode, DataGridViewAutoSizeColumnsMode, et DataGridViewAutoSizeColumnMode.
- Pour les en-têtes de ligne, utilisez le champ AutoSizeToDisplayedHeaders ou AutoSizeToFirstHeader de l’énumération DataGridViewRowHeadersWidthSizeMode.
Pour une scalabilité maximale, désactivez le dimensionnement automatique et utilisez le redimensionnement par programmation.

Pour plus d'informations, consultez Options de dimensionnement dans le contrôle DataGridView Windows Forms.

Utilisation efficace des collections cellules, lignes et colonnes sélectionnées

La SelectedCells collection ne fonctionne pas efficacement avec de grandes sélections. Les collections SelectedRows et SelectedColumns peuvent également être inefficaces, bien qu’à un moindre degré, car il y a beaucoup moins de lignes que de cellules dans un contrôle classique DataGridView, et beaucoup moins de colonnes que de lignes. Pour éviter les pénalités de performances lors de l’utilisation de ces regroupements, suivez les instructions suivantes :

Pour déterminer si toutes les cellules de la DataGridView collection ont été sélectionnées avant d’accéder au contenu de la SelectedCells collection, vérifiez la valeur de retour de la AreAllCellsSelected méthode. Notez toutefois que cette méthode peut entraîner la non-partage des lignes. Pour plus d'informations, consultez la section suivante.
Évitez d’utiliser la Count propriété de la System.Windows.Forms.DataGridViewSelectedCellCollection cellule pour déterminer le nombre de cellules sélectionnées. Utilisez plutôt la DataGridView.GetCellCount méthode et transmettez la DataGridViewElementStates.Selected valeur. De même, utilisez les méthodes DataGridViewRowCollection.GetRowCount et DataGridViewColumnCollection.GetColumnCount pour déterminer le nombre d'éléments sélectionnés, plutôt que d'accéder aux collections de lignes et de colonnes sélectionnées.
Évitez les modes de sélection basés sur les cellules. Au lieu de cela, définissez la DataGridView.SelectionMode propriété sur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

Utilisation de lignes partagées

Une utilisation efficace de la mémoire est obtenue dans le contrôle DataGridView grâce à des lignes partagées. Les lignes partageront autant d’informations sur leur apparence et leur comportement que possible en partageant des instances de la DataGridViewRow classe.

Bien que le partage d’instances de lignes économise de la mémoire, les lignes peuvent facilement devenir non partagées. Par exemple, chaque fois qu’un utilisateur interagit directement avec une cellule, sa ligne devient non partagée. Comme cela ne peut pas être évité, les instructions de cette rubrique sont utiles uniquement lorsque vous travaillez avec de très grandes quantités de données et uniquement lorsque les utilisateurs interagissent avec une partie relativement petite des données chaque fois que votre programme est exécuté.

Une ligne ne peut pas être partagée dans un contrôle indépendant DataGridView si l’une de ses cellules contient des valeurs. Lorsque le DataGridView contrôle est lié à une source de données externe ou lorsque vous implémentez le mode virtuel et fournissez votre propre source de données, les valeurs de cellule sont stockées en dehors du contrôle plutôt que dans les objets de cellule, ce qui permet de partager les lignes.

Un objet de ligne ne peut être partagé que si l’état de toutes ses cellules peut être déterminé à partir de l’état de la ligne et des états des colonnes contenant les cellules. Si vous modifiez l’état d’une cellule afin qu’elle ne puisse plus être déduite de l’état de sa ligne et de sa colonne, la ligne ne peut pas être partagée.

Par exemple, une ligne ne peut pas être partagée dans l’une des situations suivantes :

La ligne contient une seule cellule sélectionnée qui n’est pas dans une colonne sélectionnée.
La ligne contient une cellule avec ses propriétés ToolTipText ou ContextMenuStrip définies.
La ligne contient un DataGridViewComboBoxCell dont la propriété Items est définie.

En mode lié ou virtuel, vous pouvez afficher des info-bulles et des menus contextuels pour chaque cellule en gérant les événements CellToolTipTextNeeded et CellContextMenuStripNeeded.

Le DataGridView contrôle tente automatiquement d’utiliser des lignes partagées chaque fois que les lignes sont ajoutées au DataGridViewRowCollection. Utilisez les instructions suivantes pour veiller à ce que les lignes soient partagées :

Évitez d’appeler la Add(Object[]) surcharge de la Add méthode et la Insert(Object[]) surcharge de la Insert méthode de la DataGridView.Rows collection. Ces surcharges fonctionnelles créent automatiquement des lignes non partagées.
Vérifiez que la ligne spécifiée dans la DataGridView.RowTemplate propriété peut être partagée dans les cas suivants :
- Lors de l’appel des surcharges Add() ou Add(Int32) de la méthode Add ou de la surcharge Insert(Int32,Int32) de la méthode Insert de la collection DataGridView.Rows.
- Lorsque vous augmentez la valeur de la DataGridView.RowCount propriété.
- Lors de la définition de la DataGridView.DataSource propriété.
Assurez-vous que la ligne indiquée par le paramètre indexSource peut être partagée lors de l'appel des méthodes AddCopy, AddCopies, InsertCopy et InsertCopies de la collection DataGridView.Rows.
Assurez-vous que la ligne ou les lignes spécifiées peuvent être partagées lors de l’appel de la surcharge Add(DataGridViewRow) de la méthode Add, de la méthode AddRange, de la surcharge Insert(Int32,DataGridViewRow) de la méthode Insert, et de la méthode InsertRange de la collection DataGridView.Rows.

Pour déterminer si une ligne est partagée, utilisez la méthode pour récupérer l’objet DataGridViewRowCollection.SharedRow de ligne, puis vérifiez la propriété de l’objet Index . Les lignes partagées ont toujours une Index valeur de propriété de –1.

Empêcher les lignes de devenir non partagés

Les lignes partagées peuvent devenir non partagées suite à l’action du code ou de l’utilisateur. Pour éviter un impact sur les performances, vous devez éviter de faire en sorte que les lignes deviennent non partagées. Pendant le développement d’applications, vous pouvez gérer l’événement RowUnshared pour déterminer quand les lignes deviennent non partagées. Cela est utile lors du débogage des problèmes de partage de lignes.

Pour empêcher les lignes de devenir non partagées, utilisez les consignes suivantes :

Évitez d’indexer la Rows collection ou d’effectuer une itération avec une foreach boucle. Vous n’aurez généralement pas besoin d’accéder directement aux lignes. DataGridView les méthodes qui fonctionnent sur les lignes prennent des arguments d’index de ligne plutôt que des instances de ligne. En outre, les gestionnaires pour les événements liés aux lignes reçoivent des objets d’argument d’événement avec des propriétés de ligne que vous pouvez utiliser pour manipuler des lignes sans rompre le partage.
Si vous devez accéder à un objet de ligne, utilisez la DataGridViewRowCollection.SharedRow méthode et passez l’index réel de la ligne. Notez toutefois que la modification d’un objet de ligne partagé récupéré via cette méthode modifie toutes les lignes qui partagent cet objet. La ligne des nouveaux enregistrements n’est pas partagée avec d’autres lignes. Toutefois, elle n’est donc pas affectée lorsque vous modifiez une autre ligne. Notez également que différentes lignes représentées par une ligne partagée peuvent avoir différents menus contextuels. Pour récupérer le menu contextuel approprié à partir d’une instance de ligne partagée, utilisez la GetContextMenuStrip méthode et passez l’index réel de la ligne. Si vous accédez à la propriété de la ligne partagée ContextMenuStrip à la place, elle utilisera l’index de ligne partagé de -1 et ne pourra pas récupérer le menu contextuel approprié.
Évitez d’indexer la DataGridViewRow.Cells collection. L'accès direct à une cellule fera que sa ligne parente ne soit plus partagée, entraînant l'instanciation d'un nouveau DataGridViewRow. Les gestionnaires des événements liés aux cellules reçoivent des objets contenant des arguments d’événement définissant des propriétés de cellules, que vous pouvez utiliser pour manipuler les cellules sans que les lignes ne deviennent partagées. Vous pouvez également utiliser la CurrentCellAddress propriété pour récupérer les index de ligne et de colonne de la cellule active sans accéder directement à la cellule.
Évitez les modes de sélection basés sur les cellules. Ces modes provoquent le fait que les lignes ne soient plus partagées. Au lieu de cela, définissez la DataGridView.SelectionMode propriété sur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.
Ne gérez pas les événements DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged. Ces événements entraînent les lignes à devenir non partagées. En outre, n’appelez pas les méthodes DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged, qui déclenchent ces événements.
N’accédez pas à la DataGridView.SelectedCells collection lorsque la DataGridView.SelectionMode valeur de propriété est FullColumnSelect, ColumnHeaderSelectou FullRowSelect RowHeaderSelect. Cela entraîne l’annulation du partage de toutes les lignes sélectionnées.
N’appelez pas la DataGridView.AreAllCellsSelected méthode. Cette méthode peut entraîner la dissociation des lignes.
N’appelez pas la DataGridView.SelectAll méthode lorsque la valeur de propriété DataGridView.SelectionMode est CellSelect. Cela entraîne l’annulation du partage de toutes les lignes.
Ne définissez pas la propriété ReadOnly ou Selected d'une cellule à false lorsque la propriété correspondante dans sa colonne est définie sur true. Cela entraîne l’annulation du partage de toutes les lignes.
N’accédez pas à la DataGridViewRowCollection.List propriété. Cela entraîne le départage de toutes les lignes.
N’appelez pas la Sort(IComparer) surcharge de la Sort méthode. Le tri avec un comparateur personnalisé entraîne l’annulation du partage de toutes les lignes.

Partager via