Prossime lezioni

QUESTA SETTIMANA
gioved 13 aprile, ore 14-16

Buongiorno! PROSSIME SETTIMANE

mercoled 19 aprile, ore 9-11
gioved 20 aprile, ore 14-16
mercoled 26 aprile, ore 9-11
Notizie definitive sul corso e sull'esame!
Il corso dura per 10 settimane (40 ore totali)
1) Introduzione al .NET Core e alla sintassi del C#;
2) Creare un modello del mondo che ci circonda: classi e interfacce;
3) Scoprire e rimuovere i bug con lo unit testing;
4) Usare LINQ per lavorare con collezioni di oggetti;
5) Evitare duplicazioni di codice con ereditariet e polimorfismo;

Accedere a un DB
ice
Consumare webserv Principi sviluppo agile

Creare pacchetti NuGet Parallelismo

Usare file di testo
Calendario

Il corso terminer il 24 maggio;

Almeno 4 appelli:
Primo appello nella seconda met di giugno;
Poi ancora a luglio, settembre ed ottobre;
...altri? E nel 2018?
Modalit dell'esame

Questionario in aula di circa 40 domande da fare in 3 ore;

Non si potr accedere a internet;

Non cartaceo, ma via webapp resa disponibile entro fine corso;

Ci sar una simulazione d'esame;

Simile agli esami di certificazione Microsoft.

https://www.microsoft.com/it-it/learning/
DEMO
Anteprima della webapp di valutazione
Nella puntata precedente...
E' pi probabile che il nostro software funzioni
(secondo la specifica) se scriviamo componenti
semplici e li sottoponiamo ad unit test.

Gli oggetti possono sollevare eventi

...e qualsiasi altro componente pu sottoscriversi

per essere notificato del verificarsi dell'evento.
Sull'importanza dello unit testing...
Non ci richiesto di essere infallibili

E' stranoto che TUTTE le persone commettono errori;

...ma i nostri software dovrebbero essere privi di errori.

Con lo unit testing conciliamo queste due situazioni;

Come programmatori, il nostro compito di continuare a

correggere il programma finch non funziona secondo la specifica;

Non vi abbattete se qualcuno vi segnala un bug, non sta criticando

voi ma vi sta solo indicando che servono altri test.
Fate molti esercizi!
MAESTRO MIYAGI

HO ELIMINATO UN
BUG!
Cercate di non rinunciare mai allo unit testing

Neanche quando diventate esperti e riuscite a prevedere il

comportamento dei vostri programmi;

Quando sarete pi esperti, verrete assegnati a progetti pi

complessi o clienti pi importanti e quindi lo unit test
sempre necessario.

Le date di consegna a breve termine vi metteranno alla prova.

Nel mondo reale...
Sono Ross

Oggi che il tuo primo giorno

devi farmi questa applicazione
e dev'essere pronta per ieri
Difendere il proprio lavoro

Siate assertivi, per il vostro bene;

Dite quello che pensate ma senza risultare arroganti o offensivi.
 Rispetter la data di consegna

Ma non sono soddisfatta. Senza un tempo

adeguato non riuscir a fare un lavoro
di qualit, idoneo alle aspettative.

Come azienda, rischiamo di compromettere

la nostra immagine e il rapporto con il cliente.
Migliorate le vostre soft skills

Abilit tecniche Soft skills

 Interessante, quindi Lei
lavora nel settore bancario
Abbiamo una soluzione di
reportistica specifica per
gli ambiti finanziari
Ah, tu fadighi co
le banche?
...
Non mi interessa

Qui si fa come dico io

Caro Ross, perderai i migliori

professionisti che passano dalla
tua azienda.
Dove eravamo rimasti?
Membri delle classi: gli eventi

Servono ad inviare notifiche ad altri componenti software che si

sono sottoscritti all'evento;

public class Politico {

public event EventHandler<string> FrasePronunciata;

}
Sottoscrivere un evento (si dice anche "gestire" un evento)

Si usa l'operatore +=

IPolitico politico = new Politico();

politico.FrasePronunciata += Reagisci;

public void Reagisci(object sender, string frase) {

//Applaudi, fischia, urla, arrabbiati, insulta, ...
}
Sollevare un evento

Vuol dire notificare i sottoscrittori dell'evento (se ce ne sono);

Per inviare la notifica, si usa il metodo Invoke dell'evento.

public class Politico {

public event EventHandler<string> FrasePronunciata;

public void PrendiLaParola() {

while(true)
FrasePronunciata?.Invoke(this, "Abbasseremo le tasse!");
}
Eventuali argomenti
}
sender
Attenzione quando sollevate un evento!

L'evento sar null (assenza di valore) se non ci sono sottoscrittori e

quindi l'Invoke solleverebbe un'eccezione!

FrasePronunciata.Invoke(this, "Frase");
Eccezione se non ci

Usate il null conditional operator sono sottoscrittori!

FrasePronunciata?.Invoke(this, "Frase");

Che equivale a scrivere

if (FrasePronunciata != null) FrasePronunciata.Invoke(this, "Frase");
 S S ER E M O
A BB A
E T A S S E!
L
Rimuovere la sottoscrizione ad un evento

Quando non ci interessa pi ricevere l'evento, rimuoviamo la

sottoscrizione con l'operatore -=

politico.FrasePronunciata -= Reagisci;
DEMO
Gestire un evento ed usare le lambda expressions
Sottoscrizione con lambda expression
IOrologio orologio = new Orologio();
orologio.TempoScaduto += (object sender, EventArgs e) => {
//Avvisa il giocatore che ha perso la partita
};

Lambda expression
Lambda expression

E' una forma compatta per definire metodi anonimi;

Non sono membri di una classe, ma sono metodi anonimi che

possiamo passare come argomento o assegnare ad una variabile.

EventHandler<Colore> notificaSconfitta = (sender, colore) =>

{
Console.WriteLine($"Il giocatore {colore} ha perso!");
}
Lambda expression
UN METODO LA SUA EQUIVALENTE LAMBDA

void Metodo() { () => {

//Fai qualcosa //Fai qualcosa
} }
Lambda expression
UN METODO LE SUE EQUIVALENTI LAMBDA

void Stampa(int et) { (int et) => {

Console.Write(et); Console.Write(et);
} //Fai qualcosa
}

et => Console.Write(et);

Questa versione si usa quando il compilatore in grado di inferire il

tipo di parametri (es. quando si passa la lambda come parametro)
Lambda expression
UN METODO LE SUE EQUIVALENTI LAMBDA

bool Maggiorenne(int et) { (int et) => {

return et >= 18; return et >= 18;
} }

et => et >= 18;

Pi compatto di cos :)
Tipi di delegate: EventHandler, Action e Func

Un delegate un tipo di oggetto a cui affidiamo un metodo;

...questo ci consente di assegnare metodi a variabili o di passarli

come argomento ad altri metodi;

EventHandler<Colore> notificaSconfitta = (sender, colore) => { };

Action<int> stampa = et => Console.Write(et);

Func<int, bool> maggiorenne = et => et >= 18;

Tipi di delegate: EventHandler, Action e Func

Un delegate un tipo di oggetto a cui affidiamo un metodo;

...questo ci consente di assegnare metodi a variabili o di passarli

come argomento ad altri metodi;

EventHandler<Colore> notificaSconfitta = (sender, e) => { };

notificaSconfitta.Invoke(this, Colore.Bianco);

Action<int> stampa = et => Console.Write(et);

stampa.Invoke(36);

Func<int, bool> maggiorenne = et => et >= 18;

bool esito = maggiorenne.Invoke(36);
Domande?
Generics

Alcune classi riescono a funzionare in combinazione con vari tipi

di oggetto.
EventHandler<Colore>

EventHandler una classe che ha lo scopo di invocare dei metodi

e, nel farlo, ci permette di configurare il tipo di parametro.
Generics: List<T>

Uno dei generics pi usato List<T>;

E' una collezione di oggetti di un tipo che scegliamo noi.

List<string> citt = new List<string>() { "Roma", "Milano", "Torino" };
citt.Add("Napoli");
citt.RemoveAt(1);
citt.Insert(0, "Venezia");

Console.WriteLine(citt[0]); //Venezia

string elenco = string.Join(",", citt);

Console.WriteLine(elenco); //Venezia,Roma,Torino,Napoli
Generics: List<T>

Ci permette di lavorare agevolmente con collezioni di oggetti;

Aggiungere: Add, AddRange, Insert, InsertRange;
Rimuovere: Remove, RemoveAt, RemoveRange;
Ordinare: Sort, Reverse.

Internamente usa un Array.

Array

Ha meno funzionalit di List<T> perch un tipo "vecchio",

introdotto 15 anni fa quando ancora non esistevano i generic;

string[] citt = new string[] { "Roma", "Milano", "Torino" };

Array.Resize(ref citt, 4);

citt[3] = "Napoli";
Per rimuovere "Milano" dovremmo
spostare tutti gli elementi una posizione e
poi ridurre la dimensione dell'array.
Ciclare gli elementi con un ciclo for

Ci serve ad esaminare gli elementi di una collezione, uno ad uno;

for (int i = 0; i < citt.Length; i++) {

string cittCorrente = citt[i];

Console.WriteLine(cittCorrente);

}
Se citt un Array, il numero totale di
elementi lo otteniamo da Length. Se una
List<T>, lo otteniamo da Count.
Ciclare gli elementi con un ciclo foreach

Ci serve ad esaminare gli elementi di una collezione, uno ad uno;

foreach (string cittCorrente in citt) {

Console.WriteLine(cittCorrente);

}
Una classe ciclabile se implementa IEnumerable
IEnumerable

IEnumerable<T>

ICollection<T> ICollection

IList<T> IList

List<T> Array
Se volessi creare una mia classe ciclabile...

...che interfaccia dovrei implementare?

IEnumerable: l'oggetto pu essere ciclato, ma solo in avanti;
IEnumerable<T>: posso indicare il tipo di oggetto;
ICollection<T>: posso sapere di quanti elementi composto
l'oggetto senza doverlo ciclare con un foreach;
IList<T>: ho il supporto all'accesso randomico.
LINQ
Lambda expressions e LINQ
//Qui, mele una List<Mela>
mele.
.Where(mela => mela.Tipo == "Golden")
.Select(mela => mela.Polpa)
.Take(20);

Le lambda sono le nostre "strategie".

Nella Where, la strategia di filtro.
Nella Select, la strategia di proiezione.