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

Article
06/21/2023

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 lignes de devenir non partagés

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 Les 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 ou DataGridViewRow individuelsDataGridViewCell. Cela inclut l’objet de ligne spécifié par la RowTemplate propriété. Chaque nouvelle ligne cloné à partir du modèle de ligne reçoit 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 du DataGridView contrôle sont représentés par ContextMenuStrip les contrôles. 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 ou RowContextMenuStripNeeded les CellContextMenuStripNeeded événements. 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 ensemble 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 ou DisplayedCellsExceptHeaders le DisplayedCells champ des DataGridViewAutoSizeRowsModeénumérations , DataGridViewAutoSizeColumnsModeet DataGridViewAutoSizeColumnMode les lignes.
- Pour les en-têtes de ligne, utilisez le ou AutoSizeToFirstHeader le AutoSizeToDisplayedHeaders champ de l’énumérationDataGridViewRowHeadersWidthSizeMode.
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 et SelectedColumns les SelectedRows collections peuvent également être inefficaces, bien qu’à un moindre degré, car il y a beaucoup moins de lignes que de cellules dans un contrôle classiqueDataGridView, 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, case activée 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 et DataGridViewColumnCollection.GetColumnCount les DataGridViewRowCollection.GetRowCount méthodes 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 par le DataGridView biais de 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 enregistre la mémoire, les lignes peuvent facilement devenir non partagée. Par exemple, chaque fois qu’un utilisateur interagit directement avec une cellule, sa ligne devient non partagé. 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 son ou ContextMenuStrip ses ToolTipText propriétés définies.
La ligne contient un DataGridViewComboBoxCell ensemble Items de propriétés.

En mode lié ou en mode virtuel, vous pouvez fournir des outils Astuces et des menus contextuels pour des cellules individuelles en gérant les événements et CellContextMenuStripNeeded les CellToolTipTextNeeded événements.

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 vous assurer que les lignes sont 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 créent automatiquement des lignes non partagés.
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 Add() ou Add(Int32) surcharges de la Add méthode ou Insert(Int32,Int32) de la surcharge de la Insert méthode de la DataGridView.Rows collection.
- 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 peut être partagée lors de DataGridView.Rows l’appel indexSource de la AddCopycollection , AddCopieset InsertCopy InsertCopies des méthodes.
Assurez-vous que la ligne ou les lignes spécifiées peuvent être partagées lors de l’appel de la Add(DataGridViewRow) surcharge de la Add méthode, de AddRange la méthode, Insert(Int32,DataGridViewRow) de la surcharge de la Insert méthode et de la InsertRange méthode de la DataGridView.Rows collection.

Pour déterminer si une ligne est partagée, utilisez la DataGridViewRowCollection.SharedRow méthode pour récupérer l’objet de ligne, puis case activée la propriété de l’objetIndex. 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 provoquer le partage des lignes. Pendant le développement d’applications, vous pouvez gérer l’événement RowUnshared pour déterminer quand les lignes deviennent non partagés. Cela est utile lors du débogage des problèmes de partage de lignes.

Pour empêcher les lignes de devenir non partagés, utilisez les instructions 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 les entraîner à devenir non partagés.
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 ContextMenuStrip la ligne partagée à la place, elle utilise l’index de ligne partagée de -1 et ne récupère pas le menu contextuel approprié.
Évitez d’indexer la DataGridViewRow.Cells collection. L’accès direct à une cellule entraîne l’instanciation d’une nouvelle DataGridViewRowligne parente. Les gestionnaires pour les événements liés aux cellules reçoivent des objets d’argument d’événement avec des propriétés de cellule que vous pouvez utiliser pour manipuler des cellules sans provoquer le partage de lignes. 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 entraînent l’annulation du partage des lignes. Au lieu de cela, définissez la DataGridView.SelectionMode propriété sur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.
Ne gérez pas les événements ou DataGridView.RowStateChanged les DataGridViewRowCollection.CollectionChanged événements. Ces événements entraînent l’annulation du partage des lignes. En outre, n’appelez pas les DataGridViewRowCollection.OnCollectionChanged méthodes ou DataGridView.OnRowStateChanged les méthodes 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 non-partage 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 ou Selected la ReadOnly propriété d’une cellule false sur laquelle la propriété correspondante dans sa colonne est définie truesur . Cela entraîne l’annulation du partage de toutes les lignes.
N’accédez pas à la DataGridViewRowCollection.List propriété. Cela entraîne l’annulation du 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.