Il corso si rivolge a chi ha già dimestichezza con la programmazione ad oggetti e con linguaggi simili a Java o C++.

Transcript

1 1.Introduzione a C# C#, si legge «c sharp», può essere considerato il linguaggio di programmazione per eccellenza del Framework.NET: diversamente dagli altri linguaggi, come Visual Basic o C++, esso è nato espressamente per la nuova piattaforma. In questo senso, è significativo il fatto che Microsoft stessa si sia servita di C# per scrivere gran parte delle librerie di.net. Uno degli slogan che hanno accompagnato C# fin dalla sua nascita lo presenta come «un linguaggio facile come Java, potente come il C++». In effetti, come vedremo, le somiglianze con i due linguaggi sono molte, e non solo dal punto di vista della sintassi. Le differenze comunque ci sono ma la loro trattazione esula dagli obiettivi di questo corso, che si propone, invece, di analizzare nello specifico il linguaggio C#. Chi fosse interessato a differenze e somilgianze, può trovare maggiori informazioni usando i collegamenti a fine lezione (in lingua inglese) oppure, avendo a disposizione Visual Studio 2005, si possono trovare maggiori dettagli sull'argomento cercando «Comparison Between Java and C#» e «Comparison Between C++ and C#» nella guida in linea. Questa guida, in una prima fase, introdurrà ai concetti chiave di questo linguaggio, nella seconda parte del corso invece, ci si concentrerà sull'ambiente di sviluppo Visual Studio 2005 e sulle nuove funzionalità introdotte dalla versione 2.0 del Framework. Infine fornirà una panoramica degli strumenti messi a disposizione per la realizzazione di applicazioni web con ASP.NET. Il corso si rivolge a chi ha già dimestichezza con la programmazione ad oggetti e con linguaggi simili a Java o C++. Sono volutamente tralasciate le spiegazioni sulla sintassi di base: per esempio i costrutti if, switch, for, while, etc. Chi già conosce linguaggi come c++, Java, php o Javascript non vedrà grosse novità. Chi invece non avesse familiarità con i linguaggi cosiddetti "c-like" può trovare in fondo alla lezione un link per approfondire. In ogni caso, dove necessario per la comprensione del corso, saranno indicati esplicitamente i collegamenti con i concetti trattati su altre fonti. In queste prime pagine ci occuperemo delle caratteristiche proprie di C# e delle innovazioni che introduce nel modo di programmare. Al momento della stesura di questa guida, il Framework.NET 2.0 e Visual Studio 2005 sono ancora in fase di beta test (in particolare, è stato usato Visual Studio 2005 Beta 2), quindi è possibile, anche se in linea di massima non dovrebbe accadere, che alcune delle caratteristiche mostrate saranno diverse dalla versione finale. Poiché la versione italiana verrà rilasciata solo dopo il rilascio ufficiale del prodotto, si è fatto riferimento alle voci dei menù e delle finestre della versione inglese; ove possibile, è stata fornita una traduzione, che però in alcuni casi potrebbe non corrispondere con l'effettiva localizzazione in italiano.

2 Questa guida si propone di suscitare curiosità sul mondo di C#, fornendo però gli strumenti minimi necessari ad approfondire individualmente gli argomenti affrontati. 2.C# e VB.NET a confronto C# e Visual Basic.NET sono due tra i molti linguaggi di programmazione disponibili per la piattaforma.net. Il Common Language Runtime (CLR) del Framework.NET costituisce, infatti, una piattaforma di esecuzione comune per un gran numero di linguaggi, tra cui C++, J#, Cobol.NET. Più che stabilire quale sia il "migliore", è interessante capire le peculiarità di ciascun linguaggio. Ci soffermeremo sulla valutazione delle differenze più importanti. Ad una prima analisi è evidente che VB.NET risulta la scelta preferita per chi proviene dalle versioni precedenti di VB e ASP-VBScript, mentre C# è più accattivante per chi proviene da esperienze con C++ e Java. La sintassi di C# assomiglia moltissimo a quella di Java, mentre quella di VB.NET è evoluzione del Visual Basic. La differenza più importante nel passaggio dal vecchio al nuovo non riguarda tanto la sintassi quanto la sensazione di novità in termini di approccio alla programmazione ad oggetti. Chi è abituato a lavorare in C++ o Java trova un ambiente in cui i concetti sono analoghi quando non del tutto sovrapposti. Per esempio in.net come in Java tutto è un oggetto: è abbandonato ogni tipo di approccio ibrido con la programmazione strutturata in stile C++. Quindi chi proviene dai "vecchi" ASP e VB si trova davanti ad un linguaggio simile in alcuni aspetti della sintassi di base ma con un approccio alla programmazione a oggetti che è comune a tutto il Framework ed è più proprio di Java e compagnia. C# è un linguaggio nuovo, mentre VB.NET porta con sé l'eredità di tutte le versioni precedenti di Visual Basic (la sintassi di VB.NET, seppur aggiornata con il supporto agli oggetti, è praticamente la stessa di quella di Visual Basic 4.0, rilasciato nell'ormai lontano 1996). Un primo aspetto evidente è che il codice scritto in VB.NET risulta più lungo rispetto all'equivalente in C#. Consideriamo, per esempio, una funzione che prende in ingresso due numeri e ne calcola la media: //C# public double CalcolaMedia(double N1, double N2) return (N1 + N2) / 2; 'Visual Basic.NET Public Function CalcolaMedia(ByVal N1 As Double, ByVal N2 As Double) As Double Return (N1 + N2) / 2 End Function

3 Un'altra grande differenza, forse la più evidente, è che C# è case sensitive, ovvero fa distinzione tra maiuscole e minuscole, mentre VB case insensitive: per C# le variabili nomepersona e NomePersona sono diverse, mentre per Visual Basic.NET sono la stessa. Al di là delle differenze che riguardano la sintassi, C# permette di realizzare cose che in VB.NET non si possono fare, e viceversa. Ad esempio, C#, mostrando la sua derivazione dal C++, consente di utilizzare i puntatori, cosa che VB.NET non permette. Alcune differenze architetturali sono state colmate con la versione 2.0 del Framework, che introduce anche per Visual Basic.NET l'overloading degli operatori (altra caratteristica che C# ha preso da C++) e la possibilità di documentare il codice scritto utilizzando il linguaggio XML. Infatti C# permette la documentazione delle classi usando dei tag nel codice in modo molto somigliante ai commenti per JavaDocs. VB.NET, in particolare con la nuova versione del Framework, rende ancora più semplice e veloce la scrittura di applicazioni: tra i tanti esempi che si potrebbero fare a riguardo, citiamo il namespace My, che fornisce un rapido accesso a tutta una serie di proprietà e metodi di uso comune, consentendo uno sviluppo più efficiente. Le informazioni contenute nel namespace My sono comunque disponibili anche da C#, ma la sua presenza in VB.NET rende molto più agevole lo svolgimento di alcuni compiti. Ad esempio, per scaricare un file da Internet, usando Visual Basic.NET con il Framework 2.0 è sufficiente un'istruzione: My.Computer.Network.DownloadFile(" "C:/Test") In C# non esiste un oggetto My e dovremmo istanziare noi un oggetto della classe Network per ottenere lo stesso effetto. Inoltre, l'elenco dei membri che appare grazie all'intellisense in VB.NET è diviso in due schede in cui vengono messi in evidenza gli elementi di uso comune, facilitando la selezione della voce desiderata. In C# l'elenco dei membri viene sempre visualizzato nella sua interezza. Figura 1: L'IntelliSense di Visual Basic.NET Questa rapida carrellata sulle differenze tra C# e Visual Basic.NET non ha la pretesa di essere esaustiva: per maggiori informazioni (riguardanti soprattutto le più evidenti diversità di sintassi),

4 consultare i collegamenti a fine pagina. Inoltre, disponendo di Visual Studio 2005, è possibile ottenere maggiori dettagli sull'argomento cercando Language Equivalents nella guida in linea. 3.Il primo programma Il.NET framework SDK, ovvero l'insieme di tutti gli strumenti necessari alla creazione di software per la piattaforma.net, è liberamente scaricabile dal sito Microsoft. Dunque è sufficiente usare un editor di testi per sviluppare applicazioni.net, anche se quando ci si orientasse verso programmi più complessi e dotati di interfaccia grafica, l'adozione di un ambiente di sviluppo visuale diventa quasi indispensabile. Realizziamo subito il nostro primo programma. Costruiremo un'applicazione "console", ovvero eseguibile dal prompt dei comandi. Per scrivere un programma di questo tipo non è strettamente necessario un ambiente di sviluppo come Visual Studio (che analizzeremo in dettaglio nelle prossime Lezioni), data l'assenza di elementi grafici o di connessioni complesse tra classi. Pensiamo di voler realizzare la classica applicazione che stampa a video la stringa "Ciao Mondo!", aspetta che l'utente prema il tasto INVIO e, quindi, termina. Il codice è il seguente: public class HelloWorld public static void Main() System.Console.WriteLine("Ciao Mondo!"); System.Console.ReadLine(); Chi ha già una conoscenza di Java potrà notare una certa somiglianza, dal punto di vista della sintassi, tra i due linguaggi. Per eseguire il programma, salviamolo in un file di testo con nome, ad esempio, HelloWorld.cs. Lìestensione «.cs» contraddistingue i file sorgenti di C#. Con la versione 2.0 di.net, nel menù Start di Windows comparirà il gruppo Microsoft.NET Framework SDK v2.0, al cui interno si trova il comando SDK Command Prompt che permette di aprire un prompt dei comandi con le variabili di sistema per l'uso degli strumenti a riga di comando del Framework già impostate. Quindi possiamo spostarci nella cartella in cui è stato salvato il file «Hello.cs» e digitare il comando: >csc Hello.cs csc.exe è il compilatore C#, il risultato di questa operazione è un file eseguibile di nome «Hello.exe». Per avviare il frutto delle nostre fatiche è sufficiente digitare:

5 >Hello Figura 1. L'output del programma Iniziamo a prendere dimestichezza con la struttura di un programma C# esaminando le poche righe di questo esempio. L'espressione «public class HelloWorld» serve per definire una classe di nome «HelloWorld». Quello di classe è un concetto fondamentale, che approfondiremo nel corso delle prossime lezioni, al momento basti sapere che tutto il codice di un programma C# definisce classi e scambi di informazioni tra classi. main è un metodo particolare. Il cosiddetto punto di ingresso dell'applicazione, ovvero il primo metodo che viene richiamato quando si avvia il programma. Tutti i programmi eseguibili realizzati con C#, compresi quelli per Windows, devono avere una (e solo una) classe con all'interno un metodo main, altrimenti in fase di esecuzione si otterrà un messaggio di errore. L'istruzione System.Console.WriteLine() stampa a video il messaggio, mentre System.Console.ReadLine() fa sì che l'applicazione aspetti che l'utente prema il tasto INVIO prima di terminare. Abbiamo così realizzato un semplice programma in C#, per prendere subito confidenza con i primi strumenti e per stimolare la nostra curiosità su alcuni concetti che saranno trattati con maggior dettaglio nelle prossime lezioni. 4.Le classi (1a parte) Il concetto di classe è alla base di ogni linguaggio di programmazione orientato agli oggetti ed ha la potenza di definire le caratteristiche di un insieme di oggetti che hanno proprietà e compiono azioni uguali. Rappresenta tutti gli oggetti che appartengono ad una certa classe, appunto. Per fare un'esempio si pensi alle automobili: ogni automobile è diversa da un'altra ma tutte hanno quattro ruote un propulsore e compiono l'azione di avanzare o frenare. Questi elementi comuni le fanno rientrare in un unico concetto. Un'unica classe. Più praticamente una classe è una collezione di variabili, metodi e proprietà. Anche in questo caso, C# riprende la sintassi di Java dove per definire una classe si usa il costrutto class.

6 public class Persona string mnome; string mcognome; //Altre variabili... public Persona(string Nome, string Cognome) //Imposta le proprietà iniziali della classe. mnome = Nome; mcognome = Cognome; public void StampaMessaggio() private void Appoggio() Una classe è identificata anche come "tipo di dato", infatti porta con se sia la rappresentazione dei dati, sia le operazioni sugli stessi, in realtà il concetto di classe è più vasto. Possiamo però cosiderare le istanze di una classe, ovvero gli oggetti che realizzano il concetto di classe, come variabili definite da un certo tipo di dato. //Crea un oggetto p che è istanza della classe Persona Persona p = new Persona("Marco", "Minerva"); Per ogni classe istanziata, viene creato un'oggetto ed è invocato un metodo detto costruttore della classe. Il costruttore, così come avviene in Java e in C++, ha lo stesso nome della classe e non restituisce alcun valore (nel nostro esempio il metodo public Persona). In VB.NET, invece, il costruttore è definito in un metodo dichiarato come Sub New. Il costruttore è utilizzato per impostare le proprietà che la classe deve avere al momento della sua creazione: nel nostro esempio, quando si crea una istanza della classe Persona, le sue variabili mnome e mcognome assumono i valori specificati nel relativo argomento del costruttore. Dichiarazione dei metodi I metodi di una classe possono essere definiti come public, private, protected oppure internal (Friend in Visual Basic.NET): queste parole chiave vengono solitamente chiamate modificatori di accesso. Con public, una routine diventa accessibile da tutte le istanze della classe. Private, invece, impedisce che la routine sia visibile al di fuori della classe di in cui è definita. Se non si specifica il modificatore di accesso, private è il valore predefinito. Ad esempio, utilizzando ancora la nostra classe Persona:

7 Persona p = new Persona("Marco", "Minerva"); //Corretto, StampaMessaggio è public p.stampamessaggio(); //Errato, Appoggio è private, quindi non è accessibile p.appoggio(); Dichiarando una metodo della classe Persona come protected, essa sarà visibile nell'ambito in cui definiamo le classi che ereditano da Persona ma non potrà essere utilizzata nel codice in cui istanziamo oggetti di questa classe. L'ereditarietà sarà trattata nelle prossime lezioni. In pratica, protected equivale a private, con la differenza che il metodo è visibile anche alle classi che ereditano da quella principale. Infine, ciò che è dichiarato come internal è visibile solo all'interno dell'assembly dell'applicazione; per il concetto di assembly fare riferimento alle Lezioni dedicate all'uso di Visual Studio Dopo il modificatore di accesso del metodo, nella dichiarazione è necessario specificare il tipo di dato restituito. È possibile indicare un qualsiasi tipo di dato: int, string, byte, etc. Si può specificare anche il nome di una classe, poiché, ricordiamo, una classe è un tipo. Questo tipo di metodi corrisponde alle Function di VB. Per restituire il valore, è necessario utilizzare la parola chiave return, seguita da una qualsiasi espressione che abbia lo stesso tipo del valore di ritorno del metodo. Tale istruzione causa anche l'uscita dal metodo. Ad esempio: public int Quadrato(int N) return N * N; //Eventuale codice scritto qui non verrà eseguito. In C# un metodo che restituisce un valore deve obbligatoriamente contenere la parola chiave return, altrimenti, in fase di compilazione, si otterrà un errore. Le funzioni di Visual Basic, invece, possono non presentare il return: in tal caso il valore restituito è quello di default per il particolare tipo di dati. I metodi che non restituiscono un valore, come StampaMessaggio() e Appoggio() dell'esempio, hanno tipo void; essi corrispondono alle Sub di Visual Basic. Si può comunque usare la parola return in un metodo void, che in questo caso ha il solo scopo di uscire dalla procedura: in questo caso, quindi return non deve essere seguito da alcuna espressione.

8 5. Le classi (2a parte) Le proprietà Una classe può contenere anche un altro tipo di metodi, le cosiddette proprietà. Si tratta di particolari routine che permettano di leggere e/o impostare i valori di determinate proprietà di una classe. Aggiungiamo, per esempio, la seguente proprietà alla classe Persona: public string Nome get return mnome; set mnome = value; Essa permette di avere accesso in lettura/scrittura alla variabile mnome, che altrimenti non sarebbe visibile all'esterno della classe. Il blocco get deve restituire la variabile associata alla proprietà, quindi, come detto prima, deve contenere l'istruzione return. Il codice del blocco set, invece, viene eseguito quando si modifica il valore della proprietà; la parola chiave value contiene il nuovo valore da assegnare. L'utilizzo delle proprietà è intuitivo: Persona p = new Persona("Marco", "Minerva"); //Stampa "Marco" (richiama il blocco get) Console.WriteLine(p.Nome); //Imposta il nome a "Pippo" (richiama il blocco set) p.nome = "Pippo"; Allo stesso modo è possibile aggiungere una proprietà Cognome. È lecito domandarsi perché utilizzare le proprietà, quando si potrebbe più semplicemente rendere pubbliche le variabili mnome e mcognome. Conviene avere una classe con membri privati accessibili solo tramite proprietà quando si devono effettuare dei controlli sui valori assegnati ai membri stessi. Ad esempio, supponiamo di voler impedire che l'utente inserisca un nome o un cognome vuoto: se impostiamo le variabili mnome e mcognome come pubbliche questo controllo non può essere effettuato. Infatti si ha libero accesso alle variabili che possono essere impostate su qualunque stringa valida (compresa, dunque, la stringa vuota). Per risolvere il problema, è sufficiente definire i membri come privati e modificare la proprietà Nome nel modo seguente: public string Nome get return mnome; set if (value == string.empty)

9 mnome = "(Nessun nome)"; else mnome = value; In modo analogo, anche la proprietà Cognome deve essere ridefinita. string.empty è un campo a sola lettura che rappresenta la stringa vuota. Se Nome oppure Cognome vengono impostati sulla stringa vuota, questo codice li definisce, rispettivamente, come Nessun nome e Nessun cognome. Notiamo che, per ottenere un comportamento coerente di tutta la classe, anche il costruttore deve essere modificato in modo da effettuare un controllo sugli argomenti. È buona norma definire delle proprietà che consentano di modificare i valori delle variabili utilizzate da una classe, in modo da avere un maggior controllo sui dati specificati, piuttosto che dare libero accesso alle variabili stesse. Le proprietà possono anche essere di sola lettura, se dispongono del solo blocco get, oppure di sola scrittura, se hanno solo il codice associato al set. Per ottenere un comportamento analogo in Java oppure in C++, è necessario definire due metodi distinti, i cosiddetti metodi getter (per recuperare il valore) e setter (per impostarlo). Il codice completo della classe può essere scaricato qui. Nel file da scaricare è incluso un semplicissimo esempio di uso della classe Persona. Metodi «statici» Negli esempi visti finora, per accedere ai metodi della classe Persona occorreva creare un'istanza della classe. In alcuni casi, tuttavia, può risultare utile avere delle procedure che non hanno bisogno di un'istanza per essere utilizzate, ma che possono essere richiamate semplicemente con il nome della classe. Ad esempio, supponiamo che il metodo Quadrato di cui abbiamo parlato in precedenza sia contenuto nella classe «Matematica». È sensato pensare che una procedura di questo tipo possa essere richiamata senza dover prima creare un'istanza della classe che la contiene. Per questo si usa la parola chiave static (che corrisponde allo Shared di VB.NET): public static int Quadrato(int N) return N * N; L'utilizzo di questa routine è immediato: //q assume il valore 25 int q = Matematica.Quadrato(5);

10 Notiamo che le funzioni WriteLine() e ReadLine() della classe Console, che abbiamo introdotto in precedenza, sono proprio metodi statici. I namespace Più classi possono essere raggruppate in un unico namespace. Ad esempio: namespace Prova public class Classe1 public class Classe2 Con questo costrutto, per dichiarare, ad esempio, un oggetto di tipo Classe1 è necessario scrivere: Prova.Classe1 c1 = new Prova.Classe1(); lo stesso vale per Classe2. Fatto questo, è possibile accedere ai metodi ed alle proprietà delle classi nel modo consueto. I namespace sono sempre public. È possibile definire namespace annidati, ad esempio: namespace N1 namespace N2 public class Classe1 public class Classe2 N1.N2.Classe1 c1 = new N1.N2.Classe1(); N1.N2.Classe2 c2 = new N1.N2.Classe2(); Tutte le classi che compongono l'infrastruttura.net sono organizzate in namespace. Ad esempio, la classe Form, da cui ereditano tutte le Windows form (che tratteremo in seguito) è raggiungibile nel namespace Windows.System.Forms.Form. Per non dover indicare ogni volta i namespace in cui si trovano le classi che si stanno utilizzando, è possibile utilizzare la parola chiave using (analoga a import di Java), con cui si specifica in quali namespace devono essere cercate le classi. Le clausole using devono essere specificate all'inizio della classe, prima di qualunque altra istruzione. Ad esempio, nel programma «HelloWorld» realizzato nelle precedenti lezioni si fa uso

11 della classe Console, che è contenuta nel namespace System; invece di indicarlo esplicitamente, è possibile ricorrere alla parola chiave using: using System; public class HelloWorld public static void Main() Console.WriteLine("Ciao Mondo!"); Console.ReadLine(); 6. I tipi di dati base e passaggio dei parametri I tipi di dati base derivano direttamente dai tipi di dato di Java, dei quali conservano anche il nome, anche la conversione tra tipi di dato, il cosiddetto «casting» funziona alla maniera di Java. Ci sono invece novità introdotte da C# per quanto riguarda i tipi di dato definiti dall'utente: le struct e le enum. Il tipo struct permette di definire nuovi tipi di dati a partire da quelli esistenti: public struct Persona public string Nome; public string Cognome; Questa dichiarazione definisce un tipo di dato Persona composto da due variabili di tipo stringa (i cosiddetti membri della struttura). Notiamo che, a differenza del C++, da cui deriva il concetto di struct, ogni membro deve avere un modificatore di accesso (public, private, ecc.). Questo perché il tipo struct è molto potente: può essere dotato di un costruttore (che si comporta esattamente come il costruttore di una classe), di proprietà e di metodi. Modifichiamo la struttura Persona aggiungendovi un costruttore e una proprietà che restituisce il nome completo, quindi riprendiamo il nostro primo programma ed aggiorniamolo per mostrare l'uso della struct: public class HelloWorld public struct Persona public string Nome; public string Cognome; public Persona(string Nome, string Cognome)

12 this.nome = Nome; this.cognome = Cognome; public string NomeCompleto get return Nome + " " + Cognome; public static void Main() Persona p = new Persona("Marco", "Minerva"); System.Console.WriteLine("Ciao " + p.nomecompleto + "!"); System.Console.ReadLine(); All'interno del metodo Main la struttura Persona viene utilizzata come se si trattasse di una classe. Notiamo che, invece di usare il costruttore, avremmo potuto scrivere: Persona p; p.nome = "Marco"; p.cognome = "Minerva"; Ottenendo lo stesso risultato, ovvero la stampa del messaggio "Ciao Marco Minerva!". Questo è possibile perché i membri Nome e Cognome della struttura sono stati dichiarati public; se, invece, fossero stati definiti private, non sarebbe stato consentito utilizzare le tre istruzioni sopra riportate (si sarebbe ottenuto un errore in fase di compilazione, come già spiegato a proposito delle classi), e l'unico modo lecito di impostare i membri Nome e Cognome sarebbe stato quello di utilizzare il costruttore. Fare clic qui per scaricare l'esempio. A questo punto è naturale chiedersi quali siano le differenze tra struct e class. La spiegazione è fornita dalla guida in linea: "Il tipo struct è adatto alla rappresentazione di oggetti leggeri [...] Se ad esempio si dichiara una matrice di oggetti [classi] Point, si allocherà ulteriore memoria per i riferimenti a ciascun oggetto. In questo caso la struttura risulta meno onerosa". Inoltre una struct può implementare interfacce ma non può ereditare. Le enum consentono di associare nomi simbolici a costanti numeriche. Il costrutto deriva dal C++ dove i membri delle enum sono sempre di tipo «int», mentre in C# è possibile indicarne esplicitamente il tipo: public enum Stati : byte Italia, America, Francia, Inghilterra //,...

13 Questa dichiarazione definisce una enumerazione i cui membri sono di tipo byte. Richiamando il metodo ToString() di una variabile di tipo enum, è possibile ottenere la stringa contenente il nome simbolico del valore corrente. Ad esempio: Stati s = Stati.America; System.Console.WriteLine("Stato selezionato: " + s.tostring()); Questo codice stampa a video il messaggio "Stato selezionato: America". Concludiamo questa Lezione con qualche cenno sul passaggio dei parametri ai metodi. I parametri in C# possono essere passati in tre modi: in, out e ref. Queste parole chiave determinano cosa accade alla variabile passata come argomento quando si esce dal metodo. in è il tipo di passaggio predefinito: la routine non può modificare la variabile, o, meglio, qualunque modifica della variabile interna al metodo viene persa quando si esce dal suo scope (il tipico passaggio "per valore"). ref e out sono i classici passaggi di parametro per riferimento. Viene passato il riferimento (il puntatore) alla variabile e non il suo valore, così anche nello scope del metodo si fa riferimento allo stasso oggetto in memoria. La differenza tra ref e out è che ref richiede che si inizializzi la variabile prima della chiamata del metodo, mentre con out è sufficiente dichiarare la variabile e passarla senza inizializzazione. In pratica con out è possibile inizializzare intere strutture dati dall'interno di un metodo. Vediamo ora alcuni semplici esempi per chiarire quanto illustrato: // Se non specificato diversamente, il parametro è di tipo «in» public void Calcola(int N) N = 10; public void CalcolaOut(out int N) N = 10; public void CalcolaRef(ref int N) N += 1; Un possibile utilizzo di questi metodi è il seguente: int i = 7; Calcola(i); //All'uscita, i vale ancora 7 int i = 7; CalcolaRef(ref i); //All'uscita, i vale i + 1 = 8 // i è solo dichiarata non inizializzata int i; // la passiamo con «out»

14 CalcolaOut(out i); //All'uscita, i vale 10 Osserviamo che, per utilizzare un parametro out oppure ref nella chiamata ad un metodo, è necessario indicare esplicitamente che si tratta di un argomento passato out o ref. 7. Ereditarietà L'ereditarietà è uno dei concetti base della programmazione orientata agli oggetti. Si definisce ereditarietà la possibilità per una classe (detta classe derivata) di ereditare da un'altra (la classe base) le variabili, i metodi, le proprietà e di estendere il concetto della classe base e specializzarlo. Tornando all'esempio delle automobili potremmo avere come classi derivate da automobili le sottoclassi: «auto con cambio manuale» e «auto con cambio automatico». Entrambe le sottoclassi ereditano tutte le proprietà e i comportamenti della classe base ma specializzano il modo di cambiare le marce. Tutte le classi del Framework.NET ereditano implicitamente dalla classe base Object. In C# la relazione di ereditarietà tra le classi si esprime usando i due punti (:) che equivalgono a Inherits di VB.NET. Riprendiamo una parte della classe Persona che abbiamo realizzato in precedenza: public class Persona string mnome; protected string mcognome; public Persona(string Nome, string Cognome) mnome = Nome; mcognome = Cognome; public string Nome get return mnome; set mnome = value; //... Osserviamo che la variabile mcognome è stata dichiarata come protected. Vogliamo ora definire un nuovo concetto, quello di Studente, ovvero una Persona dotata di un numero di matricola. Per fare questo, Studente deve ereditare da Persona (si può dire anche che Studente estende Persona): public class Studente : Persona private int mmatricola;

15 public Studente(string Nome, string Cognome, int Matricola) : base(nome, Cognome) mmatricola = Matricola; public int Matricola get return mmatricola; set mmatricola = value; Avendo definito questa relazione, nella classe Studente è possibile utilizzare tutto ciò che in Persona è stato definito come public, protected o internal, sia esso una variabile, una routine o una proprietà. Ad esempio, all'interno di Studente è possibile utilizzare la variabile mcognome, che in Persona è definita protected, mentre mnome non è visibile, poiché il modificatore di accesso predefinito è private. Esaminiamo il frammento : base(nome, Cognome) subito dopo il costruttore di Studente. Esso richiama il costruttore della classe base passandogli gli argomenti specificati: in questo modo è possibile impostare le variabili mnome e mcognome della classe Persona sugli stessi valori passati al costruttore di Studente. Se avessimo voluto che il nome della persona, indipendentemente da quanto indicato nel costruttore di Studente, fosse sempre "Pippo", mentre il cognome fosse quello passato, sarebbe stato sufficiente scrivere: : base("pippo", Cognome) Questo costrutto è necessario perché, quando si crea un oggetto di una classe che deriva da un'altra, prima del costruttore della classe derivata viene richiamato quello della classe base: nel nostro esempio, quando si istanzia un oggetto di tipo Studente, viene richiamato prima il costruttore della classe Persona, e, in seguito, quello di Studente. Poiché la classe Persona non ha un costruttore senza argomenti, bisogna indicare esplicitamente tramite la parola chiave «base» quale costruttore richiamare. Se invece Persona avesse avuto un costruttore privo di argomenti, «base» non sarebbe servita. Oltre che a questo scopo, «base» serve, in generale, per avere accesso ai metodi, alle variabili ed alle proprietà della classe che si sta derivando. Il corrispondente di «base» in Visual Basic è la parola chiave MyBase. Provando a dichiarare oggetti di tipo Persona e Studente, si ottiene quanto segue: Studente stud = new Studente("Marco", "", 0); stud.matricola = ;

16 // Corretto: Matricola è una property della classe Studente stud.cognome = "Minerva"; // Corretto: Cognome è una property ereditata da Persona Persona pers = new Persona("Marco", ""); pers.cognome = "Minerva"; // Corretto: Cognome è una property della classe Persona pers.matricola = ; // Errato: la property Matricola non è visibile da Persona Senza le istruzioni : Persona e : base(nome, Cognome) nella classe Studente, eliminiremmo l'ereditarietà e otterremmo un messaggio di errore relativo all'istruzione: stud.cognome = "Minerva" Cliccare qui per scaricare le due classi Persona e Studente. Grazie all'ereditarietà, dove è previsto l'uso di una certa classe, è quasi sempre possibile utilizzare una classe derivata. Questo è, probabilmente, uno degli aspetti più interessanti dell'ereditarietà. Per esempio, supponiamo di avere una funzione che, ricevuti come argomenti due oggetti di tipo Persona, restituisce true se i loro nomi sono uguali: public static bool NomiUguali(Persona p1, Persona p2) return (p1.nome == p2.nome); Come argomenti a questa funzione, possono essere passati sia istanze della classe Persona, sia istanze di tutte le classi che ereditano da Persona, quindi anche oggetti di tipo Studente. Infatti, dal momento che esso eredita da Persona, dispone di tutte le proprietà pubbliche della classe base (in altre parole, uno Studente è una Persona, quindi può essere usato in tutti i contesti in cui è richiesta una Persona). Il seguente codice è corretto: Persona pers = new Persona("Marco", "Rossi"); Studente stud = new Studente("Marco", "Minerva", ); Console.WriteLine(NomiUguali(pers, stud)); // Stampa true Un fatto molto interessante è che all'interno della routine NomiUguali la variabile stud viene vista come una Persona, e, quindi, di stud sono visibili i metodi e le proprietà pubbliche della classe Persona, non quelli di Studente. È possibile scaricare un esempio di utilizzo cliccando qui. L'ereditarietà è singola, in C# come in VB.NET, ovvero una classe può avere solo una classe base, a differenza del C++, che supporta l'ereditarietà multipla: in altre parole, non è possibile definire una classe C che eredita contemporaneamente da A e da B. Torneremo su questi concetti più avanti.

17 8. Polimorfismo Il termine polimorfismo indica la possibilità di definire metodi e proprietà con lo stesso nome, in modo che, ad esempio, una classe derivata possa ridefinire un metodo della classe base con lo stesso nome. Continuiamo ad usare le nostre classi Persona e Studente realizzate nelle lezione precedente per capire il concetto di polimorfismo. Inizialmente, avevamo definito il metodo pubblico StampaMessaggio() nella classe Persona, ma non ne abbiamo ancora scritto il corpo. Vogliamo fare in modo che questa routine stampi a video le informazioni sulla persona. È naturale pensare che, analogamente, anche la classe Studente abbia un metodo StampaMessaggio() che mostri, oltre alle informazioni sulla persona, anche quelle proprie di uno studente. Perciò dobbiamo definire i metodi nel modo seguente: public class Persona //... public virtual void StampaMessaggio() System.Console.WriteLine("Nome: " + mnome + " " + mcognome); //... public class Studente : Persona //... public override void StampaMessaggio() System.Console.WriteLine("Nome: " + mnome + " " + mcognome); System.Console.WriteLine("Matricola: " + mmatricola); //... Il metodo StampaMessaggio() è definito in entrambe le classi, ma ha un comportamento diverso, dal momento che in Studente viene stampato anche il numero di matricola. A seconda che si dichiari un oggetto di tipo Persona oppure Studente, verrà richiamata la routine StampaMessaggio() corrispondente. Per fare questo, abbiamo usato il polimorfismo: il metodo StampaMessaggio() nella classe base è stato dichiarato usando la parola chiave «virtual» (che corrisponde a Overridable in Visual Basic.NET): con essa si indica che è possibile avere un'altra definizione per la stessa routine in una classe derivata. In Studente, infatti, StampaMessaggio() è stato definito specificando la parola chiave «override» (Overrides in VB): in questo modo si dice che tale funzione sovrascrive un metodo con lo stesso nome che è stato definito nella classe base.

18 In alcuni casi può essere necessario, all'interno del metodo ridefinito, richiamare il metodo che si sta ridefinendo. Nel nostro esempio, il metodo StampaMessaggio() della classe Studente potrebbe richiamare il metodo StampaMessaggio() di Persona, che si occupa già di mostrare il nome e il cognome, limitandosi quindi a stampare solo le informazioni proprie di uno studente. Per fare questo, si deve usare la parola chiave «base», che, come già accennato nella lezione precedente, consente di avere accesso alla classe che si sta derivando; alla luce di queste considerazioni, il metodo StampaMessaggio() di Studente diventa: public override void StampaMessaggio() base.stampamessaggio(); System.Console.WriteLine("Matricola: " + mmatricola); In pratica, base.stampamessaggio() richiama il metodo corrispondente nella classe base. L'esempio che abbiamo realizzato può essere scaricato cliccando qui. C'è anche un altro modo per sfruttare il polimorfismo, ovvero usando la parola chiave «new» (equivalente a Shadows in VB.NET), che nasconde una definizione della classe base con lo stesso nome. L'esempio sopra riportato, usando «new», diventa: public class Persona //... public void StampaMessaggio() System.Console.WriteLine("Nome: " + mnome + " " + mcognome); //... public class Studente : Persona //... public new void StampaMessaggio() base.stampamessaggio(); System.Console.WriteLine("Matricola: " + mmatricola); //... Come si vede, nella classe base la parola chiave «virtual» è sparita, mentre in Studente il metodo StampaMessaggio() è preceduto da «new». È possibile scaricare le due classi modificate cliccando qui. È importante notare che, usando la coppia «virtual» e «override», il metodo che sovrascrive una routine della classe base deve avere non solo lo stesso nome, ma anche lo stesso numero di argomenti e dello stesso tipo.

19 Invece, usando «new», è possibile ridefinire un metodo completatmente. Con «new» si può addirittura nascondere una variabile della classe base con un intero metodo nella classe derivata. Questa rapida panoramica è solo una introduzione al polimorfismo, per approfondire è sempre utile consultare la Guida in linea. 9. Overloading Overloading significa «sovraccaricare» ovvero definire più versioni di un metodo, utilizzando lo stesso nome ma una firma diversa. Per firma di un metodo si intede il numero e/o il tipo di argomenti nella dichiarazione. Sulla base degli argomenti effettivamente passati alla routine, verrà riconosciuta la firma e richiamato il metodo corretto. Vediamo subito un esempio: public static void Stampa(string Messaggio) System.Console.WriteLine("Il messaggio è: " + Messaggio); public static void Stampa(int Numero) System.Console.WriteLine("Il numero è: " + Numero); Le due definizioni della routine Stampa() differiscono solo per il tipo dell'argomento: string nel primo caso, int nel secondo. Richiamando questi due metodi, si ottiene il seguente risultato: //Stampa: "Il messaggio è: Questa è una stringa". Stampa("Questo è una stringa"); //Stampa: "Il numero è 15". Stampa(15); L'overloading viene spesso usato nella definizione del costruttore di una classe. Riprendiamo il costruttore della nostra classe Persona: public Persona(string Nome, string Cognome) if (Nome == string.empty) mnome = "(Nessun nome)"; else mnome = Nome; if (Cognome == string.empty)

20 mcognome = "(Nessun cognone)"; else mcognome = Cognome; Finora, per creare una persona senza nome né cognome, era necessario passare esplicitamente la stringa vuota nel costruttore: Persona p = new Persona("", ""); In questo caso, però, sarebbe preferibile poter istanziare la classe Persona senza passare alcun argomento al costruttore. Tale risultato può essere facilmente raggiunto con l'overloading del costruttore: public Persona() mnome = "Nessun nome"; mcognome = "Nessun cognome"; public Persona(string Nome, string Cognome) mnome = Nome; mcognome = Cognome; Così facendo, se si crea una Persona indicando nome e cognome, essi verranno salvati nelle variabili mnome e mcognome, poiché viene richiamato il costruttore Persona(string Nome, string Cognome), mentre, se si crea una Persona senza parametri, è invocato il costruttore Persona(), che imposta mnome e mcognome, rispettivamente, su "Nessun nome" e "Nessun cognome". //Imposta: mnome = Marco, mcognome = Minerva Persona p1 = new Persona("Marco", "Minerva"); //Imposta mnome = Nessun nome, mcognome = Nessun cognome Persona p2 = new Persona(); Un costruttore può chiamarne un altro. Nel nostro esempio, anziché assegnare esplicitamente le variabili mnome e mcognome nel costruttore senza argomenti, sarebbe stato possibile richiamare l'altro costruttore, "dicendogli" come impostare il nome e il cognome della persona: public Persona() : this("nessun nome", "Nessun cognome") La parola chiave «this» permette di avere accesso ai metodi, alle variabili ed alle proprietà della classe corrente, così come «base» permette di avere accesso alla classe da cui si eredita. Il corrispettivo di «this» in VB.NET è «Me». Questa soluzione è da preferire poiché, in caso di modifiche al costruttore, è sufficiente intervenire su un solo punto del codice.

21 Se, ad esempio, dopo aver creato la classe Persona, si decidesse che il nome deve essere sempre preceduto dalla stringa "Sig.", nel primo esempio di overloading del costruttore sarebbe stato necessario modificare il codice in due parti diverse. Nel caso in cui siano previsti più costruttori, le porzioni di codice da cambiare possono essere più numerose e, quindi, aumenta la probabilità di dimenticarsi qualche modifica. La nuova classe Persona è disponibile qui. Overloading degli operatori L'overloading degli operatori, derivato dal C++, consiste nel ridefinire il comportamento di operatori come +, -, <, >, ==, etc., affinchè assumano comportamenti a seconda degli oggetti cui sono applicati. C# supporta l'overloading degli operatori a partire dalla sua prima versione, mentre VB.NET ha introdotto questa funzionalità solo con la versione 2.0 del Framework. Partiamo come sempre dalla classe Persona. Non avendo altre informazioni, C# assume che due variabili di tipo Persona siano uguali se fanno riferimento all'istanza dello stesso oggetto, ovvero: Persona p1 = new Persona("Donald", "Duck"); Persona p2 = new Persona("Donald", "Duck"); //Stampa true Console.WriteLine(p1 == p1); //Stampa False, gli oggetti p1 e p2 sono diversi Console.WriteLine(p1 == p2); //Ora p2 fa riferimento alla stessa istanza di p1 p2 = p1; //Stampa true Console.WriteLine(p1 == p2); Quello che vorremmo, invece, è che due persone risultassero uguali se il nome e il cognome fossero gli stessi (nell'esempio sopra riportato, vorremmo che il primo confronto 'p1 == p2' restituisse true). Per fare questo, o ogni volta facciamo il controllo sulle proprietà Nome e Cognome oppure, più semplicemente, ridefiniamo l'operatore '==' per la classe Persona creando un metodo con la parola chiave «operator»: public static bool operator ==(Persona p1, Persona p2) if (p1.nome == p2.nome && p1.cognome == p2.cognome) return true; return false;

22 public static bool operator!=(persona p1, Persona p2) if (p1.nome!= p2.nome p1.cognome!= p2.cognome) return true; return false; Bisogna ridefinire insieme gli operartori che stabiliscono relazioni simili. Avendo ridefinito l'operatore '==', il Framework ci richiede che venga ridefinito anche l'operatore '!=' (e viceversa), così come, se avessimo ridefinito <, avremmo dovuto definire anche > (e viceversa). L'overloading degli operatori è sempre definito con metodi statici. Dopo l'indicazione del tipo di dato restituito (solitamente bool oppure lo stesso tipo della classe per cui si sta creando l'overloading, a seconda dell'operatore in questione), è necessario specificare l'operatore che si sta ridefinendo. Sulla guida in linea troviamo l'elenco di tutti gli operatori che possono essere sottoposti ad overloading. Infine, bisogna indicare a quali tipi di dati si applica: nel nostro esempio, '==' e '!=' si applicano a oggetti della classe Persona. Gli argomenti del metodo sono due nel caso di operatori binari (come mostrato nel nostro esempio), oppure uno solo se l'operatatore è unario (++, --, ecc.). Ridefinendo gli operatori '==' e '!=', il compilatore si aspetta che vengano anche ridefiniti i metodi Equals() e GetHashCode(), che ogni classe possiede in quanto li eredita dalla classe base Object. Ad ogni modo, se non vengono specificati, si ottiene solo un warning di compilazione. Definiamoli comunque, per avere una classe più robusta: public override bool Equals(object o) if (o is Persona) return this == (Persona) o; return (object)this == o; public override int GetHashCode() //Questa routine dovrebbe restituire un codice hash identificativo //dell'istanza corrente della classe. return 0; Nel metodo Equals() si è utilizzato l'operatore «is», necessario per controllare che l'oggetto passato alla funzione sia di tipo Persona: in caso positivo, l'oggetto viene convertito e il controllo sull'uguaglianza è fatto utilizzando la nostra definizione di '=='.

23 Altrimenti, l'oggetto corrente viene convertito ad Object, quindi si usa il confronto standard, per cui due variabili di tipo object sono uguali se fanno riferimento all'istanza dello stesso oggetto. Grazie a questa ridefinizione, ora possiamo ottenere il risultato desiderato: Persona p1 = new Persona("Donald", "Duck"); Persona p2 = new Persona("Donald", "Duck"); Console.WriteLine(p1 == p2); //Stampa true Console.WriteLine(p1.Equals(p2)); //Stampa true Cliccare qui per scaricare la classe Persona realizzata fino a questo punto. A titolo di esempio, nel file da scaricare è stato ridefinito anche l'operatore '+', che "somma" due persone, ovvero crea una nuova Persona il cui nome e cognome sono la concatenazione dei nomi e dei cognomi delle persone di partenza. Al di là dell'utilità di un'operazione del genere, si tratta comunque di un esempio in più da tenere in considerazione. 10. Le classi astratte Una classe astratta è un tipo particolare di classe di cui non si può creare una istanza con la parola chiave «new». Per essere utilizzata, infatti, deve essere obbligatoriamente ereditata. Mostriamo subito un esempio di classe astratta, partendo dal quale introdurremo una serie di importanti concetti: public abstract class Figura protected string mnome; protected int mnumerolati; public Figura(string Nome, int NumeroLati) mnome = Nome; mnumerolati = NumeroLati; public string Nome get return mnome; public int NumeroLati get return mnumerolati; public abstract double Perimetro get; public abstract double Area get;

24 public abstract void Disegna(); Una classe astratta si dichiara con la parola chiave «abstract». Al suo interno possono essere definite variabili, metodi e proprietà, proprio come abbiamo fatto finora (nell'esempio sopra riportato, le variabili mnome e mnumerolati, il costruttore, e le proprietà Nome e NumeroLati). Oltre a ciò, è possibile dichiarare un'altra serie di metodi e proprietà che devono essere obbligatoriamente implementate dalle classi che ereditano da essa: i cosiddetti metodi e proprietà astratti. Nel nostro caso, la classe che eredita da Figura deve fornire una implementazione delle proprietà Perimetro e Area (dalla definizione si comprende che saranno di sola lettura, se fossero state di lettura/scrittura avremmo avuto get; set;) e del metodo Disegna. La classe Quadrato eredita correttamente da Figura: public class Quadrato : Figura private double mlato; public Quadrato(int Lato) : base("quadrato", 4) mlato = Lato; public override double Perimetro get return mlato * 4; public override double Area get return mlato * mlato; public override void Disegna() //... Figura è la classe che racchiude le caratteristiche comuni ad ogni figura geometrica. La definizione fornita obbliga tutte le classi che ereditano da essa a ridefinire i metodi e le proprietà dichiarati abstract, altrimenti in fase di compilazione si otterrà un messaggio di errore in quanto alla dichiarazione del metodo non corrisponde nessuna azione concreta: nessun codice da eseguire. Ad esempio, eliminando il metodo Disegna dalla classe Quadrato, la compilazione fallisce segnalando che 'Quadrato' non implementa il metodo astratto ereditato Figura.Disegna().

25 Per le classi astratte valgono le stesse considerazioni fatte a proposito dell'ereditarietà, ovvero se un metodo richiede una classe astratta come argomento, al suo posto potrà essere utilizzata una qualunque classe che eredita da essa. In VB.NET una classe astratta si dichiara con MustInherit e un metodo astratto con MustOverride. 11. Le interfacce A differenza delle classi astratte, un'interfaccia è un gruppo completamente astratto di membri che può essere considerato come la definizione di un contratto: chi implementa una interfaccia si impegna a scrivere il codice per ciascun metodo. Questo significa, in primo luogo, che tutti i metodi e le proprietà definite all'interno di un'interfaccia sono implicitamente astratti, ovvero non è possibile fornirne l'implementazione all'interno dell'interfaccia stessa. Per creare un'interfaccia, si utilizza la parola chiave «interface»: public interface IEsempio void Metodo1(); bool Metodo2(); string Proprieta1 get; set; int Proprieta2 get; In questo esempio abbiamo seguito la convenzione secondo cui i nomi delle interfacce dovrebbe iniziare con la lettera I maiuscola. Tutto ciò che è dichiarato all'interno di una interfaccia è pubblico (ed è un errore indicare il modificatore public). Un'interfaccia non può contenere variabili, struct, enum e, come già accennato, implementazioni di metodi (tutte cose che, invece, sono consentite nelle classi astratte). Un'interfaccia viene implementata da una classe. Per indicare che una classe implementa un'interfaccia, in C# si usa il carattere ":", lo stesso con cui si esprime l'ereditarietà tra classi (in VB.NET si usa la parola chiave Implements): public class Esempio : IEsempio public void Metodo1() //... public bool Metodo2() return true; public string Proprieta1 get return string.empty; set /*...*/

26 public int Proprieta2 get return 0; Come avviene per le classi astratte, la classe che implementa un'interfaccia deve fornire l'implementazione di tutti i suoi metodi e delle sue proprietà, in questo caso però non c'è bisogno della parola chiave override, è sufficiente che i metodi definiti abbiano lo stesso nome con cui sono dichiarati nell'interfaccia. In VB.NET, invece, i nomi assegnati ai metodi non sono vincolanti, poiché il metodo dell'interfaccia che si sta implementando è indicato esplicitamente. Come già visto in precedenza, una classe può ereditare da una sola classe base, mentre può implementare un numero illimitato di interfacce: in questo caso, è necessario definire i metodi e le proprietà di tutte le interfacce: public class Studente : Persona, IEsempio1, IEsempio2 Questa dichiarazione indica che la classe Studente estende Persona e implementa IEsempio1 ed IEsempio2. Supponiamo che IEsempio1 ed IEsempio2 contengano un metodo con lo stesso nome, ad esempio un metodo void Calcola(). La classe Studente deve definirli entrambi: per evitare conflitti, i nomi dei metodi devono essere preceduti dal nome dall'interfaccia in cui sono definiti: public void IEsempio1.Calcola() public void IEsempio2.Calcola() Un'interfaccia può ereditarne un'altra: in questo caso, la classe che implementa l'interfaccia ereditata deve implementare non solo tutti i suoi metodi e proprietà, ma anche quelli dell'interfaccia base. Un oggetto che implementa un'interfaccia, inoltre, può essere utilizzato in tutte le parti del codice in cui è richiesta tale interfaccia, quindi anche le interfacce definiscono una nozione di ereditarietà. Sia le interfacce sia le classi astratte servono per definire una serie di funzionalità di base che devono essere realizzate dalle classi che le ereditano o le implementano. La scelta di utilizzare un'interfaccia oppure una classe astratta può a volte risultare difficile. MSDN consiglia: «Mediante le classi astratte possono essere forniti anche membri che sono già stati implementati. Pertanto, con una classe astratta è possibile garantire una certa quantità di funzionalità identiche, a differenza di quanto avviene con un'interfaccia (che non può contenere alcuna implementazione)[...]. Se le funzionalità da creare saranno utilizzate in una vasta gamma di oggetti diversi, usare un'interfaccia. Le classi astratte devono essere usate principalmente per gli oggetti strettamente correlati, mentre le interfacce sono più adatte a fornire funzionalità comuni a classi non correlate».