Datagridview display molto lento [RISOLTO]

di il
18 risposte

Datagridview display molto lento [RISOLTO]

Salve a tutti e grazie a chi potrà darmi una mano.

in Vindows Form c# ho una Form che contiene :

1 combobox

1 button 

10 textbox

1 datagridview


Rilevo un problema di visualizzazione del contenuto della datagridview. Risulta particolarmente lento sia nella visualizzazione del contenuto delle celle, nella paginazione che spostare semplicemente il cursore di cella in cella o scorrere le righe.

 
N.B. Nell'angolo in alto a destra si attiva e disattiva la form (il tasto Rosso di chiusura Form passa dallo stato disable a enabled), il tempo che intercorre, circa 2 secondi, è il tempo necessario per reperire i dati, creare il dataTable e con il binding  popolare il source della datagridview. Pertanto deduco che possa essere solo una questione di grafica dato il numero elevato di colonne.
Mentre i dati estratti provengono dalla lettura di una stored procedure e il ciclo while legge circa 700.000 records, esegue i calcoli, li distrinuisce statisticamente all'interno di un array multi dimensione (67 dimensioni).
A fine ciclo while l'array viene riordinato per come dovrà essere caricato nella datagridview. 
Alla fine di questo processo l'array viene enumerato con un ciclo for per aggiungere le righe nel DataTable, ecc…ecc…


La datagridview al massimo può avere 3 pagine 
Minimo può contenere 80 righe e al massimo circa 200 righe

Contiene 67 colonne, tutte formattate con lo stesso stile di font e tutte di tipo numerico di due cifre tranne una che contiene al massimo 3 cifre numeriche.   Esempio:

La datagridview è solo di lettura
- non è permesso le aggiunte, eliminazioni e aggiornamento delle celle
- non è permesso l'ordinamento delle colonne
- non è permesso il ridimensionamento delle righe e delle colonne
- non è configurata la riga alternativa
- non è consentito la selezione multi linea o colonna
- non esistono Eventi di nessun tipo (essendo si solo lettura non si deve far scaturire nessun evento)
Le dimensioni:
- le dimensioni delle celle sono tutte fisse (noset)
- le dimensioni della datagridview è fissa 
- le dimensioni della form è fissa e si può solo ridurre ad icona (non è consentito il max size)
Load datagridview:
- la datagridview viene popolata interamente da codice, dove viene creato un dataTable con le 67 colonne di tipo int.
- in circa 2 secondi avviene l'estrazione dei dati, il popolamento del dataTable, del bindingsource e il source della datagridview. Quindi un processo molto veloce e apprezzabile vista la fonte da cui si attinge che è abbastanza vasta.
- non vengono applicati filtri alla datagridview
- non viene applicato nessun tipo di ordinamento alla datagridview



Questo è la parte del codice che popola la datagridview:

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;

namespace MyLotto65
{

    public partial class FormTabelloneRitardi : Form
    {

        // set bindingsource tabellone and datatable 
        private BindingSource bindingSourceTabellone;
        private DataTable dataTableTabellone;


        // FORM INITIALIZE
        public FormTabelloneRitardi()
        {
            InitializeComponent();
        }

        // FORM LOAD
        private void FormTabelloneRitardi_Load(object sender, EventArgs e)
        {
            // create datatable tabellone for datagridview
            MyCreateDataTableColumns();

            // load datagridview
            MyDatagridviewCreateLoad();
        }
        
        
        // DATAGRIDVIEW LOAD
        private void MyDatagridviewCreateLoad()
        {
            // set wait cursor
            Cursor.Current = Cursors.WaitCursor;
            // clear datagridview
            this.DgvTab.DataSource = string.Empty;

            // set date parameter - ricerca estrazioni alla data selezionata
            DateTime ExtractDate = Convert.ToDateTime(this.ComboBoxDateSearch.Text);

            // create statistica tabellone ritardi
            int[,] aryTabellone = ClassUtilityLotto.MyTabelleneRitardiRl(ExtractDate);

            // clear datatable
            dataTableTabellone.Clear();

            // load rows in the datatable
            for (int i = 0; i < aryTabellone.GetLength(0); i++)
            {
                // create row
                DataRow newRow = dataTableTabellone.NewRow();
                // load column
                for (int j = 0; j < aryTabellone.GetLength(1); j++)
                {
                    // check if value = 0, set = empty
                    object cellValue = aryTabellone[i, j] == 0 ? DBNull.Value : (object)aryTabellone[i, j];
                    newRow[j] = cellValue;
                }
                // add new row
                dataTableTabellone.Rows.Add(newRow);
            }

            // datatable rows empty delete
            for (int i = dataTableTabellone.Rows.Count - 2; i >= 0; i--)
            {
                if (string.IsNullOrEmpty(dataTableTabellone.Rows[i]["Ritardo"].ToString())) { dataTableTabellone.Rows.RemoveAt(i); }
            }

            // load datagridview binding source 
            bindingSourceTabellone.DataSource = dataTableTabellone;
            this.DgvTab.AutoGenerateColumns = false;
            this.DgvTab.DataSource = bindingSourceTabellone;

            // set wait cursor
            Cursor.Current = Cursors.Default;
            // set focus
            this.DgvTab.Focus();
        }

        // DATAGRIDVIEW CREATE DATATABLE COLUMN
        private void MyCreateDataTableColumns()
        {
            // create new datatable e bindingsource
            dataTableTabellone = new DataTable();
            bindingSourceTabellone = new BindingSource();

            // add columns in the datatable
            dataTableTabellone.Columns.Add("Ritardo", typeof(int));

            dataTableTabellone.Columns.Add("Ba1", typeof(int));
            dataTableTabellone.Columns.Add("Ba2", typeof(int));
            dataTableTabellone.Columns.Add("Ba3", typeof(int));
            dataTableTabellone.Columns.Add("Ba4", typeof(int));
            dataTableTabellone.Columns.Add("Ba5", typeof(int));
            dataTableTabellone.Columns.Add("BaRl", typeof(int));

            dataTableTabellone.Columns.Add("Ca1", typeof(int));
            dataTableTabellone.Columns.Add("Ca2", typeof(int));
            dataTableTabellone.Columns.Add("Ca3", typeof(int));
            dataTableTabellone.Columns.Add("Ca4", typeof(int));
            dataTableTabellone.Columns.Add("Ca5", typeof(int));
            dataTableTabellone.Columns.Add("CaRl", typeof(int));

            dataTableTabellone.Columns.Add("Fi1", typeof(int));
            dataTableTabellone.Columns.Add("Fi2", typeof(int));
            dataTableTabellone.Columns.Add("Fi3", typeof(int));
            dataTableTabellone.Columns.Add("Fi4", typeof(int));
            dataTableTabellone.Columns.Add("Fi5", typeof(int));
            dataTableTabellone.Columns.Add("FiRl", typeof(int));

            dataTableTabellone.Columns.Add("Ge1", typeof(int));
            dataTableTabellone.Columns.Add("Ge2", typeof(int));
            dataTableTabellone.Columns.Add("Ge3", typeof(int));
            dataTableTabellone.Columns.Add("Ge4", typeof(int));
            dataTableTabellone.Columns.Add("Ge5", typeof(int));
            dataTableTabellone.Columns.Add("GeRl", typeof(int));

            dataTableTabellone.Columns.Add("Mi1", typeof(int));
            dataTableTabellone.Columns.Add("Mi2", typeof(int));
            dataTableTabellone.Columns.Add("Mi3", typeof(int));
            dataTableTabellone.Columns.Add("Mi4", typeof(int));
            dataTableTabellone.Columns.Add("Mi5", typeof(int));
            dataTableTabellone.Columns.Add("MiRl", typeof(int));

            dataTableTabellone.Columns.Add("Na1", typeof(int));
            dataTableTabellone.Columns.Add("Na2", typeof(int));
            dataTableTabellone.Columns.Add("Na3", typeof(int));
            dataTableTabellone.Columns.Add("Na4", typeof(int));
            dataTableTabellone.Columns.Add("Na5", typeof(int));
            dataTableTabellone.Columns.Add("NaRl", typeof(int));

            dataTableTabellone.Columns.Add("Pa1", typeof(int));
            dataTableTabellone.Columns.Add("Pa2", typeof(int));
            dataTableTabellone.Columns.Add("Pa3", typeof(int));
            dataTableTabellone.Columns.Add("Pa4", typeof(int));
            dataTableTabellone.Columns.Add("Pa5", typeof(int));
            dataTableTabellone.Columns.Add("PaRl", typeof(int));

            dataTableTabellone.Columns.Add("Rm1", typeof(int));
            dataTableTabellone.Columns.Add("Rm2", typeof(int));
            dataTableTabellone.Columns.Add("Rm3", typeof(int));
            dataTableTabellone.Columns.Add("Rm4", typeof(int));
            dataTableTabellone.Columns.Add("Rm5", typeof(int));
            dataTableTabellone.Columns.Add("RmRl", typeof(int));

            dataTableTabellone.Columns.Add("To1", typeof(int));
            dataTableTabellone.Columns.Add("To2", typeof(int));
            dataTableTabellone.Columns.Add("To3", typeof(int));
            dataTableTabellone.Columns.Add("To4", typeof(int));
            dataTableTabellone.Columns.Add("To5", typeof(int));
            dataTableTabellone.Columns.Add("ToRl", typeof(int));

            dataTableTabellone.Columns.Add("Ve1", typeof(int));
            dataTableTabellone.Columns.Add("Ve2", typeof(int));
            dataTableTabellone.Columns.Add("Ve3", typeof(int));
            dataTableTabellone.Columns.Add("Ve4", typeof(int));
            dataTableTabellone.Columns.Add("Ve5", typeof(int));
            dataTableTabellone.Columns.Add("VeRl", typeof(int));

            dataTableTabellone.Columns.Add("Nz1", typeof(int));
            dataTableTabellone.Columns.Add("Nz2", typeof(int));
            dataTableTabellone.Columns.Add("Nz3", typeof(int));
            dataTableTabellone.Columns.Add("Nz4", typeof(int));
            dataTableTabellone.Columns.Add("Nz5", typeof(int));
            dataTableTabellone.Columns.Add("NzRl", typeof(int));
        }
    }
}


In pratica ho disattivato tutte le proprietà che ritengo non siano utili allo scopo come da immagine :





Secondo voi è possibile migliorare le prestazioni di visualizzazione della datagridview ? 

Grazie.

18 Risposte

  • Re: Datagridview display molto lento [RISOLTO]

    Stai cancellando il tabellone (clear) e lo ricrei ad ogni variazione (add).

    Se su una matrice di dati ascisse a, b, c, d e ordinate 1, 2, 3, 4 mi cambia solo l'ultimo dato (d;4) tu riscrivi tutta la griglia quando basta solo griglia.cella(d;4)="ciao".

    La griglia la cri solo all'avvio poi come la battaglia navale vai a cambiare solo quello che serve senza ridisegnare tutto (clear e add). Non devi cancellare nulla e non devi aggiungere nulla solo modificare il valore di alcune (ma anche tutte) celle. 

  • Re: Datagridview display molto lento [RISOLTO]

    Ciao sihsandrea grazie per la risposta…

    20/03/2024 - sihsandrea ha scritto:


    Stai cancellando il tabellone (clear) e lo ricrei ad ogni variazione (add).

    Solo ad ogni nuova visualizzazione …. cioè quando si cambia la data fine estrazione, viene ricalcolata la nuova statistica ed esposizione dei dati. In questo caso cambiano le posizioni dei numeri nelle righe e se ne aggiungono altri nuvi e ne escono alcuni dalle prime posizioni… insomma , cambia la statistica e quindi elimino il contenuto del datatable e lo ricarico con le nuove impostazioni :

                // create statistica tabellone ritardi
                int[,] aryTabellone = ClassUtilityLotto.MyTabelleneRitardiRl(ExtractDate);
    
                // clear datatable
                dataTableTabellone.Clear();
    
                // load rows in the datatable
                for (int i = 0; i < aryTabellone.GetLength(0); i++)
                {
                    // create row
                    DataRow newRow = dataTableTabellone.NewRow();
                    // load column
                    for (int j = 0; j < aryTabellone.GetLength(1); j++)
                    {
                        // check if value = 0, set = empty
                        object cellValue = aryTabellone[i, j] == 0 ? DBNull.Value : (object)aryTabellone[i, j];
                        newRow[j] = cellValue;
                    }
                    // add new row
                    dataTableTabellone.Rows.Add(newRow);
                }
    
                // datatable rows empty delete
                for (int i = dataTableTabellone.Rows.Count - 2; i >= 0; i--)
                {
                    if (string.IsNullOrEmpty(dataTableTabellone.Rows[i]["Ritardo"].ToString())) { dataTableTabellone.Rows.RemoveAt(i); }
                }
    
                // load datagridview binding source 
                bindingSourceTabellone.DataSource = dataTableTabellone;
                this.DgvTab.AutoGenerateColumns = false;
                this.DgvTab.DataSource = bindingSourceTabellone;
    

    Quando il datatable è pronto con i nuovi dati , elimino le eventuali righe completamente vuote e caricho il binding e il source della datagridview.

    Pertanto quando mi trovo in visualizzazione della datagridview le informazioni non cambiano più , si possono solo leggere e scorrere per riga o per pagina 
    Quest'ultima operazione da parte dell'utente è assai lenta graficamente come da esempio sopra. 

    E quando consulti i dati e scorri le informazioni, tutto è statico , tutto è già caricato nella datagridview , in questa fase le informazioni non cambiano più. Non ci sono calcoli o formattazioni da elaborare durante la visualizzazione. 

    Quindi non mi so spiegare come mai ci metta tanto a refreshare le celle e le righe mentre ti sposti nella datagridview. 
    Perchè è lento se tutti i dati sono consolidati e caricati a monte e si devono solo ed esclusivamente visualizzare?

    Mi sfugge qualcosa ? 

    Grazie!


    Edit…
    ho anche tolto il colore personalizzato delle 12 colonne in modo  di avere un un unico stile di visualizzazione, ma non cambia nulla, le prestazioni sono le medesime in fase di visualizzazione.

  • Re: Datagridview display molto lento [RISOLTO]

    19/03/2024 - By65Franco ha scritto:


    Mentre i dati estratti provengono dalla lettura di una stored procedure e il ciclo while legge circa 700.000 records

    sicuro che ti serve elaborare tutti e 700.000 record? io elaborerei solo quelli che cambiano (mi sembra di capire che si tratta di ritardi).

    19/03/2024 - By65Franco ha scritto:


    in circa 2 secondi avviene l'estrazione dei dati, il popolamento del dataTable, del bindingsource e il source della datagridview

    anche se impiegasse 5 minuti non giustifica il repaint della griglia, che, ripeto, lo fai una sola volta all'avvio del programma, poi modifichi solo le celle interessate estrapolandole dall'array una volta eseguiti i calcoli.

    19/03/2024 - By65Franco ha scritto:


    Risulta particolarmente lento sia nella visualizzazione del contenuto delle celle, nella paginazione che spostare semplicemente il cursore di cella in cella o scorrere le righe

    verifica se al passaggio da una cella all'altra riesegui i calcoli (e il repaint con “add” e, se si, elimina il codice associato.

    stacca i due eventi:

    i calcoli li fai ogni tot di tempo (o ogni volta che aggiorni il ritardo in tabella controllando un campo 'ultimo aggiornamento' in modo da ridurre i 700.000 record a solo quelli che effettivamente cambiano.

    elimina dataTableTabellone.Columns.Add("testo", typeof(int)) e concentrati a correggere le singole celle (quelle che cambiano di valore ovviamente)

    passare da una cella all'altra non comporta (o di norma non dovrebbe comportare) il cambiamento dei dati nella griglia quindi non ha senso rifare i calcoli. (al massimo ti segni in una variabile le coordinate della cella e nel caso fortuito che in quel momento stanno cambiando i dati ti riposizioni alla cella.

  • Re: Datagridview display molto lento [RISOLTO]

    sihsandrea

    il flusso , come da codice sopra esposto, è così organizzato:

    1. in apertura form (form load) viene :
      1. definito a livello di classe il bindingsource e il datatable
      2. viene richiamato una sola volta il metodo per per definire una sola volta il tipo e le colonne del datatable
      3. viene richiamato il metodo che estrae i dati per popolare il datatable il bindingsource e la datagridiview
      4. viene visualizzata la datagridview
    2. se viene richiesta la visualizzazione dei dati ad una data diversa, allora si esegue solo:
      1. viene richiamato il metodo che estrae i dati per popolare il datatable il bindingsource e la datagridiview
      2. viene visualizzata la datagridview 

    -La statistica viene elaborata molto velocemente , impiega poco più di 1 secondo
    -Caricato l'array con la nuova statistica, per popolare il datatable binding e datagridview impiega meno di mezzo secondo.



    -La statistica al cambio di data deve essere ricalcola tutta dall'inizio in quanto entrano a far parte nuovi numeri e gli altri esistenti cambiano tutti di posizione sulla base dei nuovi numeri entrati nella statistica. (cambiano i ritardi e le posizioni di ritardo per tutti i numeri in tutte le righe). Alcuni escono dalla prima posizione e si postano all'ultima e così via dicendo.

    Ma questa parte di calcolo non mi preoccupa, è ottimizzata ed è velocissima.


    20/03/2024 - sihsandrea ha scritto:


    passare da una cella all'altra non comporta (o di norma non dovrebbe comportare) il cambiamento dei dati nella griglia quindi non ha senso rifare i calcoli. (al massimo ti segni in una variabile le coordinate della cella e nel caso fortuito che in quel momento stanno cambiando i dati ti riposizioni alla cella

    -Quando si consulta il tabellone, i dati sono statici, non cambiano, non viene eseguito nessun calcolo e/o formattazione, è proprio un discorso grafico… per esempio se sei alla fine della pagina e ti sposti di una riga in bassso, la datagridview disegna la nuova riga compare con la stessa lentezza come da esempio sopra riportato. Idem se cambi pagina, ridisegna le nuove righe sempre con quella lentezza.

    E' per questo che sono portato a pensare che sia un problema legato alle troppe colonne e celle da visualizzare.
    Infatti in fase di sviluppo, i test li ho fatti sempre con le prime 7 colonne ed era velocissimo il refresh.
    Poi quando ho finito con i test ho inserito tutte le altre colonne e il risultato è quello illustrato.

    Non mi capacito , o per meglio dire non colgo se il problema grafico è risolvibile. :(

  • Re: Datagridview display molto lento [RISOLTO]

    sihsandrea

    Ho anche testato il SuspendLayout e ResumeLayout .. ma nulla cambia, le prestazioni sono le stesse…

                DgvTab.SuspendLayout();
    
                // load datagridview binding source 
                bindingSourceTabellone.DataSource = dataTableTabellone;
                this.DgvTab.AutoGenerateColumns = false;
                this.DgvTab.DataSource = bindingSourceTabellone;
    
                // set wait cursor
                Cursor.Current = Cursors.Default;
                // set focus
                this.DgvTab.Focus();
    
                DgvTab.ResumeLayout(false);
    
  • Re: Datagridview display molto lento [RISOLTO]

    Verificherei le proprietà RowHeadersVisible e RowHeadersWidthSizeMode perché so che in alcuni casi il ridimensionamento automatico degli header e delle conseguenti colonne può avere impatti nella visualizzazione.

  • Re: Datagridview display molto lento [RISOLTO]

    20/03/2024 - By65Franco ha scritto:


    per esempio se sei alla fine della pagina e ti sposti di una riga in bassso, la datagridview disegna la nuova riga compare con la stessa lentezza come da esempio sopra riportato.

    Non puoi mettere uno scroll verticale?

    20/03/2024 - By65Franco ha scritto:


    Ho anche testato il SuspendLayout e ResumeLayout .. ma nulla cambia, le prestazioni sono le stesse…

    Nel momento in cui mostri la tabella viene popolata.

    Si nota un repaint che va da sinistra a destra e dall'alto verso il basso.

    Visto che la tabella mantiene la.stessa formattazione puoi provare a commentare il codice che aggiunge le righe (in modo da poterlo ripristinare decommentandolo) e sostituirlo con un ciclo che scrive in ogni cella i valori nuovi e vedere se cabia qualcosa.

    La scrittura nelle celle è più rapida.

    Se le nuove righe sono inferiori alle precedenti elimini le restanti righe, se sono di più inserisci le righe mancanti.

    Tuttavia, se anche con una sola riga mostri le restanti in bianco basta solo attribuire il valore “” alle restanti celle.

    Non dovresti modificare di molto il codice solo inserire due variabili intere, una per la riga e una per la colonna e dall'array (che userei come matrice -riga;colonna) estrapoli i dati. Se hai la matrice puoi evitare l'uso delle variabili. La matrice rispecchia le celle e ogni dato va al suo posto (circa ½ secondo) senza il fastidio effetto tendina.

  • Re: Datagridview display molto lento [RISOLTO]

    Ho visto solo ora che lo scroll c'è…

  • Re: Datagridview display molto lento [RISOLTO]

    Ciao Alka , grazie per la risposta…

    le prorpietà sono così impostate:


    In quanto non mi occorre avere l'intestazione di riga essendo solo in visualizzazione


    In quanto non è permesso rifìdimensionare nè colonne nè righe e nenche la form non è ridimensionabile , si può solo ridurre ad icona. 

    Per questo tipo di visualizzazione non occorre interagire con le funzionalità della datagridview … tutto è statico e tutto è tenuto fisso.

    Dapo aver consultato le documentazioni anch'io Alka speravo di ottenere dei benifici, ma purtroppo nulla cambia nelle prestazioni. 

  • Re: Datagridview display molto lento [RISOLTO]

    20/03/2024 - By65Franco ha scritto:


    Dapo aver consultato le documentazioni anch'io Alka speravo di ottenere dei benifici, ma purtroppo nulla cambia nelle prestazioni. 

    Ahimé, credo che la problematica sia allora derivante da un funzionamento non ottimale della griglia in sé, o meglio dal fatto che - per svolgere i propri compiti - la griglia deve effettivamente gestire complessità che rendono più lento il rendering in presenza di molti dati.

    Non conosco gli “internals” della DataGridView, ma ho esperienza su altri linguaggi (es. Delphi) dove le griglie sono un tema scottante e dove ci sono diversi accorgimenti per evitare di incappare nella problematica di rallentare troppo il rendering in presenza di molti dati.

    Il DataGridView è già più complesso del DataGrid, che analogamente alla vecchia MSFlexGrid (che memorie…) tende a creare una griglia grande tanto quanto i dati che deve mostrare; in presenza di tanti, tanti, tanti record infatti, le prestazioni degradano ben presto a causa di questo; in Delphi ad esempio, la griglia visualizza e aggiorna la grafica dei soli record visualizzati nella videata (il numero di righe è sempre e solo quello visibile) e provvede tramite cache o con il supporto fornito dai componenti collegati a recuperare i dati che servono limitatamente ai soli che devono essere visibili nella finestra, senza ricreare le righe ma aggiornando quelle mostrate, e senza utilizzare handle di Windows o altre risorse. L'effetto è una velocità estrema nella visualizzazione potenziale di milioni e milioni di record.

    Alla fine del pippone, credo che il suggerimento possibile sia quello di:

    • valutare possibili alternative all'attuale DataGridView che supportino modalità più “intelligenti” nel rendering massivo (ad esempio questa, ma cercando magari se ne trovano di gratis e opensource), o magari usare la vecchia DataGrid;
    • come direbbero i gamer, “craftarsi” una griglia propria, ossia creare un controllo che tramite Drawing2D disegni la tabella (o una rappresentazione simile) tramite le funzioni grafiche;
    • provare a disattivare alcune feature, tipo il “double buffering” sulla griglia, in modo da verificare se - al costo di un rendering con qualche “flicker” in più, ci si guadagna in prestazioni.

    A me purtroppo al momento non viene in mente altro. :|

  • Re: Datagridview display molto lento [RISOLTO]

    20/03/2024 - Alka ha scritto:


    Alla fine del pippone, credo che il suggerimento possibile sia quello di:

    • valutare possibili alternative all'attuale DataGridView che supportino modalità più “intelligenti” nel rendering massivo (ad esempio questa, ma cercando magari se ne trovano di gratis e opensource), o magari usare la vecchia DataGrid;
    • come direbbero i gamer, “craftarsi” una griglia propria, ossia creare un controllo che tramite Drawing2D disegni la tabella (o una rappresentazione simile) tramite le funzioni grafiche;
    • provare a disattivare alcune feature, tipo il “double buffering” sulla griglia, in modo da verificare se - al costo di un rendering con qualche “flicker” in più, ci si guadagna in prestazioni.

    A me purtroppo al momento non viene in mente altro. :|

    Grazie Alka,

    Concordo con il Ahimè  :-(

    in effetti la datagridview se ha 3 pagine da caricare, le carica tutte e rende usufruibile la griglia solo quando ha caricato l'ultima cella dell'ultima pagina e non prima. Sicuramente già questo è un sintomo di un datagridview non ottimizzato per pagina visualizzata, ma la stessa la rende disponibile solo se ha finito di caricare tutto.


    Concordo che per ottenere prestazioni accettabili graficamente, sarà necessario percorrere altre strade e approcci.


    Procedendo nei test, posso confermare che il problema emerge all'aumentare delle colonne da visualizzare. Più colonne corrisponde a minori prestazioni grafiche.

    A conferma di ciò… se si seleziona una certa data per la quale si estraggono e si processano solamente  128 records , questi creano solo 16 righe da visualizzare nella datagridview e le prestazioni di riempimento delle righe sono le medesime, cioè le stesse  come aver letto i 700.000 mila records che producono le 120 righe da visualizzare:

    Esempio di prestazioni:

    Come puoi vedere, pochi o tanti records, oppure poche o tante righe, all'aumentare delle colonne corrisponde un degrado sempre più pesanti delle prestazioni grafiche a prescindere dal numero delle righe.
    Per esperienza su altre datagridview ho notato che fino a 20-25 colonne, le prestazioni sono ancora accettabili anche se già si evince un certo degrato. (ma rimane accettabile)


    A questo punto penso di procedere con un approccio diverso seguendo alcuni dei tuoi consigli.

    Ringrazio tutti per l'attenzione e per i suggerimenti… 

    Un saluto ;-)

  • Re: Datagridview display molto lento [RISOLTO]

    Ma hai provato a gestire la DoubleBuffered? Alka suggeriva di disabilitarla, ma secondo me non ce l'hai attivata.

  • Re: Datagridview display molto lento [RISOLTO]

    Salve Franco,

    Microsoft anni fa pubblico' una serie di faq e approfondimenti sulla DataGridView, che ora trovi disponibile presso https://documents.pub/document/data-grid-view-faq.html

    viene documentata anche la modalita' bound = Virtual, che mi pare ricordare effettuasse il caricamento della griglia “solo su necessita'”, cioe' “se non scrolli fino alla Nesima riga, non la carica sul controllo”…

    ovviamente e' tutto molto piu' “manuale”, in quanto devi rispondere ad eventi tipo CellValueNeeded etc, ma potrebbe essere una soluzione…

    salutoni romagnoli
    – 
    Andrea

  • Re: Datagridview display molto lento [RISOLTO]

    20/03/2024 - Sgrubak ha scritto:


    Ma hai provato a gestire la DoubleBuffered? Alka suggeriva di disabilitarla, ma secondo me non ce l'hai attivata.

    Ciao,

    riprendo adesso il progetto… ora verifico e faccio test

Devi accedere o registrarti per scrivere nel forum
18 risposte