Slide che raccolgono vario materiale ed esempi per chi vuole imparare a programmare C#.

1. C# per tutti
Come imparare a programmare e sopravvivere
Matteo Valoriani
Microsoft Student Partner
matteo.valoriani@studentpartner.com

2. 2
Obiettivi del corso
• Fornire le basi teoriche per sviluppare
programmare con un linguaggio ad oggetti
• Fornire le basi proatiche per utilizzare il
framework .Net
• Familiarizzare con i tool di sviluppo

3. 3
Calendario e programma(2)
• 10/11 ore 16.15
– Lettura e scrittura file
– Serializzazione
– Installazione e utilizzo di Blend
– Eventi
– Grafica e MVVM
– XAML - Silverlight
– Applicazioni mobile
• 17/11 ore 16.15
– Utilizzo di Linq e accesso ai DB
– C# elementi avanzati: Extended, Optional parameter, Delegate, Named, Lambda expressions

4. 4
Calendario e programma
• 27/10 ore 16.15
– Installazione e utilizzo di Visual Studio 2010
– Principi di programmazione a oggetto (OO)
– C# primi passi: Oggetti, Tipi, Metodi, Costruttori
• 3/11 ore 16.15
– Overload, Eredità, Override
– Abstract, Interfaccie, Static
– Eccezioni, Documentazione

5. 5
Link utili
Libri e esempi:
• http://csharpcourse.com/
• http://msdn.microsoft.com/it-it/library/aa287551(v=VS.71).aspx
• http://www.microsoft.com/italy/beit/Default.aspx
Software:
• http://www.asict.polimi.it/software/microsoft/msdn-academic-alliance.html
• https://www.dreamspark.com/default.aspx
• http://weblogs.asp.net/sreejukg/archive/2011/01/06/documenting-c-library-using-
ghostdoc-and-sandcastle.aspx
• http://grantpalin.com/2010/01/10/net-projects-generating-documentation-with-
sandcastle/

6. 6
Storia (solo un po’)
• In principio fu la luce ….
• Gennaio 1999, Anders Hejlsberg crea un team per realizzare un
nuovo linguaggio chiamato Cool, C-like Object Oriented Language
• Gennaio 2002, il framework .Net è disponibile per il download e il
linguaggio è rinominato C#
• Settembre 2005, esce la v.2, C# diventa una valida alternativa a
Java
• Agosto 2007, esce la v.3 e successivamente la 3.5 (attualmente la
più usata) che introducono elementi funzionali nel linguaggio
• Aprile 2010, esce la v.4

7. 7
Caratteristiche di C#
• Multi-paradigm programming language
• Language interoperability(C/C++, VB,…)
• Interoperabilità via standard web(SOAP, XML,…)
• Linguaggio Object Oriented (Tutto è DAVVERO un
oggetto)

8. 8
Framework .Net
• Ambiente di programmazione orientato agli oggetti
coerente
• Minimizzi la distribuzione del software e i conflitti di
versioni.
• Esecuzione sicura anche dei codici creati da produttori
sconosciuti o semi-trusted.
• Elimanre i problemi di prestazioni degli ambienti basati su
script o interpretati.
• Rendere coerente l'esperienza dello sviluppatore attraverso
tipi molto vari di applicazioni(web, windows, mobile)
• Generare tutte le comunicazioni in base agli standard
industriali per assicurare che il codice basato su .NET
Framework possa integrarsi con qualsiasi altro codice.

9. 9
Framework .Net(2)

10. 10
Architettura

11. Programmazione a Oggetti
11

12. 12
Prima della programmazione OO
• Anni ‘50 e inizio anni ’60, programmazione a spaghetti:
– Basata sul salto incondizionato GOTO
• Anni ’60, programmazione strutturata:
– GOTO = ALTERNATIVA + RIPETIZIONE + SEQUENZA
– Programma come workflow

13. 13
Prima della programmazione OO
• Anni ’60, programmazione Modulare:
– Programma composto da moduli che cooperano
– Ogni modulo è indipendente
– Moduli riusabili
– Sviluppo separato

14. 14
I primi linguaggi OO
• Fine anni ’60, ideata la programmazione a oggetti
• Anni ’70, nasce il primo linguaggio a oggetti
SmallTalk
• Anni ’80, vengono sviluppati ADA e C# e si
diffonde la programmazione ad oggetto

15. 15
Principi di Programmazione OO
• Astrazione dell’idea di programma:
– Prende spunto dal mondo «reale» per creare un mondo «virtuale»
– Ogni programma è un insieme di «Oggetti» che interagiscono
• Le «Classi»:
– Idea platonica della forma, la
– Dichiarazione delle strutture dati interne
– Operazioni, «metodi», che si possono
eseguire sulla struttura dati
Le classi costituiscono dei modelli astratti, che a tempo di
esecuzione sono istanziati per creare oggetti software. Questi
ultimi sono dotati di proprietà e di metodi secondo quanto
dichiarato dalle rispettive classi.

16. 16
Oggetti
• Stato di un oggetto
– Lo stato rappresenta la condizione in cui si trova l’oggetto
– Lo stato è definito dai valori delle variabili interne all'oggetto
(proprietà)
• Comportamento di un oggetto (behavior)
– Determina come agisce e reagisce un oggetto
– È definito dall’insieme di operazioni che l’oggetto può compiere
(metodi)

17. 17
Oggetto vs Classe
Compile Time Run Time
Studente.class Mario
Identity=1
Studente
Laura
Identity=2
Stessa struttura, ma dati
diversi. Sono due diverse
CLR istanze.

18. 18
Istanze
Nome Classe
persona1
Persona
Nome istanza Valore
______________________ dell’attributo
dell’oggetto
Nome = «Mario»
Cognome = «Verdi»
Nome
dell’attributo
Indirizzo = «Via Roma»
Numero = «3»
_____________________
Mangiare
Dormire
Operazioni che Cambiare abitazione
la classe è in
grado di fare

19. 19
Caratteristiche Linguaggio OO
Incapsulamento:
• i dati che definiscono lo stato interno di un
oggetto sono accessibili solo ai metodi
dell'oggetto stesso.
• Per alterare lo stato interno dell'oggetto, è
necessario invocarne i metodi.
• L'oggetto è come una black-box, cioè una
«scatola nera» di cui attraverso l'interfaccia è
noto cosa fa, ma non come lo fa.
• Information hiding, gestione della visibilità di
quello che accade dentro la scatola

20. 20
Caratteristiche Linguaggio OO (2)
Ereditarietà:
• Permette di derivare nuove classi
a partire da quelle già definite.
• Una classe derivata,
sottoclasse, mantiene i metodi e gli attributi delle classi da
cui deriva (classi base, o superclassi)
• La sottoclasse può definire i propri metodi o attributi e può
ridefinire i metodi ereditati (overriding)
• Quando una classe eredita da una sola superclasse si parla
di eredità singola; viceversa, si parla di eredità multipla.
• Meccanismo per ottenere l'estensibilità e il riuso del codice

21. 21
Caratteristiche Linguaggio OO (3)
Polimorfismo:
• Le istanze di una sottoclasse possono essere
utilizzate al posto di istanze della superclasse
• I metodi che vengono ridefiniti in una sottoclasse
sono detti polimorfi, in quanto lo stesso metodo si
comporta diversamente a seconda del tipo di
oggetto su cui è invocato.

22. 22
Altre keyword
• Interfaccia:
– Tipi e operazioni definiti in un componente che sono
visibili fuori del componente stesso.
• Specifica:
– Funzionamento del componente, espresso mediante
proprietà osservabili attraverso l'interfaccia.
• Implementazione:
– Strutture dati e funzioni definiti dentro al componente,
non necessariamente visibili da fuori.

23. 23
Pensare ad oggetti
• In un programma di tipo procedurale, si è soliti
iniziare a ragionare in maniera top-down, partendo
cioè dal main e creando mano a mano tutte le
procedure necessarie.
• Pensare ad oggetti vuole dire identificare gli oggetti
che entrano in gioco nel programma che vogliamo
sviluppare e saperne gestire l'interazione degli uni
con gli altri.
• Nella programmazione ad oggetti serve definire
prima le classi e poi associare ad esse le proprietà ed i
metodi opportuni.

24. 24
Come si scelgono gli oggetti?
• Cosa si vuole che sia in grado di fare?
– Un oggetto che abbia uno o due soli metodi deve fare
riflettere
– Oggetti senza o con troppi metodi sono, in genere, da
evitare
• Quali proprietà sono necessarie affinché l'oggetto sia
in grado di eseguire le proprie azioni?
– Attributi, proprietà che descrivono le caratteristiche
peculiari di un oggetto (peso, altezza, …)
– Componenti, proprietà che sono atte a svolgere delle
azioni(testa, mani, piedi, …)
– Peer objects, proprietà che a loro volta sono identificate e
definite in altri oggetti (auto di una persona,…)

25. 25
Accoppiamento & Coesione
• Accoppiamento: quanto sono legate (dipendenze
reciproche) due unità separate di un programma.
• Coesione: quantità e eterogeneità dei task di cui una
singola unità (una classe o un metodo) è responsabile. Se
una classe ha una responsabilità ristretta ad un solo
compito il valore della coesione è elevato.
Obiettivo: alta coesione e basso accoppiamento

26. C#
Ora iniziamo veramente

27. 27
Visual studio 2010
• Integrated Development Environment (IDE)
• Supporto a molti linguaggi: C, C++, C#, F#, Visual
Basic .Net e ASP .Net
• Integra la tecnologia IntelliSense la quale
permette di correggere errori prima ancora di
compilare

28. 28
Console Application
• No componenti visuali (buttons, text boxes, etc.)
• Solo output di testo
• Due tipi:
– MS-DOS prompt - Windows 95/98/ME
– Command prompt - Windows 2000/NT/XP

29. 29
Struttura di un progetto
Insieme di progetti
Cartella che contiene
le librerie
File .CS : contiene il codice C# di una
classe
Progetto: raccoglie classi che
realizzano il programma

30. 30
Ciao Corso
Indica dove prendere le librerie usate
using System;
Metodo per raggruppare le
funzionalità
namespace CiaoCorso
{ Nome della classe
class Program
{
static void Main(string[] args)
{
// Scrive sulla console
System.Console.WriteLine("Ciao Corso");
// Aspettta che la persona digiti un carattere
System.Console.ReadKey(); }
}
} Metodo speciale: punto di ingresso
dell’applicazione. Ogni applicazione ne
deve avere uno.

31. 31
Ciao Corso (2)
Commenti
// Scrive sulla console
System.Console.WriteLine("Ciao Corso");
// Aspettta che la persona digiti un carattere
System.Console.ReadKey();
Namespace Metodo
Oggetto

32. 32
Strutture base: Cicli
Numero fisso di volte
For:
for (int i = 0; i < length; i++)
{//fai qualcosa} Finche la condizione è vera il
While: ciclo continua
while (condizione==true)
{ //fai qualcosa }
Do:
do{//fai qualcosa
} while (condizione== true);

33. 33
Strutture base: Cicli(2)
For:
foreach (Persona item in listaPersone)
{
item.ChiSei();
}

34. 34
Alternative
If
if (condizione == true)
{//fai qualcosa }
else
{//fai qualcosa}
Switch
switch (switch_on) {
case 1://fai qualcosa
break;
case 2://fai qualcosa
break;
default: //fai qualcosa
}

35. 35
Creare una classe
class NomeClasse
{
//Proprità
visibilità tipo nomeProrpietà;
//Costruttore
public NomeClasse() { }
//Metodi
visibilità tipoRitornato nomeMetodo1() { }
}

36. 36
Tipi
• Signed  sbyte, short, int, long
• Unsigned  byte, ushort, uint, ulong
• Character  char
• Floating-point  float, double, decimal
• Logical  bool
• Reference  object, string
In realtà tutti sono tipi «alias» di oggetti:
• object: System.Object
• string: System.String
• bool: System.Boolean
• int: System.Int32

37. 37
Enum
• Modo efficiente per definire un insieme di costanti integrali che possono
essere assegnate a una variabile
• Per impostazione predefinita, il tipo sottostante di ogni elemento
dell'enumerazione è int, ma si può assegnare altri tipi numerici
• Si può assegnare in modo esplicito il valore
enum Days { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday,
Saturday };
enum Months : byte { Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct,
Nov, Dec };
enum MachineState { PowerOff = 0, Running = 5, Sleeping = 10,
Hibernating = Sleeping + 5 }
Days meetingDay = Days.Monday;
Console.WriteLine(meetingDay ); //Monday

38. 38
Modificatori di accesso
public Nessuna restrizione di accesso.
protected L'accesso è limitato alla classe di appartenenza o
ai tipi derivati dalla classe di appartenenza.
internal L'accesso è limitato all'assembly corrente.
protected internal L'accesso è limitato all'assembly corrente o ai
tipi derivati dalla classe di appartenenza.
private L'accesso è limitato al tipo di appartenenza.

39. 39
Campi e Proprietà
Le proprietà consentono a una classe di esporre un modo
pubblico per ottenere e impostare valori, nascondendo
tuttavia il codice di implementazione o di verifica.
Campo Parola chiave usata alla fine di
metodi che restituiscono un valore
private string email;
public string Email Parola chiave, si riferisce al valore
passato che vogliamo assegnare
Proprietà {
get { return email; }
set { email = value; }
}
Abilito la letture, get, e la scrittura della proprietà, set

40. 40
Metodi
«Azioni» che permettono di interagire con gli oggetti
Tipo restituito
Creo una stringa vuota
public string ChiSei() {
string result = "";
result = "Io sono " + nome + " " + cognome + "/n";
result = result + "La mia email è " + email;
return result;
} Il simbolo + viene usato per
«concatenare», cioè unire, le stringhe
Alla stringa iniziale concateno altre parti
Valore restituito dalla funzione

41. 41
Costruttori
Servono per creare l’istanza della classe, cioè l’oggetto
usato durante l’esecuzione del programma
private string Nome;
private string Cognome;
public Persona(string Nome, string Cognome) {
this.Nome = Nome;
this.Cognome = Cognome;
}
La keyword this permette di risolvere i problemi di nomi

42. 42
Overload
Metodo con stesso nome, ma con parametri diversi o con valore di ritorno
diverso
public Persona(string Nome, string Cognome, ) {
this.Nome = Nome;
this.Cognome = Cognome;
}
public Persona(string nome, string cognome, string email)
{
this.nome = nome;
this.cognome = cognome;
this.email = email;
}

43. 43
Utilizzo dei metodi
static void Main(string[] args)
{
Persona mario = new Persona("Mario", "Verdi");
La keyword new, serve per creare nuovi
oggetti. Si usa prima del costruttore
mario.Email = "mario@polimi.it";
Le proprietà si utilizzano semplicemente con = senza le ()
string rit = mario.ChiSei();
Console.Write(rit);
Classica chiamata di un
Console.ReadKey();
metodo con valore di
} ritorno

44. 44
Ereditarietà
Permette di estendere classi già esistenti con nuove funzionalità, senza dover
riscrivere tutto il codice
class Studente : Persona
{ … } Classe da cui eredita
Nuova classe
• La classe Studente(S) è effettivamente sia Studente che Persona(P).
• È possibile utilizzare un'operazione di «cast» per convertire S in un oggetto P.
L'operazione di cast non implica la modifica dell'oggetto S, ma limita
semplicemente la visualizzazione dell'oggetto S ai dati e ai comportamenti
dell'oggetto P
• Dopo aver eseguito il cast di un oggetto S in un oggetto P, è possibile eseguire il
cast dell'oggetto P per convertirlo di nuovo in S.
• Non è possibile fare il cast da P a S se l’oggetto non è un istanza di S.

45. 45
Richiamo costruttore base
private int matricola;
public Studente(string nome, string cognome,
int matricola) : base(nome, cognome) {
this.matricola = matricola;
}
• La keyword «base» che richiama i metodi della classe base, in questo caso
direttamente il costruttore, e gli passa i parametri
• Dopo l’esecuzione del costruttore della classe base, vengono eseguite le
operazioni rimanenti.

46. 46
Richiamo costruttore base(2)
private int matricola;
public Studente(string nome, string cognome,
int matricola) : base(nome, cognome) {
this.matricola = matricola;
}
• La keyword «base» che richiama i metodi della classe base, in questo caso
direttamente il costruttore, e gli passa i parametri
• Dopo l’esecuzione del costruttore della classe base, vengono eseguite le
operazioni rimanenti.
public Studente(string nome, string cognome) :
this(nome, cognome, 00000) { }
• In questo caso il costruttore richiama il costruttore definito prima settando un
valore di default per la matricola

47. 47
Override
• Sostituisco un metodo della classe base
public virtual string ChiSei()
Nella classe base aggiungo la parola «virtual»
public override string ChiSei() {
string result = base.ChiSei();
result = result + "n" + "La mia matricola è " +
matricola;
return result;
}
Nella sottoclasse aggiungo la parola «override» prima
del metodo

48. 48
Override(2)
Metodo alternativo:
public new string ChiSei() {
string result = base.ChiSei();
result = result + "n" + "La mia matricola è " +
matricola;
return result;
} Nella sottoclasse aggiungo la parola «new» prima del
metodo
• In realtà new nasconde la definizione della classe base con lo
stesso nome
• Il comportamento risultante è diverso rispetto a override

49. 49
new Vs override
Studente mario = new Studente("Mario", "Verdi");
mario.Email = "mario@polimi.it";
string rit = mario.ChiSei();
Console.Write(rit);
Casting, uso mario come un oggetto Persona
Console.Write("nn");
rit = (mario as Persona).ChiSei();
Console.Write(rit);
Console.ReadKey();

50. 50
new Vs override
Se uso new Se uso virtual+override
DerivedClass B = new DerivedClass(); DerivedClass B = new DerivedClass();
B.DoWork(); B.DoWork();
// Calls the new method. // Calls the new method.
BaseClass A = (BaseClass)B; BaseClass A = (BaseClass)B;
A.DoWork(); A.DoWork();
// Also calls the old method. // Also calls the new method.

51. 51
Classi e metodi «sealed»
public sealed class D { // Class members here. }
• Una classe sealed non può essere utilizzata come classe
base.
public class D : C {
public sealed override void DoWork() { }
}
La parola chiave sealed prima della parola chiave override
nega l'aspetto virtuale del membro per qualsiasi ulteriore
classe derivata. Non si può utilizzare override nelle sottoclassi.

52. 52
Classi e metodi «abstract»
• Non è possibile creare un'istanza di una classe astratta.
• Scopo di una classe astratta è di fornire una definizione comune di una
classe base condivisibile da più classi derivate.
public abstract class A { // Class members here. }
• Le classi astratte possono inoltre definire metodi astratti aggiungendo la
parola chiave abstract prima del tipo restituito del metodo
public abstract class A {
public abstract void DoWork(int i);
}
• I metodi astratti non prevedono implementazione
• La definizione del metodo è seguita da un punto e virgola.
• Le classi derivate della classe astratta devono implementare tutti i
metodi astratti.

53. 53
«interface»
• Le interfacce vengono definite tramite la parola chiave «interface»
• 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.
• I membri delle interfacce sono automaticamente pubblici.
public interface IEsempio {
void Metodo1();
bool Metodo2();
string Proprieta1 { get; set; }
int Proprieta2 { get; }
}
public class Esempio : Iesempio{// Implementazione. }

54. 54
Struttura ad oggetti
Descrive i metodi che tutte le
Interfaccia
classi devono implementare
Implementazione dei metodi
Classe Astratta
validi per tutte le classi
Classe Classe Implementazione specifica dei
Concreta1 Concreta2 metodi e funzionalità aggiuntive

55. 55
Classi e metodi «Static»
• Le classi statiche e i relativi membri vengono utilizzati per creare dati e funzioni a
cui sia possibile accedere senza creare un'istanza della classe.
• Una classe può essere dichiarata statica per indicare che contiene solo membri
statici.
• Non è possibile creare istanze di una classe statica utilizzando la parola chiave
new.
• Spesso usate come classi di supporto
static class TempConverter {
public static double CelsiusToFahrenheit(string temperatureCelsius){
double celsius = System.Double.Parse(temperatureCelsius);
double fahrenheit = (celsius * 9 / 5) + 32;
return fahrenheit; }
//... }

56. 56
Visual Studio 2010
• IntelliSense: completamento automatico del codice che si attiva non
appena si inizia a digitare qualcosa nell'editor.
• Refactoring: con questo termine si intende una serie di funzionalità che
permettono di modificare velocemente e sistematicamente il codice
scritto.
• Code Snippets e Surrounding: gli "snippet" sono porzioni di codice di uso
comune, come il codice dei costrutti for e while. Clic col tasto destro del
mouse nella finestra del codice e selezionando il comando Insert
Snippet..., oppure digitando il nome dello snippet e premendo due volte
il tasto TAB

57. 57
Convenzioni dei nomi
• Convenzione Pascal:
– La prima lettera dell'identificatore e la prima lettera di
ogni parola concatenata successiva sono in
maiuscolo. È possibile utilizzare la convenzione Pascal
per gli identificatori costituiti da tre o più
caratteri. (BackColor)
• Convenzione Camel:
– La prima lettera dell'identificatore è in minuscolo,
mentre la prima lettera di ogni parola concatenata
successiva è in maiuscolo. (backColor)

58. 58
Convenzioni dei nomi(2)
Identificatore Case Esempio
Classe Pascal AppDomain
Tipo di enumerazione Pascal ErrorLevel
Valori di enumerazione Pascal FatalError
Evento Pascal ValueChanged
Classe dell'eccezione Pascal WebException
Campo statico di sola lettura Pascal RedValue
Interfaccia Pascal IDisposable
Metodo Pascal ToString
Spazio dei nomi Pascal System.Drawing
Parametro Camel typeName
Property Pascal BackColor

59. 59
Documentazione
// commenti in una sola riga
/* commenti su più righe */
/// Commenti per la generazione della
documentazione XML
• In C# è possibile creare documentazione per il codice includendo
tag XML nel commento del codice sorgente subito prima del blocco
di codice cui fanno riferimento.
<c> <para> <see>
<code> <param> <seealso>
<example> <paramref> <summary>
<exception> <permission> <typeparam>
<include> <remarks> <typeparamref>
<list> <returns> <value>

60. 60
Documentazione(2)
/// <summary>
/// Descrizione del metodo
/// </summary>
/// <param name="nomeParametro1">Descrizione
Parametro1</param>
/// <exception cref="Exception">Sollevata quando
...</exception>
/// <returns> Descrizione valore di
ritorno</returns>

61. 61
Documentazione(3)
• /// + tab inserisce automaticamente parte dei
commenti
• Sandle Castle permette di generare la
documentazione in vari formati.
http://sandcastle.codeplex.com/
• Sandcastle Help File Builder
http://shfb.codeplex.com/
• http://broadcast.oreilly.com/2010/09/build-html-documentation-for-
y.html#Step1
• http://weblogs.asp.net/sreejukg/archive/2011/01/06/documenting-c-library-
using-ghostdoc-and-sandcastle.aspx

62. 62
Eccezioni
Throw:
static double SafeDivision(double x, double y) {
if (y == 0)
throw new System.DivideByZeroException();
return x / y;
} Parola chiave per «sollevare» le eccezioni

63. 63
Eccezioni(2)
Try/Cath/Finally: In questo blocco si inseriscono le
try { operazioni che si tentano di eseguire
result = SafeDivision(a, b);
Console.WriteLine("{0} divided by {1} = {2}", a, b, result);
}
Istruzioni da eseguire se si verificano
catch (DivideByZeroException e) { Eccezioni di tipo DivideByZeroException
Console.WriteLine("Divisione per 0");
} Istruzioni da eseguire se si verificano Eccezioni
catch (Exception e) { di tipo diverso da DivideByZeroException
Console.WriteLine("Altra eccezione");
}
finally { Console.WriteLine("Fine programma");
Cosolole.ReadLine(); } Operazioni che volgiamo comunque eseguire

64. 64
Eccezioni(3)
• Se per una determinata eccezione non sono presenti gestori,
l'esecuzione del programma verrà interrotta con un messaggio di
errore
• Gli oggetti eccezione contengono informazioni dettagliate
sull'errore, ad esempio lo stato dello stack di chiamate e una
descrizione dell'errore
• È meglio evitare la gestione delle eccezioni, cercando di prevedere
le cause che possono portare ad una situazione imprevista
• Un abuso di try...catch può appesantire molto un programma

65. 65
Eccezioni Personalizzate
class MiaException : Exception
{
public MiaException() : base() { }
public MiaException(string message) : base(message) {}
public MiaException(string message, System.Exception inner)
: base(message, inner) { }
protected MiaException(System.Runtime.Serialization.
SerializationInfo info,System.Runtime.Serialization.
StreamingContext context) { }
}
• Costruttori che dovrebbero essere implementati nella nuova
classe
• È possibile aggiungere altri costruttori e metodi

66. 66
Delegati
• Meccanismo per associare ad un metodo un
implementazione realizzata da un’altro metodo
• Simile ai puntatori a finzione del C e alle callback
di C++
• I delegati si possono sommare (+=) e sottrarre (-=)

67. 67
Delegati(2)
public delegate double Delegato(double dVal); // dichiaro un metodo che può essere delegato
class Program {
static void Main(string[] args) {
Program pr = new Program();
// associo al metodo delegato una implementazione
Delegato q = new Delegato(pr.Quadrato);
q += new Delegato(pr.Cubo);
// eseguo le normali operazioni sul delegato
double dVal = Double.Parse(Console.ReadLine());
dVal = q(dVal); Console.ReadKey(); }
//implementazione del metodo quadrato
public double Quadrato(double dVal) {
Console.WriteLine("sono il delegato calcolo il quadrato di " + dVal + " : " + dVal*dVal);
return dVal*dVal; }
//implementazione del metodo cubo
public double Cubo(double dVal) {
Console.WriteLine("sono il delegato calcolo il cubo di " + " : " + dVal * dVal*dVal);
return dVal* dVal * dVal; }
}

68. 68
Eventi
• Gli eventi sono simili alle chiamate di metodo, ma la
loro invocazione deve essere generata esternamente.
• Un esempio è la pressione di un pulsante in una
interfaccia grafica o una pagina web.
• Tramite gli eventi una classe o un oggetto sono in
grado di segnalare ad altre classi o oggetti una
situazione di interesse.
• La classe che genera l'evento è chiamata autore e le
classi che gestiscono l'evento sono chiamate
«hendler».

69. 69
Eventi(2)
class OggettoConEvento
{
public event EventHandler nuovoEvento;
public void ScatenaEvento( {
if (nuovoEvento != null)
nuovoEvento(this, EventArgs.Empty); } }
class Program {
static void Main(string[] args) {
OggettoConEvento obj = new OggettoConEvento();
obj.nuovoEvento += new EventHandler(obj_nuovoEvento);
System.Threading.Thread.Sleep(1000*4);
obj.ScatenaEvento(); }
static void obj_nuovoEvento(object sender, EventArgs e) {
Console.WriteLine("si è scatenato un evento");
Console.ReadKey(); }
}

70. 70
Operazioni su file
• La classe statica File permette le operazioni sui file
• Verificare che un file esiste:
File.Exists(FILE_NAME);
• FileStream permette di accedere o creare un file:
FileStream fs = new FileStream("test.txt",
FileMode.Open, FileAccess.ReadWrite);
• Sempre chiudere il file al termine delle operazioni o le modifiche
potrebbero andare perse:
fs.Close();

71. 71
Scrivere e leggere su file
StreamWriter sr = new StreamWriter(fs);
sr.Write(text);
sr.Close(); Prende come parametro uno Stream o il
nome del file
Esistono varie modalità di scrittura
StreamReader sr = new StreamReader("test.txt");
string res = sr.ReadLine();
sr.Close();
Analogo al Writer

72. 72
Scrivere e leggere su file
• Attenzione a gestire le numerose eccezioni che
possono essere sollevate
• Si può eseguire operazioni anche in file binario
(BinaryWriter e BinaryReader)
• Esistono molte variazioni sul tema

73. 73
Serializzazione
• Utile per salvare un oggetto in un supporto di memorizzazione
lineare (un file o un'area di memoria) o per trasmetterlo su una
connessione di rete
• In forma binaria o può utilizzare codifiche testuali (XML,…)
• Lo stato dell'oggetto può essere ricreato nello stesso identico stato
dal processo inverso, chiamato deserializzazione.
• La serializzazione mina l'incapsulamento di un tipo di dato astratto
esponendone potenzialmente i dettagli implementativi privati.
• Per scoraggiare i concorrenti dal realizzare prodotti compatibili con
i propri spesso i produttori di software proprietari mantengono
segreti i dettagli dei formati di serializzazione dei loro programmi.
Alcuni offuscano o cifrano deliberatamente i dati serializzati.

74. 74
Serializzazione C#
• Per rendere un oggetto serializzabile basta aggiungere l’attributo
[Serializable] prima della classe
[Serializable]
public class Persona {// classe}
• Di default tutte le proprietà e i campi diventano serializzabili, anche
quelli privati, è possibile disabilitare la serializzazione con
l’attributo [NonSerialized]
[NonSerialized]
private string tempCount;

75. 75
Serializzazione C# (2)
• Per inizializzare automaticamente gli oggetti non serializzati si può
utilizzare l’interfaccia IDeserializationCallback e il metodo
OnDeserialization
[Serializable]
public class Persona : IDeserializationCallback {
public void OnDeserialization(object sender)
{tempCount=0;}
// altri metodi….
}

76. 76
Serializzazione Binaria
FileStream fs = new FileStream("Serializzazione.txt",
FileMode.OpenOrCreate);
File o stream dove salvare l’oggetto
BinaryFormatter bf = new BinaryFormatter();
Oggetto per le operazioni di serializzazione
bf.Serialize(fs, mario);
Persona marioDes = (Persona)bf.Deserialize(fs);
Serializzazione e deserializzazione
fs.Close();
Chiudi il file

77. 77
Serializzazione Xml
• Serializzazione SOAP: stessa procedura di prima utilizzando
la classe SoapFormatter
• System.Runtime.Serialization.Formatters.Soap.dll
• Esiste un altro modo per serializzare in XML e
personalizzare il file di output
– Maggiore interoperabilità
– Semplicità di gestione
– Migliore compatibilità all’indietro
– E’ possibile serializzare soltanto membri pubblici e non privati
di una classe
– Non è possibile serializzare oggetti grafici

78. 78
Serializzazione XML(2)
FileStream fs = new FileStream("Serializzazione.txt",
FileMode.OpenOrCreate);
XmlSerializer xs = new XmlSerializer(typeof(Persona));
Tipo dell’oggetto che si vuole
xs.Serialize(fs, mario); serializzare
Persona mario = (Persona)xs.Deserialize(fs);
fs.Close();
Serializzazione e deserializzazione
• La classe Persona deve implementare un costruttore senza
parametri
public Persona(string nome, string cognome, string email){}

79. 79
Serializzazione XML(3)
Attributi che possono essere aggiunti per personalizzare il file di output:
• [XmlIgnore()], permette di non serializzare un membro pubblico
• [XmlElement(ElementName = "TaxRate")], permette di cambiare il
nome dell’attributo nel file xml
• [XmlArray("ListaPersona")], permette di definire il nome di una lista di
oggetti
• [XmlArrayItem("Persona")], permette di definire il nome degli elementi
dentro una lista

80. 80
Database
• Insieme di dati collegati secondo un particolare modello
logico in modo da consentire la gestione dei dati stessi
(inserimento, ricerca, …)
• Crea una struttura più articolata delle informazioni
• La parola «database» viene spesso usata come
abbreviazione dell'espressione database management
system (DBMS), che si riferisce invece a software per la
creazione e la gestione efficiente dei dati di un database

81. 81
Database Relazionale
• Formato da «Tabelle» le cui colonne sono dette «Attributi»
e rappresentano delle proprietà significative
• Le righe dette «Record» o «Tuple» contengono i dati
memorizzati
• Il linguaggio per interagire con i DB è SQL(Structured Query
Language)
– Nato a metà anni 70 nei lab IBM
– Pensato per l’interrogazione di DB, non per la programmazione
– Non gestisce strutture a oggetto
– Molto rigido
– Non integrato nel linguaggio di programmazione

82. 82
Entity Framework 4.1 (2)
• Elemento ponte tra il mondo OO e quello dei DB
Relazionali
• Permette di utilizzare diversi approcci:
– Database First: parto da un DB già esistente e creo le
classi
– Model First: dal modello a oggetti creo il DB
– Code First: simile al precedente, ma gestisco da codice
la mappatura con il DB

83. 83
Entity Framework 4.1
Linguaggi di interrogazione
Gestione di alto livello degli
oggetti
Trasformazione record e
entità
Interfaccia verso diversi
DB(SQLServer, Oracle, mySql, …)

84. 84
Language Integrated Query (LINQ)
• Aggiunto dalla versione 3.5 del framework .Net e fortemente
integrato nel linguaggio.
• Definisce un insieme di operatori che possono essere usati per
interrogare e manipolare dati da varie sorgenti che rappresentano i
dati sotto forma di oggetti.
• Se la sorgente non memorizza in maniera nativa i dati come
oggetti, è necessario l'utilizzo di un connettore per accedere ai dati.
• Il risultato di una query viene restituito come una collezione di
oggetti in memoria che possono essere enumerati.

85. 85
Linq keyword
• from - è la keyword di inizio di ogni query LINQ e specifica la fonte di dati
nella quale dovrà essere eseguita la query.
• where - è la clausola che specifica quali elementi saranno ritornati dalla
query; applica una sorta di filtro di selezione.
• select - è la clausola che definisce i tipi di valori che saranno prodotti
dalla query.
• group - è la clausola che raggruppa i risultati secondo una certa chiave.
• orderby - effettua l'ordinamento (ascendente o discendente).
• join - permette di effettuare prodotti cartesiani tra più fonti di dati, come
in SQL.
• into - è la keyword contestuale che indica in quale variabile temporanea
vengono salvati i risultati di una select, di un group o di un join.
• let - è la keyword che permette di salvare temporaneamente il risultato
di una subquery per poi utilizzarlo all'interno della query principale.

86. 86
Esempio Linq
var query =
from contact in contacts
where contact.FirstName = "Matteo"
orderby contact.ContactID
select new {
ContactID = contact.ContactID,
LastName = contact.LastName,
FirstName = contact.FirstName};
http://msdn.microsoft.com/en-us/vcsharp/aa336746

87. 87
Generics

88. 88
Iteratori