1.1 Introduzione
.Net è nato con lo scopo di convertire il web da un contenitore di informazioni,
in un contenitore di servizi Il vantaggio appare evidente se pensiamo a quanto
sia difficile, con le tecnologie odierne, coordinare le varie operazioni che
effettuiamo sulla rete e quanto sia ancora più difficile mettere in comunicazione
tra di loro applicazioni e servizi differenti. Pensate che sogno sarebbe poter
avere sul proprio palmare la disponibilità residua della carta di credito,
con gli ultimi movimenti effettuati, senza dover inserire tutto a mano, oppure
essere sempre aggiornato con le ultime notizie delle agenzie di stampa sugli
argomenti che ci interesano e senza nemmeno fare un click Se pensate che sia
solo un sogno, sappiate che tra gli obiettivi principali di .NET, ci sono
proprio cose come questa: rendere l’utente più “passivo” ed aumentare
dunque la qualità con cui riceve informazioni, in pratica far si che siano
le informazioni che cerchino noi e non il contrario. Tutti i prodotti attualmente
rilasciati o che stanno per esserlo hanno il suffisso .NET. : Windows.NET,
ASP.NET, Visual Studio.NET, Windows CE.NET, gli stessi .NET Enterprise Servers,
che una volta faceva parte dell’architettura Windows DNA. .NET (che si legge
dotNET e non puntoNET, all’italiana) è essenzialmente sinonimo di InterNET.
Per poter programmare in .NET abbiamo bisogno soltanto di installare il framework
.NET (l’ultima versione è la 3.5) a meno che non utilizziamo il nuovo
sistema operativo windows.Net server 2003 che il framework lo ha gia’
di serie. A mio avviso, l’aspetto rivoluzionario dell’iniziativa
.NET è che consente agli sviluppatori di adottare un paradigma di programmazione
unificato, indipendentemente dal linguaggio utilizzato o dal tipo di applicazioni
che realizzano.
1.1 Architettura del framework.NET
tutti gli oggetti delle libreria di classi di .NET sono strettamente
correlati,e non è possibile creare applicazioni eccezionali focalizzandosi
soltanto su una piccola parte del .NET framework ed ignorare il resto. Il
modo migliore di capire come funzioni il .NET è osservarne l’architettura
Esso è composto da vari strati come mostrato in figura (fig.1)
Figura 1
Partendo dal fondo della gerarchia troviamo le API di Windows.
.NET mette a disposizione una visualizzazione orientata all’oggetto
delle funzioni del sistema operativo, ma non le sostituisce;infatti la maggior
parte delle chiamate effettuate all’interno del framework .NET sono
chiamate ad una dll del kernel di Windows. Allo stesso livello delle API di
Windows troviamo i servizi di COM+. E’ quindi possibile creare componenti
.NET che sfruttino i vantaggi delle transazioni, della sincronizzazione e
dei servizi relativi alla sicurezza offerti da COM+, anche se con questo approccio
l’esecuzione deve passare necessariamente da .NET a COM, e questo comporta
un certo overhead con conseguente spreco di cicli di CPU. Ma bisogna anche
dire che nella maggior parte delle applicazioni, questo overhead è del tutto
trascurabile. Il primo vero e proprio strato del Framework .NET è il Common
Language Runtime (CLR). Esso è responsabile dei servizi di base .NET, come
ad esempio la gestione della memoria, la garbage collection, la gestione strutturata
delle eccezioni ed il multithreading. Il porting del framework .NET su altri
sistemi operativi (come il progetto di un framework sotto UNIX) comporta la
scrittura di una versione del CLR per il nuovo sistema operativo. Il CLR è
contenuto nel file MSCorEE.dll e tutte le applicazioni .NET invocano una funzione
contenuta in questa dll all’inizio dell’esecuzione. Il CLR rappresenta
il cuore del Framework, basti pensare che tutti i linguaggi di programmazione
più utilizzati, come ad esempio C++ e Visual Basic, hanno sempre avuto dei
file “runtime” (MSVBVM60.DLL per Visual Basic e MSCRT40.DLL per
C++) che dovevano essere distribuiti con l’applicazione; ora è il CLR che
si occupa dell’esecuzione e della gestione del codice. Coloro che hanno programmato
in Java avranno sicuramente familiarità con il concetto di runtime unificato,
dato che la Java Virtual Machine di Sun (JVM) si basava sulla stessa concezione,
con la sola differenza che il CLR compila nativamente tutto il codice eseguito.
Il CRL è quindi un modulo runtime univoco per tutti i linguaggi
.NET che si occupa dell’esecuzione di tutto il codice. I compilatori .NET
generano un linguaggio IL (Intermediate Language) (a differenza
del codice macchina generato dai vecchi compilatori come ad esempio Visuali
Basic 6) che viene compilato JIT (Just in Time) prima di essere eseguito.
E’ importante sottolineare che IL non è interpretato ma convertito in codice
macchina ed eseguito.
Il CTS (Common Type System) si occupa invece della gestione
unificata di tutti i tipi presenti nei vari linguaggi del Framework .NET,
definendo come devono essere dichiarati, usati e gestiti dal runtime. E’ possibile
realizzare applicazioni utilizzando qualunque linguaggio di programmazione
che sia conforme alle specifiche indicate dal CTS. Il livello sopra il CLR
contiene la Base Class Library (BCL) in cui vengono definiti tutti i tipi
di dato fondamentali, come System.Object (la radice della gerarchia di oggetti
di .NET). i tipi numerici e data, il tipo string,matrici e collezioni. Sempre
la BCL contiene le classi per la gestione delle funzionalità principali del
.NET, come l’input /output su file, il threading, la serializzazione
e la sicurezza. La BCL è contenuta nel file MSCorLib.dll. Lo strato successivo
è denominato: Data and XML. Questo strato è costituito dalle classi .NET che
consentono di utilizzare database ed il linguaggio XML.
XML è parte integrante del framework .NET e senza dover ricorrere a componenti
esterne, come accadeva con i linguaggi precedenti al .NET; infatti XML è da
considerarsi come il formato utilizzato da .NET per la memorizzazione di qualsiasi
informazione. Tutti i file di configurazione si basano su XML, e naturalmente
il framework .NET è dotato di un potente e veloce parser XML. La parte “Data”
di questo strato è adibita all’uso dei database, ed è ciò che viene
comunemente denominato ADO.NET. A dispetto della somiglianza dei nomi tra
ADO ed ADO.NET, essi sono molto diversi tra loro. ADO include tutte le tecniche
per database disponibili (cursori lato server e lato client, recordset,resultset
disconnessi,conenction e gli aggiornamenti batch), ADO.NET si concentra esclusivamente
sui resultset disconnessi (chiamati dataset) e non offre alcun supporto per
i cursori lato server. L’oggetto Dataset è molto più potente e versatile
dell’oggetto recordset di ADO e può immagazzinare dati provenienti da
più tabelle appartenenti allo stesso database o a database differenti. Uno
dei grossi vantaggi di.NET è la possibilità di trattare documenti XML come
una qualsiasi fonte dati, come una tabella di un database, inoltre con .NET
è possibile utilizzare, attraverso il meccanismo di databinding (associazione
dei dati ad un controllo della pagina), incluso nel sistema, degli oggetti
potentissimi che permettono di creare report, motori di ricerca e più in generale
di visualizzare dati in maniera completa e con pochissimo sforzo, ovvero,
scrivendo pochissime righe di codice. Con gli oggetti datagrid, datalist e
repeater, potete dimenticarvi anche come si crea una tabella HTML. E’ infatti
tutto fatto in automatico, attraverso questi oggetti. ADO.NET è contenuto
nel file System.Data.dll mentre la parte XML è contenutanel file System.XML.dll
Salendo nella gerarchia del framework .NET incontriamo lo strato ASP.NET e
Windows Form, entrambi posizionati sullo stesso livello. Queste parti del
framework contengono tutte le classi necessarie per la realizzazione dell’interfaccia
utente in un browser. Anche se i due strati si trovano sullo stesso livello
sono molto differenti tra loro dal punto di vista delle tecnologie utilizzate.
ASP.NET opera sul server e genera codice HTML che poi viene interpretato
dal browser di un client che può avere in esecuzione un qualsiasi sistema
operativo, le windows forms girano sul client e deve essere necessariamente
una macchina windows. Il penultimo strato prima della vetta è il Common Language
Specification (CLS), un insieme di specifiche messe a disposizione dalla Microsoft
per agevolare i produttori di compilatori .Queste specifiche determinano il
gruppo minimo di funzionalita’ che un linguaggio .NET deve possedere.
In cima al nostro diagramma di Figura 1 troviamo i linguaggi di programmazione
(Visual Basic,c++,c#,j#,javascript ed altri).Dal momento che tutti i linguaggi
di programmazione,siano essi Microsoft o no, hanno come obbiettivo il CLS
e tutti utilizzano i tipi di dato del framework .NET, tutti risultano simili
tra loro molto di più dei linguaggi del passato.
1.2 La compilazione delle pagine
Per compilare le applicazioni scritte in Visual Basic .NET, C# o altro linguaggio,
basterà eseguire dalla riga di comando:
| - | Comando | Descrizione |
| - | csc.exe /r:NomeFile.dll NomeFile.cs | per compilare NomeFile.cs (C#) in NomeFile.exe |
| - | vbc.exe /r:NomeFile.dll NomeFile.vb |
per compilare NomeFile.vb (Visual Basic .NET) in NomeFile.exe |
Il comando /r: indica al compilatore di effettuare un Reference
ad una DLL, in questo caso quindi, il file sorgente, include riferimenti a tipi,
classi… presenti nella DLL NomeFile.dll.
Il Framework .NET consente di creare, oltre che file eseguibili (.EXE), anche
DLL; per ottenere questo risultato basterà semplicemente aggiungere il comando
/t:library in fase di compilazione:
| - | Comando | Descrizione |
| - | csc.exe /t:library /r:NomeFile.dll NomeFile.cs |
per creare una DLL da un file .cs (C#) |
| - | vbc.exe /t:library /r:NomeFile.dll NomeFile.vb |
per creare una DLL da un file .vb (Visual Basic .NET) |
Quelli appena mostrati sono dei semplici esempi di argomenti che possono essere
associati al comando di compilazione (csc.exe, vbc.exe …), ne esistono altri
che consentono di gestire riferimenti a files, modalità di compilazione, operazioni
di debug, controllo sui tipi … E’ importante sottolineare che il codice eseguibile
prodotto da un compilatore tradizionale è differente rispetto al codice eseguibile
generato del Framework .NET in quanto i compilatori tradizionali (C, Pascal,
C++ ecc…) effettuano una traduzione in codice nativo, al contrario, .NET,
genera un eseguibile in formato IL (Intermediate Language) e sarà compito del
CLR trasformare il codice IL in codice nativo, utilizzando il JIT Compiler
(compilatore Just in time). Dopo questa premessa è facile intuire che un eseguibile
generato in .NET (quindi in IL) non potrà essere eseguito su sistemi che non
presentano il Framework .NET installato in quanto non sarà possibile riconoscere
ed interpretare l’IL.
Il compilatore JIT si occupa della conversione della pagina in codice nativo
solo nel momento in cui si richiede l’utilizzo di una particolare funzione del
programma, convertendo solo la porzione di codice presa in considerazione; questo
consente di ottimizzare il tempo di compilazione e l’occupazione in Kb del file
generato. Nella nuova logica introdotta da .NET, ogni applicazione deve essere
considerata come un’insieme di Asembly (librerie) e da un file
“Assembly principale” (il file .exe) necessario per avviare l’applicazione;
gli Assembly presentano il vantaggio di essere autodescrittivi in quanto contengono:
codice IL, metadati con informazioni su strutture, classi… Lo schema seguente
illustra le operazioni eseguite durante la fase di compilazione.
Avviando il programma, viene caricato il primo Assemlby, successivamente vengono
caricate le Classi base di .NET; il CLR si occupa invece di controllare i tipi
ed i permessi di esecuzione sulla base delle informazioni presenti nei metadati
ed alle impostazioni di sicurezza del Sistema.
Altri compiti importanti del CLR sono:
| - | Descrizione |
| - | Controllare gli spazi di memoria da liberare, ovvero quelli che non sono più necessari all’esecuzione del programma (Garbage Collector). |
| - | Gestire le eccezioni |
| - | Verificare l’aderenza del codice con gli standard definiti dal CTS (Common Type System) e CLS (Common Language Specification) |
1.3 Esecuzione delle pagine ASP.NET
Quello appena visto è come compilare una applicazione per creare un eseguibile
.exe. Ora ci occupiamo della procedura per compilare un’applicazione per
essere eseguita in Internet. Infatti uno dei vantaggi di ASP.NET nei confronti
di ASP è che possiamo compilare le pagine. Quando una pagina .aspx (ASP.NET)
viene eseguita, il Framework .NET compila la pagina in un assembly che viene
collocato nella directory %systemroot%/Microsoft.NET/Framwork/V1.n.nnnn/Temporary
ASP.NET files. Questo assembly contiene una singola classe che deriva dalla
classe System.Web.UI.Page e che contiene il codice necessario all’esecuzione
della pagina. La prima esecuzione di una pagina .aspx può richiedere alcuni
secondi (il tempo necessario per la compilazione) ma, le richieste successive,
saranno notevolmente più veloci in quanto verranno soddisfatte istanziando la
classe generata e attraverso il rendering della pagina. 
Quando viene generata una classe per una determinata pagina .aspx, tutti i files
dipendenti (file inclusi, files esterni…) diventano parte della classe compilata,
questo consente di verificare, ad ogni accesso successivo alla pagina, se sono
state effettuate modifiche al file .aspx o ai vari files inclusi e, in caso
affermativo, eliminare l’assembly (in quanto non più aggiornato) e rigenerarlo.
Una volta compilata la nostra applicazione ASP.NET, ciò che otterremo sara’
un file .dll contenente il codice di programmazione da noi usato, ed i vari
file .aspx, che conterranno solo il codice html delle pagine; ciò ci porta ad
un altro dei principali vantaggi introdotti dal .NET framework: la possibilità
di copiare direttamente una DLL all’interno di un’applicazione senza
dover riavviare il Sistema o sovrascrivere una DLL già esistente ed utilizzata
da un altro software; questa tecnica consente di evitare il famoso problema
delle DLL, conosciuto come “DLL Hell”, oltre che semplificare notevolmente
la distribuzione di applicazioni su qualunque sistema.
1.4 L’inferno delle DLL (DLL Hell)
L’Inferno delle DLL (DLL Hell) nasce quando diverse applicazioni
utilizzano e condividono la stessa DLL o lo stesso oggetto COM
(Component Object Model); la situazione tipica è quella che avviene in seguito
all’installazione di un nuovo programma che registra e sovrascrive una
DLL esistente, questa modifica porterà ad una situazione in cui i programmi
che utilizzavano quest’ultima DLL potrebbero non funzionare più correttamente.
Il framework .NET risolve questo problema introducendo un approccio “side
by side” ovvero la capacità di installare, mantenere e gestire contemporaneamente
diverse versioni di componenti COM. La semplificazione appena descritta, viene
gestita dal framework grazie al fatto che le applicazioni sono autodescrittive
e viene tenuta traccia dell’ultima esecuzione di ogni singola applicazione,
al fine di memorizzare l’elenco dei componenti che hanno portato a buon fine
l’esecuzione; grazie a questa tecnica, in caso di malfunzionamenti, sarà sempre
possibile riportare le applicazioni al loro stato iniziale.
Conclusioni
.NET permette di sviluppare qualsiasi tipo di applicazione: stand-alone, client/server,
per sistemi handheld (palmari, smart phones, smart devices), per il web. In
pratica, per tutto quello che vuol dire “applicazione” Per gli sviluppatori
rappresenta un vantaggio notevole dato che permette di poter scrivere un’applicazione
e farla girare su tutte le altre piattaforme supportate. Microsoft ha rubato
l’idea a Sun? Per certi versi è vero, .NET è un Java megliorato ed in grande
stile. Di Java ha preso le cose migliori, di Java non ha le cose peggiori. Anche
.NET si basa su un CLR (Common Language Runtime), un runtime che esegue
al volo il codice, che viene automaticamente convertito dai compilatori in MSIL
(Microsoft Intermediate Language). Dunque, la mia applicazione scritta in VB.NET
o in C#, verrà sempre convertita in MSIL prima di essere eseguita. Il vantaggio
di un framework comune per tutti i linguaggi vuol dire essenzialmente una cosa:
con .NET utilizzare uno o l’altro l’inguaggio è essenzialmente e finalmente
una scelta dello sviluppatore. Tutti i linguaggi permettono di fare praticamente
le stesse identiche cose: cambia la forma, la sostanza è la stessa. Grazie al
.NET si è risolto anche il problema del DLL Hell, oltre al fatto che le pagine
web in ASP.NET sono ormai ordinate, infatti la parte di html è separata dalla
parte di programmazione vera e propria; ciò porta ad un miglioramento della
coordinazione tra il grafico , che si occuperà solo della parte html, ed il
programmatore, che si occuperà di scrivere il codice nel linguaggio a lui più
adatto.
