Meilleures pratiques pour la mise à l'échelle du contrôle DataGridView Windows FormsBest Practices for Scaling the Windows Forms DataGridView Control

Le contrôle DataGridView est conçu pour offrir une évolutivité maximale.The DataGridView control is designed to provide maximum scalability. 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.If you need to display large amounts of data, you should follow the guidelines described in this topic to avoid consuming large amounts of memory or degrading the responsiveness of the user interface (UI). Cette rubrique présente les problèmes suivants :This topic discusses the following issues:

  • Utilisation efficace des styles de celluleUsing cell styles efficiently

  • Utilisation efficace des menus contextuelsUsing shortcut menus efficiently

  • Utilisation efficace du redimensionnement automatiqueUsing automatic resizing efficiently

  • Utilisation efficace des collections de cellules, de lignes et de colonnes sélectionnéesUsing the selected cells, rows, and columns collections efficiently

  • Utilisation de lignes partagéesUsing shared rows

  • Empêcher le partage de lignesPreventing rows from becoming unshared

Si vous avez des besoins spécifiques en matière de performances, vous pouvez implémenter le mode virtuel et fournir vos propres opérations de gestion de données.If you have special performance needs, you can implement virtual mode and provide your own data management operations. Pour plus d’informations, consultez modes d’affichage des données dans le contrôle DataGridView Windows Forms.For more information, see Data Display Modes in the Windows Forms DataGridView Control.

Utilisation efficace des styles de celluleUsing Cell Styles Efficiently

Chaque cellule, ligne et colonne peut avoir ses propres informations de style.Each cell, row, and column can have its own style information. Les informations de style sont stockées dans des objets DataGridViewCellStyle.Style information is stored in DataGridViewCellStyle objects. La création d’objets de style de cellule pour de nombreux éléments de DataGridView individuels peut être inefficace, en particulier lors de l’utilisation de grandes quantités de données.Creating cell style objects for many individual DataGridView elements can be inefficient, especially when working with large amounts of data. Pour éviter un impact sur les performances, suivez les instructions ci-dessous :To avoid a performance impact, use the following guidelines:

Utilisation efficace des menus contextuelsUsing Shortcut Menus Efficiently

Chaque cellule, ligne et colonne peut avoir son propre menu contextuel.Each cell, row, and column can have its own shortcut menu. Les menus contextuels du contrôle DataGridView sont représentés par des contrôles ContextMenuStrip.Shortcut menus in the DataGridView control are represented by ContextMenuStrip controls. Tout comme avec les objets de style de cellule, la création de menus contextuels pour de nombreux éléments de DataGridView individuel aura un impact négatif sur les performances.Just as with cell style objects, creating shortcut menus for many individual DataGridView elements will negatively impact performance. Pour éviter cette pénalité, suivez les instructions ci-dessous :To avoid this penalty, use the following guidelines:

  • Évitez de créer des menus contextuels pour des cellules et des lignes individuelles.Avoid creating shortcut menus for individual cells and rows. Cela comprend le modèle de ligne, qui est cloné avec son menu contextuel lorsque de nouvelles lignes sont ajoutées au contrôle.This includes the row template, which is cloned along with its shortcut menu when new rows are added to the control. Pour une extensibilité maximale, utilisez uniquement la propriété ContextMenuStrip du contrôle pour spécifier un menu contextuel unique pour l’ensemble du contrôle.For maximum scalability, use only the control's ContextMenuStrip property to specify a single shortcut menu for the entire control.

  • Si vous avez besoin de plusieurs menus contextuels pour plusieurs lignes ou cellules, gérez les événements CellContextMenuStripNeeded ou RowContextMenuStripNeeded.If you require multiple shortcut menus for multiple rows or cells, handle the CellContextMenuStripNeeded or RowContextMenuStripNeeded events. Ces événements vous permettent de gérer les objets de menu contextuel vous-même, ce qui vous permet de régler les performances.These events let you manage the shortcut menu objects yourself, allowing you to tune performance.

Utilisation efficace du redimensionnement automatiqueUsing Automatic Resizing Efficiently

Les lignes, les colonnes et les en-têtes peuvent être redimensionnés automatiquement à mesure que le contenu des cellules change afin que le contenu entier des cellules soit affiché sans découpage.Rows, columns, and headers can be automatically resized as cell content changes so that the entire contents of cells are displayed without clipping. La modification des modes de dimensionnement peut également redimensionner des lignes, des colonnes et des en-têtes.Changing sizing modes can also resize rows, columns, and headers. Pour déterminer la taille correcte, le contrôle de DataGridView doit examiner la valeur de chaque cellule qu’il doit prendre en charge.To determine the correct size, the DataGridView control must examine the value of each cell that it must accommodate. Lors de l’utilisation de 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.When working with large data sets, this analysis can negatively impact the performance of the control when automatic resizing occurs. Pour éviter des pénalités en matière de performances, suivez les instructions ci-dessous :To avoid performance penalties, use the following guidelines:

Pour plus d’informations, consultez options de dimensionnement dans le contrôle DataGridView Windows Forms.For more information, see Sizing Options in the Windows Forms DataGridView Control.

Utilisation efficace des collections de cellules, de lignes et de colonnes sélectionnéesUsing the Selected Cells, Rows, and Columns Collections Efficiently

La collection SelectedCells ne fonctionne pas efficacement avec de grandes sélections.The SelectedCells collection does not perform efficiently with large selections. Les collections SelectedRows et SelectedColumns peuvent également être inefficaces, bien qu’à un degré moindre, car il y a beaucoup moins de lignes que de cellules dans un contrôle DataGridView classique, et beaucoup moins de colonnes que de lignes.The SelectedRows and SelectedColumns collections can also be inefficient, although to a lesser degree because there are many fewer rows than cells in a typical DataGridView control, and many fewer columns than rows. Pour éviter des pénalités en matière de performances lors de l’utilisation de ces regroupements, suivez les instructions suivantes :To avoid performance penalties when working with these collections, use the following guidelines:

Utilisation de lignes partagéesUsing Shared Rows

Une utilisation efficace de la mémoire est obtenue dans le contrôle DataGridView par le biais de lignes partagées.Efficient memory use is achieved in the DataGridView control through shared rows. Les lignes partageront la plus grande quantité d’informations sur leur apparence et leur comportement possible en partageant des instances de la classe DataGridViewRow.Rows will share as much information about their appearance and behavior as possible by sharing instances of the DataGridViewRow class.

Tandis que le partage d’instances de ligne permet d’économiser de la mémoire, les lignes peuvent facilement devenir non partagées.While sharing row instances saves memory, rows can easily become unshared. Par exemple, chaque fois qu’un utilisateur interagit directement avec une cellule, sa ligne devient non partagée.For example, whenever a user interacts directly with a cell, its row becomes unshared. Étant donné que 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 réduite des données chaque fois que votre programme est exécuté.Because this cannot be avoided, the guidelines in this topic are useful only when working with very large amounts of data and only when users will interact with a relatively small part of the data each time your program is run.

Une ligne ne peut pas être partagée dans un contrôle de DataGridView indépendant si l’une de ses cellules contient des valeurs.A row cannot be shared in an unbound DataGridView control if any of its cells contain values. Lorsque le contrôle de 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 des objets de cellule, ce qui permet de partager les lignes.When the DataGridView control is bound to an external data source or when you implement virtual mode and provide your own data source, the cell values are stored outside the control rather than in cell objects, allowing the rows to be shared.

Un objet Row peut être partagé uniquement 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.A row object can only be shared if the state of all its cells can be determined from the state of the row and the states of the columns containing the cells. 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.If you change the state of a cell so that it can no longer be deduced from the state of its row and column, the row cannot be shared.

Par exemple, une ligne ne peut pas être partagée dans l’une des situations suivantes :For example, a row cannot be shared in any of the following situations:

En mode dépendant ou en mode virtuel, vous pouvez fournir des info-bulles et des menus contextuels pour des cellules individuelles en gérant les événements CellToolTipTextNeeded et CellContextMenuStripNeeded.In bound mode or virtual mode, you can provide ToolTips and shortcut menus for individual cells by handling the CellToolTipTextNeeded and CellContextMenuStripNeeded events.

Le contrôle DataGridView tente automatiquement d’utiliser des lignes partagées à chaque fois que des lignes sont ajoutées à la DataGridViewRowCollection.The DataGridView control will automatically attempt to use shared rows whenever rows are added to the DataGridViewRowCollection. Suivez les indications ci-dessous pour vous assurer que les lignes sont partagées :Use the following guidelines to ensure that rows are shared:

  • É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.Avoid calling the Add(Object[]) overload of the Add method and the Insert(Object[]) overload of the Insert method of the DataGridView.Rows collection. Ces surcharges créent automatiquement des lignes non partagées.These overloads automatically create unshared rows.

  • Assurez-vous que la ligne spécifiée dans la propriété DataGridView.RowTemplate peut être partagée dans les cas suivants :Be sure that the row specified in the DataGridView.RowTemplate property can be shared in the following cases:

  • 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, InsertCopyet InsertCopies de la collection DataGridView.Rows.Be sure that the row indicated by the indexSource parameter can be shared when calling the AddCopy, AddCopies, InsertCopy, and InsertCopies methods of the DataGridView.Rows collection.

  • Assurez-vous que la 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.Be sure that the specified row or rows can be shared when calling the Add(DataGridViewRow) overload of the Add method, the AddRange method, the Insert(Int32,DataGridViewRow) overload of the Insert method, and the InsertRange method of the DataGridView.Rows collection.

Pour déterminer si une ligne est partagée, utilisez la méthode DataGridViewRowCollection.SharedRow pour récupérer l’objet Row, puis vérifiez la propriété Index de l’objet.To determine whether a row is shared, use the DataGridViewRowCollection.SharedRow method to retrieve the row object, and then check the object's Index property. Les lignes partagées ont toujours une valeur de propriété Index de – 1.Shared rows always have an Index property value of –1.

Empêcher le partage de lignesPreventing Rows from Becoming Unshared

Les lignes partagées peuvent devenir non partagées suite à une action de l’utilisateur ou du code.Shared rows can become unshared as a result of code or user action. Pour éviter un impact sur les performances, vous devez éviter de rendre les lignes non partagées.To avoid a performance impact, you should avoid causing rows to become unshared. Pendant le développement d’applications, vous pouvez gérer l’événement RowUnshared pour déterminer quand les lignes deviennent non partagées.During application development, you can handle the RowUnshared event to determine when rows become unshared. Cela est utile lors du débogage de problèmes de partage de lignes.This is useful when debugging row-sharing problems.

Pour empêcher le partage de lignes, suivez les instructions ci-dessous :To prevent rows from becoming unshared, use the following guidelines:

  • Évitez d’indexer la collection Rows ou d’effectuer une itération à l’aide d’une boucle foreach.Avoid indexing the Rows collection or iterating through it with a foreach loop. En général, vous n’avez pas besoin d’accéder directement aux lignes.You will not typically need to access rows directly. DataGridView méthodes qui opèrent sur des lignes prennent des arguments d’index de ligne plutôt que des instances de ligne.DataGridView methods that operate on rows take row index arguments rather than row instances. En outre, les gestionnaires des é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 rendre non partagées.Additionally, handlers for row-related events receive event argument objects with row properties that you can use to manipulate rows without causing them to become unshared.

  • Si vous devez accéder à un objet Row, utilisez la méthode DataGridViewRowCollection.SharedRow et transmettez l’index réel de la ligne.If you need to access a row object, use the DataGridViewRowCollection.SharedRow method and pass in the row's actual index. Notez, toutefois, que la modification d’un objet de ligne partagé récupéré via cette méthode modifiera toutes les lignes qui partagent cet objet.Note, however, that modifying a shared row object retrieved through this method will modify all the rows that share this object. Toutefois, la ligne des nouveaux enregistrements n’est pas partagée avec d’autres lignes. par conséquent, elle n’est pas affectée lorsque vous modifiez une autre ligne.The row for new records is not shared with other rows, however, so it will not be affected when you modify any other row. Notez également que les différentes lignes représentées par une ligne partagée peuvent avoir des menus contextuels différents.Note also that different rows represented by a shared row may have different shortcut menus. Pour récupérer le menu contextuel approprié à partir d’une instance de ligne partagée, utilisez la méthode GetContextMenuStrip et transmettez l’index réel de la ligne.To retrieve the correct shortcut menu from a shared row instance, use the GetContextMenuStrip method and pass in the row's actual index. Si vous accédez à la propriété ContextMenuStrip de la ligne partagée à la place, elle utilise l’index de ligne partagé-1 et ne récupère pas le menu contextuel approprié.If you access the shared row's ContextMenuStrip property instead, it will use the shared row index of -1 and will not retrieve the correct shortcut menu.

  • Évitez d’indexer la collection DataGridViewRow.Cells.Avoid indexing the DataGridViewRow.Cells collection. L’accès direct à une cellule entraîne le non-partage de sa ligne parente, l’instanciation d’un nouveau DataGridViewRow.Accessing a cell directly will cause its parent row to become unshared, instantiating a new DataGridViewRow. 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 entraîner le partage de lignes.Handlers for cell-related events receive event argument objects with cell properties that you can use to manipulate cells without causing rows to become unshared. 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.You can also use the CurrentCellAddress property to retrieve the row and column indexes of the current cell without accessing the cell directly.

  • Évitez les modes de sélection basés sur des cellules.Avoid cell-based selection modes. Ces modes entraînent le non-partage des lignes.These modes cause rows to become unshared. Au lieu de cela, affectez à la propriété DataGridView.SelectionMode la valeur DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.Instead, set the DataGridView.SelectionMode property to DataGridViewSelectionMode.FullRowSelect or DataGridViewSelectionMode.FullColumnSelect.

  • Ne gérez pas les événements DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged.Do not handle the DataGridViewRowCollection.CollectionChanged or DataGridView.RowStateChanged events. Ces événements entraînent le non-partage des lignes.These events cause rows to become unshared. En outre, n’appelez pas les méthodes DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged, qui déclenchent ces événements.Also, do not call the DataGridViewRowCollection.OnCollectionChanged or DataGridView.OnRowStateChanged methods, which raise these events.

  • N’accédez pas à la collection DataGridView.SelectedCells lorsque la valeur de la propriété DataGridView.SelectionMode est FullColumnSelect, ColumnHeaderSelect, FullRowSelectou RowHeaderSelect.Do not access the DataGridView.SelectedCells collection when the DataGridView.SelectionMode property value is FullColumnSelect, ColumnHeaderSelect, FullRowSelect, or RowHeaderSelect. Toutes les lignes sélectionnées ne sont alors plus partagées.This causes all selected rows to become unshared.

  • N’appelez pas la méthode DataGridView.AreAllCellsSelected.Do not call the DataGridView.AreAllCellsSelected method. Cette méthode peut provoquer le non-partage de lignes.This method can cause rows to become unshared.

  • N’appelez pas la méthode DataGridView.SelectAll lorsque la valeur de la propriété DataGridView.SelectionMode est CellSelect.Do not call the DataGridView.SelectAll method when the DataGridView.SelectionMode property value is CellSelect. Toutes les lignes deviennent alors non partagées.This causes all rows to become unshared.

  • Ne définissez pas la propriété ReadOnly ou Selected d’une cellule sur false lorsque la propriété correspondante dans sa colonne est définie sur true.Do not set the ReadOnly or Selected property of a cell to false when the corresponding property in its column is set to true. Toutes les lignes deviennent alors non partagées.This causes all rows to become unshared.

  • N’accédez pas à la propriété DataGridViewRowCollection.List.Do not access the DataGridViewRowCollection.List property. Toutes les lignes deviennent alors non partagées.This causes all rows to become unshared.

  • N’appelez pas la surcharge Sort(IComparer) de la méthode Sort.Do not call the Sort(IComparer) overload of the Sort method. Si vous triez avec un comparateur personnalisé, toutes les lignes deviennent non partagées.Sorting with a custom comparer causes all rows to become unshared.

Voir aussiSee also