da asp ad asp.net 2download.microsoft.com › download › d › a › b ›...
TRANSCRIPT
Da ASP ad ASP.NET 2.0
1
Da ASP ad ASP.NET 2.0
Daniele Bochicchio – Content Manager ASPItalia.com
[email protected] – http://blogs.aspitalia.com/daniele/
Chi sono?• Content Manager di ASPItalia.com
– Porto avanti la più grande community italiana di sviluppatori ASP ed ASP.NET, con 35.000 iscritti
• Scrivo, scrivo, scrivo :)– Articoli su riviste italiane (VBJ, ioProgrammo, Internet
Magazine, etc)
– Libro “ASP 3 per Esempi”
– Libro “ASP.NET 2.0 per tutti” – http://books.aspitalia.com/
– Articoli, script, blog, forum, newsgroup
• Consulenze– Corsi, training, mentoring, progettazione, sviluppo
– Speaker in eventi per Microsoft Italia
• Microsoft ASP.NET MVP– Riconoscimento per l’impegno nel supporto agli utenti
3
Programma• Ore 9.30 – 11.00
– Parte I
• Ore 11.00 – 11.15– Break I
• Ore 11.15 – 13.00– Parte II
• Ore 13.00 – 14.00– Pranzo
• Ore 14.00 – 15.30– Parte III
• Ore 15.30 – 15.45– Break II
• Ore 15.45 – 18.00– Parte IV
Da ASP ad ASP.NET 2.0
2
Agenda
• .NET Framework intro
• C# intro
• ASP.NET intro
• ASP Vs. ASP .NET
• VB.NET <> VB6
• VB.NET<>VBScript
• <% 9%>
• COM o non COM, questo è il dilemma9
5
Prima di tutto: l’HTTP è stateless
• Il web è basato sul protocollo HTTP (HyperText Transfer Protocol – protocollo di trasferimento ipertesti).
• Il protocollo HTTP è molto semplice: un client effettua la richiesta, impostando delle headers, un server risponde con il body (contenuto) e le headers.
• Le headers vengono utilizzate per trasmettere informazioni (come i cookie).
Prima di partire
• ASP.NET è una tecnologia nuova per fare cose vecchie• ASP.NET è parte del .NET Framework
– Ambiente object oriented– Nuovi linguaggi: oggi usiamo C# e VB.NET– Nuovo modo di scrivere e progettare le cose– ADO.NET per l’accesso ai dati
• ASP.NET in quanto tale– Cambia il modo di scrivere pagine web– Cambia il modo di pensare le pagine web
• Oggi trattiamo ASP.NET– Non dimenticatevi che il .NET Framework esiste!– Il buon programmatore ASP.NET conosce il framework (e lo
studia sui libri :)
6
Da ASP ad ASP.NET 2.0
3
7
ASP.NET != ASP
• ASP.NET è stato progettato per mantenere la compatibilità con la sintassi e il runtime delle pagine ASP esistenti.
• Altra cosa importante è che è possibile far eseguire diverse versioni di ASP.NET affiancate.– Possiamo avere 1.0, 1.1 e 2.0 che girano insieme senza darsi problemi a vicenda.
8
ASP.NET != ASP
• Nelle applicazioni ASP, soprattutto se utilizzano particolari oggetti COM è molto difficile se non traumatico distribuirle su altri webserver.
• Con ASP.NET basta copiare tutti i file. Non si registra niente.– Per raggiungere questi obbiettivi, ASP.NET configura le applicazioni web tramite file XML memorizzati nelle directory stesse, in questo modo non è più necessario utilizzare la configurazione di IIS.
– Niente COM (evviva! :) a meno che non dobbiamo accedere ad oggetti “legacy”.
Un ambiente multi forma
• Il .NET Framework permette di sviluppare qualsiasi tipo di applicazione:– stand-alone– client/server– mobile (palmari, smart phones, smart devices), per il web.
• Come sviluppatore, certamente rappresenta un vantaggio notevole.
• In genere per ognuna di queste singole implementazioni, si utilizza un linguaggio o una sua variante particolare.
9
Da ASP ad ASP.NET 2.0
4
Linguaggi del .NET Framework
Visu
al Studio 2005
Visu
al Studio 2005
Common Language SpecificationCommon Language Specification
Visual Visual
BasicBasicC++C++ C#C# J#J# ……
.NET Framework.NET Framework
CLS: Common Language Specification
• Le CLS definiscono le specifiche comuni a tutti i linguaggi .NET in modo che gli assembly prodotti siano usabili da tutti i linguaggi.
• Una conseguenza (vantaggio) ovvia rispetto ai linguaggi tradizionali va in direzione della compatibilità binaria.
• Il CTS definisce come devono essere costruiti e definiti i tipi (visibilità, contenuto in termini di proprietà, metodi, ecc.).
Perché C#?
• C# non soffre di difetti imputabili a compatibilità all’indietro (C# è nato col .NET Framework).
• C# è standard ECMA/ISO (come CLI).
• C# è meno “verboso” rispetto a VB.NET.
• C# ha forti analogie con C++ e Java.
• C# supporta l'uso di puntatori in modalità unsafe.
Da ASP ad ASP.NET 2.0
5
Alcune precisazioni
• C# non è più potente di VB.NET.
• C# non produce codice più “veloce” di VB.NET.
• C# non è il linguaggio “ufficiale” di .NET.
• C# non è la copia di Java.
• C# non è il successore di C++.
Caratteristiche di C#
• C# è un linguaggio nato col .NET Framework.
• C# è un linguaggio object oriented.
• C# è un linguaggio case sensitive: attenzione alle lettere maiuscole/minuscole per variabili e keyword.
Consiglio:
• Rispettare le regole di nomenclatura del codice.
• Ricordare sempre che la nomenclatura in C# è diversa rispetto a quella utilizzata in altri linguaggi come Java.
Struttura di un’applicazione .NET
• Una o più classi e/o strutture (tipi)
– Classi e strutture sono tipi costituiti da campi, proprietà, metodi ed eventi (membri).
• Uno o più file sorgenti
– In Visual Studio non si possono creare progetti utilizzando diversi linguaggi.
– È possibile usare DLL (assembly) create utilizzando un qualsiasi linguaggio .NET (CLS).
Da ASP ad ASP.NET 2.0
6
La prima applicazione: Hello World!
public class HelloWorld {public static void Main(){
System.Console.WriteLine("Hello World!");}
}
public class HelloWorld {public static void Main(){
System.Console.WriteLine("Hello World!");}
}
Classe Console
del namespace System
Tutto in .�ET è
una classe
Entry-point
dell'applicativo
• L'entry-point è il punto di ingresso di una applicazione che nelle applicazioni WinForm e Console è la funzione Main.
I tipi di base• Dichiarati nel namespace System (mscorlib.dll):
– Boolean, Byte, SByte, Char– Int16, Int32, Int64, UInt16, UInt32, UInt64– Decimal, Single, Double– DateTime, TimeSpan– String
• Il linguaggio C# dichiara alcuni alias per questi tipi:
– bool (Boolean), byte (Byte), sbyte (SByte), char (Char)– short (Int16), int (Int32), long (Int64),
ushort(UInt16), uint(UInt32), ulong(UInt64)– decimal (Decimal), float (Single), double (Double)– nessun alias per DateTime, TimeSpan– string (String)
• In rosso i tipi che non sono conformi alle specifiche CLS.
Value Type e Reference TypeValue Type
• Contengono direttamente il dato nell’ambito dello stack del thread.
• Una copia di un Value Type implica la copia dei dati in esso contenuti.
• Le modifiche hanno effetto solo sull’istanza corrente.
• Contengono sempre un valore(null non è direttamente ammesso).
• I Value Type comprendono:– i tipi primitivi come int, byte, bool, ecc.– enum, struct (definiti dall'utente).
• Esempi:
int i = -1;
bool b = true;
double d = 0;
byte x, y, z;
char chr = 'R';
enum PersonGender { Male, Female }
Reference Type
• Contengono solo un riferimento ad un oggetto nell’ambito dell’heap.
• La copia di un Reference Type implica la duplicazione del solo reference.
• Le modifiche su due reference modificano l'oggetto a cui puntano.
• Il reference che non referenzia nessuna istanza vale null.
• Tutte le classi sono Reference Type!
• Esempi:
string s;
string s = “Ricky";
Attenzione: il tipo string è un caso particolare perchè è immutabile.
DataTable dt;
DataSet ds = new DataSet();
Person p = new Person();
Da ASP ad ASP.NET 2.0
7
System.Object• System.Object è il reference type “root” della gerarchia di tutti i tipi del .NET Framework.
• System.Object e con esso tutti i reference type espongono questi metodi di base:
– Equals – Comparazione di oggetti
– Finalize – Distruzione delle risorse unmanaged
– GetHashCode – Generazione di un numero utile in un algoritmo di hashing
– ToString – Generazione di una stringa che descrive l'istanza del tipo
Boxing e Unboxing• Vantaggi dei Value Type:
– non sono allocati nel managed heap, ma sullo stack del thread
– non sono soggetti al Garbage Collector
– non sono referenziati da puntatori
• È possibile contenere un Value Type in un Reference Type: questa operazione si chiama Boxing.– È necessaria quando si vuole associare ad un tipo di valore un
riferimento.
– Il Boxing è un operazione costosa perché le informazioni di un value type devono essere copiate dallo stack nel managed heap.
– L'operazione inversa si chiama Unboxing (molto meno costosa).
– Al costo delle operazioni di Boxing e Unboxing si somma il costo di memoria del managed heap.
Gli statement• Statement condizionali
– if, switch
• Statement iterativi
– while, do, for, foreach
• Statement di salto
– goto, break, continue, return, throw
• Altri statement
– vuoto, dichiarativi, espressioni, label, try-catch-finally (gestione eccezioni), check/uncheck (unsafe), lock (sincronizzazione multi-thread), using (pattern IDisposable)
Da ASP ad ASP.NET 2.0
8
Statement condizionali
if (espressione){
// ...}else{
// ....}
if (espressione){
// ...}else{
// ....}
switch (espressione){
case valore1:// ...break;
case valore2:// ...break;
case valore3:case valore4:
// ...break;
default:// ...break;
}
switch (espressione){
case valore1:// ...break;
case valore2:// ...break;
case valore3:case valore4:
// ...break;
default:// ...break;
}string s = (a < b) ? "vero“ : "falso";string s = (a < b) ? "vero“ : "falso";
Espressione booleana (true/false) Sono ammesse anche le stringhe
Operatore ternario
Valori multipli
Statement iterativi
while (espressione){
// ...}
while (espressione){
// ...}
foreach (DataRow row in Table1.Rows){
// ...}
foreach (DataRow row in Table1.Rows){
// ...}
for (int i = 0; i < 100; i++){}
for (int i = 0; i < 100; i++){}
Espressione booleana (true/false)
Array / Collection
Inizializzazione
do{
// ...}while (espressione);
do{
// ...}while (espressione);
Controllo ad
ogni ciclo
Incremento ad
ogni ciclo
Statement di saltofor (int i = 0; i < 100; i++){
Console.Write(i);if (i == 5)
break;if (i > 2)
continue;Console.WriteLine("*");
}
for (int i = 0; i < 100; i++){
Console.Write(i);if (i == 5)
break;if (i > 2)
continue;Console.WriteLine("*");
}
Da evitare!
Scarsa leggibilità
goto OK;
// ...
OK:
goto OK;
// ...
OK:
0*
1*
2*
…345
Stop!
Output
Da ASP ad ASP.NET 2.0
9
Gli operatori• Uguaglianza
• Condizionali
• Relazione
• Incremento
• Decremento
• Aritmetici
• Shift
• Unari / Binari
• Assegnazione
• == !=
• && || ?:
• < <= > >= is
• ++
• --
• + - * / % (% � modulo/resto)
• >> <<
• & | ^ (and, or, xor)
• = += -= *= /= %= <<= >>= &= |= ^=
Array• Gli array memorizzano delle sequenze finite di elementi, la cui lunghezza deve essere nota a priori.
• Tutti gli elementi devono essere dello stesso tipo e non possono essere read-only.
• Gli elementi vengono richiamati in base ad un indice numerico che parte sempre da zero.
• Gli array non sono direttamente ridimensionabili.
• La dimensione di un array può essere calcolata a runtime.
• Il metodo GetLength permette di conoscere il rank della n-esima dimensione dell'array.
Array multidimensionali
byte[] vettore;byte[] vettore; int[,] matrice;int[,] matrice;
byte[] vettore = new byte [5];
oppure
byte[] vettore = new byte [] {1,2,3,4,5};
int[,] matrice = new int [2,3];
oppure
int[,] matrice = new int [,] {{1,2,3}, {4,5,6}};
�� ��
Dimensione = 2Dimensione = 1
Da ASP ad ASP.NET 2.0
10
Collection
• Le collection mantengono una lista dinamica di oggetti, la cui lunghezza non ha limiti intrinseci.
• Gli elementi possono essere di diverso tipo (meglio di no!) e possono essere read-only.
• A seconda delle interfacce implementate, gli elementi possono essere enumerati e listati secondo modalità diverse.
• Sono meno performanti degli array.
Namespace System.Collections
• ArrayList
• BitArray
• Hashtable
• Queue
• Stack
• StringCollection
• Ecc.
Tipi, classi e oggetti
• Un tipo è una rappresentazione concreta di un concetto. Per esempio, il tipo built-in float fornisce una rappresentazione concreta di un numero reale. (*)
• Una classe è un tipo definito dall'utente. (*)
• Un oggetto è l'istanza di una classe caratterizzato da:– un’identità (distinto dagli altri);
– un comportamento (compie elaborazioni tramite i metodi);
– uno stato (memorizza dati tramite campi e proprietà).
public class MyClass{
// ...}
MyClass c = new MyClass();
public class MyClass{
// ...}
MyClass c = new MyClass();
(*) The C++ Programming Language, Third Edition. Bjarne Stroustrup
Da ASP ad ASP.NET 2.0
11
Classi• Una classe può contenere ed eventualmenteesporre sulla sua interfaccia:– Dati (campi e proprietà);
– Funzioni (metodi).
• Una classe può essere partial, ossia può esseredefinita in file differenti (versione 2.0).
File part1.cs
public partial class MyClass{
// ...}
File part1.cs
public partial class MyClass{
// ...}
File part2.cs
public partial class MyClass{
// ...}
File part2.cs
public partial class MyClass{
// ...}
Accessibilità• I tipi definiti dall'utente (classi, strutture, enum) e i membri di
classi e strutture (campi, proprietà e metodi) possono avere accessibilità diversa (accessor modifier):
– publicAccessibile da tutte le classi
– protectedAccessibile solo dalle classi derivate
– privateNon accessibile dall’esterno
– internalAccessibile all’interno dell’assembly
– protected internalCombinazione delle due
• Differenziare l'accessibilità di un membro è fondamentale per realizzare l’incapsulamento.
• L’insieme dei membri esposti da un classe rappresenta la sua interfaccia.
Metodi di una classe
• In sostanza la dichiarazione di un metodo è composta di:– zero o più keyword;– il tipo di ritorno del metodo oppure void;– il nome del metodo;– l'elenco dei parametri tra parentesi tonde.
• La firma (signature) di un metodo è rappresentata dal nome, dal numero dei parametri e dal loro tipo; il valore ritornato non fa parte della firma.public void MyMethod (string str){
// ...return; // opzionale
}
public void MyMethod (string str){
// ...return; // opzionale
}
public int MyMethod (string str){
int a = int.Parse(str);return a;
}
public int MyMethod (string str){
int a = int.Parse(str);return a;
}
Da ASP ad ASP.NET 2.0
12
Passaggio dei parametri 1/6
• I parametri di un metodo possono essere passati:– By Value (default);– By Reference (keyword ref);
– By Reference in uscita (keyword out).
int x; // variabile non inizializzataMyMethod(2, 3, out x);
public static void MyMethod (int a, int b, out int c){
c = a + b;}
int x; // variabile non inizializzataMyMethod(2, 3, out x);
public static void MyMethod (int a, int b, out int c){
c = a + b;}
int x = 0; // variabile inizializzataMyMethod(2, 3, ref x);
public static void MyMethod (int a, int b, ref int c){
c = a + b;}
int x = 0; // variabile inizializzataMyMethod(2, 3, ref x);
public static void MyMethod (int a, int b, ref int c){
c = a + b;}
Passaggio dei parametri 2/6
Di default i parametri vengono passati By Value.
• È comunque possibile:
– passare un Value Type By Value;
– passare un Value Type By Reference;
– passare un Reference Type By Value;
– passare un Reference Type By Reference.
Passaggio di un Value Type By Value:
• in assenza della keyword ref oppure out la variabile viene passata al metodo By Value (default);
• la variabile viene copiata all'interno del metodo e quindi la riassegnazione non influenza il chiamante.
Passaggio dei parametri 3/6
public void MyMethod (int a){
// ...}
public void MyMethod (int a){
// ...}
Value Type
Da ASP ad ASP.NET 2.0
13
Passaggio dei parametri 4/6
Passaggio di un Value Type By Reference:
• le keyword ref oppure out indicano che la variabile viene passata By Reference;
• un puntatore invisibile alla variabile viene copiato all'interno del metodo che può variare il suo valore.
public void MyMethod (ref int a){
// ...}
public void MyMethod (ref int a){
// ...}
Value Type
Passaggio dei parametri 5/6Passaggio di un Reference Type By Value:
• L'assenza di ref o out indica che la variabile viene passata By Value.
• La variabile non viene “copiata” perchè non è un Value Type, viene passato solo il suo riferimento che è un puntatore.
• La variabile non può essere assegnata nuovamente. Per esempio:dt = new DataTable(); // non influisce sul chiamante
• La variabile passata può essere modificata solo se uno dei suoi membri consente di farlo. Per esempio: dt.Clear();
public void MyMethod (DataTable dt){
// ...}
public void MyMethod (DataTable dt){
// ...}
Reference Type
Passaggio dei parametri 6/6Passaggio di un Reference Type By Reference:
• La presenza di ref o out indica che la variabile viene passata By Reference.
• La variabile non viene “copiata” perchè non è un Value Type, viene passato solo il suo riferimento che è un puntatore.
• La variabile può essere assegnata nuovamente. Per esempio:dt = new DataTable();
• La variabile passata può essere modificata anche tramite uno dei suoi membri. Per esempio: dt.Clear();
public void MyMethod (ref DataTable dt){
// ...}
public void MyMethod (ref DataTable dt){
// ...}
Reference Type
Da ASP ad ASP.NET 2.0
14
Classi e proprietà
• È il modo migliore per soddisfare uno dei pilastri della programmazione OOP: incapsulamento.
• Una proprietà può provvedere accessibilità in lettura (get) scrittura (set) o entrambi.
• Si può usare una proprietà per ritornare valori calcolati o eseguire una validazione.
public class MyClass{
private string _name;
public string Name{
get { return _name; }set { _name = value; }
}}
MyClass c = new MyClass();c.Name = "Ricky";
public class MyClass{
private string _name;
public string Name{
get { return _name; }set { _name = value; }
}}
MyClass c = new MyClass();c.Name = "Ricky";
public class MyClass{
private string[] val =new string[] {"uno", "due", "tre"};
public string this[long i]{
get { return val[i]; }set { val[i] = value; }
}}
MyClass c = new MyClass();Console.WriteLine(c[1]); // "due"
public class MyClass{
private string[] val =new string[] {"uno", "due", "tre"};
public string this[long i]{
get { return val[i]; }set { val[i] = value; }
}}
MyClass c = new MyClass();Console.WriteLine(c[1]); // "due"
Proprietà tradizionale Indexer
Accessibilità differenziata nelle proprietà
• Accessibilità delle proprietà (versione 2.0):
– get e set possono avere accessibilità diversa;
– la loro accessibilità deve essere più restrittiva di quella indicata nella proprietà;
– non può essere usata nelle interfacce.public class MyClass{private string _name;
public string Name{
get { return _name; }private set { _name = value; }
}}
public class MyClass{private string _name;
public string Name{
get { return _name; }private set { _name = value; }
}}
Dati statici e di istanza 1/2• I dati relativi ad una classe sono marcati con la keyword static e descrivono le informazioni comuni a tutti gli oggetti dello stesso tipo.
• Ciò che è marcato static può essere utilizzato senza la necessità di istanziare oggetti.
public class MyClass{
public static int One;public int Two;
}
MyClass c1 = new MyClass();MyClass c2 = new MyClass();
MyClass.One = 3;c1.Two = 5;c2.Two = 7;
public class MyClass{
public static int One;public int Two;
}
MyClass c1 = new MyClass();MyClass c2 = new MyClass();
MyClass.One = 3;c1.Two = 5;c2.Two = 7;
Attenzione: anche le classi possono essere definite come static (solo a partire dalla versione 2.0).
Da ASP ad ASP.NET 2.0
15
Dati statici e di istanza 2/2
• Cosa accade in memoria?
Codice macchinaCodice macchina
Dati statici
indipendenti dal
numero di istanze
1
public class MyClass{
public static int One;public int Two;public string Three;
}
MyClass c1 = new MyClass();MyClass c2 = new MyClass();MyClass c3 = new MyClass();
c1.Two = 1;c1.Three = "Uno";c2.Two = 2;c2.Three = "Due";c3.Two = 3;c3.Three = "Tre";
MyClass.One = 10;
public class MyClass{
public static int One;public int Two;public string Three;
}
MyClass c1 = new MyClass();MyClass c2 = new MyClass();MyClass c3 = new MyClass();
c1.Two = 1;c1.Three = "Uno";c2.Two = 2;c2.Three = "Due";c3.Two = 3;c3.Three = "Tre";
MyClass.One = 10;
thisthisthisthis
Uno
2thisthisthisthis
Due
3
thisthisthisthis
Tre
10
c1c2
c3
MyCla
ss
Keyword this
• this è un riferimento che punta all'istanza della classe stessa.
• È usabile solo in relazione ai membri non statici.
1
thisthisthisthis
Uno
c1
public class MyClass{
public int One;
public void MyMethod (int val){
this.One = val;}
}
public class MyClass{
public int One;
public void MyMethod (int val){
this.One = val;}
}
Costruttore 1/2
• Il costruttore è fondamentale perchè permette di dare all'oggetto uno stato iniziale stabile e congruo.
• Il costruttore di default non ha argomenti.
public class Person{
private string _name;private int _age;
public Person (string name, int age){
_name = name;_age = age;
}}
public class Person{
private string _name;private int _age;
public Person (string name, int age){
_name = name;_age = age;
}}
public class Person{
private string _name;private int _age;
public Person (string name, int age){
_name = “Ricky”;_age = 34;
}}
public class Person{
private string _name;private int _age;
public Person (string name, int age){
_name = “Ricky”;_age = 34;
}}
Da ASP ad ASP.NET 2.0
16
Costruttore 2/2
• Il costruttore può avere una visibilità ristretta. In questo caso l'istanza deve essere creata da un metodo o da un’altra classe (Factory).
• Può esistere un costruttore statico che permette di definire lo stato dei membri statici. Il costruttore statico viene chiamato in modo implicito (e quindi è senza parametri e senza keyword di accessibilità) subito prima che qualsiasi membro statico o di istanza sia usato.public class Person{
// costruttore ad accessibilità privataprivate Person() { ... }// metodo per la creazione dell’istanzapublic Person FactoryMethod() { ... }
}
public class Person{
// costruttore ad accessibilità privataprivate Person() { ... }// metodo per la creazione dell’istanzapublic Person FactoryMethod() { ... }
}
public class Person{
// costruttore staticostatic Person() { ... }
}
public class Person{
// costruttore staticostatic Person() { ... }
}
Distruttore
• Niente a che fare con il distruttore del C++.• Il garbage collector è preposto alla distruzione non deterministica
degli oggetti nel managed heap.• Il garbage collector rende disallocabili gli oggetti di cui il programma
non mantiene più alcun reference diretto o indiretto.• Il distruttore è un alias per il metodo Finalize che viene chiamato
dal garbage collector quando opportuno.• Se il distruttore non è definito, l'oggetto non finisce nella coda di
finalizzazione.• Il pattern IDisposable è la soluzione ideale per poter disallocare
risorse.public class Person{
~Person(){
// ...}
}
public class Person{
~Person(){
// ...}
}
Overloading di metodi e proprietà
• Possono esistere metodi e proprietà con lo stesso nome.
• È possibile perchè il vero “nome” è rappresentato dalla firma: nome, numero e tipi dei parametri, ivi inclusi i modificatori come ref o out.
• Non possono esistere due metodi che differiscono del solo parametro di ritorno (non fa parte della firma).
public int Sum (int a, int b){
return a + b;}
public int Sum (int a, int b){
return a + b;}
public int Sum (decimal a, decimal b){
return a + b;}
public int Sum (decimal a, decimal b){
return a + b;}
public int Sum (int a, ref int b){
return a + b + c;}
public int Sum (int a, ref int b){
return a + b + c;}
public int Sum (int a, int b, int c){
return a+b+c;}
public int Sum (int a, int b, int c){
return a+b+c;}
Da ASP ad ASP.NET 2.0
17
Overloading degli operatori
• Offre la possibilità di specificare il comportamento degli operatori aritmetici quando applicati ad istanze della classe.public class ComplexNumber{
public float Real;public float Complex;
public ComplexNumber (float real, float complex){
this.Real = real;this.Complex = complex;
}
public static ComplexNumber operator + (ComplexNumber a, ComplexNumber b)new ComplexNumber(a.Real + b.Real, a.Complex + b.Complex);
} {return
}
public class ComplexNumber{
public float Real;public float Complex;
public ComplexNumber (float real, float complex){
this.Real = real;this.Complex = complex;
}
public static ComplexNumber operator + (ComplexNumber a, ComplexNumber b)new ComplexNumber(a.Real + b.Real, a.Complex + b.Complex);
} {return
}
Classi annidate
• Le classe annidata è semplicemente un tipo definito all'interno di un'altra classe.
public class MyClass{
public class MyNestedClass{
public int One;}
}
// ...
// occorre specificare il nome della classe containerMyClass.MyNestedClass nested = new MyClass.MyNestedClass();
nested.One = 1;
public class MyClass{
public class MyNestedClass{
public int One;}
}
// ...
// occorre specificare il nome della classe containerMyClass.MyNestedClass nested = new MyClass.MyNestedClass();
nested.One = 1;
Strutture
• Quanto visto finora per le classi è tipicamente valido anche per la definizione di strutture (keyword struct).
• Il compilatore genera sempre un costruttore di default che inizializza tutti i membri della struttura al valore di default.
• È possibile dichiarare unicamente costruttori con parametri.public struct ComplexNumber{
public float Real;public float Complex;
public ComplexNumber (float real, float complex){
this.Real = real;this.Complex = complex;
}
public static ComplexNumber operator + (ComplexNumber a, ComplexNumber b){
return new ComplexNumber (a.Real + b.Real, a.Complex + b.Complex);}
}
public struct ComplexNumber{
public float Real;public float Complex;
public ComplexNumber (float real, float complex){
this.Real = real;this.Complex = complex;
}
public static ComplexNumber operator + (ComplexNumber a, ComplexNumber b){
return new ComplexNumber (a.Real + b.Real, a.Complex + b.Complex);}
}
Da ASP ad ASP.NET 2.0
18
Classi vs Strutture
È un Value Type.È un Reference Type.
Supportano l’ereditarietà.
Supportano il metodo Finalize.
Supportano costruttori e l’inizializzazione dei membri.
Possono definire data member, proprietà, metodi.
Classi Strutture Possono definire data member, proprietà, metodi.
Non supportano l’ereditarietà.
Non supportano il metodo Finalize.
Non supportano costruttori di default e l’inizializzazione dei membri.
Namespace 1/2
• Consente di raggruppare logicamente un certo numero di tipi in un insieme e risolvere l’ambiguità nei nomi dei tipi.
• Esempio:System.Web.UI.WebControls.DataGridSystem.Windows.Forms.DataGrid
• Il namespace di base prende il nome di System.
• La direttiva using permette di evitare di scrivere il nome completo della classe.using System;
// ...
Console.WriteLine("Hello, World");
using System;
// ...
Console.WriteLine("Hello, World");
Namespace 2/2
• Per dichiarare un namespace si usa la keyword namespace.
namespace MyProject{
namespace MyNamespace{
public class MyClass{
// ...}
}}
MyProject.MyNamespace.MyClass c =new MyProject.MyNamespace.MyClass();
namespace MyNamespace{
public class MyClass{
// ...}
}
MyNamespace.MyClass c =new MyNamespace.MyClass();
Da ASP ad ASP.NET 2.0
19
Ereditarietà
• Si applica quando tra due classi esiste una relazione “è un tipo di“. Esempio: Customer è un tipo di Person.
• Consente di specializzare e/o estendere una classe.• Si chiama ereditarietà perchè la classe che deriva (classe
derivata) può usare tutti i membri della classe ereditata (classe base – keyword base) come se fossero propri, ad eccezione di quelli dichiarati privati.
public class Person{
protected string Name;}
public class Customer : Person{
public void ChangeName (string name){
base.Name = name;}
}
public class Person{
protected string Name;}
public class Customer : Person{
public void ChangeName (string name){
base.Name = name;}
}
Classe base
Classe derivata
Ereditarietà singola e multipla
• Non è ammessa l’ereditarietà multipla.
• Una classe può derivare unicamente da una sola altra classe.
Strumento musicale
Pianoforte
Strumentomusicale
Pianoforte
Mobile
Singola Multipla
Classi base
Classi derivate
Polimorfismo• Il polimorfismo è la possibilità di
trattare un’istanza di un tipo come se fosse un’istanza di un altro tipo.
• Il polimorifismo è subordinato all'esistenza di una relazione di derivazione tra i due tipi.
• Affinchè un metodo possa essere polimorfico, deve essere marcato come virtual o abstract.
Strumentomusicale
ChitarraViolino Pianoforte
public class Orchestra{
public Strumento Violino,Chitarra,Pianoforte;
public Orchestra(){
violino = new Violino();violino.Accorda();
}}
public abstract class Strumento{
public abstract void Accorda();}
public class Violino : Strumento{
public override void Accorda(){
// ...}
}
// ...
public class Orchestra{
public Strumento Violino,Chitarra,Pianoforte;
public Orchestra(){
violino = new Violino();violino.Accorda();
}}
public abstract class Strumento{
public abstract void Accorda();}
public class Violino : Strumento{
public override void Accorda(){
// ...}
}
// ...
Da ASP ad ASP.NET 2.0
20
Classi astratte e metodi virtuali
• Una classe è astratta (abstract) se contiene almeno un metodo astratto.
• Un metodo è astratto se dichiara la sua firma, ma non fornisce alcuna implementazione.
• Se una classe derivata deve poter provvedere una nuova implementazione di un metodo, nella classe base questo deve essere contrassegnato come virtuale (virtual).
• La classe derivata che voglia (o debba) fornire una implementazione sostitutiva di una classe base deve marcare con override il metodo.
public abstract class Strumento{
public abstract void Accorda();
public virtual void PausaTempo(){
// ...}
}
public abstract class Strumento{
public abstract void Accorda();
public virtual void PausaTempo(){
// ...}
}
public Piano : Strumento{
public override void Accorda(){
// ...}
public override void PausaTempo(){
// ...}
}
public Piano : Strumento{
public override void Accorda(){
// ...}
public override void PausaTempo(){
// ...}
}
Modificatori predefiniti• Per tipi
– abstract:Il tipo deve essere derivato.– sealed: Il tipo non può essere derivato.
• Per membri– static: Non è un membro dell’istanza, ma del tipo.– readonly: Può essere inizializzato solo nel costruttore(diverso rispetto a const).
• Per metodi– static: Il metodo è associato al tipo non all’istanza.– Virtual: Il tipo derivato può eseguire l’override.– new: Maschera il metodo del tipo base.– override: Ridefinisce il metodo del tipo base.– abstract: Il tipo derivato deve eseguire l’override.– sealed: Il tipo derivato non può eseguire l’override.
Interfacce
• Un’interfaccia è simile ad una classe astratta pura, ossia con soli metodi e/o proprietà astratte.
• Un’interfaccia è priva di qualsiasi implementazione e di modificatore di accessibilità (public, private, ecc.).
• Un’interfaccia definisce un contratto che la classe che la implementa deve rispettare.
• Una classe può implementare più interfacce contemporaneamente.
public interface IStrumento{
void Accorda();void StartTime();
}
public interface IStrumento{
void Accorda();void StartTime();
}
public Piano : IStrumento{
public void Accorda(){
// ...}
public void StartTime(){
// ...}
}
public Piano : IStrumento{
public void Accorda(){
// ...}
public void StartTime(){
// ...}
}
Da ASP ad ASP.NET 2.0
21
Perché usare le interfacce?
• Perché rappresentano tipi astratti che permettono di limitare l’accoppiamento.
• Perché in .NET l’ereditarietà multipla non è ammessa.
• Per creare dipendenze tra i tipi senza ricorrere all’ereditarietà.
• Per caricare assembly in modo dinamico e realizzare un sistema pluggabile.
IDisposable e keyword using
• Gli oggetti possono usare memoria e/o risorse: la prima è gestita dal Garbage Collector, le seconde devono essere gestite via codice.
• Cosa si intende per risorse?– Handle grafici, di file, delle porte di comunicazione, ecc...– Connessioni a database– Risorse del mondo unmanaged
• Dispose è il metodo tramite cui rilasciare immediatamente le risorse aperte.
• Per evitare che dimenticando di chiamare Dispose si lascino risorse aperte, si definisce anche la Finalize (distruttore) e si implementa il Pattern Dispose.
• L’interfaccia IDisposable dichiara il metodo Dispose e definisce il contratto per quelle classi che devono rilasciare risorse.
using (FileStream fs = File.OpenRead(filePath)){
// ...}
using (FileStream fs = File.OpenRead(filePath)){
// ...}
Implementa IDisposable
Qui viene chiamata Dispose()
Cast, keyword is e as• Il cast è l'operazione di
conversione di un tipo ad un altro.
• In caso di incompatibilità nella conversione viene lanciata una eccezione (ossia un errore) di tipo InvalidCastException.
• as serve per convertire un tipo in un altro senza rischiare una InvalidCastException ed èutilizzabile solo sui Reference Type (safe cast).
• is serve per sapere se un'istanza è di un certo tipo.
MyClass x = y as MyClass; // safe cast
if (x == null)Console.WriteLine(“Tipo non valido");
MyClass x = y as MyClass; // safe cast
if (x == null)Console.WriteLine(“Tipo non valido");
try{
MyType x = (MyType) y; // cast// ...
}catch(InvalidCastException exc){
// ...}
try{
MyType x = (MyType) y; // cast// ...
}catch(InvalidCastException exc){
// ...}
MyType x;
if (y is MyType)x = (MyType) y; // Conversione sicura
elseConsole.WriteLine(“Tipo non valido");
MyType x;
if (y is MyType)x = (MyType) y; // Conversione sicura
elseConsole.WriteLine(“Tipo non valido");
Da ASP ad ASP.NET 2.0
22
Gestione delle eccezioni 1/2• try serve a racchiudere gli
statement per i quali si vogliono intercettare gli errori (chiamate annidate comprese).
• catch serve per catturare uno specifico errore. Maggiore è la indicazione dell’eccezione, maggiore è la possibilità di recuperare l'errore in modo soft.
• finally serve ad indicare lo statement finale da eseguire sempre, sia in caso di errore, sia in caso di normale esecuzione.
SqlConnection conn =new SqlConnection(strConn);
try{
conn.Open();ElaboraRisultati(conn);
}catch(SqlException exc){
// informazioni specifiche// di SqlException
}catch(Exception exc){
// qui entra solo se non è// una SqlException
}finally{
// questo codice viene sempre// eseguitoconn.Close();
}
SqlConnection conn =new SqlConnection(strConn);
try{
conn.Open();ElaboraRisultati(conn);
}catch(SqlException exc){
// informazioni specifiche// di SqlException
}catch(Exception exc){
// qui entra solo se non è// una SqlException
}finally{
// questo codice viene sempre// eseguitoconn.Close();
}
Gestione degli eccezioni 2/2• throw serve a lanciare
un'eccezione specifica.
• L’eccezione risale lo stack delle chiamate fino a che non viene gestita da un blocco catchspecifico o dal gestore di default (“L’applicazione ha generato...").
• Si può sollevare una nuova eccezione o rilanciare l’eccezione che è stata intercettata.
SqlConnection conn =new SqlConnection(strConn);
try{
conn.Open();ElaboraRisultati(conn);
}catch(SqlException){
// rilancia l'eccezione// al chiamantethrow;
}
SqlConnection conn =new SqlConnection(strConn);
try{
conn.Open();ElaboraRisultati(conn);
}catch(SqlException){
// rilancia l'eccezione// al chiamantethrow;
}
public void MyMethod (string myString){
if (str == null)throw new ArgumentNullException(“myString");
}
public void MyMethod (string myString){
if (str == null)throw new ArgumentNullException(“myString");
}
Delegate 1/3• I delegate sono l'equivalente .NET dei puntatori a funzione
del C/C++ unmanaged, ma hanno il grosso vantaggio di essere tipizzati.
• La dichiarazione di un tipo delegate serve a stabilire un contratto che specifica la firma di uno o più metodi.
• Questo permette al compilatore di controllare che il puntatore a funzione e la funzione stessa siano compatibili, evitando problemi.
• Un delegate è un'istanza di tipo delegate e può referenziare:– un metodo di un'istanza di un oggetto in memoria;– un metodo statico.
Da ASP ad ASP.NET 2.0
23
Delegate 2/3
• In C# lo si dichiara con la parola chiave delegate.
• Il compilatore crea di conseguenza una classe che deriva da System.Delegate oppure System.MulticastDelegate (di nome MyDelegate).
• Queste due classi sono speciali e solo il compilatore può derivarle.
• Da programma il delegate viene istanziato passandogli nel costruttore il nome del metodo di cui si vuole creare il delegate.
• L'istanza può finalmente essere invocata.
delegate void MyDelegate (int i);delegate void MyDelegate (int i);
MyDelegate del = new MyDelegate (MyMethod);MyDelegate del = new MyDelegate (MyMethod);
del(5); // esegue MyMethod (int)del(5); // esegue MyMethod (int)
void MyMethod (int i) { ... }void MyMethod (int i) { ... }
Delegate 3/3
delegate void MyDelegate (int i); // funzione "prototipo"
class Program{
public static void Main(){
TakesADelegate (new MyDelegate (DelegateFunction));}
public static void TakesADelegate (MyDelegate SomeFunction){
SomeFunction(21);}
public static void DelegateFunction (int i){
System.Console.WriteLine(“Delegate with number: {0}.", i);}
}
delegate void MyDelegate (int i); // funzione "prototipo"
class Program{
public static void Main(){
TakesADelegate (new MyDelegate (DelegateFunction));}
public static void TakesADelegate (MyDelegate SomeFunction){
SomeFunction(21);}
public static void DelegateFunction (int i){
System.Console.WriteLine(“Delegate with number: {0}.", i);}
}
Eventi 1/3
• Un evento è un membro che permette alla classe di inviare notifiche verso l’esterno.
• L'evento mantiene una lista di subscriber che vengono iterati per eseguire la notifica.
• Tipicamente sono usati per gestire nelle Windows Forms le notifiche dai controlli all’oggetto container (la Form).
• Si parla di:– PublisherInoltra gli eventi a tutti i subscriber– SubscriberRiceve gli eventi dal publisher
Proprietà
Metodi
Eventi
Oggetto
Da ASP ad ASP.NET 2.0
24
Eventi 2/3• In C# lo si dichiara con la parola
chiave event.
• Per invocare l'evento, lo si chiama come un normale metodo.
• Il delegate rappresenta la firma che deve avere il metodo del subscriber all'evento.
• Per eseguire il subscribe è sufficiente aggiungere all'evento un delegate.
public class MyClass{
public event MyDelegate MyEvent;
public void FireAway() {
if(MyEvent != null)MyEvent();
}}
public class MyClass{
public event MyDelegate MyEvent;
public void FireAway() {
if(MyEvent != null)MyEvent();
}}
public class OneClass{
private void f() {
Console.WriteLine("Evento!");}
public void Subscribe() {
MyClass c = new MyClass();c.MyEvent += new MyDelegate(f);
}}
public class OneClass{
private void f() {
Console.WriteLine("Evento!");}
public void Subscribe() {
MyClass c = new MyClass();c.MyEvent += new MyDelegate(f);
}}
delegate void MyDelegate();delegate void MyDelegate();
Eventi 3/3
• Ciascun subscriber deve essere aggiunto alla lista del publisher (subscribe).
• Il subscriber può essere rimosso dalla lista (unsubscribe).
Publisher di
un evento
Publisher di
un evento
SubscriberSubscriber
SubscriberSubscriber
c.MyEvent -= new MyDelegate (f);c.MyEvent -= new MyDelegate (f);
Publisher di
un evento
Publisher di
un evento
SubscriberSubscriber
SubscriberSubscriber
c.MyEvent += new MyDelegate (f);c.MyEvent += new MyDelegate (f);
Parametri per eventi• È buona norma che il delegate per un evento passi due
parametri:– sender:l'oggetto che ha scatenato l'evento;
– args:un’istanza di una classe che deriva da EventArgs.
• Se non c'è bisogno di passare parametri particolari all’evento, si usa il tipo EventArgs.
• In alternativa si usa una delle tante classi derivate da EventArgs definite nel .NET Framework.
• Oppure si definisce una nuova classe che deriva da EventArgs.
Da ASP ad ASP.NET 2.0
25
Attributi 1/2• Gli attributi sono:
– espressioni utili per decorare porzioni di codice;
– classi che specializzano System.Attribute.
• Ogni classe derivata di System.Attribute èdirettamente utilizzabile come attributo. È raccomandato l’uso del suffisso Attribute nella definizione del nome delle suddette classi. Il suffisso può essere omesso in fase di decorazione del codice.
• È possibile decorare elementi del codice quali classi, metodi, proprietà, assembly, ecc.
Attributi 2/2
• Gli attributi servono per decorare: non eseguono direttamente codice, ma permettono al contesto di esecuzione di rilevarli e intraprendere determinate azioni.
• È questo ciò che fanno:– formatter;– XmlSerializer;
– worker process di ASP.NET;
– compilatori;
– ecc.
[Serializable()]public class Person{
// ...}
[assembly: CLSCompliant(true)]
[Serializable()]public class Person{
// ...}
[assembly: CLSCompliant(true)]
Generics: dalla teoria alla pratica 1/3• Obiettivo: rendere generico il tipo per
– class
– struct
– interface
– delegate
– metodi
Esempio:
metodo che scambi i valori di due variabili.
I due metodi riguardano solamente int estring. E gli altri tipi?
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
int a = 1, b = 3;Swap(ref a, ref b);int a = 1, b = 3;Swap(ref a, ref b);
string a = "a", b = "b";Swap(ref a, ref b);string a = "a", b = "b";Swap(ref a, ref b);
Da ASP ad ASP.NET 2.0
26
Generics: dalla teoria alla pratica 2/3
Problemi di questa soluzione:• boxing e unboxing per i Value Type;• Se chiamo Swap(1, “a") non dà errore di compilazione.
void Swap(ref object x, ref object y){
object Temp = x;x = y;y = Temp;
}
void Swap(ref object x, ref object y){
object Temp = x;x = y;y = Temp;
}
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
int a = 1, b = 3;Swap(ref a, ref b);int a = 1, b = 3;Swap(ref a, ref b);
string a = "a", b = "b";Swap(ref a, ref b);string a = "a", b = "b";Swap(ref a, ref b);
La soluzione con C# e .�ET Framework 1.x
Generics: dalla teoria alla pratica 3/3
void Swap<T> (ref T x, ref T y){
T Temp = x;x = y;y = Temp;
}
void Swap<T> (ref T x, ref T y){
T Temp = x;x = y;y = Temp;
}
int a = 1, b = 3;
Swap<int>(ref a, ref b);
oppure
Swap(ref a, ref b);
int a = 1, b = 3;
Swap<int>(ref a, ref b);
oppure
Swap(ref a, ref b);
string a = "a", b = "b";
Swap<string>(ref a, ref b);
oppure
Swap(ref a, ref b);
string a = "a", b = "b";
Swap<string>(ref a, ref b);
oppure
Swap(ref a, ref b);
La soluzione con C# e .�ET Framework 2.0
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref int x, ref int y){
int Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
void Swap(ref string x, ref string y){
string Temp = x;x = y;y = Temp;
}
void Swap(ref object x, ref object y){
object Temp = x;x = y;y = Temp;
}
void Swap(ref object x, ref object y){
object Temp = x;x = y;y = Temp;
}
Perchè usare i Generics?
• Novità della versione 2.0 del .NET Framework.
• Ottimi per collezioni tipizzate (ma non solo).
• Usabili sia per i Value Type che per i Reference Type.
• Facilitano il riutilizzo del codice.
• Controllo a compile time dei tipi.
• Niente cast e boxing.
• Permettono migliori performance.
Da ASP ad ASP.NET 2.0
27
Generics 1/2
• Vincoli (constraint):
– where� Vincola il tipo T ad essere MyObject o uno deisuoi derivati (anche interfacce). Questo vincolo non si applica a classi sealed, tipi primitivi, ValueTypes, delegati, enumerazioni, array.
– struct� Vincola il tipo T ad essere un Value Type.
– class� Vincola il Tipo T ad essere un Reference Type.
– new()� T deve avere un costruttore pubblico senza parametri.
class MyClass<T> where T : MyObject, new(){
// ...
}
class MyClass<T> where T : MyObject, new(){
// ...
}
Generics 2/2• Inizializzazione di un oggetto T
• Null check
T x = default(T);
// x = null se T è un Reference Type// x = 0 se è un Value Type
T x = default(T);
// x = null se T è un Reference Type// x = 0 se è un Value Type
void SomeMethod<T> (T x){
if (x == null){
throw new NullException();}
}
void SomeMethod<T> (T x){
if (x == null){
throw new NullException();}
}
System.Collections.Generic
• Comparer<T>
• List<T>
• Queue<T>
• Stack<T>
• Dictionary<K,V>
• Ecc.List<int> intList = new List<int>();
intList.Add(1); // Nessun boxingintList.Add(2); // Nessun boxingintList.Add("Three"); // Errore di compilazione
int i = intList[0]; // Cast non necessario
List<int> intList = new List<int>();
intList.Add(1); // Nessun boxingintList.Add(2); // Nessun boxingintList.Add("Three"); // Errore di compilazione
int i = intList[0]; // Cast non necessario
Da ASP ad ASP.NET 2.0
28
System.Collections.ObjectModel
• Collection<T>
• KeyedCollection<TKey, TItem>
• ReadOnlyCollection<T> using System.Collections.ObjectModel;
public class PersonCollection : Collection<Person>{
// ...}
using System.Collections.ObjectModel;
public class PersonCollection : Collection<Person>{
// ...}
Generics vs Template
• I generics hanno un comportamento simile ai template del C++.
– I template generano il codice al compile time.• I template sono type safe.
– I generics generano il codice al run time.• Il JIT (Just In Time Compiler) genera codice nativo del tipo giusto e solo quando serve.
– I generics controllano il codice al compile time.• È possibile vincolare il tipo generico (Constraint).
– Il nuovo linguaggio C++/CLI ha sia template che generics.
Nullable Types 1/2
• Permettono la nullabilità dei Value Type (versione 2.0).
• I Value Type marcati come nullabili vengono incapsulati dentro una struct di nome System.Nullable<T>.
• Sinonimo di Nullable<T> è T?.
T
structNullable<T>
System.Nullable<int> x2 = 100;x2 = null;System.Nullable<int> x2 = 100;x2 = null;
DateTime? dt = DateTime.Now;dt = null;DateTime? dt = DateTime.Now;dt = null;
int? x1 = 10;x1 = null;int? x1 = 10;x1 = null;
Da ASP ad ASP.NET 2.0
29
Nullable Types 2/2• HasValue ritorna un bool che indica se l'istanza è null.
• La proprietà Value ritorna il Value Type contenutooppure una InvalidOperationException se Value è null.
• Il valore di default di un Nullable Type è un'istanza dove HasValue vale false e Value è indefinito (null).
• Esiste il costruttore new T?(x).• Esiste la conversione (cast) implicita da T a T?.• Esiste l’operatore chiamato null coalescing ??a ?? b � se a non è null restituisce a altrimenti b (a può essere un Nullable o Reference Type)
Anonymous methods
• Ricordate i delegate? Quelli che servono, per esempio, per gli eventi... ☺
• Ora è possibile semplificare il loro uso:
button2.Click += delegate(object sender, EventArgs e){MessageBox.Show("Click!");
};
button2.Click += delegate(object sender, EventArgs e){MessageBox.Show("Click!");
};
button1.Click += new EventHandler(button1_Click);
// ...
private void button1_Click(object sender, EventArgs e){MessageBox.Show((sender as Control).Name);
}
button1.Click += new EventHandler(button1_Click);
// ...
private void button1_Click(object sender, EventArgs e){MessageBox.Show((sender as Control).Name);
}
La prima pagina ASP.NET
• ASP.NET compila automaticamente la nostra pagina, creando una classe generata dinamicamente che deriva dalla classe System.Web.UI.Page.
• La classe contiene dunque già una logica ed una serie di informazioni di base, che noi di fatto estendiamo creando la nostra pagina.
• In pratica, la nostra pagina è una classe che ha modificato (ereditando) alcune caratteristiche dalla classe di base System.Web.UI.Page.
Da ASP ad ASP.NET 2.0
30
Gli eventi
• Come tutti gli oggetti, anche la pagina ASP.NET ha degli eventi, che si verificano in determinate condizioni:
– PreInit: prima dell’init (novità della 2.0)– Init: quando la pagina viene inizializzata– Load: quando la pagina ed i controlli che contiene sono stati
caricati– Unload: dopo che tutte le informazioni sono state inviate al
client e la pagina è stata elaborata– PreRender: prima del rendering delle informazioni– Error: quando si verifica un errore
Il PostBack
• ASP.NET implementa un meccanismo noto come “PostBack” tra client e server.
• Questo permette di passare nuovamente il controllo al server per l’elaborazione, in maniera molte volte automatica, al verificarsi di eventi particolari, ad esempio la pressione di un pulsante.
• In questo caso, quello che si verifica è il ricaricamento della stessa pagina ed il verificarsi dell’evento PostBack, che permette di programmare in maniera migliore questa eventualità.
E come mantenere lo stato
• In questo modello è ovviamente importante mantenere lo stato della pagina tra le varie richieste. ASP.NET lo fa attraverso il ViewState, che altro non è che una traccia dello stato dei controlli tra queste varie richieste.
• Le informazioni vengono archiviate sotto forma di coppie chiave/valore attraverso l’oggetto System.Web.UI.StateBag.
• La stringa generata dall’oggetto viene inviata attraverso i campi delle form, crittografata in un certo valore per evitare contraffazioni della stessa (usa il MAC).
Da ASP ad ASP.NET 2.0
31
Come funziona il ViewState
• Il ViewState è utilissimo, ma occupa spazio tra le richieste. Quando non è necessario si può disabilitare con la direttiva:
• <%@ Page EnableViewState=“false” %>
• E’ anche possibile disabilitarlo sulla base del singolo controllo, utilizzando un attributo con lo stesso nome. <asp:label 9. EnableViewState=“false” />
La direttiva @Import
• Questa istruzione è molto utilizzata per importare esplicitamente i riferimenti alle classi di un particolare namespace.
• <%@ Import namespace=“System.Data.SQLClient” %>
• Nell’esempio importiamo il namespace necessario per l’accesso alle funzionalità di SQL Server.
Specificare il linguaggio
• Questa direttiva consente di specificare illinguaggio della pagina.
• Per VB.NET– <%@ Page Language=“VB” %>
• Per C#– <%@ Page Language=“C#” %>
Da ASP ad ASP.NET 2.0
32
Il debugging
• ASP.NET implementa un sofisticato meccanismo per gestire trace e debug, ovvero tracciamento delle richieste e dell’esecuzione dellapagina, e debugging della stessa.
• Sono strumenti già integrati nel runtime, potenti e facili da usare. Il debugging con VS.NET è integrato e ricorda da vicino quello di VB 6.
• Per abilitare il debug si utilizza la proprietà Debug della classePage:– <%@ Page Debug=“true” %>
• Questa istruzione abilita il debug, ovvero la visualizzazione estesadegli errori, con un pezzo di codice che visualizza subito l’errorestesso con la posizione dello stesso.– Mai usare un’app in debug in produzione, i simboli rallentano
l’esecuzione!
Il tracing
• Per abilitare il tracing, bisogna utilizzare la proprietà Trace della classe Page– <%@ Page Trace=“true” %>
• E’ possibile fare in modo che il tracing accodi le richieste in una pagina unica (trace.axd), agendo sul web.config.
Server controls
• Un server control è un pezzo di markup con ID univoco rispetto al contenitore e l’attributo runat=“server”
• Es:– <asp:button id=“button” runat=“Server” />– <a id=“Link” runat=“server”>Testo</a>
Da ASP ad ASP.NET 2.0
33
Mantengono lo stato da soli
• I controlli server mantengono le proprietà impostate fra round-trip tramite un campo hidden– __VIEWSTATE
• Si può disabilitare
Server Controls
• HTML Controls– Sintassi HTML
– Mappati 1:1 con controlli HTML
– Namespace System.Web.UI.HtmlControls
• Web Controls– Sintassi diversa
– Tutti gli HTML Control• Più controlli avanzati
– Maggiori funzionalità
HTML Controls
• Vengono definiti all’interno del namespace System.Web.UI.HtmlControls che contiene due classi di base e altre classi per i controlli interattivi.
• La Classe di base per gli HTML Server Controls è System.Web.UI.HtmlControls.HtmlControl
Da ASP ad ASP.NET 2.0
34
HTML Controls
• Classe HtmlGenericControl– Contiene la maggior parte degli elementi definiti come HTML
• Classi HTML Server Controls Specifiche– Esistono classi specifiche per elementi specifici
• <a> Classe “HtmlAnchor” - Proprietà: Href, Target, Title, Name –Evento: OnServerClick
• <img> Classe: “HtmlImage” – Proprietà: Align, Alt9• <select> Classe “HtmlSelect” – Proprietà: Multiple, Size, DataSource9 - Evento: OnServerChange
Web Controls
• <asp:TextBox runat=“server” id=“txtName” Text=“default”></asp:TextBox>
• Modello ad oggetti consistente e strongly-typed – txtName.Text = “Daniele”
– txtName.BackColor = Color.Red
• Rendering differente per browser– Esempio: Label
• Funzionalità differenti per browser– Esempio: Validation Control
Alcuni esempi
• <asp:textbox /><input type=text>• <asp:button /><input type=submit>• <asp:imagebutton /><input type=image>• <asp:checkbox /><input type=checkbox>• <asp:radiobutton /><input type=radiobutton>• <asp:listbox /><select size=“5”>• <asp:dropdownlist /><select>• <asp:hyperlink /><a href=“...”>• <asp:image /><img src=“...”>• <asp:label /><span>• <asp:panel /><div>• <asp:table /><table>
Da ASP ad ASP.NET 2.0
35
Altri Web Controls
• List Controls– Iterativi su una base di dati
• DropDownList, ListBox, RadioButtonList, CheckBoxList
• Data Controls: Repeater, DataList, DataGrid
• Validation Controls
• Rich Controls– Calendar, AdRotator, Xml
• Mobile Controls: per device e telefonini
Validator Controls
• ASP.NET per velocizzare l’implementazione di pagine interattive, introduce i Validator Controls, per controllare l’input delle form.
• Ad ogni elemento di Input è associabile uno o più Validator Controls, e quindi ad ogni invio di pagina vengono verificati tutti i dati ed in caso di errore il Control “ValidationSummary “ visualizzerà i messaggi di errore relativi al Validator Control.
Client-Side/Server-Side Validation
• ASP.NET gestisce client-side validazioni e server-side
• Client-side Validation – Dependent on browser version
– FeedBack immediato
– Riduce i round-trip
• Server-side Validation– Riesegue le validazioni
– Controllo su fonte dati
Valido?
Valido?
User
Inserimento
No
No
Si
Si
MsgErrore
Client
Server
Web Application
Processing
Da ASP ad ASP.NET 2.0
36
Client o Server?
• Con i Server Control (<asp:) automatico in base alle capacità del browser
• ClientTarget=“DownLevel”– tutti
• ClientTarget=“UpLevel“– Usa Javascript
La pagina è un tipo :)
• Anche la pagina è un oggetto• La classe deriva da System.Web.UI.Page• Si possono costruire variabili membro• HTML diventa parte del metodo Render• Il codice di rendering diventa parte del metodo Render
• WebForm e Controlli Server-side sono costruiti sulla classe Page
• La classe Page fa da ponte verso Request, Response, etc.
Compilazione della pagina
ASPXASPX
FileFileRequestRequest
ASPXASPX
EngineEngine
ParsingParsing
Class
File
su
Disco
GenerazioneGenerazione
PagePage
ClassClass Istanza, Istanza,
Esecuzione e Esecuzione e
RenderingRendering
ResponseResponse
RequestRequest
CreazioneCreazione
IstanzaIstanza
ResponseResponse
CodeCode--
behindbehind
filefile
Da ASP ad ASP.NET 2.0
37
User controls
– Sono pezzi di pagine, salvati in file separati– Hanno estensione .ascx
• Includono HTML• Includono codice• Possono essere tenuti in cache (fragment caching)
– Pro• Sono facilmente creabili• Supportano facilmente il caching• Si modificano senza ricompilare
– Contro• Molto “macchinosi”• Favoriscono lo “spaghetti-code”• Hanno dipendenze maggiori verso il progetto che li contiene
109
La direttiva @Register
• Rende possibile l’uso di uno user control nella pagina
– <%@ Register tagprefix=“prefisso” tagname=“nome” src=“path” %>
• Tagprefix indica la parte iniziale utilizzata per richiamare il controllo, tagname il nome dopo i :
• In questo caso il controllo indica il namespace in cui si trovano i nostri controlli, indicando con assembly il nome del file con la class library.– <%@ Register tagprefix=“corso” namespace=“Studente”
assembly=“MyAssembly” %>
111
SessionState: gestire lo stato
• Il Web è stateless• Mantenere lo stato delle informazioni
– Valori– Variabili– Proprietà
• Server-Side per riutilizzarli fra richieste diverse
• Sulla stessa pagina• Sull’intera applicazione
Da ASP ad ASP.NET 2.0
38
112
Gestire lo stato
• Server Side– Web.Config– Application – Session (se cookie andrebbe dopo)– Caching
• Client/Server Side– Cookie – Hidden Field– QueryString– ViewState
113
Application
• Classe HttpApplicationState• Oggetto Application• Esposto come proprietà di
– HttpContext e Page
• Memoria condivisa per tutta l’applicazione– Indipendente dall’utente– Accesso tramite Nome/Valore– Non usarla per dati temporanei
• Difficile impostare una scadenza
• Da non confondere con la classe HttpApplication esposta come ApplicationInstance che rappresenta l’intera applicazione ASP.NET e non un’area di memoria
114
Session a confronto
• In ASP 1/2/3 le session – Necessitano del supporto dei cookie sul client– Sono single-machine e non adatte a configurazione di load-balancing
– Consumano molta RAM• In ASP.NET le session
– Possono lavorare come prima oppure non necessitare dei cookie
– Essere multi-machine– Appoggiarsi su DB o su uno State Server
Da ASP ad ASP.NET 2.0
39
115
Session
• Classe HttpSessionState• Oggetto Session• Esposto come proprietà di
– HttpContext e Page• Memoria condivisa per tutta l’applicazione
– Dipendente dall’utente– Accesso tramite Nome/Valore– Non usarla per dati temporanei
• Difficile impostare una scadenza
• Implementata dal modulo System.Web.SessionState.SessionStateModule
Cos’è il SessionState di ASP.NET
116
BrowserBrowserServerServer
BrowserBrowser SessionSession
SessionSession
CookieCookie
CookieCookie
URL SessURL Sess
URL SessURL Sess
ASPNET_WP.EXEASPNET_WP.EXE
HttpRuntimeHttpRuntimeClassClass
Modulo XModulo X SessionSessionHTTP HandlerHTTP HandlerPagina1.aspxPagina1.aspx
HttpRuntimeHttpRuntimeClassClass
Modulo XModulo X SessionSessionHTTP HandlerHTTP HandlerPagina2.aspxPagina2.aspx
ASP.NET worker thread 1ASP.NET worker thread 1
ASP.NET worker thread 2ASP.NET worker thread 2
Come si usa
• Session[“nome”] = Valore
• Valore = Session[“nome”].ToString()
• Non occorre definire le varibili– Come con ASP
– Ma occhio a controllarne l’esistenza prima di utilizzarne un valore• Ed a fare il casting
117
Da ASP ad ASP.NET 2.0
40
118
Configurazioni possibili
• <sessionState mode="Off|Inproc|StateServer|SQLServer" cookieless="true|false"
timeout="number of minutes" stateConnectionString="tcpip=server:port" sqlConnectionString="sql connection string" /> – Off se non si usa
119
Session senza Cookie
• <sessionState cookieless=“true" />
• Non necessita di cookie abilitati sul client• Il cookie viene copiato nei vari Url linkati dalla pagina– Http://xxx.com/3463287462764/pagina.aspx
• Utilizzabile in tutte le modalità– Session.Mode
• Gestiti dal filtro ISAPI ASPNET_FILTER.DLL
120
In-process Session
<<sessionStatesessionStatemode=“mode=“InProcInProc” ” cookielesscookieless="="true|falsetrue|false" /> " />
•• Più velocePiù veloce
•• Singolo Server Singolo Server –– No Load BalancingNo Load Balancing
•• Se ASPNET_WP crasha Se ASPNET_WP crasha –– Addio SessionAddio Session
BrowserBrowser
ASPNET_WPASPNET_WP
BrowserBrowser SessionSession
SessionSession
CookieCookie
CookieCookie
URL SessURL Sess
URL SessURL Sess
Da ASP ad ASP.NET 2.0
41
ASPState Session
121
<<sessionStatesessionState mode=“mode=“StateServerStateServer” ” cookielesscookieless="="true|falsetrue|false" "
stateConnectionStringstateConnectionString="="tcpiptcpip=server3:42424"=server3:42424" /> />
•• ASPNET_STATE Può girare anche sullo stesso serverASPNET_STATE Può girare anche sullo stesso server
•• Se ASPNET_WP crasha Se ASPNET_WP crasha –– Le Session sopravvivonoLe Session sopravvivono
•• Più lento di InProcess Più lento di InProcess –– Più veloce di SQL Server SessionPiù veloce di SQL Server Session
•• Load BalancingLoad Balancing
•• Se crasha ASPNET_STATE Se crasha ASPNET_STATE –– Addio Sessioni di tutti i serverAddio Sessioni di tutti i server
BrowserBrowser
ASPNET_WPASPNET_WP
SERVER 2SERVER 2BrowserBrowser
CookieCookie
CookieCookie
URL SessURL Sess
URL SessURL SessASPNET_STATEASPNET_STATE
SERVER 3SERVER 3
SessionSessionBrowserBrowserCookieCookieURL SessURL Sess
ASPNET_WPASPNET_WP
SERVERSERVER 11
SessionSession
SessionSession
122
SQL Server Session
<<sessionStatesessionState mode=“mode=“SQLServerSQLServer” ” cookielesscookieless="="true|falsetrue|false" "
sqlConnectionStringsqlConnectionString=“=“ConnStringConnString”” /> />
•• SQL può girare anche sullo stesso serverSQL può girare anche sullo stesso server
•• Se ASPNET_WP crasha Se ASPNET_WP crasha –– Le Session sopravvivonoLe Session sopravvivono
••Metodo più lento ma più sicuro (se in cluster)Metodo più lento ma più sicuro (se in cluster)
•• Load Balancing Load Balancing
BrowserBrowser
ASPNET_WPASPNET_WP
SERVER 2SERVER 2BrowserBrowser
CookieCookie
CookieCookie
URL SessURL Sess
URL SessURL Sess
SessionSessionBrowserBrowser
CookieCookieURL SessURL Sess
ASPNET_WPASPNET_WP
SERVER 1SERVER 1
SessionSession
SessionSession
SQL Server SQL Server (anche (anche Cluster)Cluster)
123
SQL Server Session
• %WinDir%\Microsoft.NET\Framework\vxxxx\InstallSQLState.sql
• Per creare Database e Stored Procedure– DataBase: ASPState– SP: Insert, Get, Update
• I dati vengono appoggiati al TEMPDB– Al Restart di SQL Server le Session vengono perse– Possiamo modificare InstallSQLState per creare e appoggiare i dati su un altro DB
• Nella 1.1 InstallPersistSQLState.sql
Da ASP ad ASP.NET 2.0
42
124
Per avere un’idea
0
200
400
600
800
1000
1200
1400
ASP.NET InProc ASP.NET State Store ASP.NET SQL Store
Requests/Sec (2P Server)
ASP to ASP.NET - Focus
• L'installazione di ASP.NET non impedisce il funzionamento delle applicazioni ASP esistenti– Usano worker process completamente separati
• Le applicazioni ASP e ASP .NET:– possono essere eseguite side-by-side (usano estensioni di file differenti)
– non condividono Session e Application• anche se è possibile farlo scrivendo tanto codice (o sfruttando qualcuno che l’ha fatto :) )
– Sono comunque possibili strategie di migrazione parziale
ASP.NET: vantaggi
• Il codice eseguito:– E’ compilato– Può utilizzare tutte le classi del .NET Framework– È un ambiente più “visuale”– Sessioni cookieless e scalabili in una web farm– E’ un ambiente Object Oriented– E’ tipizzato– E’ tipizzato– E’ tipizzato :)
Da ASP ad ASP.NET 2.0
43
ASP e ASP .NET: analogie
• Gli oggetti Request e Response sono ancora supportati
• Gli include funzionano ancora– Ma ci sono modi sicuramente più belli di includere codice :)
• Supportano codice applicativo frammisto ad HTML• La direttiva Language è ancora supportata (in realtà viene sottointeso Page)
• VB .NET sa “imitare” fin troppo bene VBScript
ASP .NET: differenze da ASP
• Le pagine ASP.NET supportano un solo linguaggio
• Le pagine ASP.NET supportano più di una direttiva
• E’ necessario dichiarare le funzioni in blocchi <script runat=server>
<%
Sub DoSomething()
Response.Write “Ciao a tutti !!!"
End Sub
DoSomething
%>
<script language="VB" runat=server>
Sub DoSomething()
Response.Write (“Ciao a tutti !!!")
End Sub
</script>
<%
DoSomething()
%>
ASP .NET: differenze da ASP
• ASP.NET non supporta le funzioni di rendering in-line
<% Sub RenderSomething() %>
<font color="red"> Sono le ore:
<%=Now %> </font>
<% End Sub %>
<%
RenderSomething
RenderSomething
%>
<script language="VB" runat=server>
Sub RenderSomething()
Response.Write("<font color=red> ")
Response.Write(“Sono le ore: " & Now)
End Sub
</script>
<%
RenderSomething()
RenderSomething()
%>
Da ASP ad ASP.NET 2.0
44
ASP .NET: differenze da ASP
• Option Explicit è impostato per default• E’ necessario dichiarare le variabili aventi scope page-level in blocchi <script runat=server>
• le "pagine" ASP .NET si chiamano Web Form• Molti dei settaggi di IIS per le applicazioni ASP.NET vengono ignorati (specie su IIS 6)– La configurazione sta in ASP.NET
• Web.config• Machine.config
ASP .NET: da VBScript a VB .NET
• Niente Set e Let• Niente proprietà predefinite non indicizzate• Le parentesi sono necessarie per chiamare procedure/funzioni (anche se non hanno parametri)
• Per default, gli argomenti sono passati ByVal• Possiamo avvalerci della tipizzazione :)• VB.NET e C# simili
– CLI– CLS– Si parlano!
ASP .NET vs. COM
• Il CLR consente agli oggetti .NET di interagire senza (particolari) difficoltà con i componenti COM tradizionali.
• Un componente può essere istanziato:– in late binding mediante Server.CreateObject(ProgId)– in early binding creando un assembly di interoperabilità con tblimp.exe o VS .NET
– Mediante il tag <object>
• L’uso di componenti non free-threaded (STA – fatti con VB6) richiede l’inserimento dell’attributo ASPCompat=“True” nella direttiva Page– degrada le performance– ASP.NET diventa single threaded
Da ASP ad ASP.NET 2.0
45
ASP to ASP .NET: la via alternativa
• Possiamo “capovolgere” il problema: perché non mantenere un front-end ASP convertendo i componenti COM in Assembly .NET?– Teoricamente si, ma lascia la “porta” aperta ad alcune complicazioni.
• Il modo più semplice è utilizzare regasm.exe• Si peggiora il deployment
– Oggetti COM
• Si rimane legati a COM– COM è il male! :D
© 2006 Microsoft Corporation. All rights reserved.© 2006 Microsoft Corporation. All rights reserved.
This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN
THIS SUMMARY.THIS SUMMARY.Content created by Daniele Bochicchio.Content created by Daniele Bochicchio.
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
1
Da ASP.NET 1.1 ad ASP.NET
Daniele Bochicchio – Content Manager ASPItalia.com
[email protected] – http://blogs.aspitalia.com/daniele/
Chi sono?• Content Manager di ASPItalia.com
– Porto avanti la più grande community italiana di sviluppatori ASP ed ASP.NET, con 35.000 iscritti
• Scrivo, scrivo, scrivo :)– Articoli su riviste italiane (VBJ, ioProgrammo, Internet
Magazine, etc)
– Libro “ASP 3 per Esempi”
– Libro “ASP.NET 2.0 per tutti” – http://books.aspitalia.com/
– Articoli, script, blog, forum, newsgroup
• Consulenze– Corsi, training, mentoring, progettazione, sviluppo
– Speaker in eventi per Microsoft Italia
• Microsoft ASP.NET MVP– Riconoscimento per l’impegno nel supporto agli utenti
3
Programma• Ore 9.30 – 11.00
– Parte I
• Ore 11.00 – 11.30– Break I
• Ore 11.30 – 13.00– Parte II
• Ore 13.00 – 14.00– Pranzo
• Ore 14.00 – 15.30– Parte III
• Ore 15.30 – 16.00– Break II
• Ore 16.30 – 17.30– Parte IV
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
2
4
Agenda
• Le novità di ASP.NET 2.0
• Page Framework
• Themes, Master Pages
• Building Blocks
• Site Navigation
• ADO.NET
• DataBinding
5
Cos’è ASP.NET 2.0
• Versione 2.0 di ASP.NET– Compatibile con 1.0 e 1.1
• Architettura migliorata– Provider Model Design Pattern
– Modularizzazione
– Declarative Controls
• Nuova modalità di accesso ai dati– Meno codice necessario
6
VS 2005
• Gestione del codice– Mai più modifiche arbitrarie del codice nel design view
– Completo supporto degli standard e dei linguaggi di MarkUp
• HTML 3.2 e 4.0
• XHTML 1.0 Strict e Transitional
– Validazione inline in base al browser e/o alla versione, supportati
• IE, Netscape, Opera
– Completo supporto dei CSS
– Completo supporto per l’accessibilità
– Validazione secondo le raccomandazioni e le linee guida del W3C (WCAG 1.0)
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
3
7
VS 2005
• Intellisense migliorato
• Supporto di intellisense nel code-beside e nel code-separation
• Supporto di intellisense anche per HTML, XHTML, CSS, Web.Config, XML
• HTML Tag Navigator and Tag Outlining– Consentono di orientarsi all’interno del codice
in maniera più semplice raggruppando intere parti del codice
8
Gestione dei progetti
• Pubblicazione e aggiornamento (non più richieste le estensioni di FP, basta il File System, IIS o l’FTP)
• Solution Less (non più necessario file di progetto)
• Single File Solution (ora è possibile editare anche un singolo file dell’applicazione senza compilare l’intero progetto)
• Nuovo concetto di code-beside e separazione del codice trasparente– Nuova directory (app_code) dove poter inserire
tutti i sorgenti delle classi utilizzate nell’applicazione, compilati al volo
9
Gestione dei progetti
• Con questo add-in torna il modello simile a VS.NET 2003
• http://msdn.microsoft.com/asp.net/reference/infrastructure/wap/default.aspx
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
4
10
Providers
ASP.�ET 2.0 “Building Block” API
MembershipMembership
Windows SQL Server Custom
Role ManagerRole Manager PersonalizationPersonalization
Site NavigationSite Navigation Database CachingDatabase Caching ManagementManagement
Provider Model Design Pattern
JET (Access)
ASP.NET 2.0 Developer Stack
11
ASP.�ET 2.0 API
MembershipMembership Role ManagerRole Manager PersonalizationPersonalization
Site NavigationSite Navigation Database CachingDatabase Caching ManagementManagement
ASP.NET 2.0 Developer Stack
12
Nuovo ASP.NET 2.0 “Building Block” APIs
MembershipMembership Role ManagerRole Manager PersonalizationPersonalization
Site NavigationSite Navigation Database CachingDatabase Caching ManagementManagement
ASP.NET 2.0 Developer Stack
Nuovo ASP.NET 2.0 “Page Framework” Features
Master PagesMaster Pages Themes/SkinsThemes/Skins Adaptive UIAdaptive UI
Nuovi Controlli (Oltre 40)
SecuritySecurity Web PartsWeb PartsDataData NavigationNavigation
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
5
13
Il focus di ASP.NET 2.0
• Produttività–Ridurre le linee di codice necessarie–Migliorare VS 2005–Rendere più ricco il web
• Estendibilità–Facilmente espandibile–Pronto per tutte le esigenze
• Performance e scalabilità
14
Per cominciare
• Migliorie–Costruzione di applicazioni semplificata
–Piattaforma più stabile (oltre 5 anni di presenza del .NET Framework)
• Facile upgrade– IIS5, IIS5.1 e IIS6.0
–Compatibile con la 1.1 (basta ricompilare)
15
Web Developer Web Server
�Web Server built-in
�Non è necessario IIS per sviluppare
�Accesso consentito solo a richieste dall’IP
locale
�Chiusura automatica alla chiusura di VS 2005
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
6
16
Nuovo compilation model
�Nella pagina:
<% Page Codefile=“default.aspx.cs”
Inherits=“Web.Default_aspx” %>
�Nel file .cs:
� public partial class Default_aspx: Page
�Niente code behind, si chiama code
separation
� Partial class: un classe su più file
17
Nuovo compilation model
�Niente più compilazioni dei codeFile in un
assembly
� Viene caricato a runtime
� Bisogna fare il deployment anche dei sorgenti
� Consente di aprire anche il singolo file in
modifica
� Una modifica ad una pagina non fa riciclare
l’app domain
18
La riscossa del code-inline
�VS 2005 supporta nativamente il code-inline
� codice in linea nella pagina, dentro <SCRIPT>
� favorisce il deployment: una pagina, un file
� non ha controindicazioni
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
7
19
Ma io voglio compilare tuttoH
� Tool aspnet_compiler.exe
� Modalità no markup: rimuove tutto e genera
una serie di assemblies
� Modalità “easy”: stile VS 2003, compila solo il
codice in assemblies, lascia intatto l’HTML
� Web Application Project� http://msdn.microsoft.com/asp.net/reference/infrastructure/wap/default.aspx
20
Fare il build in VS 2005
� Il build prova a compilare:
� pagine
� codefile
� assemblies, etc
�Gli errori contenuti nel markup (es,
DataBinding) ora vengono visualizzati
subito
�Aiuta a fare il deployment
21
Nuove directory di sistema
� /app_Code/
� Basta piazzare i sorgenti delle classi
�Compilazione al volo in assembly
� /app_GlobalResources/
� Contiene le risorse globali .resx compilate al
volo in assembly
� /app_LocalResources/
� Contiene le risorse locali .resx
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
8
L’ordine di compilazione
� Importante quando ci sono cross reference:
� /App_GlobalResources/
� /App_LocalResources/
� /App_Code/
�global.asax
�*.aspx, *.ascx, *.asmx
� /App_Themes/
22
23
Le dir di ASP.NET 2.0
• Nuove directory riservate– Nuova naming convention (app_funzione)– Evitare directory con il prefisso app_
• Directory riservate– /Bin – contiene gli assemblies (come nella 1.x)– /App_Code – contiene file sorgenti (.cs o .vb)– /App_Data – contiene dati (.mdb,.xml,.txt)– /App_Themes – contiene themes e skins– /App_WebReferences – contiene file .wsdl– /App_LocalResources – contiene risorse locali– /App_GlobalResources – contiene risorse globali
24
Il supporto per XHTML e gli standard
• Output XHTML– Non è inviato di default, va modificato il
web.config
– Richiede modifiche al Javascript delle pagine• niente attributo name nell’HTML, va sistemato il
codice utilizzando getElementById()
• <xhtmlConformance mode=“”/> – Default è “Transitional”
–Può essere “Legacy” or “Strict”– Se Strict, le pagine devono essere XHTML
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
9
25
File Javascript di sistema
• I file Javascript di sistema con Validation, etc, ora sono inclusi in un Handler– niente file fisici tra le varie dir
• Niente aspnet_regiis –i per ogni nuovo sito!
– I file sono caricati così:• WebResource.axd?a=s&r=WebUIValidation.js
– Non è più possibile modificare i file manualmente
– E’ suggeribile utilizzare i meccanismi OO di Javascript
26
Differenze tra VS.NET 2003 e VS 2005
• Il template di default include un DOCTYPE per XHTML 1.0 Transitional– Va modificato se si usa XHTML 1.1 (mode
strict)
– E’ consigliabile pensare le proprie applicazioni come XHTML
• miglior supporto da parte dei browser
• Sintassi XML-like
• Formattazione demandata ai CSS
27
ProblemiH
• Possibili problemi per naming collision– Più di 2.000 nuove classi nella 2.0
– Nomi comuni: Membership, Roles, Theme
• Non impatta sugli assembly compilati– il CLR sa quale tipo recuperare
– Le collisioni si potrebbero manifestare solo se si ricompila
• Ed in questo caso si può ovviare– Cambiando nome alle classi
– Usando il FQN (il percorso completo di namespace)
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
10
28
Visual Studio Conversion Wizard
• Visual Studio 2005 ha progetti diversi– Nuova struttura, più flessibile per i progetti web
• Benefici principali– Niente file di progetto
– Niente compilazione in singola DLL
– Si possono modificare pagine e codice mentre si debugga
– Niente bisogno di ricompilare dopo le modifiche
– Modello codeFile più pulito
– Possibilità di usare più linguaggi nello stesso progetto
29
Visual Studio Conversion Wizard
• VS 2005 converte in automatico i progetti dalle 2003 all’apertura– Viene installato un programma in grado di
aprire i progetti con la giusta versione
– Se convertito è a senso unico• Non si può più riaprire il progetto in VS.NET 2003
• Ma si può farne il backup
– L’operazione genera anche un log
30
Principali differenze di sintassi• ASP.NET 1.1
• Pagina<%@ page codeBehind=“webform1.aspx.cs” inherits=“WebForm1” %>
• Code-behindpublic class WebForm1 : System.Web.UI.Page
• ASP.NET 2.0• Pagina
<%@ page codeFile=“webform1.aspx.cs” inherits=“WebForm1” %>
• codeFilepublic partial class WebForm1 : System.Web.UI.Page
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
11
31
Master Pages
32
Master Pages
• Una master page è un po’ come uno user control– è però più rivolta al design
– direttiva <%@Master %>
– può contenere codice
– può usare l’ereditarietà• Una master page può estenderne un’altra
33
Master Pages
• Site.Master– Definisco contenuto generale– <asp:ContentPlaceHolder id=“Center” ... />
• <%@Page MasterPageFile = “Site.Master”%>– <asp:Content ContentPlaceHolderId=“Center”>
• Contenuto della pagina– </asp:Content>
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
12
34
Theme
• Possibilità di utilizzare skin grafici con i temi:– <% Page Theme=“RossoNero” %>– <% Page Theme=“RossoNeroOldStyle” %>
• Un tema è un insieme di file sotto la dir /app_Themes/– Contiene uno o più file .skin– Può contenere immagini e CSS personalizzati
• Uno skin è un file con dichiarazione di controlli
35
Theme & Skins
• Directory Theme– MioTema1
• Label.Skin– Background Blu – Foreground Bianco
• TextBox.skin– Background Bianco – Foreground Verde
– MioTema2• Label.Skin
• TextBox.Skin
36
Theme & Skins
• Un tema può essere specificato:– Globalmente (Web.config, sezione pages)– Localmente
• <%Page Theme=“Tema”%>• Page.Theme = “Tema” (va fatto nell’evento
Page_PreInit)
• Per fare le cose per bene, skin e temi dovrebbero far sempre riferimento ad un file CSS, senza necessità di dichiarare lo stile dentro lo skin
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
13
37
Applicare skin ad user (e custom) control
• Bisogna aggiungere l’attributo Themeable:[Themeable(true)]
public static MyControl: UserControl
{
}
38
Site Navigation
• TreeView– Immagini e testo
• Menu– Anche con rendering dinamico
• SiteMapPath– Controllo “briciole di pane” (Sei in: Home>etc)
39
<asp:TreeView />
– Sviluppato per lavorare con i nuovi data source controls
– Consente una navigazione simile a quella di MSDN
– Consente di popolare i nodi anche client side se il browser lo supporta (IE 5.0+, Netscape 6.0)
– Visualizza CheckBox controls
– Personalizzazione attraverso themes
– Introduce il ClientCallBack (popolamento on demand alla AJAX)
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
14
40
<asp:SiteMap />
– Basato su un file di testo in formato XML:
– <siteMap
xmlns="http://schemas.microsoft.com/..." >
<siteMapNode title="Home" url="~/Default.aspx" description=“Vai alla Home">
<siteMapNode title=“Ordini" url="~/orders/default.aspx"
description=“Pagina degli ordini"> ...
41
<asp:SiteMap />
– Basato su un file di testo in formato XML:<siteMap
xmlns="http://schemas.microsoft.com/..." >
<siteMapNode title="Home" uurl="~/Default.aspx“
description=“Vai alla Home">
<siteMapNode title=“Ordini" url="~/orders/default.aspx"
description=“Pagina degli ordini"> ...
– Il controllo accetta un SiteMapProvider (default, XmlSiteMapProvider)
42
Cross-page Post Back
• Una webform può fare il PostBack su un’altra pagina:– <asp:button PostBackUrl=“pagina2.asxp” />
• La pagina che riceve il PostBack accede allo stato dei controlli attraverso la classe PreviousPage– Page.PreviousPage.FindControl(“txt”)
– È un Control generico, va fatto il casting
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
15
43
Validation Group
• Si possono creare gruppi di convalida:– attributo ValidationGroup su
• Button, Validator
– Alla pressione del button, se è presente l’attributo vengono invocato solo i validator corrispondenti
44
Url Rewriting già incluso
• Non è necessario creare un HttpHandler se il mapping è statico:– <system.web>
<urlMappings><add url="~/default.aspx" mappedUrl="~/content.aspx?what=home" />
</urlMappings>
• Per siti dinamici, meglio HttpHandler
45
Security e pipeline per risorse non ASP.NET
• Nuovo Handler per le risorse non native– affianca StaticFileHandler, che serve solo risorse
statiche– Consente di sfruttare la pipeline di ASP.NET, ma
poi ripassa il controllo ad IIS per eseguire la richiesta:
• <add path=“.asp" verb="GET,HEAD,POST" type="System.Web.DefaultHttpHandler" validate="True" /> (nel web.config)
– Se si mappa *.* su ASP.NET sotto IIS 6, ilrisultato è quello di poter usare la Security diASP.NET da ASP!
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
16
46
Il web.config
• ASP.NET, a differenza di ASP, prevede un meccanismo di configurazione delle opzioni dell’applicazione web basato su un semplice file di testo, chiamato web.config.
• Al suo interno sono contenute le impostazioni, con codifica XML, il che lo rende immediato e potente allo stesso tempo.
• ASP.NET dunque non si affida ad IIS per la configurazione dell’applicazione ed è dunque più semplice modificare le impostazioni di base anche senza avere accesso fisicamente al server.
47
Configurare l’applicazione
• Il vantaggio di uno strumento del genere è principalmente nella sua versatilità: non è più necessario fermare un servizio, le modifiche avvengono in real-time.
• E’ inoltre facilmente possibile replicare le stesse impostazioni all’interno di una web farm (basta copiare un file).
• Infine è anche possibile stabilire gestori personalizzati per gli errori HTTP (404, 500, etc) oltre che per le estensioni, anche se con IIS5 è comunque necessario mapparle anche all’interno del server web.
48
.NET Data Access Overview
• Accesso a qualsiasi fonte dati relazionale e non– Privilegiato verso SQL Server (Managed provider)– Dalla 1.1 privilegiato SQL Server / Oracle
• Modalità connessa alla fonte dati– Accesso ai dati in streaming
• Read-only, Forward-only– Performances e scalabilità– Nessun utilizzo involontario di cursori server-side
• Da gestire esplicitamente con comandi T-SQL• Modalità disconnessa dalla fonte dati
– Funzionalità estese di caching in-memory– Aggiornamenti batch– Indipendenza dalla fonte dati– Rappresentazione interna in XML– Esportazione in XML
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
17
ADO.NET Component Model
49
.NET Application.NET Application
ODBCODBC
OLE DBOLE DB
Other DBMSOther DBMSNonNon--relationalrelational
sourcessources
OLE DB ProviderOLE DB Provider
SQL ServerSQL Server
TDS
TDS
System.Data.SqlClientSystem.Data.SqlClient System.Data.OleDbSystem.Data.OleDbOtherOther
Other DSOther DS
DataSetDataSet
System.Data.OdbcSystem.Data.Odbc
50
SqlDataReader
• Fornisce funzionalità di accesso read-only e forward-only su uno stream di record ritornati dall’esecuzione di un comando sul database
• Viene creato a partire da un oggetto SqlCommand• Il metodo Read legge la prima riga e le successive
nello stream fino al termine– Ritorna false al termine del result set
• Un solo record alla volta in memoria– Aumenta performance e scalabilità delle applicazioni
• Implementa l’interfaccia IEnumerable e quindi è possibile utilizzarlo come fonte dati nel DataBinding (in automatico solo con Web Controls)
51
Architettura Connessa vs. Disconnessa
• I Managed Provider implementano le classi necessarie alla connessione verso una fonte dati
• La classe DataAdapter funziona da bridge per alimentare la parte disconnessa
• Il DataSet è il componente che implementa le funzionalità di In-Memory database
• Le modifiche fatte ai dati disconnessi possono essere riportate sulla fonte dati utilizzando i comandi associati al DataAdapter– Solo il comando di Select è indispensabile– È possibile costruire gli altri utilizzando il CommandBuilder– Conviene costruire i propri comandi che chiamano Stored
Procedure per eseguire le modifiche
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
18
52
DataSet Object Model
DataSet
DataTableCollectionDataRelationsCollection
DataRelation DataTable
.DataColumnCollectionDataRowCollectionConstraintCollection
DataColumnDataRowConstraint
DataTable DataTable
DataColumn DataRow
.ChildRelations
.ParentRelations.Select
.Tables.Relations
.Item .Item
.Item .Item.Item
.Constraints .Rows .Columns
.ChildTable
.ChildColumns
.ParentTable
.ParentColumns
53
Architettura del DataSet
• L’oggetto DataSet rappresenta un contenitore di dati in memoria e contiene una serie di– Tabelle
– Relazioni tra le tabelle
– Vincoli di integrità dei dati
• L’utilizzo di tali oggetti è assolutamente simile nelle funzionalità ad un database relazionale
• È possibile salvare i dati contenuti in formato XML e i relativi metadati in XSD (Xml Schema Definition)
54
Popolare il DataSet
• Il DataSet non dipende dalla fonte dati utilizzata per popolarlo– È possibile utilizzare un oggetto di tipo DataAdapter per
popolare il DataSet– Il DataSet può essere popolato con informazioni
provenienti da differenti fonti dati• SQL Server, Oracle, File XML, ecc.
– Si può costruire la struttura via codice e utilizzarlo come data store senza nessun legame con una fonte dati
• Le DataTable utilizzano tipi di dati .NET, indipendenti dalla sorgente
• Non funzionano via ws/remoting:– Dalla 2.0 sono serializzabili di default
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
19
55
DataTable
• Rappresenta il contenitore delle informazioni in memoria
• Struttura descritta da una collection di DataColumn e da una di Constraint– Primary Key– UniqueConstraint– ForeignKeyConstraint
• Supporta la Cascading DRI attraverso le proprietà DeleteRule e UpdateRule (come SQL Server...)
• La proprietà AcceptRejectRule consente di propagare le modifiche fatte su una tabella “master” ad una o più “details”
56
Architettura del DataAdapter
Data
DataAdapter
Connection
Select
Command
Insert
Command
Update
Command
Delete
Command
DataSet
.Fill.Fill
.Update.Update
CommandBuilder
57
Il metodo Fill
• L’operazione di query e l’apertura della connessione verso la fonte dati viene eseguita alla chiamata del metodo Filldell’oggetto DataAdapter– Accetta come parametri il DataSet da utilizzare e
il nome di una tabella o un oggetto DataTable da riempire
– Se la tabella non esiste viene creata• La connessione al database viene creata (se
necessario), aperta e chiusa automaticamente al riempimento del DataSet
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
20
58
Architettura Connessa vs. Disconnessa
• Quando i dati arrivano al DataSet perdono ogni legame con la fonte dati
• È possibile recuperare lo schema dei dati che viene mantenuto in cache nel DataSet
• La rappresentazione interna di schema e dati è in formato XML
• È possibile alimentare il DataSet sia con dati relazionali che direttamente con documenti XML per dati e schema
59
ADO.NET & XML
• Il DataSet– Carica/salva nativamente dati in formato XML– Supporta il caricamento di schema in formato XSD– Uno Schema può essere dedotto dai dati XML
• Il DataSet può essere associato ad un XmlDataDocument– Eredita ed estende XmlDocument– Espone una vista relazionale/tabellare sui dati XML– Permette un utilizzo avanzato dei dati XML
• Fortemente tipizzato• Collegato a controlli UI
– Permette l’utilizzo degli strumenti XML su dati relazionali• Validazioni dello schema• Trasformazioni XSL/T• Query XPath
60
Data Binding
• Associazione fra un elemento visivo e un dato– In modo dichiarativo– Molto semplice– Molto veloce– Molti datasource supportati– Semplice
• Automatizzata• Più semplice agganciare codice ottimizzato per
insert/update/delete• Dichiarativa
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
21
61
Data Binding “multiplo”
• Controlli che supportano la proprietà DataSource• Possono essere agganciati a oggetti che
supportano IEnumerable, IList, ICollection– DataTable/DataView– DataReader– Custom Collections
• I controlli supportano il metodo DataBind()– Che valuta il loro DataSource e popola il controllo– Invoca anche il metodo DataBind() di tutti i controlli
Children– Come per Page
62
List-Bound Control
• DataSource = sorgente di dati
• DataMember = interna alla sorgente
• DataTextField = Valore da visualizzare
• DataValueField = Valore “chiave”
63
Repeater
• Contenitore generico
• Itera sui dati
• Eseguendo il rendering dell’ItemTemplate per ogni elemento della collezione DataSource
• Utile per avere controllo completo sul rendering dei dati
• L’unico che vi può far avere XML (o RTF, per esempioH :))
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 1
22
64
DataList
• Visualizza i dati in una lista• Utile per visualizzazioni a lista
– Il default è righe/colonne• Simile alla DataGrid ma
– Più semplice da usare– Più leggera e quindi veloce
• Richiede almeno un ItemTemplate• Ogni template ha un suo stile
– HeaderStyle– ItemStyle– EditItemStyle
• Quello che lo rende speciale:– RepeatColumns = “2”– RepeatDirection = Horizontal/Vertical
© 2006 Microsoft Corporation. All rights reserved.© 2006 Microsoft Corporation. All rights reserved.
This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN
THIS SUMMARY.THIS SUMMARY.Content created by Daniele Bochicchio.Content created by Daniele Bochicchio.
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
1
1
Agenda
• Accesso ai dati
• Costruire applicazioni 3-tier
• Provider Model
• Membership API
• Roles API
• Profile API
• Cache
2
ADO.NET 2.0
• Molte funzioni Database-indipendent
• Migliori performance
• DataTable serializzabile e più ricco
• DataSet più performante in fase di
inserimento di grosse quantità di dati
• Pieno supporto ad XML
• Supporto per cache basata su db
3
Migliorie al DataSet
• Performance e scalability maggiori
• Aggiunto un LoadOption enumerator in fase di loadin
• Istanza stand-alone di DataTable
• Batched update
• data type XML
– lavora con il tipo nativo di SQL Server 2005
• Tipi definiti dall’utente nel DataSet
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
2
4
Performance
• Indicizzazione interna delle righe– Insert e delet sono log-n
– Update Invariato
• Serializzazione Binary– nella 1.x sempre in XML• Ottimo per scambiare dati, non per le performance
– nella 2.0 XML opzionale• Veloce e compatto, specie con grandi quantità di dati
• Basta usare:– DataSet.RemotingFormat = SerializationFormat.Binary
5
Altre funzionalità
• Metodo DataSet.CreateDataReader
– ritorna un DataTableReader
– si può specificare quali tabelle includere
6
Istanze del DataTable
• Operazioni comuni per il DataSet disponibili
anche su DataTable:
– ReadXml, ReadXmlSchema, WriteXml,
WriteXmlSchema, Clear, Clone, Copy, Merge,
GetChanges
• DataTable auto-serializable:
– è possibile restituire un DataTable da Web
Service o Remoting
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
3
7
I nuovi Data Controls
• Numerose le novità rispetto ad ASP.NET
1.x
– Nuovo modello dichiarativo facile e potente
– Riduzione drastica delle righe di codice per la
presentazione dei dati, spesso zero-code
– Molte funzionalità non richiedono più codice
• Visualizzazione e selezione dei dati
• Ordinamento, paginazione e caching dei dati
• Aggiornamento, inserimento e cancellazione dei
dati
• Parametrizzazione
8
DataBound Controls
• Permettono l’associazione dei dati ai
DataBound controls, che sono:
– <asp:SqlDataSource>
• Supporto per SQL Server (SqlClient)
• Supporto anche per le stored procedures
– <asp:ObjectDataSource>
– <asp:AccessDataSource>
– <asp:SiteMapDataSource>
– <asp:XmlDataSource>
9
DataBound Controls
• Il binding dei dati ora può essere fatto
senza codice
– <asp:gridview DataSourceID=“sorgente” />
– <asp:SqlDataSource id=“sorgente”
connectionstring=“G”
SelectCommand=“SELECT * FROM Authors”
/>
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
4
10
DataBound Controls
• Supporto estensivo per il design time
• Integrati con server explorer
• Customizzabili
11
DataBound Controls
• Non c’è più bisogno di fare il bind esplicito
– Ci pensa in automatico il controllo utilizzando
la sorgente
– Supporto per selezione, inserimento,
modifica, cancellazione
• SelectCommand
• UpdateCommand
• DeleteCommand
• InsertCommand
12
DataBound Controls
• Supporto per parametri• <asp:SqlDataSource SelectCommand=“SELECT *
FROM Authors WHERE state = @state” G>
<SelectParameters>
<asp:CommandParameter Name=“@state”
ControlID=“State” PropertyName=“Text” />
</SelectParameters>
• Possibilità di utilizzare query parametriche
– Valore da controlli, QueryString, Cookie,
Form, Session, Profile
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
5
13
DataBound Controls - Svantaggi
• Il codice SQL è nalla pagina
– Ma si può usare ObjectDataSource e
continuare ad avere le proprie custom entities
• Paginazione, ordinamento e filtro usano i
DataSet
– Con grandi quantità di dati manipolare in
memoria porta lentezza
• Stesso modello dalla 1.1
– Il databing è solo richiamato in automatico
14
<asp:GridView />
• Il successore del popolare DataGrid
• Lavora benissimo in accoppiata con i nuovi data source provider
• Sorting, paginazione e filtro incluso– Niente codice!
• Supporto per i themes
• Adaptive rendering in base al device
• Supporto di default per la mancanza di dati– EmptyDataTemplate
• Template specifico
– EmptyDataText• Testo
15
<ASP:DetailsView />
• Molto simile al GridView
• Consente di visualizzare un solo data
record alla volta
• Consente di editare, inserire, modificare e
cancellare record
• Molto potente ma un po’ più semplice da
utilizzare del GridView
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
6
16
ObjectDataSource
• Permette di fare il binding di proprie
collezioni
– Preserva l’architettura
– Favorisce un corretto disegno
dell’applicazione
– Favorisce il riutilizzo e la centrallizzazione del
codice
17
ObjectDataSource
• Funziona con classi esistenti
– Serve un metodo che ritorna una collection
enumerabile
– Si perdono funzionalità automatiche (sorting,
paging) che vanno implmentate manualmente
• Bisogna scrivere codice, ma ci pagano per questoG
:)
18
ObjectDataSource
• <asp:ObjectDataSource TypeName=“Authors”
SelectMethod=“GetAuthors” />
public static class Authors
{
public static DataSet GetAuthors()
{
return ds; //qualcosa di meglio!
}
}
• UpdateMethod, InsertMethod, DeleteMethod– Pieno supporto per tutte le funzionalità
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
7
19
IIS e ASP.NET
INETINFO.exeINETINFO.exe
ISAPI ISAPI Extension Extension ManagerManager
ASP.NETASP.NETWorker ProcessWorker Process
HTTP RequestHTTP Request
.ASPX.ASPX
.ASMX.ASMX
.ASHX.ASHX
.DISCO.DISCO
.SOAP.SOAP
ASP.DLLASP.DLLASP.NET ASP.NET PipelinePipeline
INETINFO.exeINETINFO.exe
ISAPI ISAPI Extension Extension ManagerManager
ASPNET_ISAPI.DLLASPNET_ISAPI.DLL
•• ASP.NET non usa ISAPI/ASP per ASP.NET non usa ISAPI/ASP per eseguire il codiceeseguire il codice
•• ISAPI Extension ASPNET_ISAPI.DLL ISAPI Extension ASPNET_ISAPI.DLL redirige le richieste sul worker process di redirige le richieste sul worker process di ASP.NETASP.NET
20
HttpHandler e HttpModule
ASPNET_WP.EXEASPNET_WP.EXE
HttpRuntimeHttpRuntimeClassClass
Modulo 1Modulo 1 Modulo 2Modulo 2PageHandlerPageHandlerPagina1.aspxPagina1.aspx
HttpRuntimeHttpRuntimeClassClass
Modulo 1Modulo 1 Modulo 2Modulo 2PageHandlerPageHandlerPagina2.aspxPagina2.aspx
ASP.NET worker thread 1ASP.NET worker thread 1
ASP.NET worker thread 2ASP.NET worker thread 2
21
HttpHandler e HttpModule
ASPNET_WP.EXEASPNET_WP.EXE
HttpRuntimeHttpRuntimeClassClass
AuthentAuthent AuthorizAuthorizPageHandlerPageHandlerPagina1.aspxPagina1.aspx
HttpRuntimeHttpRuntimeClassClass
AuthentAuthentPageHandlerPageHandlerPagina2.aspxPagina2.aspx
ASP.NET worker thread 1ASP.NET worker thread 1
ASP.NET worker thread 2ASP.NET worker thread 2
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
8
22
HttpModules di default• Interfaccia IHttpModule
• <httpModules>
• <add name="OutputCache" type="System.Web.Caching.OutputCacheModule"/>
• <add name="Session" type="System.Web.SessionState.SessionStateModule"/>
• <add name="WindowsAuthentication" type="System.Web.Security.WindowsAuthenticationModule"/>
• <add name="FormsAuthentication"type="System.Web.Security.FormsAuthenticationModule"/>
• <add name="PassportAuthentication"type="System.Web.Security.PassportAuthenticationModule"/>
• <add name="UrlAuthorization"type="System.Web.Security.UrlAuthorizationModule"/>
• <add name="FileAuthorization"type="System.Web.Security.FileAuthorizationModule"/>
• </httpModules>
23
HttpHandler
• Gestore della risorsa
• Ogni estensione viene legata ad un
HttpHandler
• Come in Windows: ogni estensione è
legata ad un programma
• Esistono diversi HttpHandler di default
• Interfaccia IHttpHandler
<httpHandlers>
• <httpHandlers>
• <add verb="*" path="trace.axd" type="System.Web.Handlers.TraceHandler"/>
• <add verb="*" path="*.aspx"
• type="System.Web.UI.PageHandlerFactory"/>
• <add verb="*" path="*.ashx"
• type="System.Web.UI.SimpleHandlerFactory"/>
• <add verb="*" path="*.asax" type="System.Web.HttpForbiddenHandler"/>
• <add verb="*" path="*.ascx" type="System.Web.HttpForbiddenHandler"/>
• <add verb="*" path="*.config" type="System.Web.HttpForbiddenHandler"/>
• <httpHandlers>
24
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
9
25
Web.Config Authorization
• <configuration>
<system.web><authorization>
<deny users=“?” />
<allow users=“Dominio\Utente” />
<allow roles=“Dominio\Gruppo” />
<deny users=“*” />
</authorization>
<system.web>
• </configuration>
26
Metodi di Authentication
• Si impostano nel web.config
– None
–Windows (default)
– Forms
– Passport
27
Windows Authentication
• Lavora in una Intranet
• Con gli account e gruppi esistenti
• User.Identity.Name
• Test di appartenenza a gruppi
– User.IsInRole(WindowsBuiltInRole.Administra
tor)
– User.IsInRole(“ComputerName\Administrators
”)
• Domain\Group -> Domain\\Group in C#
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
10
28
Forms Authentication
• L’autenticazione Windows non può essere usata per siti pubblici– Task amministrativi enormi– Non passa dai firewall– Conoscere il Principal Windows rende il nostro sistema più attaccabile
• ASP.NET fornisce un’infrastruttura per evitare di sviluppare tutto manulmente– Utilizza i cookie– Automatizza le redirection– Completamente customizzabile
29
Web.config
• Selezionare Forms Authentication nel
web.config
– <authentication mode=“Forms” >
• Scegliere una pagina di login• <forms loginUrl=“login.aspx” />
• Opzionalmente dare un nome al cookie
– Name=“Roadshow”
– Default: .ASPAUTH
30
Provider Model Design Pattern
• Pattern basato sullo Strategy Pattern
– Implementazione concreta offerta da n classi
– Implementazione generica (le API) esterna
• Il vantaggio immediato che comporta è
quello di rendere possibile la variazione
dell'implementazione concreta senza
dover modificare l'oggetto factory
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
11
31
Provider Model Design Pattern
• Se si cambia l'implementazione concreta (il provider) non è necessario cambiare altro
• l'oggetto che incapsula la strategia fa riferimento all'implementazione vera e propria– l'applicazione utilizza un tipo astratto da cui derivano le diverse specializzazioni
• alcune funzionalità sono esposte attraverso una classe "pubblica“ (API) che però in realtà effettua le operazioni utilizzando le classi provider– quelle che nello Strategy Pattern implementano gli oggetti concreti
32
Provider Model Design Pattern
• Il vantaggio più grande di questo approccio è
quello di rendere possibile la creazione di
nuove funzionalità completamente code-less
• le API garantiscono di essere fisse e di non
cambiare
• ci sono nuovi web controls che sono in grado
di richiamare sempre queste API "pubbliche“
• la strategia offerta dall’implementazione
concreta del provider offre funzionalità
specifiche per ogni scenario
33
Provider Model Design Pattern
• Applicato in lungo ed in largo in ASP.NET 2.0
• Ma in modo specifico in
– Membership APIs
• Gestione degli utenti
– Roles APIs
• Gestione dei ruoli
– Profile APIs
• Gestione del profilo
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
12
34
Membership
• Membership– Interfaccia per gestione dati di login
• Non per i dati dell’Utente (Nome etc) (per questo c’è Profile)
– Layer per eliminare codice ripetitivo
– Indipendente dallo storage• E’ il provider che è l’implementazione concreta
• Secure Credential Storage Services– Algoritmi di Hashing per le credenziali
– Elimina codice ripetitivo
• Gestione utenti– Validazione Credenziali / “Who is online”
– Question/Answer password
– Reset / Retrieve password
35
Membership
• Se si utilizza SQL Server, lanciare il tool a riga di
comando aspnet_regsql.exe
• Crea tabelle e stored procedure per
– Membership
– Roles
– Profile
36
Membership API
• Gestione User
– Validate
– Create, Delete, Update
• Finding/Getting User
– Per Username / Email
– Utenti online
• Gestione Password
– Password reset
– Question/Answer
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
13
37
Role Manager
• Role Manager
– Mappa gli utenti sui ruoli
– Elimina il codice da scrivere
– Costruito sulla API Role di ASP.NET 1.X
• Usa i Principal
• Non legato a Membership
– Lavorano bene insieme, maG
– Role Manager può essere utilizzato da solo
– Gcosì come MembershipG
38
Roles API
• Gestione Ruoli– Create, Delete, Update
– IsUserInRole / RolesForUser
• Aggiunta/Rimozione– AddUser[s]ToRole
– AddUser[s]ToRole[s]
• Ricerca User-to-role– GetRolesForUser
– GetUsersInRole
39
<asp:LoginView />
• Varia la visualizzazione
– Anonymous
– Logged
– Appartenenza a ruoli
• Basato su Template
– <loggedintemplate />
– <anonymoustemplate />
– <rolegroups />
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
14
40
ASP.NET 2.0 Profile
• Memorizza le informazioni per ogni utente
• Astrazione rispetto allo store
• Elimina codice ripetitivo
• Utente e Dati– Informazioni sull’utente
– Personalizzazione del contenuto
• SQL Server (o altro) back-end– Si cambia back-end, la logica di accesso è sempre la stessa
– Provider Model Design Pattern: astrazione dell’accesso ad una funzionalità a prescindere dal provider utilizzato
41
Personalization Programming
Model
• Type-Safe e Strongly-Typed– Non basato su Dictionary– Nessun Cast richiesto– Proprietà esposte e “rintracciabili”
• Recupero dei dati “smart”– On-demand Data Retrieval
• Accesso allo store solo quando utilizzato
– Dati Partizionabili
• Basato su Provider Model– Altri store pluggable– Estendibile con altre funzionalità
42
<property>
• Definisce una Proprietà dell’utente
– Name obbligatorio
– Default è di tipo System.String
– Default allowAnonymous = false
• Attributiname Nome proprietà
readOnly Solo lettura
serializeAs Come si serializzano i dati
provider Provider utilizzato
defaultValue Valore di Default
type Data type CLR
allowAnonymous Proprietà valida anche per accessi anonimi
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
15
Come recupero il profilo da classe?
• Non lo direste mai ma...
• Dovete crearlo ☺
• ProfileBase.Create(username)
• Funziona anche se è già stato creato
• Lo legge!
44
Provider di default e di terze parti
• Già inclusi:
– SQL Server (Membership, Roles, Profile)• Per SQL Server 7, 2000, 2005 (anche Express)
– Active Directory (Membership)• Per Active Directory
• Access (Membership, Roles, Profile)– http://msdn.microsoft.com/vstudio/eula.aspx?id=96713a8e-b8d4-4d6e-bb8f-027e6c8e15d8
• MySQL (Membership, Roles)– http://www.codeproject.com/aspnet/MySQLMembershipProvider.asp
• SQLLite 3.0 (Membership, Roles, Profile)
– http://www.eggheadcafe.com/articles/20051119.asp
45
RicapitolandoG
• Meno codice da scrivere
– 3 righe per fare tutto, tutto!
• Indipendente dallo storage
– Basta cambiare il provider nel web.config
– Si possono usare provider diversi• SQL Server per Roles, Active Directory per Membership
• Se ho già la mia struttura dati?
– CustomProvider• http://www.aspitalia.com/articoli/asp.net2/membership_provider.aspx
– Adattamento alla struttura di uno esistente
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
16
Caching
• Il miglior modo di ottimizzare il codice è non eseguirlo :)
• Se i dati non cambiano in un arco di tempo, perchè rieseguire le query ?
• Il codice statico è molto più veloce del codice dinamico
• L’oggetto Cache introduce il concetto di rappresentazione di fonti che possono cambiare nel tempo. Infatti è possibile associare un qualsiasi oggetto in una memoria condivisa dall’applicazione (come HttpApplication), ma con la possibilità di impostare la scadenza dell’associazione in base al tempo o alla modifica della fonte. Queste sono le funzionalità supportate da Cache:– - Scadenza basata sulla dipendenza (file o data).
– - Supporto interno del blocco (Lock() e UnLock())
– - Gestione delle risorse, con gli elementi poco utilizzati che vengono rimossi
– - CallBack, con la possibilità di eseguire del codice nel caso gli elementi vengano rimossi.
46
47
Caching di Pagine e Controlli
• Implementato da
System.Web.Caching.OutputCacheModule
ASPNET_WP.EXEASPNET_WP.EXE
HttpRuntimeHttpRuntime
ClassClassOutputCacheOutputCache SessionSession
HTTP HandlerHTTP Handler
Pagina1.aspxPagina1.aspx
HttpRuntimeHttpRuntime
ClassClassOutputCacheOutputCache
HTTP HandlerHTTP Handler
Pagina2.aspxPagina2.aspx
ASP.NET worker thread 1ASP.NET worker thread 1
ASP.NET worker thread 2ASP.NET worker thread 2
CacheCache
48
Page Output Caching
• La pagina viene eseguita la prima volta
– Viene cachata :)
– E recuperata dalla cache per le richieste
successive
• Direttiva di cache per la pagina
– <%@ OutputCache Duration=“10”
VaryByParams=“none” %>
• Oppure da codice
– Response.Cache.SetExpires(DateTime.Now.
AddSeconds(10))
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
17
49
Direttiva OutputCache
• La pagina potrebbe essere diversa in base al QueryString o alla POST
• VaryByParam– Cacha n copie della pagina in base ai parametriHTTP GET / POST
– Indicare i parametri da considerare separati da “;”
– Supporta * (per tutti i parametri)
– Esempio VaryByParam=“ID;Category”
– Parametro obbligatorio• Impostarlo a ‘none’
50
Cache API
• Classe Cache
• Namespace System.Web.Caching
• Oggetto Cache– Esposto da Page.Response
• Memoria condivisa per tutta l’applicazione– Indipendente dall’utente
– Accesso tramite Nome/Valore
– Usarla per dati temporanei
– Gli item usati “poco” vengono rimossi• Supporta la notifica di rimozione tramite il Delegate CacheItemRemovedCallBack
51
Un esempio
• Cache.Add o Cache.Insert
• (Nome
Valore
Dependency
Time
TimeSpan
Priority
CallBack
• )
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
18
Deployment
• Messa in linea dell’applicazione, in
produzione
• Con ASP.NET nel 99% dei casi è Xcopy
– Copio alcuni file ed ho tutto
– Se non si usa COM, non serve accesso fisico
– Web.config è autosufficiente per la maggior
parte delle configurazioni
Deployment con code inline
• Codice e markup nella stessa pagina
• Basta copiare
– \bin\*.*
– \*.aspx
– \*.ascx
– \*.config
– \App*\
– (eventualmente) immagini e CSS
Deployment con code File
• Codice e markup in due file
– Compilazione a runtime
• Basta copiare
– \bin\*.*
– \*.aspx
– \*.vb.* o \*.cs.*
– \*.ascx
– \*.config
– \App*\
– (eventualmente) immagini e CSS
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
19
Come fare il deployment da VS
2005• Voce “Copy web site” con tasto dx su
Solution
– Copia su
• FileSystem
• FTP
• IIS locale
• IIS remoto (richiede ext FP)
Web Application Projects (WAP)
• Riporta i progetti web sotto VS 2005
– VS 2005 >= Standard
• Nuovo progetto da
– File > New Project > C# / VB > ASP.NET Web Projects
• Stesso modello di VS.NET 2003
• Opzione per migrare da Code File a Code Behind
• Download e tutorial su http://webproject.scottgu.com/
Torna il code Behind
• 3 file per ogni pagina
– Default.aspx
• Markup
– Default.cs.aspx
• Code Behind
– Default.designer.cs.aspx
• Parte autogenerata con i server controls della
pagina
• Riferimenti in sync
– Sia da code che da design view
Da ASP.NET 1.1 ad ASP.NET 2.0 Giorno 2
20
Build con Web Application Projects
• Genera un assembly in /bin/ con il risultato
del compilato dei code behind
• Sotto usa MSBuild
– Motore di build di VS 2005
Deployment con code Behind (*)
• Codice, markup e parte autogenerata in tre file– Compilazione da VS 2005 e generazione di un assembly
• Basta copiare– \bin\*.*
– \*.aspx
– \*.ascx
– \*.config
– \App*\
– (eventualmente) immagini e CSS
(*) Va installato Web Application Projects
© 2006 Microsoft Corporation. All rights reserved.© 2006 Microsoft Corporation. All rights reserved.
This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN This presentation is for informational purposes only. MICROSOFT MAKES NO WARRANTIES, EXPRESS OR IMPLIED, IN
THIS SUMMARY.THIS SUMMARY.Content created by Daniele Bochicchio.Content created by Daniele Bochicchio.