Il linguaggio di programmazione C# è stato inizialmente progettato per essere utilizzato in combinazione con il Framework .NET, una piattaforma ricca di funzioni per lo sviluppo, l’esecuzione e la distribuzione di applicazioni.

Con tale premessa è logico dedurre che le caratteristiche del linguaggio C# riflettono, sostanzialmente, quelle di .NET per cui è necessario, prima di tutto, capire l’architettura di questo framework.

Cos’è il Framework .NET?

Il Framework .NET è una tecnologia che supporta l’implementazione e l’esecuzione di applicazioni di ultima generazione e i servizi Web XML.

Gli obiettivi per cui è stato progettato sono davvero molti, come:

• fornire un ambiente di sviluppo solido orientato agli oggetti sia in contesti in cui il codice degli oggetti viene memorizzato ed eseguito localmente, sia in ambiti in cui il codice viene eseguito da remoto o in ambiti locali, ma distribuito attraverso internet;
• fornire un ambiente di esecuzione del codice capace di minimizzare la distribuzione del software e i conflitti tra le varie versioni;
• fornire un ambiente protetto di esecuzione del codice, anche quando questo venga fornito da produttori sconosciuti;
• fornire un contesto di esecuzione del codice che elimini i problemi di prestazioni causati da ambienti basati su script o interpretati;
• Rendere coerente l’esperienza di sviluppo delle diverse tipologie di applicazioni come, per esempio, applicazioni orientate al Web e quelle Desktop.

Caratteristiche principali.

Le caratteristiche principali del Framework .NET sono essenzialmente due:

• il Common Language Runtime;
• la Libreria di Classi .NET Framework.

Il Common Language Runtime.

Il Common Language Runtime o più semplicemente runtime – indicato anche con l’acronimo CLR -, rappresenta l’ambiente di esecuzione runtime del framework e si occupa di gestire l’esecuzione del codice.
Il codice che viene eseguito sotto il suo controllo viene detto codice gestito in contrapposizione a quello che, non ricadendo sotto il suo controllo, si definisce codice non gestito.

Prima che il codice sorgente, sviluppato in C# o altri linguaggi, venga eseguito, questo deve subire un processo di compilazione che si suddivide in due fasi:

• compilazione del codice sorgente in Linguaggio Intermedio (IL – Intermediate Language);
• compilazione di IL in codice specifico della piattaforma.

Il Linguaggio Intermedio.

Come il bytecode Java, il Linguaggio Intermedio è un linguaggio di basso livello che presenta una sintassi basata su codici numerici e che viene convertita rapidamente in codice macchina nativo.

Questo linguaggio da luogo a tre vantaggi fondamentali:

• indipendenza dalla piattaforma: il file contenente istruzioni in bytecode può essere trasferito su qualsiasi piattaforma;
• migliori prestazioni: il compilatore Just in Time compila la parte di codice quando richiamata e l’eseguibile risultante viene memorizzato in modo che, durante le chiamate successive, le sezioni di codice compilate non debbano esserlo nuovamente;
• interoperabilità del linguaggio: le compilazioni in IL di codice scritto in linguaggi tra loro differenti, hanno la capacità di cooperare totalmente tra di loro. Le classi scritte in un linguaggio comunicano direttamente con le classi scritte in un altro linguaggio.

Le principali caratteristiche dell’Intermediate Language sono:

• orientamento agli oggetti e utilizzo delle interfacce;
• solida distinzione tra tipi valore e tipi riferimento;
• solida gestione dei tipi di dati.

Programmazione orientata agli oggetti e interfacce.

Il linguaggio Intermedio supporta la classica programmazione orientata agli oggetti con l’ereditarietà singola delle classi. IL supporta anche le interfacce, una sorta di contratto in cui la classe che implementa un’interfaccia dovrà implementarne sia i metodi che le proprietà.

Tipi valore e tipi riferimento.

Tra le caratteristiche più importanti di IL c’è la marcata distinzione tra tipi valore e tipi riferimento: i tipi valore sono quelli per cui una variabile memorizza direttamente i suoi dati; i tipi riferimento sono quelli per cui una variabile memorizza l’indirizzo in cui sono archiviati i dati corrispondenti.
In generale, le istanze dei tipi riferimento vengono memorizzate in un’area chiamata managed heap, mentre i tipi valore vengono memorizzati nello stack.

Gestione fortemente tipizzata dei dati.

Il linguaggio intermedio non consente operazioni che possano generare tipi di dati ambigui: per questo motivo a tutte le variabili deve essere assegnato sempre un tipo di dati specifico.
La tipizzazione forte è una caratteristica fondamentale per il raggiungimento dell’interoperabilità tra i linguaggi: una classe che deriva o contiene le istanze di altre classi deve conoscere tutti i tipi utilizzati da queste classi (concetto di tipizzazione forte).
Il Common Type System definisce i tipi di dati predefiniti incorporati nel Linguaggio Intermedio. Il codice compilato, prodotto dai linguaggi destinati a .NET, si basa su questi tipi di dati: così l’integer di Visual Basic .NET e l’int di C#, entrambi corrispondono al tipo int32 definito dal CTS nel linguaggio intermedio.

Garbage collection.

Il runtime .NET si affida al Garbage collector per rilasciare la memoria allocata dinamicamente nell’heap gestito dal Common Language Runtime. A intervalli regolari, pur non essendo deterministica la chiamata al Garbage collector, il CLR lo richiama quando l’heap gestito, per un dato processo, sta per raggiungere la massima capacità: esamina i riferimenti agli oggetti memorizzati e quelli che risultano inaccessibili dal codice vengono rimossi.

Libreria delle classi .NET Framework.

La Libreria delle classi .NET Framework è una collezione di tipi riusabili, che si integra perfettamente con il Common Language Runtime. La libreria è orientata agli oggetti e i tipi che fornisce possono essere derivati dallo sviluppatore durante l’implementazione del proprio codice gestito. Ciò produce innegabili vantaggi come la facilità di utilizzo dei tipi, la riduzione dei tempi di apprendimento delle caratteristiche del framework e la perfetta integrazione dei componenti di terze parti con le classi dello stesso.

Note.

In questa primo post sono stati affrontati argomenti teorici introduttivi e generali, non affatto esaustivi, ma alla portata di tutti coloro che sono completamente digiuni del concetto di sviluppo di applicazioni. La lezione successiva, entrerà subito nel vivo di questo linguaggio e la sua uscita è prevista per il mese di Marzo. Se avete domande da pormi, potete farlo attraverso il modulo contatti o tramite profilo facebook.

Alla prossima.