Guida concisa alla programmazione C# 2.0

Una guida concisa e chiara alla programmazione con il linguaggio C# 2.0. Lezioni a cura di Antonio Cangiano.

<November 2006>
SuMoTuWeThFrSa
2930311234
567891011
12131415161718
19202122232425
262728293012
3456789

News

Lezione 0
Lezione 1
Lezione 2
Lezione 3

Navigation

  • Home
  • Blogs
  • Forums

Subscriptions

  • RSS 2.0
  • Atom 0.3
  • Contact
Lezione 3: .NET Portable Executable, IL, Reflector e Obfuscator
Nella precedente lezione vengono esposte brevemente le differenze tra un eseguibile PE (standard) ed un eseguibile .NET PE. Come accennato, il primo è un formato di file che incapsula le istruzioni native della CPU e può essere gestito direttamente dal sistema operativo. A differenza di uno standard Windows PE, un eseguibile .NET PE viene caricato dal sistema operativo che passa subito il controllo al Common Language Runtime. Il CLR è in un'ultima analisi il responsabile dell'esecuzione e gestione del .NET PE che contiene al suo interno istruzioni IL che la CPU non sarebbe in grado di comprendere altrimenti.

Stuttura di un .NET Portable Executable

Una volta scritto il codice sorgente di un'applicazione in C#, si procede con la compilazione che genera quello che in gergo .NET viene definito assembly. Questo assembly avrà come estensione .dll se si tratta di una libreria e .exe se si tratta di un eseguibile.

Un .NET PE è un formato di file che contiene tre sezioni principali: una intestazione PE standard gestibile dal sistema operativo, una instestazione CLR e una sezione dati CLR. Quest'ultima è divisa a sua volta in due sezioni: metadata ed il codice intermedio IL vero e proprio. La sezione metadati contiene al suo interno il manifesto dell'assembly che fornisce dettagliate informazioni circa l'applicazione; informazioni utilizzate poi dall'ambiente CLR per una propria esecuzione dell'applicazione. Il manifesto include informazioni per indentificare l'assembly, i riferimenti a risorse esterne, informazioni dettagliate sui tipi di dati, ecc... Il segmento che contiene il codice IL  in fine, contiene le istruzioni gestite da parte del CLR. Si noti che IL supporta pienamente la programmazione ad oggetti con .NET (ereditarietà, polimorfismo, eventi, eccezioni, ecc...) per cui ogni programma scritto in C# viene compilato in IL in maniera piuttosto immediata e diretta. Questo spiega il fatto che lo stesso programma scritto in C#, VB.NET o J# produce codice IL quasi identico. Inoltre si noti che il codice C# gestito interamente dal CLR viene  definito managed code (codice gestito). Chi volesse approfondire il formato file .NET PE può utilizzare programmi di utilità come dumpbin.exe, PEDump.exe o PEBrowser.exe per analizzare in dettaglio gli eseguibili. Se ci si vuole invece limitare alla verifica della correttezza del formato file dell'assembly, si può utilizzare l'utility PEVerify.exe fornita nel .NET Framework.

Esecuzione di un assembly

Senza voler scendere troppo nei dettagli, è comunque importante avere un'idea di quali sono i passi che avvengono quando si esegue un .NET assembly come hello.exe:
  1. Il sistema operativo carica il PE come se fosse un qualsiasi eseguibile. Questo è possibile poiché all'interno di un .NET PE c'è una intestazione PE standard. La creazione del processo implica anche il caricamento delle dipendenze necessarie tra cui la DLL mscoree.dll.
  2. Il loader del sistema operativo va diretto al punto di entrata (entry point) del programma. L'entry point dell'assembly contiene un'istruzione x86 di salto(JMP) alla funzione _CorExeMain contenuta nel file mscoree.dll caricato inizialmente.Qui avviene il passaggio del controllo del programma dal sistema operativo al CLR. Il CLR analizza il CLR Header, carica i metadati e attraverso _CorExeMain avvia la procedura di esecuzione del codice IL a partire dal metodo Main() del programma.
  3. Il sistema operativo e la CPU non sono in grado di comprendere direttamente il linguaggio intermedio IL, per cui il CLR deve "tradurre" IL in istruzioni native comprensibili. Questa sorta di traduzione avviene tramite l'invocazione di un compilatore che viene detto Just in Time (JIT). Il termine "Just in Time" deriva dal fatto che il codice IL non viene interamente compilato in codice macchina da parte del compilatore JIT, ma la compilazione avviene solo per le porzioni di codice effettivamente richiamate dal programma al momento dell'esecuzione. La compilazione Just in Time viene anche definita come "traduzione dinamica". In altre parole, quando un metodo viene invocato nel programma, il codice IL corrispondente viene compilato dal JIT compiler. Nell'esempio 1-1 dell'HelloWorld, il  codice IL corrispondente all'istruzione C# Console.WriteLine("Hello, World!"); viene compilato in codice macchina dal compilatore JIT appena l'esecuzione del programma richiede l'invocazione del metodo Console.WriteLine. 
  4. Le istruzioni così compilate vengono eseguite e salvate nella cache. Per migliorare le prestazioni, il codice macchina dei metodi già compilati dal JIT viene salvato in modo tale da poter essere richiamato la prossima volta che i metodi vengono invocati dal programma, risparmiando così sul tempo di compilazione. La compilazione JIT ha grandi vantaggi in termini di prestazioni rispetto all'interpretazione standard del bytecode da parte di Java ad esempio, e in generale le applicazioni .NET hanno una velocità di esecuzione piuttosto buona per applicazioni non real-time o particolarmente critiche.
L'IL dell'Hello World

Entrambi .NET e Mono forniscono strumenti per la visualizzazione del codice IL generato dai rispettivi compilatori. I due disassemblatori sono:
  • ILDASM.exe per .NET
  • monodis.exe per Mono
Impartendo il comando ildasm hello.exe il disassembler appare come applicazione Windows:

Facendo doppio click su uno degli elementi presenti nella struttura ad albero è possibile visualizzare le informazioni di basso livello corrispondenti. In particolare, facendo doppio click su MANIFEST e su Main, si visualizzano il manifesto dell'assembly che contiene metadata (informazioni sull'assembly stesso) e il codice IL per il metodo Main() rispettivamente:

I lettori che utilizzano Mono, possono impartire il comando monodis hello.exe ed ottenere l'intero codice come mostrato in figura:

Sorvolando sui dettagli del manifesto dell'assembly per il momento, passiamo ad una prima analisi del metood Main().

ESEMPIO 3-1

.method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       13 (0xd)
  .maxstack  8
  IL_0000:  nop
  IL_0001:  ldstr      "Hello, World!"
  IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
  IL_000b:  nop
  IL_000c:  ret
} // end of method HelloWorld::Main

La prima riga del codice di questo record, indica che il metodo Main() è di tipo static void, ed è eseguito dal .NET Framework per cui è managed. L'access modifier private indica il livello di accessibilità del codice, che esclude la possibilità ad altre classi di richiamare il metodo. Si noti che nel codice dell'esempio 1-1 non abbiamo specificato il metodo Main come private, ma questo viene assegnato come valore di default. Le successive istruzioni non fanno altro che caricare la stringa "Hello, World!", richiamare il metodo WriteLine della classe Console, e restitutire il controllo al metodo chiamante con l'istruzione (opcode) ret. L'esempio è abbastanza triviale e la scrittura di codice IL va ben oltre gli scopi di questa guida; tuttavia si noti come la possibilità di utilizzare ILDASM o monodis permetta al programmatore di verificare cosa accade dietro le quinte, e a volte di chiarire alcuni dubbi andando a leggere il codice di basso livello IL.Ad esempio, abbiamo notato come il compilatore assegna     automaticamente l'access modifier private al metodo Main (se non specificato diversamente). Programmare in C# sarà più che sufficiente per la maggior parte dei lettori, ma .NET e Mono offrono comunque la possibilità di scrivere programmi in IL ed assemblarli come .NET assembly (eseguibili o librerie che siano). In genere programmare in C# è estremamente più comodo e produttivo, ma se si vuole ottimizzare agendo su IL in alcuni particolari punti critici dell'applicazione, avete gli strumenti per farlo: ilasm.exe per .NET e ilasm.bat per Mono (ma esistono metodi alternativi per la generazione di assembly da codice IL).

Due parole sul Reverse Engineering

I lettori più attenti avranno notato che il codice IL del metodo Main() non è troppo distante dall'originale scritto in C#. Una persona esperta può decisamente ricostruire il codice sorgente (o qualcosa di simile) a partire dall'eseguibile che viene distribuito. Inoltre esistono degli strumenti come Reflector, che permettono di ottenere il codice con due click e nessuna conoscenza avanzata di IL.Vi invito ad utilizzare Reflector per scopi didattici poiché può essere un buono strumento per capire a fondo la FCL ad esempio; tuttavia questo pone dei problemi pratici per molte aziende e sviluppatori. Nell'immagine seguente, Reflector ha ricostruito il codice dell'esempio 1-1 a partire dall'assembly hello.exe:

Il codice era banale, ma Reflector è eccellente anche quando il codice IL sottostante è piuttosto complicato. Esistono interi libri circa le problematiche del Reverse Engineering, per cui non posso affrontare opportunamente il problema in questa sede, soprattutto da un punto di vista filosofico ed etico. Alcuni programmatori sono disposti ad offrire il proprio codice sotto forma di licenze Open Source, per qui il problema in tal caso non sussiste. In altri scenari però, programmatori o aziende vogliono tutelare il proprio codice dalla concorrenza o da abusi di copyright, o migliorarne la sicurezza per diversi motivi di business. Il problema non è nuovo, Java che a sua volta produce un codice intermedio (bytecode) soffre dello stesso possibile problema.

Gli Obfuscator sono dei programmi che permettono la creazione di .NET assembly per i quali la ricostruzione del codice sorgente risulta alquanto difficile. Questi programmi infatti cercano di camuffare il codice IL in maniera tale che programmi come Reflector producano in output del codice C# praticamente illegibile al programmatore (anche se il codice IL è equivalente all'originale dal punto di vista del CLR).

Esistono soluzioni gratuite e soluzioni commerciali che offrono risultati più o meno soddisfacenti. Dotfuscator è il più diffuso e usato, ma ci tengo a segnalare un prodotto commerciale italiano che sta riscontrando grande successo e sembra essere davvero efficace: Goliath.NET della Cantelmo Software.

Per completezza, segue un'immagine di ciò che appare in Reflector quando si tenta di visualizzare il codice di hello.exe offuscato tramite Goliath.NET:

Prossima lezione

Nella prossima lezione inizieremo con le basi del linguaggio C# 2.0 a partire dall'uso dei tipi di dati.

ESERCIZI

ES. 3-1: Disassemblate il codice dell'hello.exe, modificate la stringa "Hello, World!" in "Ciao, Mondo!" nel codice IL e riassemblate il tutto in un nuovo .NET assembly.

posted Sunday, December 18, 2005 3:40 AM by Antonio with 0 Comments

Lezione 2: Compilazione ed esecuzione di Hello World

La lezione precedente mostra il classico esempio di Hello World in C# visto in superficie, dove la spiegazione si limita a illustrare in maniera introduttiva alcune caratteristiche del linguaggio. In questa lezione vengono esposti alcuni concetti importanti, cercando di andare almeno in parte "dietro le quinte" dell'altrimenti banale esempio.

Compilazione ed esecuzione

Per compilare ed eseguire l'Hello World scritto nell'esempio 1-1:

  1. Scrivete il codice dell'Hello World con il vostro editor preferito (ad esempio Notepad o Emacs, ma evitate Word) . Salvate il file con il nome hello.cs. Per acquisire familiarità, si consiglia di scrivere il codice piuttosto che copiarlo e incollarlo dalle lezioni;
  2.  Per compilare il file hello.cs ed ottenere hello.exe potete utilizzare da linea di comando:
    • csc hello.cs se utilizzate il .NET Framework
    • mcs hello.cs se utilizzate Mono
  3. Per eseguire il file hello.exe, potete utilizzare:
    • hello se utilizzate .NET
    • mono hello.exe se utilizzate Mono

L'intero processo che porta il programma a scrivere "Hello,World!" nella console, è mostrato nelle seguenti figure (rispettivamente .NET e Mono):



Si noti che il codice sorgente è salvato per convenzione in un file .cs, ma entrambi i compilatori csc e mcs sono in grado di compilare codice C# con qualsiasi estensione. Come accennato nella prefazione del corso, esistono diverse piattaforme alternative con le quali compilare gli esempi esposti, ma per una questione logistica, mi limiterò a mostrare figure ed istruzioni per le due principali piattaforme soltanto. Fatta questa doverosa premessa, si noti che se si sta utilizzando Shared Source CLI, il compilatore si chiama ancora csc, ma il file generato viene eseguito tramite l'istruzione clix hello.exe

Microsoft Intermediary Language (MSIL)

Nella compilazione "tradizionale" con linguaggi come Pascal, C o C++, il compilatore produce un file eseguibile .exe che ha al suo interno istruzioni native, eseguibili dalla CPU. Nei sistemi operativi della famiglia Windows, il file .exe generato viene detto Portable Exectuable (PE) e contiene tutte le informazioni necessarie per istruire il loader di Windows circa il caricamento e la gestione in memoria del codice eseguibile. In altre parole, il file generato dal compilatore dei linguaggi citati, può essere gestito direttamente dal sistema operativo.

Le fasi necessarie per arrivare ad eseguire del codice scritto in C# possono sembrare le stesse di linguaggi come C o C++. Infatti il codice salvato in un file, viene compilato dal compilatore (csc o mcs nel nostro caso) che genera un file .exe. Non bisogna però lasciarsi trarre in inganno, poiché esistono delle differenze sostanziali che è bene affrontare sin da subito.

Il compilatore di C# genera un file eseguibile che contiene del codice che non può essere eseguito direttamente dal sistema operativo. Questo codice intermedio è detto MSIL (Microsoft Intermediary Language, d'ora in poi chiamato IL). Il .NET Framework contiene al suo interno il Common Language Runtime (CLR) che è una Virtual Machine in grado di gestire le istruzioni IL, le risorse e gli eseguibili generati dai compilatori .NET.  Per questo motivo, l'eseguibile .exe creato da csc, può essere eseguito soltanto su quei computer dove è presente il CLR. Nello specifico, per C# 2.0 su piattaforma .NET , Microsoft distribuisce gratuitamente il Microsoft .NET Framework Version 2.0 Redistributable Package (x86) (22 Megabyte circa di download). Si faccia attenzione a non confonderlo con la versione SDK destinata agli sviluppatori (ovviamente chi ha l'SDK non ha bisogno del Redistributable Package). Lo stesso discorso teorico vale per Mono o qualsiasi delle altre piattaforme per C#, anche se i dettagli implementativi del CLR e del framework cambiano. I lettori che hanno esperienze di programmazione in Java, possono pensare al CLR come a qualcosa di simile alla JVM, e considere il codice IL prodotto dal compilatore C# come a qualcosa di affine al Bytecode generato dal compilatore Java.

Struttura del .NET Framework

La gestione degli eseguibili da parte del CLR, ed il codice intermedio IL sono aspetti determinanti della piattaforma .NET e dei suoi "cloni". Le specifiche del Common Language Infrastructure (CLI) e di C# sono standard ECMA, per cui è facile comprendere la nascita di piattaforme alternative e soprattutto di compilatori per altri linguaggi. Il CLR stesso è infatti un'implementazione Microsoft dello standard CLI. Grazie a IL e ad un insieme di regole comuni, detto CLS (Common Language Specification), è possibile utilizzare con .NET ogni linguaggio per il quale esista un compilatore conforme in grado di generare codice IL.

Senza dover scendere nei minimi dettagli del CLR e della compilazione ed esecuzione delle applicazioni C#, è comunque possibile avere una prima idea di cosa si intende con il termine .NET Framework. Volendo considerare in maniera ampia il termine .NET, possiamo a questo punto includere:

  1. Una serie di linguaggi interoperabili che possono essere utilizzati per lo sviluppo con .NET (talvolta chiamati linguaggi .NET Enabled);
  2. La FCL (raccolta di librerie organizzate attraverso i namespace) alla quale i linguaggi .NET possono accedere per le necessità più varie. Questa può essere divisa in classi di base, classi per lo sviluppo Web, per i servizi web (Web Services), per applicazioni Windows e per l'accesso e manipolazione dati usando database e XML (ADO.NET).
  3. Il Common Language Runtime che si occupa della gestione ed esecuzione degli eseguibili .NET;
  4. Il sistema operativo che sostiene tutta la struttura .NET.

Volendo si potrebbero aggiungere i vari application services, ma è meglio avere in mente uno schema semplice e meno dispersivo con cui iniziare a lavorare. La struttura delle altre piattaforme di sviluppo come Mono è analoga.

Prossima lezione

Nella prossima lezione vedremo meglio come viene gestita l'esecuzione degli eseguibili .NET PE da parte del CLR, il ruolo della compilazione JIT (Just in Time) e il codice IL dell'esempio Hello World.

Esercizi

ES. 2-1: Cambiate il codice sorgente dell'Hello World in modo che stampi "Ciao, Mondo!" senza mandare a capo il cursore. Poi compilate ed eseguite il programma.
ES. 2-2: Se la vostra riga di comando non riconosce csc come un comando valido, inserite nella variabile di ambiente PATH, il percorso alla cartella che contiene csc.exe. (lo stesso discorso vale per mcs.exe o l'equivalente compilatore). 
ES. 2-3: Date un'occhiata alle opzioni del compilatore con il comando csc /help o mcs -help .
ES. 2-4:
Provate a rimuovere singole parti del programma per familiarizzare con i messaggi di errore del compilatore (togliete una virgoletta dalla stringa "Hello, World!", poi il punto e virgola, ecc...).
ES. 2-5: Pensate che gli eseguibili hello.exe, creati da Mono e da .NET, abbiano lo stesso codice IL? Se sì, questo accade per ogni programma scritto in C#?

posted Saturday, December 17, 2005 2:44 AM by Antonio with 0 Comments

Lezione 1: Analisi di Hello World in C#

Uno dei libri più significativi nella storia dell’informatica è il cosidetto K&R, ovvero “The C Programming Language” di Brian Kernighan e Dennis Ritchie. Riprendendo la tradizione avviata da tale libro, il primo esempio di questa guida sarà il classico “Hello, World!”. Il programma in sè è banale e si limita a scrivere a video la stringa “Hello, World!”, ma può essere un’ottima verifica (sanity test) dell'installazione di tutto l'occorrente per programmare. La semplicità del programma inoltre, lo rende particolarmente adatto ad un primo approccio al linguaggio. Il seguente esempio mostra una possibile implementazione in C# (i numeri di riga servono solo per la spiegazione, non inseriteli nel vostro codice):

Esempio 1-1

   1:  // Il classico HelloWorld in C#
   2:  using System;
   3:  class HelloWorld
   4:  {
   5:      static void Main() 
   6:      {
   7:          Console.WriteLine("Hello, World!");
   8:      }
   9:  }

Prima di compilare ed eseguire il programma è bene analizzare le parti che lo compongono. 

Commenti

La prima riga del codice sorgente contiene un commento. Il compilatore ignora il contenuto della riga a partire dai caratteri //. A volte può essere utile scrivere commenti che si estendono su più righe, per cui per commentare interi blocchi di testo, C# offre un altro tipo di commento, delimitato dai caratteri /* e */ come mostrato:

/* Questo è un commento valido in C#. Lo stesso
 * risultato può essere ottenuto tramite una serie di commenti
 * a riga singola.
 */

I commenti a blocchi, vengono spesso utilizzati per commentare una porzione di codice che si intende escludere dalla compilazione. C# offre anche un terzo tipo di commenti, designati per la generazione automatica della documentazione e delimitati dai caratteri ///. Come si può vedere nel seguente esempio, dei tag XML vengono impiegati per la descrizione del codice:

/// <summary>
/// La classe principale del programma HelloWorld
/// </summary>

Prima di addentrarsi nei dettagli relativi ai commenti XML è necessario conoscere alcuni concetti base della programmazione ad oggetti in C#, per cui questo tipo di commenti verrà affrontato con chiarezza in una delle lezioni future. Si ricordi infine, che i commenti agevolano la leggibilità del codice e sono fondamentali per un buono stile di programmazione; è bene quindi abituarsi sin da subito alla scrittura degli stessi.

Il namespace System

Il .NET Framework (lo stesso dicasi per Mono) fornisce una grandissima libreria di classi per i più svariati compiti. L'insieme di queste classi, interfacce e tipi di dati viene definito FCL (Framework Class Library) ed è alla base della programmazione in .NET. L'ultizzo di queste classi già pronte agevola la creazione di applicazioni in tempi rapidi e permette al linguaggio C# di esprimere tutte le sue potenzialità. Il Framework Class Library è organizzato secondo una struttura gerarchica (o ad albero) attraverso l'uso di namespace (spazio dei nomi). Questo permette di identificare in maniera univoca due classi con lo stesso nome e favorisce il raggruppamento logico di classi simili.I namespace possono essere annidati e contenere a loro volta altri namespace. Alla radice "dell'albero" dei namespace e delle classi, c'è il namespace System. Molte delle risorse utili per la programmazione di rete sono disponibili nel namespace System.Net ad esempio (il punto permette l'accesso ai namespace sottostanti, alle classi e ai loro membri). System.Net a sua volta contiene il namespace Sockets per la programmazione con Winsock, identificato da System.Net.Sockets, e così via. L'organizzazione del framework risulta così piuttosto ordinata nonostante le migliaia di classi disponibili. L'unico inconveniente di questa struttura che si basa su namespace annidati, sta nel fatto che per identificare una classe è necessario scrivere il "percorso" tra i vari namespace a partire da System. Per ovviare a questo, C# introduce la parola chiave using che permette di indicare quali namespace si stanno usando, al fine di identificare le classi con il loro nome invece di qualificarle con il percorso completo.

Nella seconda riga dell'Hello World using System; ci permette di utilizzare la classe Console a riga 7 senza doverla identificare anteponendole "System.". Omettendo la direttiva using, avremmo dovuto sostituire la riga 7 del nostro codice con la più verbosa:

System.Console.WriteLine("Hello,World!");

Si noti che la sintassi using <namespace>; è valida per i namespace soltanto e non per le classi, per cui la seguente istruzione genera un errore in fase di compilazione:

using System.Console; //non compila

Classi

Nel nostro esempio class HelloWorld dichiara la classe HelloWorld. Tutto il contenuto della classe va racchiuso tra una parentesi graffa aperta ed una chiusa { ... } (ALT+123 e ALT +125 rispettivamente) ed ogni programma scritto in C# richiede una o più classi. Una classe è una struttura dati molto flessibile che rappresenta l’astrazione di un insieme di oggetti (istanze) aventi caratteristiche e proprietà comuni. Un oggetto è invece l’istanza di una classe. La differenza tra classe ed oggetto è fondamentale per la comprensione della programmazione object oriented.

Il metodo Main

A riga 5 del nostro programma troviamo la dichiarazione del metodo static void Main(). I metodi corrispondono in qualche modo alle procedure/funzioni dei linguaggi procedurali come il C, e come le classi racchiudono il codice tra parentesi graffe {...}. Si faccia attenzione: C# è un linguaggio case-sensitive, per cui Main e main sono due entità diverse. Main è il punto di ingresso del programma per questo è necessario che ogni programma C# abbia un metodo Main dichiarato correttamente. static indica che il metodo appartiene alla classe piuttosto che all'istanza della stessa (l'oggetto), e che va quindi invocato dalla classe, non da una sua istanza (Main deve essere static). void invece indica che il metodo Main, ed in ultima analisi il programma stesso, non restituisce alcun valore. Se si vuole far restituire un valore al termine dell'esecuzione del metodo Main, è possibile sostituire la parola chiave void con int (che corrisponde ad un intero a 32 bit). Laddove è necessario restituire un valore, per indicare che il programma è stato eseguito correttamente si usa di norma il valore 0, restuituito con l'istruzione return 0;. Per gestire i parametri passati al programma da riga di comando, il metodo Main può accettare un array di stringhe come argomento. Le seguenti dichiarazioni sono perciò entrambe valide: static void Main(string[] args) o static int Main(string[] args). Vedremo più avanti nella guida i dettagli sulla gestione degli array e degli argomenti da riga di comando.

La classe Console

Console è una classe che fornisce vari metodi per la gestione dell'input e dell'output in applicazioni console. Riga 7 del nostro Hello World, invoca il metodo static WriteLine:

Console.WriteLine("Hello,World!");

Si noti ancora una volta come l'invocazione del metodo avviene anteponendo il nome della classe di appartenenza, seguita da un punto. WriteLine mostra nello standard output uno stream di caratteri passati come argomenti e sposta il cursore sulla riga successiva. Il passaggio di un argomento ad un metodo avviene mediante la scrittura dello stesso tra le parentesi tonde che seguono l'identificativo del metodo stesso. Nel nostro caso abbiamo passato come argomento la stringa letterale "Hello World!". Si noti che esiste un metodo piuttosto simile per la scrittura dello standard output chiamato Write, invocabile scrivendo Console.Write. Write a differenza di WriteLine non manda a capo il cursore lampeggiante dopo aver scritto la stringa nella shell a video. Per concludere si noti come in C# il punto e virgola ";" rappresenta il termine delle istruzioni.

Prossima Lezione

Nella prossima lezione passeremo alla compilazione di Hello World e analizzeremo più in dettaglio aspetti relativi alla compilazione ed esecuzione di programmi C#.

Esercizi

Non ci sono esercizi per questa lezione.

posted Tuesday, December 13, 2005 2:31 AM by Antonio with 0 Comments

Lezione 0: Introduzione alla guida

Prefazione

Guida concisa alla programmazione C# 2.0 vuole essere una guida rapida, essenziale e chiara al linguaggio C#.
Circa tre anni fa avevo avviato un corso di C# diviso in una dozzina di lezioni; questa guida non è un aggiornamento o una continuazione di tale corso, nonostante il grande successo riscontrato da quelle lezioni (che erano le prime disponibili gratuitamente online in italiano). Nell'annuncio di questa guida, fatto alcuni giorni fa nel mio blog, ho spiegato tutti i motivi per cui ho deciso di ripartire da capo, piuttosto che aggiornare il corso pre-esistente. In breve, desidero creare una guida meno discorsiva e più concisa, soddisfando l'ansia di conoscenza dei lettori. Cercherò di creare lezioni in modo tale da caratterizzare la guida con le seguenti linee guida:

  • Facile da comprendere e chiara ma al tempo stesso concisa;
  • Introduttiva ma con approfondimenti dove è necessario (un pò nello stile del tutorial Java della Sun);
  • Un approccio pratico ed un avvio veloce: esempi opportuni e spiegazioni teoriche sul framework ridotte ai minimi termini (almeno nelle prime lezioni);
  • Esercizi alla fine di ogni lezione per dare la possibilità di lavorare sui concetti appresi;
  • Aggiornata alla versione 2.0 di C# e del .NET Framework e con riferimenti allo sviluppo multipiattaforma con Mono quando necessario;
  • Gli strumenti necessari per seguire la guida sono tutti disponibili gratuitamente (.NET SDK, Mono, Visual C# Express, Visual Web Developer Express, ecc...);
  • Massima qualità nei contenuti e commentabile da parte dei visitatori al fine di migliorarla e mantenerla aggiornata;
  • Non è un libro di 500 pagine, piuttosto una guida rapida online disponibile gratuitamente.

Per finire, ho scherzosamente creato una copertina sullo stile Wrox/Wiley, potete vederla qui :).
Per essere una prefazione di una guida concisa, sono stato fin troppo discorsivo, per cui vi auguro una buona lettura! ;-)

Requisiti software

Esercitarsi nello scrivere codice (esempi ed esercizi) è una delle migliori tecniche per apprendere C# e sfruttare al meglio questa guida. Si consiglia per cui di installare almeno uno dei seguenti framework:
  • .NET Framework 2.0 Software Development Kit (SDK): include compilatori, vari strumenti di sviluppo, esempi e documentazione. Disponibile solo per Windows, non include un editor visuale. Se installate il .NET Framework SDK, potete utilizzare il Blocco Note di Windows, SharpDevelop o un altro editor a vostro piacimento).
  • Mono: progetto Open Source sponsorizzato da Novell e consigliato per lo sviluppo crossplatform. Mono è disponibile per la maggior parte dei sistemi operativi (inclusi Mac OS X e Linux). Ha un editor simile a SharpDevelop chiamato MonoDevelop, che non è pero disponibile per Windows. Se desiderate installare Mono su Windows, potete sempre utilizzare Blocco Note o un altro editor di vostra scelta. Al momento Mono prevede lo sviluppo di applicazioni con le specifiche di C# 1.1, ma è possibile installarlo col supporto per alcune specifiche di C# 2.0. Gli interessati allo sviluppo multi-piattaforma, o coloro che utilizzano un sistema operativo diverso da Windows, possono anche considerare l'alternativa Shared Source CLI.

Se utilizzate Windows e volete un editor visuale per lo sviluppo rapido di applicazioni desktop potete utilizzare Visual C# 2005 Express Edition, mentre per il Web potete utilizzare Visual Web Developer 2005 Express Edition (sono entrambi gratuiti e includono il .NET Framework 2.0 nell'installazione) o addirittura Visual Studio .NET 2005 per la massima versalità.

La guida è focalizzata sul linguaggio C# piuttosto che sull'utilizzo di un particolare editor o piattaforma. Per questo motivo dovreste essere in grado di seguire le lezioni e apprendere velocemente C#, al di là del fatto che le schermate nella guida saranno leggermente differenti da ciò che vedrete sul vostro computer o che il vostro framework ha alcune "restrizioni" rispetto al .NET Framework.

Licenza

Guida concisa alla programmazione C# 2.0 è distribuita con una licenza Creative Commons. Proseguendo con la lettura state implicitamente accettando i termini d'uso, per cui fate click sull'icona seguente per leggere i dettagli legali:


Esercizi

ES. 0-1: Installate il software necessario per iniziare a lavorare con C#.

posted Monday, December 12, 2005 2:20 AM by Antonio with

gipoco.com is neither affiliated with the authors of this page nor responsible for its contents. This is a safe-cache copy of the original web site.