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

Le DataGridView contrôle est conçu pour fournir une extensibilité maximale.The DataGridView control is designed to provide maximum scalability. Si vous avez besoin afficher de grandes quantités de données, vous devez suivre les instructions 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 (IU).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 de styles de cellulesUsing 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, lignes et colonnes sélectionnéesUsing the selected cells, rows, and columns collections efficiently

  • À l’aide de lignes partagéesUsing shared rows

  • Empêcher les lignes de devenir non partagéesPreventing rows from becoming unshared

Si vous avez besoin de performances spéciales, 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 de données dans le contrôle DataGridView Windows Forms.For more information, see Data Display Modes in the Windows Forms DataGridView Control.

Utilisation efficace de Styles de cellulesUsing Cell Styles Efficiently

Chaque cellule, la ligne et la colonne peuvent 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 DataGridViewCellStyle objets.Style information is stored in DataGridViewCellStyle objects. Créer des objets de style de cellule pour les nombreux DataGridView éléments peuvent être inefficaces, en particulier lorsque vous travaillez avec 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, utilisez les instructions suivantes :To avoid a performance impact, use the following guidelines:

Utilisation efficace des Menus contextuelsUsing Shortcut Menus Efficiently

Chaque cellule, la ligne et la colonne peuvent avoir son propre menu contextuel.Each cell, row, and column can have its own shortcut menu. Menus contextuels dans le DataGridView contrôle sont représentées par ContextMenuStrip contrôles.Shortcut menus in the DataGridView control are represented by ContextMenuStrip controls. Comme avec les objets de style de cellule, création de menus contextuels de chaque nombre DataGridView éléments affecte négativement les performances.Just as with cell style objects, creating shortcut menus for many individual DataGridView elements will negatively impact performance. Pour éviter cet inconvénient, utilisez les instructions suivantes :To avoid this penalty, use the following guidelines:

  • Évitez de créer des menus contextuels pour des cellules et des lignes.Avoid creating shortcut menus for individual cells and rows. Cela inclut le modèle de ligne qui est cloné, ainsi que 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 optimiser l’évolutivité, utilisez uniquement du contrôle ContextMenuStrip propriété 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 CellContextMenuStripNeeded ou RowContextMenuStripNeeded événements.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 d’optimiser 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

Lignes, colonnes et en-têtes peuvent être automatiquement redimensionnées en tant que les modifications de contenu de cellule afin que tout le contenu des cellules est 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. Modification des modes de dimensionnement pouvez également redimensionner les lignes, colonnes et en-têtes.Changing sizing modes can also resize rows, columns, and headers. Pour déterminer la taille correcte, le DataGridView contrôle 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. Lorsque vous travaillez avec grands jeux de données, cette analyse peut 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 une dégradation des performances, utilisez les instructions suivantes :To avoid performance penalties, use the following guidelines:

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

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

Le SelectedCells collection n’effectue pas efficacement avec les grandes sélections.The SelectedCells collection does not perform efficiently with large selections. Le SelectedRows et SelectedColumns collections peuvent également être inefficaces, bien qu’à un degré moindre, car il existe beaucoup moins de lignes que de cellules dans un type DataGridView contrôle 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 la dégradation des performances lorsque vous travaillez avec ces collections, utilisez les instructions suivantes :To avoid performance penalties when working with these collections, use the following guidelines:

À l’aide de partagé des lignesUsing Shared Rows

Utilisation de la mémoire efficace s’effectue dans le DataGridView contrôle lignes partagées.Efficient memory use is achieved in the DataGridView control through shared rows. Lignes partageront autant d’informations sur leur apparence et leur comportement que possible en partageant des instances de la DataGridViewRow classe.Rows will share as much information about their appearance and behavior as possible by sharing instances of the DataGridViewRow class.

Alors que le partage des instances de ligne économise 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 n’est partagée ou non.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 très grandes quantités de données et uniquement lorsque les utilisateurs interagissent avec une relativement petite partie 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 indépendant DataGridView contrôler si l’un 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 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 cell, permettant aux lignes d’être partagées.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 ligne peut uniquement être partagé si l’état de toutes ses cellules peut être déterminé à partir de l’état de la ligne et les É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’il n’est plus peut être déduit qu’à partir de l’état de sa ligne et de 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 les situations suivantes :For example, a row cannot be shared in any of the following situations:

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

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

  • Évitez d’appeler le Add(Object[]) surcharge de la Add (méthode) et le Insert(Object[]) surcharge de la Insert méthode de la DataGridView.Rows collection.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.

  • Veillez à ce que la ligne spécifiée dans le DataGridView.RowTemplate propriété 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:

  • Également vous assurer que la ligne indiquée par le indexSource paramètre peut être partagé lors de l’appel le AddCopy, AddCopies, InsertCopy, et InsertCopies méthodes de la DataGridView.Rows collection.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.

  • N’oubliez pas que l’ou les lignes spécifiées peuvent être partagées lors de l’appel le Add(DataGridViewRow) surcharge de la Add (méthode), le AddRange (méthode), le Insert(Int32,DataGridViewRow) surcharge de la Insert (méthode) et le InsertRange procédé de la DataGridView.Rowscollection.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 DataGridViewRowCollection.SharedRow méthode pour récupérer l’objet de ligne, puis vérifiez l’objet Index propriété.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. Lignes partagées ont toujours une Index valeur de propriété de -1.Shared rows always have an Index property value of –1.

Empêcher les lignes de devenir non partagéesPreventing Rows from Becoming Unshared

Lignes partagées peuvent devenir non partagées à la suite de code ou une action utilisateur.Shared rows can become unshared as a result of code or user action. Pour éviter un impact sur les performances, vous devez éviter que les lignes deviennent non partagées.To avoid a performance impact, you should avoid causing rows to become unshared. Au cours de développement d’applications, vous pouvez gérer le RowUnshared événement 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 des problèmes de partage de lignes.This is useful when debugging row-sharing problems.

Pour empêcher les lignes de devenir non partagées, procédez comme suit :To prevent rows from becoming unshared, use the following guidelines:

  • Évitez d’indexer le Rows collection ou itérer avec un foreach boucle.Avoid indexing the Rows collection or iterating through it with a foreach loop. Il est généralement inutile d’accéder directement aux lignes.You will not typically need to access rows directly. DataGridView méthodes qui fonctionnent sur les 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, gestionnaires d’événements de ligne de recevoir des objets d’argument d’événement avec les propriétés de ligne que vous pouvez utiliser pour manipuler les lignes sans qu’elles deviennent 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 avez besoin pour accéder à un objet de ligne, utilisez le DataGridViewRowCollection.SharedRow (méthode) et passez l’index de la ligne réelle.If you need to access a row object, use the DataGridViewRowCollection.SharedRow method and pass in the row's actual index. Toutefois, notez 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. La ligne des nouveaux enregistrements n’est pas partagée avec d’autres lignes, toutefois, pour qu’elle ne sera pas affectée lorsque vous modifiez des autres lignes.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 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 correct à partir d’une instance de ligne partagée, utilisez la GetContextMenuStrip (méthode) et passez l’index de la ligne réelle.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 ligne partagée ContextMenuStrip propriété au lieu de cela, il utilisera l’index de ligne partagé-1 et ne récupérera pas le menu contextuel correct.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 le DataGridViewRow.Cells collection.Avoid indexing the DataGridViewRow.Cells collection. Accéder directement à une cellule entraîne sa ligne parente devient non partagée, l’instanciation d’un nouvel DataGridViewRow.Accessing a cell directly will cause its parent row to become unshared, instantiating a new DataGridViewRow. Gestionnaires d’événements de la cellule de recevoir des objets d’argument d’événement avec les propriétés de cellule que vous pouvez utiliser pour manipuler des cellules sans que les lignes deviennent non partagées.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 le CurrentCellAddress propriété à récupérer l’index de ligne et 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ée sur la cellule.Avoid cell-based selection modes. Ces modes, les lignes deviennent non partagées.These modes cause rows to become unshared. Au lieu de cela, définissez la DataGridView.SelectionMode propriété DataGridViewSelectionMode.FullRowSelect ou DataGridViewSelectionMode.FullColumnSelect.Instead, set the DataGridView.SelectionMode property to DataGridViewSelectionMode.FullRowSelect or DataGridViewSelectionMode.FullColumnSelect.

  • Ne gèrent pas la DataGridViewRowCollection.CollectionChanged ou DataGridView.RowStateChanged événements.Do not handle the DataGridViewRowCollection.CollectionChanged or DataGridView.RowStateChanged events. Ces événements, les lignes deviennent non partagées.These events cause rows to become unshared. En outre, n’appelez pas la DataGridViewRowCollection.OnCollectionChanged ou DataGridView.OnRowStateChanged méthodes qui déclenchent ces événements.Also, do not call the DataGridViewRowCollection.OnCollectionChanged or DataGridView.OnRowStateChanged methods, which raise these events.

  • N’accèdent pas à la DataGridView.SelectedCells collection lorsque le DataGridView.SelectionMode valeur de propriété est FullColumnSelect, ColumnHeaderSelect, FullRowSelect, ou RowHeaderSelect.Do not access the DataGridView.SelectedCells collection when the DataGridView.SelectionMode property value is FullColumnSelect, ColumnHeaderSelect, FullRowSelect, or RowHeaderSelect. Cela entraîne de toutes les lignes sélectionnées deviennent non partagées.This causes all selected rows to become unshared.

  • N’appelez pas la DataGridView.AreAllCellsSelected (méthode).Do not call the DataGridView.AreAllCellsSelected method. Cette méthode peut entraîner des lignes deviennent non partagées.This method can cause rows to become unshared.

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

  • Ne définissez pas la ReadOnly ou Selected propriété d’une cellule à false lorsque la propriété correspondante dans sa colonne est définie 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 non partagées.This causes all rows to become unshared.

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

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

Voir aussiSee also