Per creare un'applicazione è necessario eseguire tre passaggi fondamentali:

• Creare l'interfaccia utente aggiungendo ad un form i controlli desiderati, quali ad esempio caselle di testo e pulsanti di comando. Il form è una finestra che costituisce l’interfaccia della nostra applicazione. È possibile disegnare fino a 254 controlli in ogni form per creare un’applicazione che risponda pienamente alle nostre esigenze.

• Impostare le proprietà del form e dei controlli per definire gli attributi con il comando Visualizza/Proprietà F4; per esempio, il titolo con la proprietà Form1.Caption si può modificare in "Prima applicazione"; si possono decidere anche i colori di foreground , di background, il colore e le dimensioni. Le proprietà sono impostate mediante la Finestra Proprietà (visualizza la classe ed un elenco delle impostazioni delle proprietà relative al form o al controllo selezionato).

• Scrivere il codice per fornire la risposta agli eventi (il clic su un pulsante, l'apertura di un form o la digitazione in un campo) che si verificano nell’interfaccia, consentendo in questo modo l’interazione tra l’applicazione e l’utente.

• Si esegue l’applicazione tramite il menu Esegui/Avvia F5, si interrompe con Esegui/Fine.

• Salvare l’applicazione con File/Salva progetto.

Un’applicazione è un vero e proprio file .EXE, File/Crea file EXE... si salva come eseguibile, ma per funzionare correttamente nel sistema operativo Windows occorre la libreria a collegamento dinamico (VB40032.DLL) e gli OCX caricati nella directory windows\system. Nella finestra di dialogo Opzioni EXE è possibile specificare il numero di versione, il titolo e l’icona e numerose informazioni specifiche (Commenti, Copyright, Descrizione del file, Marchi registrati, Nome prodotto, Nome società) del progetto.

È possibile utilizzare la compilazione condizionale. Per esempio, per creare un codice di base comune per piattaforme diverse oppure per distribuire un’applicazione in più lingue.

#End If

Costruiamo la "Seconda applicazione", disegnare il form seguente:

• inserire una TextBox (casella di testo);

• inserire un CommandButton (pulsante di comando).

Quando si fa clic sul pulsante si deve visualizzare nella casella di testo "Hello, World". Bisogna, quindi, collegare il codice all’evento appropriato, per fare questo occorre:

Oggetto Proprietà Impostazione

Form1 Caption Seconda applicazione

BorderStyle 1 (la finestra non può essere ridimensionata)

Tex1 Text ""

Command1 Caption OK

Default True (predefinito, quando si preme CR)

TabStop True (evidenziato)

Scrivere il seguente codice, doppio clic su Command1 per aprire la finestra di codice:

End Sub

Operazione Metodo

Caricamento di un form in memoria senza visualizzarlo Load

Caricamento e visualizzazione Show

Chiusura di un form Hide

Chiusura di un form e scaricamento dalla memoria Unload

L’applicazione termina quando tutti i form sono chiusi e non è eseguito alcun codice. A volte potrebbe essere necessario terminare l’applicazione indipendentemente dallo stato dei form o degli oggetti esistenti: usare l’istruzione End.

Per determinare gli eventi per i quali scrivere il codice, è necessario prevedere le azioni dell'utente e la risposta che si desidera ottenere dall’applicazione.

Le routine di eventi consentono inoltre di:

generare altre routine di eventi;

modificare le proprietà di un oggetto;

richiamare altre routine generali non collegate ad un evento particolare.

In conclusione, il funzionamento di un’applicazione orientata agli eventi è il seguente:

TECNICHE DI SCRITTURA DEL CODICE

pic.AutoRedraw = false

Per poter utilizzare tutte le funzioni dell’Autocomposizione Installazione, è necessario salvare prima tutto il progetto e quindi chiuderlo.

Per creare il supporto di distribuzione eseguire i seguenti passi.

Maggiori sono le dimensioni delle applicazioni, maggiori sono le possibilità d'incorrere in errori, detti, in gergo, bug dal verbo debug (to) che significa mettere a punto, in pratica è un processo per riconoscere e correggere errori.

Dal progetto alla realizzazione possono essere variate sia le condizioni generali, sia le specifiche di base dell’applicazione. Il cambiamento di queste ultime è una fonte inesauribile di errori, in altri casi gli errori sembrano presentarsi in modo casuale.

Per scovare questi errori, sarebbe molto comodo possedere uno strumento che permetta di scorrere il sorgente riga per riga, controllando, se possibile in una finestra attigua, il valore assunto dalle variabili da tenere sotto controllo.

In via generale la fase di debugging si articola nei seguenti quattro passi.

Verifica dell’esistenza di un errore. I casi macroscopici si hanno quando il sistema si "pianta", altre volte l’applicazione gira correttamente fino a quando non ha a che fare con un numero (o carattere) critico al quale è associato l’errore.

Ricerca della posizione dell’errore. Questo è più difficile quanto più lunga è l’applicazione, allora conviene sezionarla ed individuare quale parte contiene l’errore.

Ricerca della causa dell’errore.

Correzione dell’errore.

Fatal: immediata interruzione, sono catturabili.

Error: impediscono la generazione del .EXE, sono catturabili.

Warning: condizioni sospette, effetti non voluti genera in ogni caso il .EXE.

Syntax error: cursore nella posizione dell’errore, la riga dell'errore si colora di rosso e compare una finestra con il suggerimento.

Compile time errors: si verificano quando il codice non è corretto, attivare la casella Strumenti/Opzioni/Ambiente/Controllo automatico sintassi.

Run time errors: errori di semantica. Quando è rilevato un errore compare una finestra con il numero dell’errore ed il messaggio di errore. Facendo clic sul pulsante Debug è possibile passare alla finestra del codice, dove la riga che ha causato l'errore e racchiusa in un riquadro, correggere l'errore e quindi continuare l'esecuzione dell'applicazione con Esegui/Continua. Per sfruttare questo disattivare la casella Strumenti/Opzioni/Avanzate/Intercettazione degli errori/Interrompi ad ogni errore.

Errori logici: l’applicazione fornisce risultati diversi da quelli previsti (fa ciò che gli avete detto di fare, anziché ciò che volevate che facesse).

"Un’applicazione che gira, non è detto che giri bene; un test può essere usato per mostrare la presenza di errori, non per mostrare la loro assenza." Dijkstra.

Non si può sostenere che un’applicazione è buona solo perché ha superato dei test.

Un test può essere:

• selettivo: non garantisce la validità perché i dati d'input sono di natura soggettiva;

• esaustivo: impossibile assegnare tutti i valori ai dati d'input perché il tempo di verifica tenderebbe ad esplodere.

Quando un’applicazione comincia ad essere rattoppata al punto, di perdere la sua struttura è più semplice riscriverla.

In genere sono a disposizione due tipi di debugger:

• presenti in un menu nell’ambiente di sviluppo: debugger integrati;

• applicazioni vere e proprie: debugger stand alone.

Le differenze tra i debugger, dal punto di vista delle potenzialità, sono numerose. Per controllare un’applicazione semplice il debugger integrato è più che sufficiente, ma quando l’applicazione si fa più grande è sicuramente necessario utilizzare un debugger stand-alone.

È bene chiarire subito, per non generare troppi entusiasmi, che i debugger non trovano da soli gli errori, ma grazie al gran numero d’informazioni che è possibile ottenere tramite questi strumenti gli errori saltano fuori, quasi, da soli.

La programmazione sotto Windows aggiunge nuove difficoltà perché vi possono essere più applicazioni che utilizzano le stesse risorse.

Unrecoverable Application Error, conosciuto meglio con la sua sigla UAE, significa che l’applicazione ha commesso un fatto grave e l’errore commesso non è controllabile: in questo caso l’applicazione è uccisa.

Per eseguire il debug di un’applicazione, è necessario sapere qual è la modalità corrente, indicata nella barra del titolo:

• fase di progettazione;

• fase di esecuzione (Esegui/Avvia F5);

• modalità interruzione (Esegui/Interrompi).

Nella Finestra Debug è possibile controllare i valori di espressioni e variabili mentre sono eseguite le istruzioni nella fase di esecuzione; mentre in modalità interruzione si possono modificare i valori di variabili o proprietà. È costituita da due riquadri:

Controllo nella parte superiore, sono visualizzate le espressioni di cui si desidera controllare i valori durante l’esecuzione.

Immediata nella parte inferiore, sono visualizzate le informazioni ottenute eseguendo il debug delle istruzioni Debug.Print [var][;] nel codice o richieste digitando direttamente i comandi nel riquadro con Print (?); al massimo è una calcolatrice ?10^2 = 100. Questo metodo è migliore rispetto alle espressioni di controllo.

Trace

Per tracciare l’attività di un’applicazione si usavano, in mancanza di strumenti di debug, istruzioni print, le function MessageBeep, MessageBox e wvsprintf per controllare come precedeva l’applicazione.

L'unità base di esecuzione non è l'istruzione, ma la riga evidenziata dalla barra di esecuzione, scegliere Esegui/Esegui istruzione F8.

Per evitare il tracing dentro le routine corrette (Tron e Troff del BASIC) scegliere Esegui/Esegui istruzione/routine MAIUSC+F8.

Per ignorare determinate sezioni di codice, ad esempio loop di grandi dimensioni scegliere Esegui/Esegui fino al cursore CTRL+F8.

Esegui/Imposta istruzione successiva CTRL+F9 solo se si trova nella stessa routine.

Solo in modalità interruzione Esegui/Mostra istruzione successiva.

Watches

Visualizza espressioni, variabili, proprietà indicate nella finestra di dialogo Strumenti/Controlla..., nella fase di esecuzione nel riquadro Controllo; a sinistra di ciascuna espressione è visualizzata un’icona che identifica il tipo di controllo.

Per modificare oppure eliminare qualsiasi controllo elencato nel riquadro Controllo scegliere Strumenti/Modifica controllo...CTRL+W.

In modalità interruzione, è possibile controllare il valore di una proprietà, variabile o espressione selezionata nella finestra del codice (per la quale non è stata definita alcuna espressione di controllo) utilizzando Strumenti/Controllo immediato...MAIUSC+F9.

Breakpoints

In fase di esecuzione, un punto di interruzione (arresto) indica che l’esecuzione deve essere interrotta immediatamente prima che sia eseguita una riga di codice specifica. È possibile impostare o rimuovere un punto di interruzione sia in modalità interruzione che in fase di progettazione (Stop del BASIC). Per inserire un punto di interruzione, posizionare il cursore sulla riga di codice nella quale si desidera interrompere l'esecuzione, scegliere Esegui/Imposta/Rimuovi punto di interruzione F9

Esegui/Rimuovi punti di interruzione CTRL+MAIUSC+F9

Quando si avvia l'applicazione, l'esecuzione continua fino a quando è raggiunto il punto di interruzione. Dopo che l’applicazione è stata interrotta, è possibile esaminare lo stato corrente dei dati, modificarli per vedere la reazione con valori limite.

È quindi possibile eseguire il codice un'istruzione alla volta scegliendo Esegui istruzione dal menu Esegui, premendo F8 oppure facendo clic sul pulsante Esegui istruzione sulla barra degli strumenti per individuare il punto in cui si verifica un problema.

Per continuare l'esecuzione del codice da un punto di interruzione, scegliere Continua dal menu Esegui oppure fare clic sul pulsante Continua sulla barra degli strumenti.

Call dialog

È visualizzato un elenco delle chiamate alle routine attive nello stack solo in modalità interruzione, in altre parole le routine dell’applicazione che sono state avviate, ma non ancora completate. Scegliere Strumenti/Chiamate...CTRL+L.

Come scrivere applicazioni per il debugging: