c # très lent à remplir le datagridview

Je suis le remplissage d'un datagridview à partir d'une datatable.

Pendant le remplissage des colonnes et des lignes, j'ai aussi le format dans le même temps, cette cause, la datagridview à charge très lentement, est-il une solution de contournement pour ce problème?

source d'informationauteur user1030916

c#datagridview

11

Ainsi que prendre soin de AutoSizeColumnsModeassurez-vous que les colonnes qui ont leur AutoSizeMode bien aussi quelque chose d'autre que de toutes les cellules.

J'ai aussi trouvé qu'il est nécessaire d'utiliser
```
SendMessage(dg.Handle, WM_SETREDRAW, false, 0); //before

//updates to datagridview here...

SendMessage(dg.Handle, WM_SETREDRAW, true, 0); //after
```
6

Je prenais environ 2 à 4 minutes pour charger 1-2k lignes. J'ai changé le redimensionnement automatique des biens et maintenant c'est à secondes, probablement de 10 à 20. J'ai couru ce droit avant ma ligne de création de la boucle pour s'assurer qu'il a obtenu toutes les colonnes.
```
foreach (DataGridViewColumn c in thisGrid.Columns)
{
    c.AutoSizeMode = DataGridViewAutoSizeColumnMode.None;
}
```

Avec ce sera datagridview rapide que java jtable 🙂

public static class ExtensionMethods
{
    public static void DoubleBuffered(this DataGridView dgv, bool setting)
    {
        Type dgvType = dgv.GetType();
        PropertyInfo pi = dgvType.GetProperty("DoubleBuffered",
            BindingFlags.Instance | BindingFlags.NonPublic);
        pi.SetValue(dgv, setting, null);
    }
}

ExtensionMethods.DoubleBuffered(dataGridView1, true);

4

Vous pouvez vérifier la propriété du DataGridView - AutoSizeColumnsMode
J'ai trouvé que si je change le mode de AllCells à DisplayedCells la performance est différente.
J'espère que cela va vous aider.
3

Lorsque vous utilisez un contrôle datagrid pour afficher des données à partir de dataabse vous devez toujours penser à utiliser une stratégie pour limiter les résultats de la définir et afficher les enregistrements uniquement lorsque l'utilisateur vraiment les voir. Cela est parfois appelé Mode Virtuel, ou pagination de données. J'ai eu un exemple de cette stratégie pour wpfmais il y a quelque chose aussi pour les winforms. Jetez un oeil à cette question: Winform DataGridview incroyablement lent par rapport à MS Access Grid je pense est lié à votre problème.
2

Les règles d'un stupide vieil homme :
- ÉVITER la DataTable, bien connu pour être inefficicient
- ÉVITEZ d'utiliser des preallocation de lignes ["Grille".Rowcount + "Grille".AddRange() +..] ( ~5 fois plus lente que la "Grille"ADD())
- Considérer qu'un DataGridView est lié "à votre écran" : c'est à dire. CHARGEZ-le avec un peu d'écrans de données.
- J'ai appliqué ces faits simples et je me permet de "charger" un "stupide" fichier de 420 000 lignes avec 159 colonnes en 15 sec. ( ~200 MO).
0

J'ai une assez bonne performance de DataGridView. L'ajout de plusieurs centaines de lignes prend environ 200ms. Voici ce que je fais:

virtual = true -- à l'aide d'un de données virtualisés grille point de vue semble rendre l'ensemble du processus plus rapide. N'oubliez pas de les mettre en œuvre correctement logViewGrid_CellValueNeeded.

Une autre chose à faire est de désactiver temporairement la mise en page des événements lors de l'ajout de données à la liste liée. Essayez de le faire:
```
logViewGrid.SuspendLayout();
//add data, perform some operations on grid view
logViewGrid.ResumeLayout(false);
```
J'ai également eu un problème avec lent lignes de coloriage; ma méthode pour le faire est la définition de chaque cellules de style séparément, comme ceci:
```
gridViewInstance.Rows[currentRow].Cells[cellIndex].Style.BackColor = val;
```
Au lieu de cela, je suis allé pour:
```
gridViewInstance.Rows[currentRow].DefaultCellStyle.BackColor = val;
```
Qui, pour 30 colonnes, m'a donné de l'importante augmentation de la vitesse dans cette partie du code.
0

J'ai fait quelques tests dans un programme où je charge 5000 lignes avec 6 colonnes et chaque cellule est chargé avec le numéro de ligne juste pour avoir quelques données. J'ai ensuite utilisé un Chronomètre pour tester chaque approche. J'ai chargé le dataviewgrid, désactivé, et le chargea ensuite permis, caché, chargé, et il a montré, et suspendlayout et resumelayout. J'ai trouvé que par le cacher et de le charger et puis, montrant qu'il a été beaucoup plus rapide dans mes tests. Il a fallu:
.91 secondes à charger
.91 secondes pour suspendLayout, charge, resumeLayout
De 25 secondes pour désactiver, de la charge et de réactiver la grille
.19 secondes pour se cacher, de charge, et de montrer la grille.

Je suis d'accord que vous devriez éviter de charger ce que vous n'avez pas besoin de le faire, mais pensé que ce test pourrait aider.

Vous devez vous connecter pour publier un commentaire.