[VB6] Snel veel data in een ListBox stoppen

[Verwijderd]

Op een zeker moment moet het programma dat ik nu aan het schrijven 3000+ items in een ListBox stoppen. Dat gaat momenteel met een loopje. Opzich werkt het wel, maar het probleem is, dat de rest van het programma op deze computer (P-III 1 gHz) ongeveer 2 tot 3 seconden bevriest, totdat de PC uitgeloopt is. Hoe kan ik dit oplossen?

Met andere woorden: wat is de beste manier om hééél veel data in zo kort mogelijke tijd in een ListBox te stoppen? Of is er wellicht een manier om ervoor te zorgen dat de loop niet de rest van het programma bevriest? Dat het vullen van de ListBox 2-3 seconden duurt is niet zo'n probleem, maar wél dat de rest dan niets doet!

Hier is de gebruikte code:

code:

For a = 0 To File1.ListCount - 1
    Desc = Mid(File1.List(a), 1, Len(File1.List(a)) - 4)
    List1.AddItem Desc
    DataAudioDescription(a) = Desc
    DataAudioFile(a) = File1.Path & "\" & File1.List(a)
Next a

Er wordt dus data uit File1 gehaald. De Mid-functie stript de extensie van de bestanden in File1, zodat die dus niet zichtbaar worden in de ListBox. Er worden tevens twee arrays bijgehouden, DataAudioDescription en DataAudioFile, zodat ik later heel makkelijk de juiste bestandsnaam kan vinden bij het ListBoxItem dat de gebruiker kiest. De For-Next-Loop zorgt ervoor dat alle data in de ListBox terecht komt.

[glashio]

Visual Basic:

For....
...
DoEvents
Next a

Dit zorgt ervoor dat je Thread ook tijd vrijmaakt voor andere Win-Processes.
Luister naar de MOD .... die weet je het haarfijn uit te leggen.

[ Voor 24% gewijzigd door glashio op 10-08-2004 15:41 . Reden: MOD weet beter ]

[Verwijderd]

Left, mid en right instructies vragen relatief veel tijd.

De data die je in DataAudioDescription(a) plaats heb je ook in je listbox staan -> list1.list(a). Wellicht kan je die er nog uit halen...

Ik denk dat je de meeste tijdwinst kan halen door de mid instructie eruit te gooien.
Succes!

[curry684]

glashio schreef op 10 augustus 2004 @ 15:30:

Visual Basic:

For....
...
DoEvents
Next a

Dit zorgt ervoor dat je Thread ook tijd vrijmaakt voor andere Win-Processes.

Dat is overigens niet per definitie de charmantste of uberhaupt werkende oplossing. DoEvents zorgt er namelijk voor dat alle events afgehandeld worden tussendoor, oftewel het is dan ook mogelijk dat je het programma afsluit of nieuwe selecties maakt terwijl je bezig bent. Meestal wil je alleen pending repaints afhandelen, dat weet ik echter niet hoe je dat onder VB6 het simpelst doet (VCL heeft bijvoorbeeld de TWinControl::Update functie die enkel pending paints voor dat ene control wegflushed zodat je iig blijft repainten).

Je opmerking is trouwens sowieso onzin, een process blokt nooit een ander proces of zelfs thread. Wat je doet met DoEvents is simpelweg de message queue tussentijds leegwerken.

[ Voor 29% gewijzigd door curry684 op 10-08-2004 15:34 ]

[Lorn]

Wat je kunt proberen is om de API-call LockWindowUpdate aan te roepen met de handle van de listbox.

Op deze manier zal de listbox niet opnieuw getekend worden na het toevoegen van een element. Dit kan een hele hoop tijd schelen, heb 't meerdere keren toegepast bij het verwijderen van een hoop elementen uit een listbox.

Niet vergeten om naderhand weer LockWindowUpdate(0&) aan te roepen om het updaten van de listbox op het scherm weer aan te zetten

[whoami]

Je kunt de 'BeginUpdate' (geen idee hoe die in VB6 heet) method v/d listbox aanroepen voordat je begint met het toevoegen van items, en als dat gedaan is moet je de EndUpdate method aanroepen.

In .NET kan je ook een hele 'range' items in 1 keer adden, ik weet niet of je dat in VB6 ook kan. Dit zou ook wat sneller moeten zijn: je gaat dan alle listitems die je aanmaakt in een array oid steken, en dan roep je de AddRange method aan met die array als argument.

Ik weet ook niet of VB6 multi-threading kent. Indien wel, dan zou je kunnen overwegen om het toevoegen van listitems op een andere thread te laten gebeuren.
Je moet er dan wel voor zorgen dat je de methods v/d ListBox in de juiste context aanroept, dwz: je moet die aanroepen binnen de UI thread.

[glashio]

Lorn schreef op 10 augustus 2004 @ 15:40:
API-call LockWindowUpdate

Intressant

Visual Basic:

Combobox.enabled=false;
...
Combobox.enabled=true

Doet hetzelfde ? Alleen wordt ie tussentijds grijs...

edit:
@curry684 Helder Thx!

[ Voor 9% gewijzigd door glashio op 10-08-2004 16:42 ]

[Verwijderd]

Er viel idd nog wat te optimaliseren aan de code. Die ziet er in de basis nu zo uit:

code:

For a = 0 To File1.ListCount - 1
    DataAudioDescription(a) = Left(File1.List(a), Len(File1.List(a)) - 4)
    List1.AddItem DataAudioDescription(a)
    DataAudioFile(a) = File1.Path & "\" & File1.List(a)
Next a

DoEvents kan inderdaad voor problemen zorgen, omdat je dan de Search string kan aanpassen. Is wel omheen te werken, door de inhoud van de TextBox buiten de loop in een stringetje te stoppen, maar ik heb gemerkt dat DoEvents de boel sterk vertraagt. Het zorgt er inderdaad zeker voor dat de rest van het programma door blijft lopen, maar het toevoegen van 3000+ items duurt dan ineens zo'n 10-12 seconden en dat is onacceptabel...

Refresh kan, maar dan moet ik denk ik meerdere controls in die loop laten refreshen. Immers, Form1.Refresh helpt niet, omdat het Form opzich niet verandert, alleen enkele controls óp het form.

De Mid-functie had ik niet echt nodig in de code, dus die heb ik vervangen voor Left, maar dat levert weinig winst op. Vrij logisch natuurlijk, omdat degene die hierover poste schreef, dat Left/Right/Mid allemaal even traag zijn. Maar goed, de code is nu iets schoner.

De genoemde API oproepen lijkt me de beste methode, omdat ik gemerkt heb dat voornamelijk het repainten veel tijd kost. Ik moet alleen ff kijken hoe ik dat ga aanpakken, want ik ben niet heel goed met het aanroepen van API's...

Be right back!

[Fire69]

Onlangs was hier ook iemand die (verschrikkelijk) veel data in een listbox wou.
Daar werden een aantal alternatieven voor deze niet zo nette manier van werken gegeven.
[rml][ VB6] Listbox kan maar 32144 regels aan, hoe verander ik dit[/rml]

[whoami]

Ik vraag me trouwens af waarom je die array nodig hebt...
Als je per listitem extra info wilt bijhouden, kan je die ook kwijt in de Tag property oid van het ListItem.

[Lorn]

Verwijderd schreef op 10 augustus 2004 @ 15:58:
De genoemde API oproepen lijkt me de beste methode, omdat ik gemerkt heb dat voornamelijk het repainten veel tijd kost. Ik moet alleen ff kijken hoe ik dat ga aanpakken, want ik ben niet heel goed met het aanroepen van API's...

Je hoeft eigenlijk alleen de volgende declaratie op te nemen in je applicatie:

Visual Basic:

Public Declare Function LockWindowUpdate Lib "user32" Alias _
  "LockWindowUpdate" (ByVal hwndLock As Long) As Long

Vervolgens roep je die API-call aan voordat je de listbox gaat vullen.

Visual Basic:

Call LockWindowUpdate(List1.hWnd)

Als de listbox eenmaal is gevuld dan dus nog een keer LockWindowUpdate aanroepen maar dan als parameter 0& meegeven.

[curry684]

glashio schreef op 10 augustus 2004 @ 15:56:
[...]
Intressant

Visual Basic:

Combobox.enabled=false;
...
Combobox.enabled=true

Doet hetzelfde ? Alleen wordt ie tussentijds grijs...

Uhm nee dat doet absoluut niet hetzelfde

LockWindowUpdate zorgt ervoor dat er geen WM_PAINTs geflushed kunnen worden. De Enabled property zorgt ervoor dat er geen focus op het ding kan komen, en forced juist een repaint om 'm disabled te tekenen

[whoami]

Is de BeginUpdate method geen wrapper rond die LockWindowUpdate ?

[Lorn]

whoami schreef op 10 augustus 2004 @ 16:22:
Is de BeginUpdate method geen wrapper rond die LockWindowUpdate ?

Volgens mij is BeginUpdate geen methode die bestaat binnen VB6... M'n MSDN Library kan 'em in ieder geval niet vinden.

[curry684]

whoami schreef op 10 augustus 2004 @ 16:22:
Is de BeginUpdate method geen wrapper rond die LockWindowUpdate ?

BeginUpdate ken ik alleen uit Delphi, en is een soort van reference-counting omhulsel eromheen ja.

[farlane]

Meen me te herinneren dat je ook een array als list voor een listbox mag gebruiken.

[whoami]

Je bedoeld als datasource voor data-binding?
In .NET kan je dat zeker doen, ik heb niet genoeg ervaring met VB6 (geen ), maar ik dacht dat het net één van de tekortkomingen was van de databinding in VB6 dat je enkel met recordsets ofzo kon binden?

Nuja: disclaimer: ik meen dat ik dat ergens gelezen had...

[Verwijderd]

whoami schreef op 10 augustus 2004 @ 16:16:
Ik vraag me trouwens af waarom je die array nodig hebt...
Als je per listitem extra info wilt bijhouden, kan je die ook kwijt in de Tag property oid van het ListItem.

Tag-property is toch per control en niet per listitem?

[Verwijderd]

farlane schreef op 10 augustus 2004 @ 16:53:
Meen me te herinneren dat je ook een array als list voor een listbox mag gebruiken.

Volgens mij kan dat pas vanaf VB.NET, dan heb je zoiets als de method AddRange. In VB6 kan het blijkbaar niet, omdat ik dan een Type Mismatch krijg.

De API helpt een hoop! Het gaat nu zeker 50% sneller, dus dat scheelt! Het programma blijft echter nog steeds hangen, echter een stuk minder lang. Ik vraag me af wat ik nog meer kan doen...

[Verwijderd]

Refresh kan, maar dan moet ik denk ik meerdere controls in die loop laten refreshen. Immers, Form1.Refresh helpt niet, omdat het Form opzich niet verandert, alleen enkele controls óp het form.

Refresh werkt dus niet, omdat de meeste controls deze method niet supporten. Deze optie valt daarmee dus af, helaas...

[Verwijderd]

Volgens mij is er niet echt een manier om dit met vb6 te doen zoals jij wilt. Je kunt proberen multithreading te doen http://www.elitevb.com/content/01,0008,01/ verder geen idee of het met vb6 dezelfde snelheid behoud.

[curry684]

Verwijderd schreef op 10 augustus 2004 @ 19:14:
Volgens mij is er niet echt een manier om dit met vb6 te doen zoals jij wilt. Je kunt proberen multithreading te doen http://www.elitevb.com/content/01,0008,01/ verder geen idee of het met vb6 dezelfde snelheid behoud.

Heb je het topic wel gelezen?

Afgezien van dat LockWindowUpdate wel degelijk de snelheid positief zal beinvloeden is het altijd nog gewoon mogelijk om handmatig GetMessage, TranslateMessage en DispatchMessage aan te gaan roepen om hiermee alleen de gewenste messages te flushen en daarmee er dus voor te zorgen dat bijvoorbeeld alleen paints, of ook mousemoves e.d. afgehandeld worden.

Het kan zeker, we hebben alleen ondertussen wel feedback nodig over in hoeverre de geboden oplossingen voldoen

[RobIII]

Ik zou eerder gaan voor een progressbar ofzo. Waarom?

• Je operatie duurt NU al lang... Dat zal in de toekomst waarschijnlijk langer worden naarmate er meer data in je app komt te zitten
• Je kunt gewoon "schaamteloos" je form laten blokkeren
• Gebruikers zien toch dat er iets gebeurt en wachten netjes af
• Methodes zoals Lighteye aandraagt (multithreading onder VB6 is an sich al ranzig, laat staan voor deze toepassing) of LockWindowUpdate (dit lost het niet structureel op) zijn natuurlijk ook niet echt gewenst...

Verder vraag ik me af waarom je uberhaupt zoveel items in een listbox wil hebben. Kun je dit niet in meerdere "sub" dingen opdelen ofzo, zodat de listbox niet zo zwaar belast wordt?

offtopic:
@ curry684

[ Voor 5% gewijzigd door RobIII op 10-08-2004 20:29 ]

[farlane]

Om te tunen zou je ook nog kunnen kijken of een SendMessage( ... , LB_ADDSTRING, ... ) het verhaal ietsje sneller maakt.

[offtopic]
Plotseling schiet me weer te binnen waarom ik VB eigenlijk niet wil gebruiken voor dingen anders dan wat db tooltjes / mooie schermpjes.

[Lorn]

Net een soort gelijke situatie mee gemaakt in een stuk code van een collega van me. Duurt erg lang om +/- 3500 records in een vsFlexGrid te plaatsen. Het proces ging een heel stuk sneller (denk aan een factor 10) nadat ik een kleine aanpassing had gedaan.

In plaats van per record het aantal rows in de grid ophogen heb ik aan het begin van de routine in een keer de Rows ingesteld op het aantal records. Hiervoor was wel een extra SQL-query nodig om de recordcount op te halen. Het resultaat is echter wel dat de grid binnen een korte tijd volstaat. Dit gekoppeld met de LockWindowUpdate en een progressbar maakt geheel er strak uitzien.

[Kuhlie]

*De* oplossing is om voordat je gaat toevoegen listbox.visible = False en direct erna listbox.visible = true. Op mijn Pentium 200 gaat in een loopje 3000 items toevoegen dan zelfs binnen een tiende seconde. Als je geen Doevents in je loopje zet zal je form niet geredrawed worden, de gebruiker ziet daardoor niet dat de listbox verdwijnt (*omdat* 'ie domweg niet verdwijnt ).

Ik denk trouwens dat je toch eens naar de rest van de code in je loopje moet kijken, zonder dat visible-gedoe duurt het op deze ouwe computer ook maar 2 seconden... Ik denk dus dat het niet alleen aan de listbox ligt.

Daarom: heb je DataAudioDescription en DataAudioDescription als String-Array gedeclareerd? En Desc als String? Zo nee, waarom niet?

[whoami]

Mensen met .NET kunnen hier eens naar kijken:

code:

ArrayList           listItems = new ArrayList();
ListViewItem        li;
            
for( int i = 0; i < 30000; i++ )
{
    li = new ListViewItem(i.ToString());
    listItems.Add (li);
}
            
System.Diagnostics.Debug.WriteLine (System.DateTime.Now.ToString ("u"));
            
listView1.BeginUpdate();
listView1.Items.AddRange ((ListViewItem[])listItems.ToArray(typeof(ListViewItem)));
listView1.EndUpdate();
            
System.Diagnostics.Debug.WriteLine (System.DateTime.Now.ToString ("u"));

Ik denk dat dit de snelste manier is in .NET.

[ Voor 9% gewijzigd door whoami op 17-08-2004 22:01 ]

[Devion]

code:

For a = 0 To File1.ListCount - 1
    DataAudioDescription(a) = Left(File1.List(a), Len(File1.List(a)) - 4)
    List1.AddItem DataAudioDescription(a)
    DataAudioFile(a) = File1.Path & "\" & File1.List(a)
Next a

Dit zal idd wel werken maar zal geen snelle code zijn iig..

Paar dingetjes:

Arrays zijn sneller als objecten.. maw: File1.path, File1.list etc. Probeer die in array strings te zetten voordat je begint.

Next a is langzamer als Next zonder a.

zorg dat alles gedeclareerd is, Variants zijn extreem langzaam. Snelste in VB6 is long omdat deze 32 bit.

Geen collections gebruiken..

Om 't allemaal wat duidelijker te maken

code:

Type T_FILE
         Filename as string * 40
         Description as string * 255
         Path as string * 100
end type

dim Files() as T_FILE ' Type met al je info, Ik ga er vanuit dat hij gevuld is
dim intCount as long 

For intCount = 0 To Ubound(Files)
    List1.AddItem Files(intCount).Filename & " " & Files(intCount).description
Next ' intCount

Dit zal iig snel genoeg zijn om 35000 records (samen met LockWindowUpdate) in +/- 2.5 secs te doen =)

[whoami]

Devion schreef op 18 augustus 2004 @ 10:13:
Dit zal iig snel genoeg zijn om 35000 records (samen met LockWindowUpdate) in +/- 2.5 secs te doen =)

Dat zal een beetje afhangen van PC tot PC.
De code die ik hiervoor gepost heb, laadt 30.000 items in een listview in in ongeveer 0.5 seconden op een PIV 2.8

[Devion]

Natuurlijk ligt het ook aan de pc..
een 8086 zal er nog iets langer over doen

[Wiebbe]

en vergeet niet dat in de VB.Net code Beginupdate word aangeroepen dat (naar eerdere berichten) een Api call was naar LockWindowUpdate.

terwijl de code van Devion vb 6.0, en niet de api aanroept

kleine details, maar wel van belang voor de ts.

[whoami]

Wiebbe schreef op 19 augustus 2004 @ 00:46:
en vergeet niet dat in de VB.Net code Beginupdate word aangeroepen dat (naar eerdere berichten) een Api call was naar LockWindowUpdate.

terwijl de code van Devion vb 6.0, en niet de api aanroept

Euh, die BeginUpdate is misschien wel een wrapper rond die API call. Hoe ga jij voor Windows programmeren zonder dat er ooit ergens (ook 'under de hood') een Windows API call gebeurt?

[Devion]

Waarom zou je een wrapper gebruiken als je de API zelf zo kan aanspreken? Redundant code maakt het alleen maar langzamer.

[Wiebbe]

whoami schreef op 19 augustus 2004 @ 08:29:
[...]


Euh, die BeginUpdate is misschien wel een wrapper rond die API call. Hoe ga jij voor Windows programmeren zonder dat er ooit ergens (ook 'under de hood') een Windows API call gebeurt?

dat was mijn punt niet, ik wil niet zeggen dat de api aanroepen een slecht punt is ofzo..

maar als die vb 6.0 code als zo snel is als hij zegt zonder de lockwindowsupdate, en de VB.NET code ook zo snel maar MET de beginupdate zal het misschien verschil uitmaken in uitvoer snelheid ?

[Devion]

Lockwindowupdate of beginupdate is alleen maar nuttig op het moment dat je veel items toevoegd omdat bij elke toevoeging een WM_PAINT wordt verstuurd. Opzich niet erg maar WM_PAINT acties duren steeds langer naarmate er meer items inkomen.

Voor kleine toevoegingen zul je dus niks merken van de 'performance winst'.

Semi off-topic:

De redundant code trouwens is gewoon omdat je meerdere functies aanroept. Opzich als deze buiten de loop vallen zal er niks aan de hand zijn maar daarbinnen kan het een aardige snelheid-hit opleveren. Zelfde geldt trouwens voor . <- puntjes (Object.objecttype.objectvar = object.objectype.objectvar2 is langzamer als hetzelfde maar dan met With object.objecttype)

[Lustucru]

farlane schreef op 10 augustus 2004 @ 16:53:
Meen me te herinneren dat je ook een array als list voor een listbox mag gebruiken.

De listbox uit msforms kan dat. In vb6 op een pIII 700 een array vullen met 30.000 items en toewijzen aan de listbox met List1.list=aLijst in 0,3 sec.

Verwijderd schreef op 10 augustus 2004 @ 17:52:
[...]

Volgens mij kan dat pas vanaf VB.NET, dan heb je zoiets als de method AddRange. In VB6 kan het blijkbaar niet, omdat ik dan een Type Mismatch krijg.

Dat heeft dus meer te maken met het component dat je gebruikt dan met vb6.

[d00d]

Ben misschien een beetje laat maar er is in VB nog een kleine performance winst mogelijk door gebruik te maken van het 'with' statement, dus:

code:

With File1
For a = 0 To .ListCount - 1
    Desc = Mid(.List(a), 1, Len(.List(a)) - 4)
    List1.AddItem Desc
    DataAudioDescription(a) = Desc
    DataAudioFile(a) = .Path & "\" & .List(a)
Next a
End With

Ik heb geen VB dus ik kan het niet testen, maar volgens mij moet het hiermee iets sneller gaan.

[farlane]

Devion schreef op 19 augustus 2004 @ 10:28:
Waarom zou je een wrapper gebruiken als je de API zelf zo kan aanspreken? Redundant code maakt het alleen maar langzamer.

Hum, das hetzelfde als vragen waarom je VB gebruikt, en niet C.

[farlane]

Niesje schreef op 19 augustus 2004 @ 13:42:
De listbox uit msforms kan dat. In vb6 op een pIII 700 een array vullen met 30.000 items en toewijzen aan de listbox met List1.list=aLijst in 0,3 sec.

Ah, ik wist dat ik er al eens gebruik van had gemaakt in VB.

[Sponge]

Ga zeker LockWindowUpdate gebruiken!

Verder:
- a is een long?
- string functies, altijd een $ gebruiken. Mid$ dus. (check m'n sig/vbfibre om te zien waarom)
- .List(a) doe je 3x. Dit is 3x een array lookup. Gebruik een tijdelijke string variabele.
- Als path hetzelfde is elke keer, cache die dan ook met de "\" er al bij...
- Gebruik listcount 1x

code:

Dim strTemp as String
Dim a as long
Dim lngCount as long

With File1
lngCount = .Listcount -1
For a = 0 To lngCount
    strTemp = .List(a)
    Desc = Mid$(strTemp, 1, Len(strTemp) - 4)
    List1.AddItem Desc
    DataAudioDescription(a) = Desc
    DataAudioFile(a) = .Path & "\" & strTemp
    Next a
End With

[ Voor 20% gewijzigd door Sponge op 19-08-2004 21:59 ]