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

Le contrôle DataGridView est conçu pour assurer une évolutivité maximale. Si vous devez afficher des grandes quantités de données, vous devez suivre les directives décrites dans cette rubrique afin d'éviter de consommer de grandes quantités de mémoire ou d'affecter la réactivité de l'interface utilisateur. Cette rubrique traite des questions suivantes :

• Utilisation efficace des styles de cellule

• Utilisation efficace des menus contextuels

• Utilisation efficace du redimensionnement automatique

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

• Utilisation de lignes partagées

• Empêcher les lignes de devenir non partagées

Si vous avez des besoins de performance particuliers, vous pouvez implémenter le mode virtuel et fournir vos propres opérations de gestion de 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 les objets DataGridViewCellStyle. Créer des objets du style de cellule pour de nombreux éléments DataGridView individuels peut s'avérer inefficace, surtout si vous travaillez avec de grandes quantités de données. Pour éviter d'affecter les performances, utilisez les directives suivantes :

• Évitez de définir des propriétés de style de cellule pour des objets DataGridViewCell ou DataGridViewRow individuels. Cela inclut l'objet de ligne spécifié par la propriété RowTemplate. Chaque nouvelle ligne qui est clonée à partir du modèle de ligne recevra sa propre copie de l'objet de style de cellule du modèle. Pour une évolutivité maximale, définissez les propriétés de style de cellule au niveau DataGridView. Par exemple, définissez la propriété DataGridView.DefaultCellStyle plutôt que la propriété DataGridViewCell.Style.

• Si certaines cellules nécessitent une mise en forme autre que la mise en forme par défaut, utilisez la même instance DataGridViewCellStyle sur les groupes des cellules, lignes ou colonnes. Évitez de définir directement des propriétés de type DataGridViewCellStyle sur des cellules, lignes ou colonnes individuelles. Pour obtenir un exemple de partage de style de cellule, consultez Comment : définir les styles de cellules par défaut pour le contrôle DataGridView Windows Forms. Vous pouvez également éviter une baisse de performance lorsque vous définissez les styles de cellule individuellement en gérant le gestionnaire d'événements CellFormatting. 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 propriété DataGridViewCell.InheritedStyle plutôt que la propriété DataGridViewCell.Style. Accéder à la propriété Style crée une nouvelle instance de la classe DataGridViewCellStyle si la propriété n'a pas déjà été utilisée. En outre, cet objet ne peut pas contenir toutes les informations de style pour 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 du style de cellule, consultez Styles de cellules dans le contrôle DataGridView Windows Forms.

Utilisation efficace des menus contextuels

Chaque cellule, ligne et colonne peut avoir son propre menu contextuel. Dans le contrôle DataGridView, les menus contextuels sont représentés par les contrôles ContextMenuStrip. Comme avec les objets de style de cellule, la création de menus contextuels pour de nombreux éléments DataGridView individuels aura un effet négatif sur les performances. Pour éviter cet inconvénient, suivez les directives suivantes :

• Évitez de créer des menus contextuels pour des cellules et des lignes individuelles. Cela inclut le modèle de ligne qui est cloné avec son menu contextuel lorsque de nouvelles lignes sont ajoutées au contrôle. Pour une évolutivité maximale, utilisez uniquement la propriété ContextMenuStrip du contrôle pour spécifier un menu contextuel unique pour le contrôle entier.

• 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 les objets de menu contextuel vous-même, et vous permettent d'ajuster la performance.

Utilisation efficace du redimensionnement automatique

Les lignes, colonnes et en-tête peuvent être automatiquement redimensionnées, à mesure que le contenu de la cellule change, pour que le contenu des cellules soit visible, sans être tronqué. Changer de mode de redimensionnement permet également de redimensionner les lignes, les colonnes et les en-têtes. Pour déterminer la taille appropriée, le contrôle DataGridView doit examiner la valeur de chaque cellule qu'il doit prendre en compte. Lorsque vous travaillez avec de grandes quantités de données, cette analyse peut affecter négativement les performances du contrôle lors du redimensionnement automatique. Pour éviter cet impact sur les performances, suivez les directives suivantes :

• Évitez d'utiliser le dimensionnement automatique sur un contrôle DataGridView présentant une grande quantité 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 également.

  • 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 évolutivité 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 de cellules, lignes et colonnes sélectionnées

La collection SelectedCells ne s'exécute pas efficacement avec les grandes sélections. Les collections SelectedRows et SelectedColumns peuvent également s'avérer inefficaces, bien qu'à un degré moindre, car on compte beaucoup moins de lignes que de cellules dans un contrôle DataGridView classique, et beaucoup moins de colonnes que de lignes. Pour éviter les impacts négatifs sur les performances lorsque vous travaillez avec ces collections, suivez les directives suivantes :

• Pour déterminer si toutes les cellules de la DataGridView ont été sélectionnées avant que vous accédiez au contenu de la collection SelectedCells, vérifiez la valeur de retour de la méthode AreAllCellsSelected. Notez toutefois que cette méthode peut entraîner une perte du partage des lignes. Pour plus d'informations, consultez la section suivante.

• Évitez d'utiliser la propriété Count de la System.Windows.Forms.DataGridViewSelectedCellCollection pour déterminer le nombre de cellules sélectionnées. À la place, utilisez la méthode DataGridView.GetCellCount et passez la valeur DataGridViewElementStates.Selected. De la même manière, 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. Affectez plutôt à la propriété DataGridView.SelectionMode la valeur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

Utilisation de lignes partagées

L'utilisation de lignes partagées permet de faire un usage efficace de la mémoire dans le contrôle DataGridView. Les lignes partageront autant d'informations sur leur apparence et leur comportement que possible en partageant des instances de la classe DataGridViewRow.

Si le partage d'instances de ligne permet d'économiser 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 n'est plus partagée. Puisque cela est inévitable, les directives présentées dans cette rubrique sont utiles uniquement lorsque vous travaillez avec de grandes quantités de données et uniquement lorsque les utilisateurs interagissent avec une quantité relativement faible des données chaque fois que votre programme est exécuté.

Une ligne ne peut pas être partagée dans un contrôle DataGridView indépendant si une de ses cellules contient des valeurs. Lorsque le contrôle DataGridView 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 des cellules sont stockées en dehors du contrôle plutôt que dans les objets de cellule, permettant aux lignes d'être partagées.

Un objet de ligne peut être partagé uniquement si l'état de toutes ses cellules peut être déterminé à partir de l'état de la ligne et de l'état des colonnes qui contiennent les cellules. Si vous modifiez l'état d'une cellule de sorte qu'il ne puisse plus être déduit 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 ne se trouve pas dans une colonne sélectionnée.

• La ligne contient une cellule dont les propriétés ToolTipText ou ContextMenuStrip sont définies.

• La ligne contient une DataGridViewComboBoxCell dont la propriété Items est définie.

En mode dépendant ou virtuel, vous pouvez fournir des info-bulles et des menus contextuels pour des cellules individuelles en gérant les événements CellToolTipTextNeeded et CellContextMenuStripNeeded.

Le contrôle DataGridView essaiera automatiquement d'utiliser des lignes partagées chaque fois que des lignes sont ajoutées à la DataGridViewRowCollection. Suivez les directives suivantes pour garantir le partage des lignes :

• Évitez d'appeler la surcharge Add(Object[]) de la méthode Add et la surcharge Insert(Object[]) de la méthode Insert de la collection DataGridView.Rows. Ces surcharges créent automatiquement des lignes non partagées.

• Assurez-vous que la ligne spécifiée dans la propriété DataGridView.RowTemplate peut être partagée dans les cas suivants :

  • En cas d'appel de la surcharge 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.

  • En cas d'augmentation de la valeur de la propriété DataGridView.RowCount.

  • En cas de définition de la propriété DataGridView.DataSource.

• Veillez à ce que la ligne indiquée par le paramètre indexSource puisse être partagée lors de l'appel des méthodes AddCopy, AddCopies, InsertCopy et InsertCopies de la collection DataGridView.Rows.

• Veillez à ce que la ou les lignes spécifiées puissent ê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 DataGridViewRowCollection.SharedRow pour récupérer l'objet de ligne, puis vérifiez la propriété Index de l'objet. Les lignes partagées ont toujours une valeur de propriété Index de -1.

Empêcher les lignes de devenir non partagées

Les lignes partagées peuvent devenir non partagées à la suite d'une action du code ou de l'utilisateur. Pour éviter un impact négatif sur les performances, vous devez éviter de provoquer une perte du partage des lignes. Pendant le développement d'applications, vous pouvez gérer l'événement RowUnshared pour déterminer à quel moment les lignes deviennent non partagées. Cela est utile en cas de débogage de problèmes de partage de ligne.

Pour empêcher les lignes de devenir non partagées, suivez les directives suivantes :

• Évitez indexer la collection Rows ou d'itérer en son sein à l'aide d'une boucle foreach. Il n'est en général pas nécessaire d'accéder directement aux lignes. Les méthodes DataGridView qui fonctionnent sur les lignes prennent des arguments d'index de ligne plutôt que des instances de ligne. En outre, les gestionnaires d'événements de ligne 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 qu'elles deviennent non partagées.

• Si vous devez accéder à un objet de ligne, utilisez la méthode DataGridViewRowCollection.SharedRow et passez l'index réel de la ligne. Notez toutefois que la modification d'un objet de ligne partagé récupéré à l'aide de cette méthode modifiera toutes les lignes qui partagent cet objet. La ligne des nouveaux enregistrements n'est cependant pas partagée avec d'autres lignes pour qu'elle ne soit pas affectée par la modification d'une autre ligne. Notez également que différentes lignes représentées par une ligne partagée peuvent avoir des menus contextuels différents. Pour récupérer le menu contextuel correct à partir d'une instance de ligne partagée, utilisez la méthode GetContextMenuStrip et passez l'index réel de la ligne. Si vous accédez à la place à la propriété ContextMenuStrip de la ligne partagée, l'index de ligne partagé -1 sera utilisé et le menu contextuel correct ne sera pas récupéré.

• Évitez d'indexer la collection DataGridViewRow.Cells. Si vous accédez directement à une cellule, sa ligne parente devient non partagée, instanciant une nouvelle DataGridViewRow. Les gestionnaires d'événements de cellule 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 que les lignes deviennent non partagées. Vous pouvez également utiliser la propriété CurrentCellAddress 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. Avec ces modes, les lignes deviennent non partagées. Affectez plutôt à la propriété DataGridView.SelectionMode la valeur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.

• Ne gérez pas les événements DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged. Avec ces événements, les lignes deviennent non partagées. Par ailleurs, n'appelez pas les méthodes DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged, qui déclenchent ces événements.

• N'accédez pas à la collection DataGridView.SelectedCells lorsque la valeur de la propriété DataGridView.SelectionMode est FullColumnSelect, ColumnHeaderSelect, FullRowSelect ou RowHeaderSelect. Si vous le faites, toutes les lignes sélectionnées deviennent non partagées.

• N'appelez pas la méthode DataGridView.AreAllCellsSelected. Avec cette méthode, les lignes deviennent non partagées.

• N'appelez pas la méthode DataGridView.SelectAll lorsque la valeur de la propriété DataGridView.SelectionMode est CellSelect. Si vous le faites, toutes les lignes deviennent non partagées.

• N'affectez pas à la propriété ReadOnly ou Selected d'une cellule la valeur false lorsque la propriété correspondante dans sa colonne a la valeur true. Si vous le faites, toutes les lignes deviennent non partagées.

• N'utilisez pas la propriété DataGridViewRowCollection.List. Si vous le faites, toutes les lignes deviennent non partagées.

• N'appelez pas la surcharge Sort(IComparer) de la méthode Sort. Si vous triez avec un comparateur personnalisé, toutes les lignes deviennent non partagées.

Voir aussi

Tâches

Comment : définir les styles de cellules par défaut pour le contrôle DataGridView Windows Forms

Référence

DataGridView

Concepts

Mode virtuel dans le contrôle DataGridView Windows Forms

Modes d'affichage des données dans le contrôle DataGridView Windows Forms

Styles de cellules dans le contrôle DataGridView Windows Forms

Options de dimensionnement dans le contrôle DataGridView Windows Forms

Autres ressources

Réglage des performances dans le contrôle DataGridView Windows Forms