Da ASP ad ASP.NET 2download.microsoft.com › download › d › a › b ›...

Da ASP ad ASP.NET 2.0

1


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


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


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


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.


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).


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();


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)


8

Statement condizionali

if (espressione){

// ...}else{

// ....}

if (espressione){

// ...}else{

// ....}

switch (espressione){

case valore1:// ...break;


case valore3:case valore4:

// ...break;

default:// ...break;

}

switch (espressione){



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


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


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();


// ...}

MyClass c = new MyClass();

(*) The C++ Programming Language, Third Edition. Bjarne Stroustrup


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


// ...}

File part2.cs


// ...}

File part2.cs


// ...}

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;

}


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;}


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.


public void MyMethod (int a){

// ...}

public void MyMethod (int a){

// ...}

Value Type


13


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


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.


private string _name;

public string Name{

get { return _name; }set { _name = value; }

}}

MyClass c = new MyClass();c.Name = "Ricky";


private string _name;

public string Name{

get { return _name; }set { _name = value; }

}}

MyClass c = new MyClass();c.Name = "Ricky";


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"


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 static int One;public int Two;

}

MyClass c1 = new MyClass();MyClass c2 = new MyClass();

MyClass.One = 3;c1.Two = 5;c2.Two = 7;


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).


15

Dati statici e di istanza 2/2

• Cosa accade in memoria?

Codice macchinaCodice macchina

Dati statici

indipendenti dal

numero di istanze

1


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 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 int One;

public void MyMethod (int val){

this.One = val;}

}


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;

}}




_name = name;_age = age;

}}




_name = “Ricky”;_age = 34;

}}




_name = “Ricky”;_age = 34;

}}


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() { ... }

}


// costruttore ad accessibilità privataprivate Person() { ... }// metodo per la creazione dell’istanzapublic Person FactoryMethod() { ... }

}


// costruttore staticostatic 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(){

// ...}

}


~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;}


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 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 MyNestedClass{

public int One;}

}

// ...

// occorre specificare il nome della classe containerMyClass.MyNestedClass nested = new MyClass.MyNestedClass();

nested.One = 1;


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 static ComplexNumber operator + (ComplexNumber a, ComplexNumber b){

return new ComplexNumber (a.Real + b.Real, a.Complex + b.Complex);}

}

public struct ComplexNumber{




}

public static ComplexNumber operator + (ComplexNumber a, ComplexNumber b){

return new ComplexNumber (a.Real + b.Real, a.Complex + b.Complex);}

}


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{


// ...}

}}

MyProject.MyNamespace.MyClass c =new MyProject.MyNamespace.MyClass();

namespace MyNamespace{


// ...}

}

MyNamespace.MyClass c =new MyNamespace.MyClass();


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.


protected string Name;}

public class Customer : Person{

public void ChangeName (string name){

base.Name = name;}

}


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 void Accorda();}

public class Violino : Strumento{


// ...}

}

// ...


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 void Accorda();

public virtual void PausaTempo(){

// ...}

}


public abstract void Accorda();

public virtual void PausaTempo(){

// ...}

}

public Piano : Strumento{


// ...}

public override void PausaTempo(){

// ...}

}

public Piano : Strumento{


// ...}

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(){

// ...}

}


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");


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();

}


try{


}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.


try{


}catch(SqlException){

// rilancia l'eccezione// al chiamantethrow;

}


try{


}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.


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


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 event MyDelegate MyEvent;

public void FireAway() {

if(MyEvent != null)MyEvent();

}}


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


c.MyEvent -= new MyDelegate (f);c.MyEvent -= new MyDelegate (f);

Publisher di

un evento

Publisher di

un evento



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.


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 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);


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;

}



}



}



}



}



}

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



}



}



}



}



}



}

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.


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


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;


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.


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).


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#” %>


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>


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


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>


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


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


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


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


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


Modulo XModulo X SessionSessionHTTP HandlerHTTP HandlerPagina2.aspxPagina2.aspx

ASP.NET worker thread 1ASP.NET worker thread 1


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


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


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


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 :)


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 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()

%>


44


• 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


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


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)


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


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



12

Nuovo ASP.NET 2.0 “Building Block” APIs

MembershipMembership Role ManagerRole Manager PersonalizationPersonalization



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


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


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


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


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


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)


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


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>


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


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)


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


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!


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


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


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


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


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


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 :))


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





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


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


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”

/>


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


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


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à


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



Modulo 1Modulo 1 Modulo 2Modulo 2PageHandlerPageHandlerPagina1.aspxPagina1.aspx


Modulo 1Modulo 1 Modulo 2Modulo 2PageHandlerPageHandlerPagina2.aspxPagina2.aspx



21

HttpHandler e HttpModule



AuthentAuthent AuthorizAuthorizPageHandlerPageHandlerPagina1.aspxPagina1.aspx


AuthentAuthentPageHandlerPageHandlerPagina2.aspxPagina2.aspx




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


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#


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


• 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


11

31


• 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


• 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


• 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


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


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 />


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


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


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


HttpRuntimeHttpRuntime

ClassClassOutputCacheOutputCache SessionSession

HTTP HandlerHTTP Handler

Pagina1.aspxPagina1.aspx

HttpRuntimeHttpRuntime

ClassClassOutputCacheOutputCache

HTTP HandlerHTTP Handler

Pagina2.aspxPagina2.aspx



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))


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

• )


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*\



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


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*\


(*) Va installato Web Application Projects




Da ASP ad ASP.NET 2download.microsoft.com › download › d › a › b ›...

Documents

Transcript of Da ASP ad ASP.NET 2download.microsoft.com › download › d › a › b ›...