Newsgroup: it.comp.lang.visual-basic
Titolo: Terminare un programma

Salve, perche se l'istruzione END non mi termina il programma in tutte le condizioni e casi possibili?
Io voglio che il programma vengo chiuso, qualunque cosa stia esso facendo e che non mi rimanga niente in memoria che devo andare a togliere con il TERMINA APPLICAZIONE dopo aver fatto Control Alt Canc.
Mi potete aiutare?
Gianni Moretti
--
TiscaliNet, libero accesso ad Internet.
http://www.tiscalinet.it
-- 
Posted from 
laguna.tiscalinet.it
 [195.130.224.86] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Salve, perche se l'istruzione END non mi termina il programma in tutte le condizioni e casi possibili?
Io voglio che il programma vengo chiuso, qualunque cosa stia esso facendo e che non mi rimanga niente in memoria che devo andare a togliere con il TERMINA APPLICAZIONE dopo aver fatto Control Alt Canc.
Mi potete aiutare?
Gianni Moretti
--
TiscaliNet, libero accesso ad Internet.
http://www.tiscalinet.it
-- 
Posted from 
twingo.tiscalinet.it
 [195.130.224.85] 


 Posted from 
laguna.tiscalinet.it
 [195.130.224.86]


 Io voglio che il programma vengo chiuso, qualunque cosa stia esso facendo
e che non mi rimanga niente in memoria che devo andare a togliere con il
TERMINA APPLICAZIONE dopo aver fatto Control Alt Canc.
Due concetti semplici semplici ma un po' difficili da mettere in pratica:
 1. mai usare l'istruzione "End";
 2. il programma lo scrivi tu e la responsabilita` di come si chiuda e` e
deve essere tua.
Se vuoi ne possiamo discutere.
--
Ciao.
Maurizio
--------
?SPQR(C)
 X
--------

Dopo aver inizializzato le classi e scaricato tutte le form fai così:
ExitProcess GetExitCodeProcess(GetCurrentProcess, 0)
dove ExitProcess, GetExitCodeProcess e GetCurrentProcess sono API, la cui
dichiarazione la trovi con l'API viewer.
In questo modo sei SICURO di "uccidere" il processo, comunque.
Byez!

> In questo modo sei SICURO di "uccidere" il processo, comunque.
Non sei sicuro neanche cosě. Esistono processi rientranti.
L'unico modo č tenere sotto controllo le classi utilizzate (ed in
uso), i processi esterni attivati (ed in pending tipo subclassing,
OCX, dll...), scaricarli ed interromperli tutti e QUINDI dare un END.
Checché ne dica Maurizio Borrelli si fa cosě.
---
GbC
http://gbc.homeip.net
---

 Checché ne dica Maurizio Borrelli si fa così.
Devo aver sbagliato a leggere la guida o devono aver sbagliato quelli che
l'hanno scritta:
"End
Interrompe l'esecuzione immediatamente. È sempre facoltativa..."
Cosa che, per me, vuol dire: non e` *mai* necessaria.
"... ma può essere inclusa in un punto qualsiasi di una routine per
interrompere l'esecuzione del codice, chiudere i file aperti con
l'istruzione Open e annullare le variabili.
[...]
Nota   L'istruzione End interrompe l'esecuzione del codice immediatamente
senza richiamare gli eventi Unload, QueryUnload o Terminate o altro codice
Visual Basic. Il codice eventualmente inserito negli eventi Unload,
QueryUnload e Terminate di form e moduli di classe non viene eseguito. Gli
oggetti creati dai moduli di classe vengono eliminati, i file aperti con
l'istruzione Open vengono chiusi e la memoria utilizzata dal programma viene
liberata. I riferimenti agli oggetti eventualmente attivati da altri
programmi vengono annullati.
L'istruzione End rappresenta un metodo per forzare l'interruzione del
programma. ..."
*Forzare*! Quindi non per terminarlo *normalmente*... E, secondo te, quando
si ha necessita` di tale forzatura?
"... Per interrompere normalmente un programma Visual Basic, è necessario
scaricare tutti i form. Il programma verrà chiuso quando non vi sono altri
programmi con riferimenti attivi agli oggetti creati da moduli di classe
pubblici del programma e quando non vi è più codice in esecuzione."


Ciao,
l'affermazione di GbC, per altro validissima, permette di individuare un
elemento fondamentale
della programmazione : la "pulizia del codice". Non è corretto, infatti,
creare istanze di oggetti
siano essi OCX o ActiveX, senza definire con esattezza il loro ambito
operativo e il punto in cui
essi verranno "distrutti" al terminare dell'applicazione. In accordo con un
mio precedente post
sullo stesso argomento, un buon programma deve avere un metodo di chiusura
centralizzato. In
questo punto si "uccidono" i processi ancora pendenti, rilasciandone le
risorse impiegate.
Questa attività "pulita" del codice predispone al corretto e fondamentale
utilizzo dell' istruzione
END.
A riguardo MSDN riporta quanto segue circa l'uso, corretto e valido,
dell'istruzione END
Remarks
When executed, the End statement resets all module-level variables and all
static local
variables in all modules. To preserve the value of these variables, use the
Stop statement
instead. You can then resume execution while preserving the value of those
variables.
Note   The End statement stops code execution abruptly, without invoking the
Unload,
QueryUnload, or Terminate event, or any other Visual Basic code. Code you
have placed in the
Unload, QueryUnload, and Terminate events of forms and class modules is not
executed.
Objects created from class modules are destroyed, files opened using the
Open statement
are closed, and memory used by your program is freed. Object references held
by other
programs are invalidated.
The End statement provides a way to force your program to halt.
For normal termination of a Visual Basic program, you should unload all
forms.
Your program closes as soon as there are no other programs holding
references to objects
created from your public class modules and no code executing.
Ciao, Vito
-- 
Posted from 
smtp5.libero.it
 [193.70.192.55] 


Maurizio, so bene cosa c'è scritto nella guida.
Ho iniziato ad usare VB dalla versione 2, ed ho maturato una certa
esperienza.
Programmo professionalmente (è il mio lavoro) ed uso anche altri
linguaggi.
Per quanto mi riguarda, mi comporto così:
- In ogni mio programma c'è un form 'master', da cui (generalmente)
parte ogni processo; è questo il form che si occupa anche della
chiusura del programma, attraverso il suo evento unload.
- Faccio uso di flag globali per controllare l'uso di processi esterni
che attivo in ragione delle mie esigenze (classi, ocx ed altro).
- Se all'evento unload alcuni processi sono attivi, cerco di chiuderli
(utilizzando i metodi già citati).
Pur con tutto questo, ho notato che alcuni task che un prg apre non si
chiudono se non con una istruzione end. Ad esempio chiamate a dll che
operano in background, utilizzo di funzioni eseguite con rundll ed
altro. Ed ho notato che l'unico modo per non lasciare 'appese' queste
funzioni è l'end.
Posso immaginare che siano state scritte in modo non corretto, ma
tanto è...
L'esperienza mi ha portato ad evitare approcci 'pragmatici' con la
programmazione. Seguire pedissequamente la guida ed i manuali (per
quanto indispensabile) spesso non porta ai risultati desiderati,
perché alle volte vengono omesse alcune cose (magari si perdono nei
meandri delle traduzioni o semplicemente nei dischi di chi scrive le
guide), o l'ambiente utilizzato non è esattamente quello, oppure non
si possiede tutta la documentazione delle funzioni esterne cui si fa
riferimento.
E siccome problemi nella chiusura dei programmi ne ho avuti (come
tutti, immagino), ho semplicemente riportato quello che la mia
esperienza mi porta a fare.
Non voglio essere polemico o altro.
Non mi reputo migliore di altri.
Non ne so ne più ne meno di tanti altri.
Ma dopo aver fatto tutto per chiudere quello che ho usato e aperto,
aggiungo una riga con end.
---
GbC
http://gbc.homeip.net
---
end :)

 Your program closes as soon as there are no other programs holding
references to objects created from your public class modules and no code
executing.
Non mi sembra il caso di ignorare quanto precede nella stessa pagina:
"End Terminates execution immediately. Never required by itself but may be
placed anywhere in a procedure to end code execution, close files opened
with the Open statement and to clear variables."
Continuo a non capire la necessita` di *forzare* la chiusura del programma
quando e` possibile portarlo ad una conclusione *normale*, come appunto dice
proprio il passo da te citato.


Personalmente tengo sotto controllo le classi, scarico i form, ci metto una
bella ExitProcess e dulcis in fundo anche un End. Altro non so proprio...8)
Byez!

Concordo pienamente con Maurizio:
MAI, ripeto MAI dare un end.
Cosě tra parentesi c'č purescritto sull'help di Vb, proprio questa dizione:
"MAI chiudere con End"
Personalmente chiudo con una routine tipo, per esempio:
Function CloseAll()
    Dim frm As Form
    ' Chiusura dei Form
    For Each frm In Forms
        If frm.Name <> "MDIfrmMain" Then
            Unload frm
        End If
        Set frm = Nothing
    Next frm
    ' Chiusura delle Connection Ado
    With Diritti
        If .State = adStateOpen Then
            .Close
        End If
    End With
    Set Diritti = Nothing
    With conQualita
        .Close
        Set conQualita = Nothing
    End With
    With conCollaudi
        .Close
        Set conCollaudi = Nothing
    End With
    ' Chiusura delle Classi personlizzate
    Set psPrintsys = Nothing
    Set dgDataGes = Nothing
    ' Savataggio dei settaggi
    ' (Parametri connectio Ado e nome ultimo login utente)
    SaveSettaggi
    ' Chiusura del form principale Mdi
    Unload MdiFrmMain
    Set MdiFrmMain=nothing
End Function
ciao
ugo

 MAI, ripeto MAI dare un end.
never say never again...
- james bound

 End Function
Anch'io prediligo questo metodo, ma se il programma inizia
con la sub Main che si fa?
dopo quelle robine li' io un end glielo metterei
--
Fibia "Sakamoto" FBI
URL: 
www.geocities.com/fibiafbi
E-Mail: 
fibi...@hotmail.com
ICQ UIN 63586057
Membro #25 delle BT Sez. Sud

Ciao, Maurizio
ti rispondo un pò un ritardo. Scusami.
Non mi riferisco solo a controlli od oggetti ActiveX ma anche a
processi asincroni, come ad esempio ricezione di messaggi da
Host o da Servers remoti.
Per ambito operativo intendo :
    Ho creato un'istanza di un oggetto con eventi (Es : Private WithEvents
mWidget As Widget  - tanto per ditare mamma MSDN)
    Quando devo chiudere l'applicazione mi devo ricordare di "distruggere"
l'istanza di mWidget .
    Questo lo faccio, è vero, nella Unload del form che ospita la creazione
di mWidget. Ma non è corretto affidare all'unica istruzione
    Unload FormToUnload questa attività.
    In tutte le mie applicazioni NELLA  FormToUnload_Unload(Cancel As
Integer), a fronte di  un oggetto creato con
            Private WithEvents mWidget As Widget
    inserisco una :
            Set mWidget  = Nothing
Sulla definizione fondamentale, centra molto la rigorosità dei termini. Non
tutte le Unload chiudono l' applicazione, solo l'ultima e solo
quella relativa al form principale. Tutte le istruzioni End chiudono
l'applicazione. La chiusura dell'applicazione con l'iltima Unload possiamo
definirla effetto collaterale. Per cui, a rigor di termini utilizzo Unload e
Set ... Nothing per rilasciare, nell'ambito operativo
della mia applicazione le istanze degli oggetti (in generale) e le risorse
da essi utilizzate e utilizzo la End per terminare l'applicazione.
In un solo punto, centralizzato.
Nel mio post precedente, infatti, avevo affermato la validità dell'utilizzo
di  Unload e Set ... Nothing, ma, ripeto, sono per l'uso canonico
dell'istruzione End.


Cari GbC e Perrotta Vito,
scusate se non continuo il discorso ma non ho tanta voglia di impelagarmi in
una discussione sul sesso degli angeli. D'altra parte vi vedo felici e
soddisfatti del vostro modo di procedere e una buona discussione non puo'
iniziare se i partecipanti non sono disponibili a cambiare idea al termine.
Almeno cosi` la vedo io.
