C# - Datagrid füllt sich sehr langsam...

WolfBauer

Erfahrenes Mitglied
Hallo,

ich habe ein Problem beim befüllen meines Datagrids. Zunächst einmal ein kleiner Code ausschnitt:

Code:
new public void RefreshContent()
{
for (int i = 0; i < ((SchemaDocumentationDoc)mDocument).CountTabelleOben; i++)
{
daten_tabellen.Rows.Add(i + 1,
((SchemaDocumentationDoc)mDocument).TableObenName[i],
((SchemaDocumentationDoc)mDocument).TableObenOwner[i],
((SchemaDocumentationDoc)mDocument).TableObenTablespace[i],
((SchemaDocumentationDoc)mDocument).GetCode(((SchemaDocumentationDoc)mDocument).TableObenGruppe[i]),
((SchemaDocumentationDoc)mDocument).TableObenPK_Name[i],
((SchemaDocumentationDoc)mDocument).TableObenSchlagwort[i],
((SchemaDocumentationDoc)mDocument).TableObenKommentar[i]);

}
}

In den Arrays sind jeweils Daten aus eine Datenbank gespeichert. Nun zu meinem Problem:
Um so mehr Daten ich in den Array´s habe umso langsamer werden die Daten in das Datagrid geschrieben. Ich habe aber bis zu 1000 Datensätze und es ist unerträglich wie lange das füllen Des Datagrids dauert.

Gibt es eine andere Möglichkeit? Geht es mit AddRange besser? Wenn ja wie?
Meine versuche mit AddRange sind gescheitert.

vielen Dank,
Gruß Wolf
 
hi!

Wo bekommst du deine Arrays her bzw. wie sieht die Struktur aus?
Post mal den Code von SchemaDocumentationDoc.

Und würd's net reichen, mDocument einmal zu casten? Ich glaub nicht, dass das viel Auswirkung auf die Performance hat, aber du würdest dir ne Menge Schreibarbeit ersparen und das Ganze wär etwas leserlicher ;-)

Also so:
Code:
new public void RefreshContent()
{
  SchemaDocumentationDoc doc = (SchemaDocumentationDoc) mDocument;
  for (int i = 0; i < ((SchemaDocumentationDoc)mDocument).CountTabelleOben; i++)
  {
    daten_tabellen.Rows.Add(i + 1,
    doc.TableObenName[i],
    doc.TableObenOwner[i],
    doc.TableObenTablespace[i],
    doc.GetCode(doc.TableObenGruppe[i]),
    doc.TableObenPK_Name[i],
    doc.TableObenSchlagwort[i],
    doc.TableObenKommentar[i]);
  }
}

mfg broetchen
 
Moin,

also das Casten ist nicht schlimm. Jedenfalls nicht für die Geschwindigkeit. Der Aufbau muß so sein. Ist hier so vereinbart worden.

hier der Code aus Schama.Doc:

Code:
      int result_tabelle_oben = 0;
      mTableObenName = null;
      mTableObenOwner = null;
      mTableObenGruppe = null;
      mTableObenSchlagwort = null;
      mTableObenKommentar = null;
      mTableObenPK_Name = null;
      mTableObenTablespace = null;

      DataField df_tabelle_oben = mInitializer.DatabaseInterface.ExecuteSelect("select tab_name,tab_owner,gruppe,schlagwort,kommentar,pk_name,tab_space from " + datenbank + "dd_tabelle order by tab_name", ref result_tabelle_oben);

      if (df_tabelle_oben != null && df_tabelle_oben.CountValues > 0)
      {
        mTableObenName = new string[df_tabelle_oben.CountValues];
        mTableObenOwner = new string[df_tabelle_oben.CountValues];
        mTableObenKommentar = new string[df_tabelle_oben.CountValues];
        mTableObenSchlagwort = new string[df_tabelle_oben.CountValues];
        mTableObenGruppe = new string[df_tabelle_oben.CountValues];
        mTableObenPK_Name = new string[df_tabelle_oben.CountValues];
        mTableObenTablespace = new string[df_tabelle_oben.CountValues];

        for (int i = 0; i < df_tabelle_oben.CountValues; i++)
        {
          mTableObenName[i] = df_tabelle_oben.GetValue(i)[0];
          mTableObenOwner[i] = df_tabelle_oben.GetValue(i)[1];
          mTableObenGruppe[i] = df_tabelle_oben.GetValue(i)[2];
          mTableObenSchlagwort[i] = df_tabelle_oben.GetValue(i)[3];
          mTableObenKommentar[i] = df_tabelle_oben.GetValue(i)[4];
          mTableObenPK_Name[i] = df_tabelle_oben.GetValue(i)[5];
          mTableObenTablespace[i] = df_tabelle_oben.GetValue(i)[6];
        }

Der wird dir aber wahrscheinlich nicht viel bringen, da die Datenbankanbindung wieder selbst geschrieben ist.

Aber an dem Auslesen aus der Datenbank kann es nicht liegen, da die Daten (egal wie viele) sehr schnell in die Arrays geladen werden.
Nur das einlesen in das Datagrid ist einfach zu langsam. (Bei sehr vielen Zeilen)

Gruß
Wolf
 
moin

Ich glaub auch nicht, dass es an den Arrays liegt, aber warum verwendest du so viele Arrays? Hat das nen speziellen Hintergrund?

Ich könnte mir vorstellen, dass es mit DataTables etwas schneller geht.

mfg broetchen
 
ich mache das mit Arrays, da ich noch nicht so lange Programmiere und das das erste Programm mit c# ist.

Bin also noch am rumprobieren. :)

naja ich werde es dann mal mit DataTables versuchen

mfg wolf
 
hi!

DataTables sind hierfür ziemich gut geeignet.

Code:
daten_tabellen.DataSource = myDataTable;

Damit werden die Daten, die in der DataTable stehen, sofort in der DataGrid angezeigt.

Wenn du hier schon mit Arrays arbeitest, warum dann mit zig verschiedenen und nicht einfach mit einem zweidimensionalen?

mfg broetchen

P.S.: Was ist ein DataField?
 
Danke bin gerade schon am basteln...

Ein Datafield ist eine Klasse von einem Kolegen von mir. Kommt nicht von C#.

werde mich melden, wenn es mit den Datatables schneller geht.

Gruß
Wolf
 
Zurück