[design] Voortgang van een methode monitoren (progressbar)

[PostbodeSiemen]

Ik hoop dat de titel een beetje de lading dekt, maar hier gaan we.

Programma is in Delphi maar dat maakt verder niet uit.

Ik heb een main class waaruit ik verschillende classes aanmaak waarop ik vervolgens methoden aanroep. Nu wil ik graag een progresbar hebben om de voortgang van bepaalde methoden in de gaten te houden. Ik vraag me alleen af hoe dit te doen.

Bij de classes/methoden die ik wil monitoren gaat het meestal om een for loop o.i.d. en daar kan ik dus makkelijk de voortgang van berekenen.
Het 'probleem' is dat de voortgang in het Model wordt gemeten (Model als in MVC) en ik uiteraard de voortgang gewoon in de view wil weergeven.

Met mijn kleine kennis van design (patterns) denk ik dat een observer/observable hier wel op zijn plaats is.

Het nare is dat ik aan de class welke ik wil monitoren ook al een observer heb gehangen welke gebruikt wordt om logberichten te verwerken.

Is het 'normaal' om, als je meerdere onderdelen van een class in de gaten wilt houden er meerdere observer en observer soorten aan hangt of wordt dit meestal in één stuk gedaan.

Ik hoop dat het probleem een beetje duidelijk overkomt.

[PostbodeSiemen]

FF dit (hopelijk wat duidelijker)

In het code blok zien we een observer interface met twee implementaties daarvan. Eén wordt gebruikt om wat gegevens uit de classes naar een log te schrijven, de andere om de voortgang te bewaken.
In de code onder de classes kun je zien wat ik min of meer in gedachten heb.

In de mainClass maak ik twee observers aan die de berichten van de observables verwerken. Deze hang ik aan de testClass waarna ik daarop de methode doIt() aanroep. In de doIt() methode wordt twee keer de notify methode aangeroepen, één keer voor de logObserver en één keer voor de progressObserver.

Moet ik nu in de notify methode van de observable er voor zorgen dat alleen de update van de observers wordt aangeroepen waarvoor dat nodig is ( maar daar wordt de observable zo lomp van en niet makkelijk uitbreidbaar) .
Of laat ik de update van alle observers aanroepen? Dan zit ik echter met het probleem dat , in dit geval, de logObserver veel te vaak wordt aangeroepen, en ik moet daarin dan gaan kijken of de update wel voor hem bedoeld was. Al met al brengt dat ook een hoop extra code mee.

code:

                |----------------|               
                | << observer >> |      
                |----------------|      
                | update()       |      
                |                |      
                |                |      
                |----------------|      
                       
|-----------------|          |-----------------------| 
|   logObserver   |          |   progressObserver    | 
|-----------------|          |-----------------------| 
|  update()       |          |   update()            |
|  writelog()     |          |   drawProgressBar()   | 
|                 |          |                       | 
|-----------------|          |-----------------------| 


                |------------------| 
                | <<observable>>   | 
                |------------------| 
                | attachObserver() | 
                | detachObserver() | 
                | notify()         | 
                |------------------| 
                
class mainClass 
{
   myProgressObserver = new progressObserver();
   myLogObserver      = new logObserver();  
   
   test = new testClass();
   test.attachObserver( myProgressObserver );
   test.attachObserver( myLogObserver );
   
   test.doIt();
}

class testClass implements observable
{
   doIt()
   {
    int progression = 0;
    while (progression < 100)
    {
       ...doe iets...; 
       setLogMessage('blaat');
       notify();
       
       ...doe iets meer...; 
       progression++;
       notify();
    }   
   }
}

[Sircuri]

Ik snap niet helemaal wat je aan het doen bent, maar 1 ding kan ik wel zeggen. Je kan beter 1 Observer en 1x notify aanroepen. Vervolgens in de update() methode controleren voor welk event deze notify bedoeld is.

Verder moet je ook heel erg opletten hoeveel actie je onderneemt in die update() method. Aangezien je elke keer dat je door die loop gaat een keer die notify aanroept. Dat vertraagt het programma enorm.

[Crazy D]

Sircuri schreef op 13 augustus 2002 @ 14:51:
Verder moet je ook heel erg opletten hoeveel actie je onderneemt in die update() method. Aangezien je elke keer dat je door die loop gaat een keer die notify aanroept. Dat vertraagt het programma enorm.

Uit ervaring kan ik zeggen dat veel gebruikers liever een progressbar die erg goed meeloopt ook al vertraagt het de boel relatief veel. Het "lijkt" sneller te gaan en dus is het "beter"