Il testing non può mai rivelare l'assenza di bug.

— Edsger Wybe Dijkstra

Corso su Mono: Anatomia di una applicazione

http://www.stenoweb.it/files/blog/mono.png Riprenderemo ora il sorgente creato nella lezione precedente per dare una rapida occhiata alla la struttura. Il codice che abbiamo scritto rappresenta una delle più semplici applicazioni possibili e visualizza la stringa “Hello World!” quando eseguito.

Va premesso che esistono svariate categoire di applicazioni nel contesto Mono. Quella presa in esame è un’applicazione che si avvale della command line, definita anche console application. Vedremo in seguito che esistono altri tipi di applicazioni tra le quali quelle che interagiscono graficamente con l’utente (o GUI based).
using System; namespace TuxJournal
{ class App
{
public static void Main()
{
System.Console.WriteLine("Hello World!");
}
}
}


Se dovessimo commentare in modo sintetico il sorgente, ad un interlocutore con nozioni di programmazione, diremmo che è composto da una sola classe contentente un entry point statico di nome Main. Senza divagare in un corso sulla programmazione partiamo dalla “singola classe” citata, si riferisce a “class App” e rappresenta l’unico elemento definito nel nostro programma. Nel mondo object oriented le entità che compongono un programma sono oggetti, questi sono sempre descritti da classi che ne definiscono struttura e comportamento (e per questo vengono anche chiamati Tipi). La nostra applicazione è così semplice da includere tutta la logica, ovvero l’emissione a video della scritta “Hello World!,” nell’entry point.

L’entry point non è altro che il primo metodo che viene invocato all’avvio del programma. Ora dovrebbe essere chiaro cosa è successo quando abbiamo scritto mono hello.exe e abbiamo visto apparire la scritta “Hello World!”, il runtime (CLR) ha cercato l’entry point e lo ha eseguito, l’unica istruzione che era presente al suo interno prevede di scrivere a video la famosa stringa.

Approfondiremo ulteriori concetti relativi alle alte parti di cui è composto il programma man mano che li rivedremo in altri sorgenti. La cosa interessante a questo punto è che l’eseguibile compilato trasportato su una macchina Windows dotata di ambiente .Net verrà eseguito senza problemi, come pure su un Mac OS X con Mono e così per tutte le architetture supportate. Come abbiamo già detto il fatto che il codice venga tradotto in un linguaggio intermedio è il meccanismo grazie al quale è garantita la portabilità del programma. Nelle utility di Mono è presente un comando che ci permette di vedere dal vivo l’IL (intermediate language) corrispondente ad un eseguibile, il comando in questione è monodis. L’uso più immediato di monodis è quello di passare sulla riga di comando l’eseguibile del quale si vuole vedere il sorgente disassemblato, nel nostro caso il comando completo è :

monodis hello.exe

L’output che otterremo sarà :
.assembly extern mscorlib
{
.ver 1:0:5000:0
.publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) .zV.4..
}
.assembly ‘hello’
{
.hash algorithm 0×00008004
.ver 0:0:0:0
}
.module hello.exe
GUID = {E5E7ED31-16F1-49BC-A4D2-ABD664BF4C13}
.namespace TuxJournal
{
class private auto ansi beforefieldinit App
extends [mscorlib]System.Object
{ method line 1
.method public hidebysig specialname rtspecialname
instance default void .ctor () cil managed
{
Method begins at RVA 0×20ec
Code size 7 (0×7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: call instance void object::.ctor()
IL_0006: ret
}
end of method App::.ctor method line 2
.method public static hidebysig
default void Main () cil managed
{
Method begins at RVA 0×20f4
.entrypoint
Code size 11 (0xb)
.maxstack 8
IL_0000: ldstr "Hello World!"
IL_0005: call void class [mscorlib]System.Console::WriteLine(string)
IL_000a: ret
}
end of method App::Main } // end of class TuxJournal.App
}

A prima vista il codice disassemblato può sconcertare ma in realtà è abbastanza semplice da interpretare, pur senza conoscenze approfondite dell’IL si distinguono chiaramente alcune parti corrispondenti al sorgente originale. In paricolare sono interessanti le seguenti righe:
IL_0000:  ldstr "Hello World!"
IL_0005: call void class [mscorlib]System.Console::WriteLine(string)
IL_000a: ret

Le tre righe corrispondono al “corpo” del metodo Main che abbiamo scritto e non fanno altro che preparare la stringa “Hello World!” ed invocare un metodo statico della classe Console (WriteLine) per stampare a video la stringa.

Proseguiremo ancora nell’approfondimento dell’applicazione nella prossima puntata, e man mano “ci allontaneremo” sempre più dai dettagli di sviluppo per acquisire una visione globale delle potenzialità che Mono è in grado di offrire.