L'argomento ADO.NET porta via un sacco di tempo e
spazio, per questo motivo preferisco aprire una piccola parentesi sulle classi
Debug e Trace. A cosa servono? Dove vengono
utilizzate?
Cominciamo con la prima: la classe Debug permette di
inserire linee di codice per visualizzare (più avanti vedremo meglio nel
dettaglio cosa si intende) alcune informazioni che possono essere utili per
debuggare la nostra applicazione. La prima cosa da sapere è che tutte le
linee di codice che utilizzano la classe Debug vengono
semplicemente ignorate quando compiliamo la nostra applicazione in modalità
Release. Mi spiego meglio, perchè credo che sia una cosa che
chi sviluppa da solo magari utilizza poco, o addirittura non sa nemmeno che
esiste. Nell'interfaccia di VS.NET 2003 è presente una toolbar, denominata
Standard: fra le altre cose, questa toolbar comprende una
piccola ComboBox che permette di decidere sotto quale modalità vogliamo
compilare e distribuire l'applicazione.
La ComboBox comprende le voci Debug,
Release e Configuration Manager. La modalità
Debug è studiata appositamente per compilare il codice ancora in fase di
sviluppo: viene generato un file PDB che serve al debugger di VS.NET per
eseguire il debug del codice. Ma torniamo a noi: la classe
Debug
espone alcuni metodi (statici) interessanti per scrivere
su uno stream le informazioni che riteniamo più utili. Lo stream può
essere un file di testo, lo schermo, etc. etc. Quali sono questi metodi?
Assert
Visualizza un messaggio se la condizione espressa
nel parametro ritorna false. A me piace tradurla in
italiano come "assicurati che...": se la condizione non è verificata,
allora la string message viene mandata allo stream di
output.
Write e WriteLine
Manda semplicemente allo stream di
output una string. Questo metodo dispone di 4 overload
diversi (per passare un object generico, ad esempio).
WriteIf e WriteLineIf
Come il metodo
Write di prima, solo che viene prima verificata una condizione.
Se la condition ritorna true, allora il messaggio viene
mandato in output.
La classe Debug espone la property Listeners, che è in
pratica una collection di uno o più stream di output, sui quali vogliamo
redirigere le nostre informazioni di debug. Io per esempio ho aperto il sorgente
dell'applicazione Age, ho aperto il codice Main() e ho dichiarato
quanto segue:
string nome_file_log = System.IO.Directory.GetCurrentDirectory() + @"\LogAge.txt";
// Istanzio un listener per fare debug dell'applicazione
TextWriterTraceListener lst = new TextWriterTraceListener(nome_file_log);
Debug.Listeners.Add(lst);
Ho dichiarato un oggetto lst appartenente alla classe
TextWriterTraceListener, specificando un nome di
file, poi l'ho alla collection Listeners della classe Debug. Da questo momento
in poi, qualsiasi chiamata ad uno dei metodi che abbiamo visto produce un output
su questo file di testo. A questo scopo, è comodo sapere che
Debug espone metodi come Indent e
Unindent per impaginare meglio l'output. La property
IndentSize permette di impostare il numero di spazi usati per un livello di indentamento.
Il metodo Main() dell'applicazione Age
adesso è il seguente:
[STAThread]
static void Main()
{
string nome_file_log = System.IO.Directory.GetCurrentDirectory() + @"\LogAge.txt";
// Istanzio un listener per fare debug dell'applicazione
TextWriterTraceListener lst = new TextWriterTraceListener(nome_file_log);
Debug.Listeners.Add(lst);
Thread.CurrentThread.CurrentUICulture = Thread.CurrentThread.CurrentCulture;
Debug.WriteLine("Avvio applicazione..." + System.DateTime.Now.ToString());
Debug.Indent();
Application.Run(new frmMain());
Debug.Unindent();
Debug.WriteLine("Chiusura applicazione..." + System.DateTime.Now.ToString());
Debug.Flush();
Debug.Close();
}
Ad ogni avvio dell'applicazione, scrivo sul file di log data ed ora di
avvio. Appena prima di essere chiusa, scrivo data ed ora di chiusura. Banale,
vero? Da notare la chiamata a Indent() e
Unindent(): se negli altri form usassi Debug per scrivere altre
informazioni, le stringhe risulteranno indentate rispetto a quelle iniziali.
Usando la classe Debug, quindi
"farcire" il codice di tutte una serie di informazioni che ci possono essere
utili per il debug, sapendo poi che quando compileremo la versione finale della
nostra applicazione, tutto quel codice verrà semplicemente rimosso. L'utente
finale non avrà mai a che fare con il file di log eventualmente generato.
La classe Trace è identica a Debug, se non
per il fatto che viene compilata anche nella
versione Release della nostra applicazione. La pagina MSDN dedicata a questa classe dice espressamente
che la classe Trace "allows you to monitor the health of your
application running in real-life settings". La classe Trace
espone gli stessi metodi e le stesse proprietà della classe
Debug.