Newsgroup: it.comp.lang.visual-basic
Titolo: VB6 - Operazioni in cascata da stoppare





Ciao a tutti.


Vi leggo spesso (a dir la verità quando il lavoro 
lo permette) ed oggi 


vi devo chiedere un piccolo aiuto. 


 


Ho realizzato una piccola macro da excel che 
riduce drasticamente un Db di access 


in termini di spazio du disco per poterli far 
scaricare da web ad alcuni clienti che purtroppo 


non possono utilizzare client ftp. 


In sostanza esporto 2 tabelle significative in 2 
banali files di testo. 


Compatto il Db originale. 


Killo il vecchio Db.


Zippo i 2 files di testo in zip con il filesystem. 



Killo i 2 files di testo. 


 


Problema: tra un'operazione e l'altra, il pc non è 
così veloce da compiere 


l'operazione precedente. 


Qualcuno sa compe potrei ovviare a questa cosa? 



 


Ex codice (i riferimenti sono di un foglio 
"opzioni" che utilizzo a mio piacimento per cambiare i vari 
settaggi):


 


  DBEngine.CompactDatabase 
(Sheets(1).Range("path") & "\" & Sheets(1).Range("db")), 
(Sheets(1).Range("path") & "\New" & Sheets(1).Range("db"))
  

  Kill (Sheets(1).Range("path") & "\" & 
Sheets(1).Range("db"))
  
  FileCopy (Sheets(1).Range("path") 
& "\New" & Sheets(1).Range("db")), (Sheets(1).Range("path") & "\" 
& Sheets(1).Range("db"))
  
  Call ZippaFile
  

  For X = 0 To 1
    Kill 
Replace(Sheets(1).Range("path") & "\" & NomiFiles(X), ".zip", 
".txt")
  Next


 


Un grazie a tutti coloro che mi 
aiuteranno.


Saluti. 


Marco.



 l'operazione precedente.
Cosa vuol dire? Ti da qualche errore?
-- 
Greg 

 ha scritto nel messaggio 
news:g8hjbg$9kv$1...@tdi.cu.mi.it...

Nel senso che non fa in tempo a finire un'azione che subito parte l'altra.
Non ci sono pause e quindi a seconda delle performance del pc mentre 
compatta cerca di cancellare, zippare e va tutto insieme.
Capito dove sta il problema? Mi servirebbe una sorta di pausa tra una cosa e 
l'altra. 

 cosa e l'altra.
Per questo c'č l'api sleep per inserire pause, oppure a seconda dei casi il 
do events ma non mi sembra sia questo il caso.
Non mi hai ancora detto se "fa tutto insieme" ma lo fa e bene, oppure se ti 
da qualche errore, oppu si inchioda qualcosa.
-- 
Greg 

 ha finito la vecchia.
Hmmm... non è detto, per quanto la cosa possa sembrare impossibile.
Ricordo di aver avuto un problema analogo: stavo sviluppando un plugin 
che doveva lanciare in sequenza vari programmi che scaricavano dati 
(nella fattispecie timbrature di dipendenti), per poi lanciare 
un'importazione (in realtà una cosa un po' più complessa).
Ogni programma era fatto per essere eseguito, scaricare quello che c'era 
da scaricare e poi uscire.
Il primo in lista veniva lanciato correttamente, ma non faceva in tempo 
a finire il lavoro che subito veniva fatto partire l'altro.
Oltretutto, ad un certo punto partiva anche il processo di importazione 
(prima che il processo di scaricamento fosse terminato, o comunque prima 
che l'ultimo programma avesse finito di fare il suo lavoro) e scoppiava 
il casino.
Eppure, mettendosi in debug e lanciando un programma alla volta, tutto 
funzionava a meraviglia.
Mi ricordo di aver tentato anche una soluzione che contemplava il 
ciclare tutti gli handle disponibili e vedere se una finestra con un 
dato titolo fosse presente prima di mandare in esecuzione il prossimo 
programma: anche questo, in debug funzionava, nel compilato no.
-- 
S.

Non ho capito bene, la butto li.
Probabilmente fa dei lanci "Shell", passando il controllo esternamente al 
programma principale e quindi non riesce a capire quando è finita una 
operazione per cominciarne un'altra.
Se è così suggerisco ShellModal, ovvero blocchi il programma finchè non 
viene rilasciato il processo che hai lanciato.
In rete trovi diverse implementazioni, forse anche nel sito comune. 

 Hmmm... non è detto, per quanto la cosa possa sembrare impossibile.
http://www.google.it/search?q=visual+basic+shellandwait&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:it:official&client=firefox-a
ciao, a.


La stessa cosa succede anche a me. :(
Passo passo tuto ok. F5  messaggi d'errore a non finire.

 In rete trovi diverse implementazioni, forse anche nel sito comune.
Adesso ci lancio un'occhiata. Grazie! 

 ciao, a.
andrea, ma funziona anche con compattazioni di db via dao, filecopy etc etc? 


Azz, questo a suo tempo mi era sfuggito!
Grazie Andrea.
-- 
S.

 ha scritto

mai provato, ma in effetti a naso direi di no. shell -> prog esterno.
a meno, altrettanto a naso, che tu non crei una serie di tuoi exe esterni 
che fanno ognuno una specifica cosa, e li lanci uno dopo l'altro, ma mi 
sembra un po' macchinoso.
piu' che altro, quando pensi ai dischi, ci sono sempre coe un po' strane.
p.e. quando con explorer copi un file, se non sbaglio (o sara' vista, ormai 
mi ci sono abituato :P), spesso explorer sta li' appeso 1/2" - 1" dopo che 
ha gia' finito.
per cui se fai filecopy a>b, poi filecopy b>c, magari il vb pensa di essere 
ok mentre windows sta ancora effettuando il commit di b.
oppure, se provi a copiare un file di 100 mb su due usb, di seguito. il 
primo sta un po' li' perche' lo legge, il secondo quasi sempre e' in cache e 
ci mette /n di meno...
ma francamente processi all'interno di un mio programma che venissero 
eseguiti quando quelli prima ancora andavano, non mi sembra mi sia capitato. 
mai rovao il multithread in vb6, li' non ti so proprio dire.
ho riguardato il tuo primo messaggio: cosa succede esattamente ?
ciao, a.

 ciao, a.
Andrea, ho provato a dare un'occhiata al shell&wait e similari, ma son tutti 
per shell che
io purtroppo non uso perchè non lancio applicazioni esterne, ma in cascata 
in macro
Ho adottato questo sistema perchè lo ritenevo semplice e molto manipolabile, 
ma purtroppo
mi si sta ritorcendo contro.
Esattamente al lancio della macro, apro un db esterno e salvo in 2 txt 
separati in modo sequenziale 2 tabelle
(mi pare una milionata di record ciascuna) e fin lì nessun problema perchè 
looppo tutto perchè ho bisogno di un
controllo per vedere se ci sono campi null, quindi non si inchioda nulla.
I problemi sorgono ora.
Devo ridurre il file mdb compattandolo ed uso il dbengine, peccato che 
questi non è come access che mi elimina il temporaneo
e quindi subito dopo il compact lancio un kill del file che si è creato per 
ridurre lo spazio del file.
Il processo del compatta e ripristina sembra essere del tutto scollegato 
dall'istruzione successiva del kill.
Il dbengine lancia il compact e pochi secondi dopo il kill cerca già di 
eliminarlo andando sistematicamente in errore.
Subito dopo dovrei zippare i 2 txt. Lì nessun problema anche se ne lancio 20 
in contemporanea.
Il problema è che nella cartella i txt devono sparire e la kill del txt è 
notevolmente più veloce della compressione dei dati.
Passo a passo via di F8 non me n'ero nemmeno accorto di tutto ciò, non ti 
dico la mia faccia quando ho lanciato tutto a ripetizione
Ora non mi taglio le vene. Se esiste una sorta di sleep che mi permette di 
mantenere il codice così com'è bene, altrimenti spacchetterò in altre
sub nello stesso progetto o creerò un batch a steps con conferma delle 
operazioni o qualcos'altro...
La consolazione è che la routine opposta invece (ricomposizione del db) 
viaggia una meraviglia perche scompatta e non cancella nulla. =)
Se a qualcuno dovesse venir in mente qualcos'altro, ben accetto, altrimenti 
amen.
Buona notte a tutti e grazie fin'ora.
Marco.

 ha scritto

dunque, se cerchi la riga seguente in g
    Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
trovi un po' di spunti
quanto al resto, mamma quanta roba -- calma !
il compact lo uso regolarmente da anni, mai avuto problemi, salvo una volta 
volta che ho stupidamente seccato l'exe da taskman.
questo e' dao, ma se vuoi devo avere anche esempi ado.
nb1 - il db lo chiudo all'inizio e riapro alla fine, e scarico i form che 
possono avere un controllo data.
nb2 - io il db vecchio lo tengo comunque...
Public Sub DbPack()
    On Error Resume Next
    Dim time1: time1 = Timer
    If MsgBox("COMPATTARE IL DATABASE?", vbYesNoCancel) <> vbYes Then Exit 
Sub
    Dim f As Form
    For Each f In Forms
        If f.MDIChild Then Unload f
    Next
    mainDb.Close
    Screen.MousePointer = 11
    DBEngine.CompactDatabase mainPath & "my.mdb", mainPath & "mynew.mdb"
    Beep
    Kill mainPath & "myold.mdb"
    Name mainPath & "my.mdb" As mainPath & "myold.mdb"
    Name mainPath & "mynew.mdb" As mainPath & "my.mdb"
    MsgBox ("Backup OK: " & vbCrLf & _
        mainPath & "my.mdb" & " -- " & _
            Format(FileLen(mainPath & "my.mdb"), "###,###,###,###") & vbCrLf 
& _
        mainPath & "myold.mdb" & " -- " & _
            Format(FileLen(mainPath & "myold.mdb"), "###,###,###,###") & 
vbCrLf & _
        Format(Timer - time1, "###,##0.##"))
    Screen.MousePointer = 0
    Set mainDb = OpenDatabase("my.mdb")
'ErrMan:
'     MsgBox Error & Error & " (" & Err & ")"
End Sub
sul resume next magari vacci cauto.
quanto al kill, un'altra routine dello stesso prog da me importa nel db 
tutti i txt di una dir, poi li elimina. anche qui mai avuto problemi. se ho 
capito, prova magari a mettere un flag
dim bZipOk as boolean
...
compact
bzipok = true
if bzipok then
    zip
else
    msgbox "comincia troppo presto"
endif
e vedi che succede
ciao, a.


Ciao Andrea,
grazie mille per la disponibilità. Ho trovato diciamo l'errore. E' una 
maledetta kill.
La tolgo al momento.
Ho deciso di mettere un timer con un file exist per vedere che tutto sia 
stato fatto
per poi passare alla pulizia della cartella. Almeno non mi faccio troppo 
male =)
Buona giornata a tutti e grazie!