Performanceproblem mit ca. 30000 Listboxeinträgen

[Hallo_Thomas]

Ich habe jetzt noch mal die letzten Tage probiert und gemacht aber ich komme irgenwie kein Stückchen vorran! Ich versuche die Geschwindigkeit des Programms im Anhang zu erhöhen, im Moment benötigt es für 30000 zahlen ca. 34s Zeit egal ob ich nun Stringliste benute oder ob ich für

Delphi-Quellcode:

for pl0 := Form1.Anzeige.count - 1 downto 0 do 
    begin 
      for x := 0 to 81 do 
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0

diese Zeile einsetze

Delphi-Quellcode:

for pl0 := 2 downto 0 do 
    begin 
      for x := 0 to 81 do 
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0

es ist auch egal ob ich Anzeige.Items.BeginUpdate; einsetze. Der Berechnungszeitraum bleibt bei 34s.

Delphi-Quellcode:

var 
  x, i, pl0, Counter: Integer; 
  cg, cb            : double; 
  counte            : array[0..81] of Integer; 
  werte             : array[0..81] of mySet; 
begin 
  Anzeige.Items.BeginUpdate; 
   Label999.Caption:=IntToStr(Anzeige.Items.Count); 
  Anzeige.Items.InsertObject(0, AItem, Pointer(AColor)); 
  DoubleBuffered := True; 
  cg := (Form2.SpinEdit1.Value); 
  cb := (Form2.SpinEdit2.Value); 
    begin 
    for i := 0 to 81 do 
    begin 
      Counte[i] := 0; 
    end; 
    werte[0] := [1]; 
    werte[1] := [2]; 
    werte[2] := [3]; 
    werte[3] := [4]; 
    werte[4] := [5]; 
    werte[5] := [6]; 
    werte[6] := [7]; 
    werte[7] := [8]; 
    werte[8] := [9]; 
    werte[9] := [10]; 
    werte[10]:= [11]; 
    werte[11]:= [12]; 
    werte[12]:= [1,2]; 
    werte[13]:= [1,3]; 
    werte[14]:= [1,4]; 
    werte[15]:= [1,5]; 
    werte[16]:= [1,6]; 
    werte[17]:= [1,7]; 
    werte[18]:= [1,8]; 
    werte[19]:= [1,9]; 
    werte[20]:= [1,10]; 
    werte[21]:= [1,11]; 
    werte[22]:= [1,12]; 
    Werte[23]:= [1,2,3]; 
    werte[24]:= [1,2,4]; 
    werte[25]:= [1,2,5]; 
    werte[26]:= [1,2,6]; 
    werte[27]:= [1,2,7]; 
    werte[28]:= [1,2,8]; 
    werte[29]:= [1,2,9]; 
    werte[30]:= [1,2,10]; 
    werte[31]:= [1,2,11]; 
    werte[32]:= [1,2,12]; 
    werte[33]:= [1,2,3,4]; 
    werte[34]:= [1,2,3,5]; 
    werte[35]:= [1,2,3,6]; 
    werte[36]:= [1,2,3,7]; 
    werte[37]:= [1,2,3,8]; 
    werte[38]:= [1,2,3,9]; 
    werte[39]:= [1,2,3,10]; 
    werte[40]:= [1,2,3,11]; 
    werte[41]:= [1,2,3,12]; 
    werte[42]:= [1,2,4,5]; 
    werte[43]:= [1,2,4,6]; 
    werte[44]:= [1,2,4,7]; 
    werte[45]:= [1,2,4,8]; 
    werte[46]:= [1,2,4,9]; 
    werte[47]:= [1,2,4,10]; 
    werte[48]:= [1,2,4,11]; 
    werte[49]:= [1,2,4,12]; 
    werte[50]:= [1,2,5,6]; 
    werte[51]:= [1,2,5,7]; 
    werte[52]:= [1,2,5,8]; 
    werte[53]:= [1,2,5,9]; 
    werte[54]:= [1,2,5,10]; 
    werte[55]:= [1,2,5,11]; 
    werte[56]:= [1,2,5,12]; 
    werte[57]:= [1,2,6,7]; 
    werte[58]:= [1,2,6,8]; 
    werte[59]:= [1,2,6,9]; 
    werte[60]:= [1,2,6,10]; 
    werte[61]:= [1,2,6,11]; 
    werte[62]:= [1,2,6,12]; 
    werte[63]:= [1,2,7,8]; 
    werte[64]:= [1,2,7,9]; 
    werte[65]:= [1,2,7,10]; 
    werte[66]:= [1,2,7,11]; 
    werte[67]:= [1,2,7,12]; 
    werte[68]:= [1,2,8,9]; 
    werte[69]:= [1,2,8,10]; 
    werte[70]:= [1,2,8,11]; 
    werte[71]:= [1,2,8,12]; 
    werte[72]:= [1,2,9,10]; 
    werte[73]:= [1,2,9,11]; 
    werte[74]:= [1,2,9,12]; 
    werte[75]:= [1,2,10,11]; 
    werte[76]:= [1,2,10,12]; 
    werte[77]:= [1,2,11,12]; 
    werte[78]:= [1,2,3,4,5]; 
    werte[79]:= [1,2,3,4,5,6]; 
    werte[80]:= [1,2,3,4,5,7]; 
    werte[81]:= [1,2,3,4,5,8]; 

    for pl0 := Form1.Anzeige.count - 1 downto 0 do 
    begin 
      for x := 0 to 81 do 
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0 
        else 
          Inc(Counte[x]); 
      end; 
      for x := 0 to 81 do 
      begin 
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
          IntToStr(Counte[x]); 
      end; 
    end; 
  end;

Anzeige.Items.endUpdate;
end;

[Delphi_Fanatic]

Also ich hab' jetzt keine Zeit mir Deinen Quelltext anzuschauen, aber trotzdem mal ein ganz allgemeiner Hinweis :

Setz' Deine Listbox oder was auch immer das sein mag auf InVisible, dann füllst Du die Einträge mit Inhalten, und danach setzt Du die wieder auf Visible.
Wenn das InVisible ist während Du das füllst - dann spart das ungemein Zeit.

[Sharky]

Zitat:

Zitat von Hallo_Thomas

Delphi-Quellcode:

.
.
.
    for pl0 := Form1.Anzeige.count - 1 downto 0 do 
    begin 
      for x := 0 to 81 do 
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0 
        else 
          Inc(Counte[x]); 
      end; 
      for x := 0 to 81 do 
      begin 
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
          IntToStr(Counte[x]); 
      end; 
    end; 
  end;

end;

Ach Thomas.......

ich habe dir jetzt schon in zwei anderen Threads gesagt (und dir Beispiele geschriebne) das Du die Ausgabe der Ergebnisse aus der Schleife für die Berechnungen hereausnehmen "sollst".

[Hallo_Thomas]

@Sharky, bevor ich Deins jetzt anschaue, erst mal Dankeschön, für die vielen korrekten Antworten. Die waren echt Spitze!!!!!!!!!!!!!!

@Delphi_Fanatic Mit Visible True oder False, die Zeit bleibt bei 34s

[Hallo_Thomas]

@ Sharky

Delphi-Quellcode:

for y := Form1.Anzeige.count - 1 downto 0 do
    begin
      for x := 0 to 409 do
      begin
        if StrToInt(Form1.Anzeige.Items[y]) in werte[x] then
          Counte[x] := 0
        else
          Inc(Counte[x]); 
      end;
      for x := 0 to 409 do
      begin
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption :=
          IntToStr(Counte[x]);
      end;
    end;

Bis jetzt lagst Du immer richtig, aber dieses einemal nicht, würdch behaupten.
Ich jetzt ein Diese Zeile so ersetzt und unten natürlich
folgendes rausgelöscht.

Delphi-Quellcode:

for x := 0 to 409 do
      begin
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption :=
          IntToStr(Counte[x]);

Jetzt sind 5 min rum das Programm rechnet immer noch, glaub ich verzweifle


P.S. Im jetzigen Programm oben und eigenlich auch schon im vorhergehenden Programm waren doch diese anWeisungen getrennt von einnander, dies hat schon einen unheimlichen Leistungsschub gebracht, aber eh bissl fehlt noch

[jbg]

Dumme Frage, aber welcher normaldenkende Mensch soll diese Anzahl an Items denn bitte schön lesen?

[jbg]

Zitat:

Delphi-Quellcode:

for x := 0 to 409 do
      begin
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption :=
          IntToStr(Counte[x]);

Das kann man umschreiben und damit die versteckte innere Schleife (FindComponent) entfernen.

Delphi-Quellcode:

for i := 0 to ComponentCount - 1 do
begin
  if (Components[i] is TLabel) and AnsiStartsText('Label', Components[i].Name) then
  begin
    x := StrToInt(Copy(Components[i].Name, 6, MaxInt));
    if (x >= 0) and (x <= 409) then
      TLabel(Components[i]).Caption := IntToStr(Counte[x]);
  end;
end;

[Sharky]

Zitat:

Zitat von Hallo_Thomas

...
Bis jetzt lagst Du immer richtig, aber dieses einemal nicht, würdch behaupten.
Ich jetzt ein Diese Zeile so ersetzt und unten natürlich
folgendes rausgelöscht.

Ich glaube Du hast mich falsch verstanden.
Schauen wir uns mal den Code an:

Delphi-Quellcode:

    for pl0 := Form1.Anzeige.count - 1 downto 0 do // (1) Das ist die Schleife für die Items (30.000)
    begin 
      for x := 0 to 81 do                          // (2) Das ist die Schleife für die Berechnung
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0 
        else 
          Inc(Counte[x]); 
      end;                                         // (2) Hier endet die Schleife für die Berechnung
      for x := 0 to 81 do                          // (3) Das ist die Schleife für die Ausgabe
      begin 
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
          IntToStr(Counte[x]); 
      end;                                         // (3) Hier endet die Schleife für die Ausgabe
    end;                                           // (1) hier endet die Schleife für die Items. 
  end;

Du weisst also jedem TLabel 30.000 mal einenen wert zu :!:
Wenn Du es aus der Schleife der Items raus nimmst:

Delphi-Quellcode:

    for pl0 := Form1.Anzeige.count - 1 downto 0 do // (1) Das ist die Schleife für die Items (30.000)
    begin 
      for x := 0 to 81 do                          // (2) Das ist die Schleife für die Berechnung
      begin 
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then 
          Counte[x] := 0 
        else 
          Inc(Counte[x]); 
      end;                                         // (2) Hier endet die Schleife für die Berechnung
    end;                                           // (1) hier endet die Schleife für die Items. 
   for x := 0 to 81 do                          // (3) Das ist die Schleife für die Ausgabe
   begin 
     (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
         IntToStr(Counte[x]); 
   end;                                         // (3) Hier endet die Schleife für die Ausgabe
  end;

dann weisst Du jedem Label genau einmal einen Wert zu.

[Hallo_Thomas]

@jbg Natürlich niemand, aber das Auswertungsprogramm , ungefähr 15 Labels benötigen jede Runde alle, die restlich ca zw. 20-300 Items

Deswegen wollte ich zur Probe erst mal

Delphi-Quellcode:

for x := 2 downto 0 do

aber auch dies hat keinen Performance Erfolg gebracht.

Und sei dir sicher, ich brauche insgesamt ca.600 Label, aber Aufgrund der momentanen Performance, kann ich mit nur 400 arbeiten.

Die 30000 nehme ich als Richtwert, da vergleichbare Programme dies angeblich verabeiten.

[TeronG]

1. mal sollte Sharky's Post viel zeit sparen ...
Und 2. falls du deine 81 (?) Label's zur Laufzeit erstellst oder gar des öfteren befüllst könntest du sie ja in ein array of TLabel stecken. sollte auch n bissl helfen ....

[EDIT]

Zitat:

Zitat von Hallo_Thomas

ich brauche insgesamt ca.600 Label,

:shock: ARRAY lässt grüßen :-D

[shmia]

TListBox.Items[] hat zwar den Datentyp TStrings, ist aber nicht von TStringList abgeleitet
sondern gehört zur Klasse TListBoxStrings !!!
Hier ein kleiner Ausschnitt aus Unit StdCtrls:

Delphi-Quellcode:

  TListBoxStrings = class(TStrings)
  private
    ListBox: TCustomListBox;
  protected
    procedure Put(Index: Integer; const S: string); override;
    function Get(Index: Integer): string; override;

Die Methoden Get und Put sind um Welten langsamer als TStringList.Get/Put.
Da nutzt auch BeginUpdate nicht viel!!

Also geht der WorkAround so:
Alle Items auf ein TStringList-Objekt kopieren, auf dieser StringListe arbeiten und am Ende zurückkopieren.

Delphi-Quellcode:

liste := TStringList.Create;
liste.Assign(ListBox1.Items);

// auf Liste arbeiten
....

// und zurück
ListBox1.Items := liste;
liste.Free;

[Hallo_Thomas]

@Sharky

Ich habe deinen Quelltext eigentlich nur reinkopiert und den rest gelöscht.
und ich bleibe dabei das jetzte Beispiel1 Programm ist auf keine Fall schneller als Programm Beispiel

Delphi-Quellcode:

procedure TForm1.Addmyitem(const AItem: string; const AColor: TColor);
var
  x, i,pl0         : Integer;
  counte            : array[0..409] of Integer;
begin
  Anzeige.Items.InsertObject(0, AItem, TObject(AColor));
  DoubleBuffered := True;

  // Alle "Counter" auf 0 setzen
  for i := 0 to 409 do
  begin
    Counte[i] := 0;
  end;
  // Hier beginnen die Berechnungen
for pl0 := Form1.Anzeige.count - 1 downto 0 do // (1) Das ist die Schleife für die Items (30.000)
    begin
      for x := 0 to 409 do                          // (2) Das ist die Schleife für die Berechnung
      begin
        if StrToInt(Form1.Anzeige.Items[pl0]) in werte[x] then
          Counte[x] := 0
        else
          Inc(Counte[x]);
      end;                                         // (2) Hier endet die Schleife für die Berechnung
      for x := 0 to 409 do                          // (3) Das ist die Schleife für die Ausgabe
      begin
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
          IntToStr(Counte[x]); 
      end;                                         // (3) Hier endet die Schleife für die Ausgabe 
    end;                                           // (1) hier endet die Schleife für die Items. 
  end;

[edit=sakura] Doppelpost gelöscht. Mfg, sakura[/edit]

[Hallo_Thomas]

Zitat:

Zitat von TeronG

1. mal sollte Sharky's Post viel zeit sparen ...
Und 2. falls du deine 81 (?) Label's zur Laufzeit erstellst oder gar des öfteren befüllst könntest du sie ja in ein array of TLabel stecken. sollte auch n bissl helfen ....

[EDIT]

Zitat:

Zitat von Hallo_Thomas

ich brauche insgesamt ca.600 Label,

:shock: ARRAY lässt grüßen :-D

Danke Dir, aber dies werde ich im Moment nicht nachgehen, da meine labels meisents mit nil angesprochen weerden im längeren Programm, hab sie hier nur veranschaulichung alle mitzählen lassen. :cyclops:

[TeronG]

?? in deiner doppeltgeposteten zip verwendest du doch deinen originalcode .. nicht Sharky's ... wenn ich das recht sehe ... hmm :gruebel: (den haste ja auch mitgepostet) ...

[shmia]

Delphi-Quellcode:

for pl0 := Form1.Anzeige.count - 1 downto 0 do // (1) Das ist die Schleife für die Items (30.000) 
    begin

(*
 *
 * du bist auch ein "Held", wenn du 410 Mal auf die gleichen Daten zugreifst !!!!
 *
 *)
   // den Wert AUSSERHALB der inneren Schleife lesen
   // und auch gleich als Integer merken (spart 409 *30000 Aufrufe auf StrToInt !!!)
   aktwert := StrToInt(Form1.Anzeige.Items[pl0]);
      for x := 0 to 409 do                          // (2) Das ist die Schleife für die Berechnung 
      begin 
        if aktwert in werte[x] then 
          Counte[x] := 0 
        else 
          Inc(Counte[x]); 
      end;

Du brauchst deine 410 Labels (was ja auch schon Wahnsinn ist) nicht 30000 Mal beschicken.
Es würde reichen, nur jedes 100. Mal die Labels zu aktualisieren:

Delphi-Quellcode:

   if ((pl1 mod 100) = 0) then
      for x := 0 to 409 do                          // (3) Das ist die Schleife für die Ausgabe 
      begin 
        (FindComponent('Label' + IntToStr(x + 2)) as TLabel).Caption := 
          IntToStr(Counte[x]); 
      end;

[Hallo_Thomas]

Zitat:

Zitat von shmia

TListBox.Items[] hat zwar den Datentyp TStrings, ist aber nicht von TStringList abgeleitet
sondern gehört zur Klasse TListBoxStrings !!!
Hier ein kleiner Ausschnitt aus Unit StdCtrls:

Delphi-Quellcode:

  TListBoxStrings = class(TStrings)
  private
    ListBox: TCustomListBox;
  protected
    procedure Put(Index: Integer; const S: string); override;
    function Get(Index: Integer): string; override;

Die Methoden Get und Put sind um Welten langsamer als TStringList.Get/Put.
Da nutzt auch BeginUpdate nicht viel!!

Also geht der WorkAround so:
Alle Items auf ein TStringList-Objekt kopieren, auf dieser StringListe arbeiten und am Ende zurückkopieren.

Delphi-Quellcode:

liste := TStringList.Create;
liste.Assign(ListBox1.Items);

// auf Liste arbeiten
....

// und zurück
ListBox1.Items := liste;
liste.Free;

Ich habs leider schon gelöscht, ich hatte schon mal dieses Programm auf

Delphi-Quellcode:

meineliste := TStringList.Create;

............

Da hatte ich die Listbox nur och zur Anzeige benutzt und die Komplette Berechnung auf meineListe umgestellt hatte aber nicht wirklich was gebracht.

[marabu]

Hallo Thomas,

du hast da ein Problem, das du unbedingt mit Delphi lösen möchtest. Dass du mit Delphi noch ein wenig auf dem Kriegsfuß stehst, ist verzeihlich. Dass du aber nicht in der Lage bist, nachdem du nun bereits ein Dutzend threads zum Thema eröffnet hast, dein Problem mit einer halben Seite Text so zu beschreiben, dass es von den Nothelfern in diesem Forum halbwegs verstanden werden kann, stimmt mich nachdenklich.

Das Problem hast du dir ja wohl nicht selbst ausgedacht - du erwähntest Vergleiche mit anderen, die du angestellt hast. Ist die eigentliche Aufgabenstellung vielleicht von jemandem formuliert worden, der die Fähigkeit besitzt, sich klar und verständlich auszudrücken und sich bei seinen Ausführungen auf das Wesentliche zu konzentrieren?

Kannst du nicht einfach einen Link auf die Aufgabenstellung posten? Wenn nicht, kannst du dann wenigstens sagen, warum nicht?

Grüße vom marabu

[TKC]

in solchen Fällen führe ich immer eine Zeitmessung der einelnen Schleifen durch !

Damit wird schnell klar wo die meiste Zeit verbraten wird ....

Delphi-Quellcode:

  istart:=GetTickCount;

  for x := 0 to 409 do
    begin
      (FindComponent('Label' + IntToStr(x + 1)) as TLabel).Caption :=IntToStr(Counte[x]);
    end;

 ShowMessage(IntToStr(GetTickCount-istart));

Ergibt bei mir beim 1. mal 157ms ... alle andern funktionen liegen bei 0ms !!

Das Problem ist aber nicht die inttostr Anweisung, sondern die Wertzuweisung an die Labels.

Die Lösung besteht darin das die Eigenschaft AutoSize der gesamten Labels auf False gesetz werden muss !!! :warn:

Ergebnis der Messung dannach : 16ms

Also ein gutes 10tel der Zeit !

[TKC]

oops ... das mit dem Datei öffnen hatte ich ja glatt übersehen :wall:

so .. hier aber jetzt die Lösung des Problems .... :-D

Der Trick ist ... das man die Werte der Listbox extra nach int Konvertiert .. s. Unten !

Delphi-Quellcode:

{-----------------------------------------------------------------------------
  Procedure: Addmyitem
  Arguments: const AItem: string; const AColor: TColor
  Hier werden neue Einträge in die Listbox durchgeführt.
  Es werden auch die Berechnung der "Punkt" und deren Ausgabe
  erledigt.
-----------------------------------------------------------------------------}

procedure TForm1.Addmyitem(const AItem: string; const AColor: TColor);
var
  x, i, y, Counter  : Integer;
  cg, cb            : double;
  counte            : array[0..409] of Integer;

  //Dynamisches Integer Array
  iArray            : array of integer;

begin
  Anzeige.Items.InsertObject(0, AItem, TObject(AColor));
  DoubleBuffered := True;
  cg := (Form2.SpinEdit1.Value);
  cb := (Form2.SpinEdit2.Value);

  //werte von Listbox Anzeige in Array of Integer konvertieren
  for i := 0 to Anzeige.Count - 1 do
    begin
      //Array vergrößern
      SetLength(iArray, i + 1);
      //String to Int wndeln
      iArray[i] := StrToInt(Anzeige.Items[i]);
    end;

  // Alle "Counter" auf 0 setzen
  Counter := 0;
  ZeroMemory(@Counte, SizeOf(counte));


  // Hier beginnen die Berechnungen
  // Jedes Item der Listbox durchlaufen  - Jetzt iArray
  for x := 0 to High(iArray) do
    begin

      if iArray[x] in [1, 3, 10] then
        Inc(Counter);

      if iArray[x] in [6] then
        Counter := 0;

      // Mit jedem SetOfByte vergleichen
      for y := 0 to 409 do
        begin
          //hier mit dem Int Array arbeiten
          if iArray[x] in werte[y] then
            Counte[y] := 0
          else
            Inc(Counte[y]);

        end;
    end;

  // Ab hier kommt die Ausgabe der Berechnungen
  Label1.Caption := IntToStr(Counter);
  if counter = cg then
    begin
      Image2.Picture.Assign(bild2);     // Bilid zuweisen
      label1.font.color := CLblack
    end
  else
    begin
      // Wass passiert wenn keiner von beiden werten zutrifft?
      // Dann könnte diese If-Abfrage nämlich weg. Entweder ist counter = cg
      // oder er ist es nicht.
      if counter = cb then
        begin
          Image2.Picture.Assign(bild1);
          label1.font.color := CLwhite;
        end;
    end;

  for x := 0 to 409 do
    begin
      (FindComponent('Label' + IntToStr(x + 1)) as TLabel).Caption := IntToStr(Counte[x]);
    end;

  //Array freigeben
  iArray := nil;
end;

[Sharky]

Zitat:

Zitat von ACE-ppc

...
Der Trick ist ... das man die Werte der Listbox extra nach int Konvertiert .. s. Unten !

Hai ACE-ppc,

das kann/sollte man noch optimieren ;-)

Zitat:

Delphi-Quellcode:

  //werte von Listbox Anzeige in Array of Integer konvertieren
  for i := 0 to Anzeige.Count - 1 do
    begin
      //Array vergrößern
      SetLength(iArray, i + 1);
      //String to Int wndeln
      iArray[i] := StrToInt(Anzeige.Items[i]);
    end;

Du vergrösserst in der Schleife das Array jedes mal um eine Einheit. Das verlangsamt die sache extrem.
Wenn ein dynamisches Array vergrössert wird passiert folgendes:

• 1. Es wird ein neuer Speicherbereich reserviert der um x Einheiten grösser ist als der alte
  2. Die Daten werden von dem alten Speicherbereich in den neuen kopiert
  3. Der alte Speicherbereich wird freigegeben

Da man ja vor der Schleife weiss wie groß das Array sein muss sollte es also auch einmal auf diese größe gesetzt werdne.

Delphi-Quellcode:

  //Arraygröße festlegen
  SetLength(iArray, Anzeige.Count - 1);
  //werte von Listbox Anzeige in Array of Integer konvertieren
  for i := 0 to Anzeige.Count - 1 do
    begin
      //String to Int wndeln
      iArray[i] := StrToInt(Anzeige.Items[i]);
    end;

Das dürfte noch einmal die Geschwindigkeit erhöhen.

[TKC]

:mrgreen: Stimmt .... naja bei der Uhrzeit kann das schon mal passieren !

Aber ich denke der Zeitunterschied von 30s zu 150ms den ich erreicht habe,
in 8min Coden ist schon recht gut.
:angel:

[TKC]

hmm .. dafür dass es ja so dringend war... könnte man ja wenigstens nen Danke erwarten .. scheint sich wohl erledigt zu haben :gruebel:

[TeronG]

Zitat:

Zitat von ACE-ppc

hmm .. dafür dass es ja so dringend war... könnte man ja wenigstens nen Danke erwarten .. scheint sich wohl erledigt zu haben :gruebel:

oder der letzte Durchlauf ist noch nicht fertig und er stoppt immer noch die Zeit :mrgreen:

[TKC]

:-D könnte gut sein !

[generic]

2 sachen solltest du machen, die ms controls sind eh sehr langsam.
stell doch den lv erstmal auf ein virtualstringtree um.

dann erübrigt sich auch die sehr langsame string to int umwandlung.
das kannst du dann direkt in int rechnen.

[TKC]

Zitat:

Zitat von generic

2 sachen solltest du machen, die ms controls sind eh sehr langsam.
stell doch den lv erstmal auf ein virtualstringtree um.

dann erübrigt sich auch die sehr langsame string to int umwandlung.
das kannst du dann direkt in int rechnen.

Naja ... ganz so ist es dann auch nicht ... eine umwandlung von IntToStr zur Anzeige
gibt es dann immer noch ... !

Ausserdem ist das Problem bereits gelöst ....