Asp net (versione 1 e 2)

Microsoft ASP.NET

ACTIVE SERVER PAGE .NET

Ing. Felice Pescatore
felice.pescatore@poste.it

ADO.NET: Compendi Consigliati

Autori:
• msdn2.microsoft.com/it-it/library/default.aspx •Francesco Balena
• www.ugidotnet.org •Dino Esposito
• www.aspitalia.com •Marco Bellinaso
• www.dotnet2themax.it •David Sheppa

ASP.NET: introduzione
ASP.NET è una tecnologia lato server per lo sviluppo di WebApplication
basate sul Framework .NET di cui è parte integrante.

ASP.NET

ASP

HTML

Active Server Page.Net

Introduzione

ASP.NET: Richiami, i Protocolli
TCP/IP
• Protocollo utilizzato per tutte le comunicazioni su Internet;
• Protocollo a due livelli: TCP e IP

Hypertext Transfer Protocol (HTTP)
• Protocollo per lo scambio di file
• Utilizzato dai browser per accedere alle risorse
• Si basa su TCP/IP
• E’ Stateless
Client Server
IIS/Apache
Richiesta
HTTP default.htm

Risposta
HTTP

ASP.NET: richiami, HTTP
 Ogni richiesta è a se stante
 Non esistono informazioni di stato in HTTP
 Per ogni richiesta dobbiamo preoccuparci di inviare il contenuto
 Ad esempio riempire i campi di un form con le informazioni digitate
dall’utente
 Es. ripresentare le informazioni digitate
<INPUT
TYPE=“TEXT”
NAME=“txtNome”
VALUE=<%=Request.QueryString(“txtNome”)%>
>

ASP.NET: richiami, Linguaggi di markup
Hypertext Markup Language (HTML)
• Creazione di pagine Web
• Si basa su tag che il browser interpreta per visualizzare il contenuto

Dynamic HTML
• Client-side
•Consente di manipolare la pagina sul client

Extensible Markup Language (XML)
• Definizione entità generiche
•Utilizzato per lo scambio di dati
<p>Ciao Ciao</p>
<br>
<font color=red>Testo</font>

Tag HTML:
•Contenuti in un file di testo
•Memorizzati su un Server
•Richiesti via Http dal browser
•Interpretati sul client

ASP.NET: richiami, Classi ASP

Client Server

http://www.dcc.com/equipment/catalog_type.asp?
IIS
ProductType=rock+shoes

Richiesta HTTP
ASP
engine
Risposta HTTP Esecuzione JScript
VB Script

ADO
default.asp
Recupero risultati

ASP.NET: richiami, Classi ASP
• Invio dati al server:

<FORM action=“NomePagina” method=“XXX”>
<INPUT TYPE=“Text” NAME=“txtNome”>
<INPUT TYPE=“Text” NAME=“txtCognome”>
<INPUT TYPE=“Submit”>
</FORM>
• Le informazioni vengono inviate a “NomePagina” sotto forma di stringhe
• GET
• txtNome=xxxx&txtCognome=yyyy
• POST
• Come header HTTP

• Response Object, Consente di gestire la risposta Http

<% Response.Write(“Ciao”)%>

• Request Object, Consente di gestire la richiesta Http

<% nome=Request.QueryString(“txtNome”)
cognome =Request.QueryString(“txtCognome”)
Response.Write(“Ciao” & nome & cognome)%>

ASP.NET: richiami, Classi ASP - Vantaggi
 Modello di programmazione semplice
 Utilizzo di normali editor HTML
 Possibilità di modificare i sorgenti in ogni momento
 Produzione di qualunque contenuto in risposta
 Nessuna forzatura per lo sviluppatore
 Utilizzo di nuove tecnologie HTML 4 / CSS
 Apertura verso altre tecnologie XML / XSLT

ASP.NET: richiami, Classi ASP - Vantaggi
 Solo codice script: Povertà di linguaggi, Utilizzo limitato di
librerie, Lentezza in esecuzione (relativa)
 Sorgenti non protetti dall’infrastruttura
 Overlap fra codice e HTML
 Debug e gestione errori
 Non abbiamo oggetti, solo stringhe
 Scrivere codice per qualsiasi cosa: Mantenere lo stato dei
campi, Validazione client e server differenti, Output differente IE / NS
/ Device
 Nessuna interazione con il SO
 IIS/W2K per settaggi applicativi

ASP.NET: l’evoluzione
• Basato sul Framework.Net e Linguaggio potente (VB, C#)
• Compilazione:
• Automatica
• E modifiche del codice sempre ammesse
• Web Form e Controlli
• Proprietà, Metodi, Eventi
• Le pagine sono classi
• Debug e gestione errori completa
• Web.config per settaggi applicativi
• Web Service integrati
• Separazione fra codice e HTML (Code Behind)


Architettura

ASP.NET: dotNet Framework

Managed Application

Unmanaged
Base Class Library
Application

Common Language Runtime

OPERATING SYSTEM

Common Language Runtime: interoperabilità, sicurezza, garbage collection,
versioning, ….
Base Class Library: GUI, collection, threads, networking, reflection, XML, …

ASP.NET: dotNet Framework

Managed Application Web Application

Unmanaged Web Form – Web Services
Base Class Library
Application ASP.NET

Web Server (IIS)

OPERATING SYSTEM

ASP.NET
Web Form: Web GUI (object – oriented, event – based, browser indipendent
Web Services: serivizi distribuiti su RPC (SOAP, HTTP)

ASP.NET: Web Application
ASP.NET definisce una Web Application come:

“la somma di tutti i file, pagine, handler, moduli e eseguibili che
possono essere invocati o eseguiti nell’ambito di una directory
virtuale su di un web applicationserver”

presentation middle tier data tier

Internet Web Services Db
Web Form
(sample.aspx)

Applicazioni Distribuite

ASP.NET: tutto comincia con una richiesta...
La richiesta per simple.aspx arriva al Web Server:
• IIS accetta ed autentica la richiesta;
• IIS individua il modulo ISAPI che gestisce la risorsa;
• Il modulo riceve l’incartamento relativo alla richiesta, ovvero i
dettagli;

Richieste per le risorse ASP.NET passano al modulo ISAPI
aspnet_isapi.dll
• Sul modulo sono mappate varie estensioni tipiche di applicazioni
ASP.NET: aspx, asmx, ashx, axd
• Altre estensioni (asax, ascx, config) sono bloccate.

ASP.NET: la nostra prima applicazione ASP.NET
Cominciamo subito a creare la nostra prima applicazione.

Useremo ovviamente Visual Studio in versione (2005 o 2008).
Tenete presente che in teoria è possibile realizzare un’applicazione
ASP.NET anche con il classico notepad.

Il primo passo è quello di creare una nuovo Web Site, scegliendo la
relativa opzione da Visual Studio, scegliere il linguaggio preferito (che può
differire di pagina in pagina) ed impostare il tipo di hosting:
• File System
• Http
• Ftp

Creato la Web Application la ritroveremo nel Solution Explorer con una
struttura similare alle seguente:

già da questo semplice progetto vediamo alcuni elementi caratterizzanti:
• Special Folder (in questo caso APP_DATA) sono cartelle speciali
gestite la fremwork;
• Web.config è il file di configurazione principale dell’applicazione
• WebForm and Code-behind page, ovvero le pagine di design e le
pagine con il codice

ASP.NET: Configurazione (1)
L’intero funzionamento di una Web Application Asp.net è configurabile attraverso
uno o più file web.config:
• scritto in XML, editabile con qualsiasi editor di testo;
• il file è mantenuto nello stesso direttorio dell’applicazione;
• i cambiamenti sono individuati automaticamente senza bisogno di riavvio.

La configurazione avviene attraverso una struttura gerarchica: è praticamente
possibile specificare una particolare configurazione per gli elementi contenuti in
ogni directory.
<configuration>
<configsections>
<add names=“httpmodules“type=“System.Web.Config.HttpModulesConfigHandler“/>
<add names=“sessionstate“ type=“...“/>
</configsections>
<httpmodules>

</httpmodules>
<sessionstate>

</sessionstate>
</configuration> esempio di web.config

ASP.NET: Configurazione (2)
Ogni web application eredita la configurazione di base contenuta nel file
machine.confing contenuta nel path di installazione del framework stesso
(%windir%Microsoft.NETFrameworkVersion).

machine.config

Root
(web.config)

Sub Dir
(web.config)

Il file machine.config contiene:
• un insieme standard di handler di sezioni di configurazione(configuration
section);
• gestione del browser capabilities, messaggi di errore, ecc.

Se proviamo ad aprire la pagina Default2.aspx (in source mode) vedremo
qualcosa di simile:
<%@ Page Language="VB" AutoEventWireup="false" CodeFile="Default2.aspx.vb" Inherits="Default2"
%>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title>Untitled Page</title>
</head>
<body>
<form id="form1" runat="server">
<div>

</div>
</form>
</body>
</html>
Dov’è finito il codice

Il Codice in una Web Application ASP.NET può essere: .cs

1. code inline: i frammenti di codice del linguaggio di .aspx
programmazione scelto sono “iniettati” nel template HTML
della pagina unitamente ai nuovi tag (stile Classic ASP, PHP);

1. code behind: codice e template HTML, arricchito con nuovi tag, risiedono
in file distinti.

Ovviamente è preferibile utilizzare il modello code behind che permette una netta
separzione tra layout e codice applicativo consentendo anche la separazione
dei compiti nel team di sviluppo (designer e sviluppatori). Nonostante ciò con
la versione 2 di ASP.NET, Microsoft ha introdotto la possibilità di utilizzare il
code inline che risulta utili in contesti in cui è necessario realizzare
velocemente pagini poco complesse.
Le classi di code behind hanno lo stesso nome della pagina con aggiunta
dell’estensione relativa al linguaggio (es: default.aspx.cs, default.aspx.vb) .

ASP.NET: Layout delle directory di una web application

Code Inline Code Behind

(DLL…)

(File .cs, .vb, ecc)

ASP.NET: esempio di pagina con code inline
<html>
<head>
<title>ASP.NET Page -CodeInline</title>
</head>
<form runat="server">
<body>
<ASP:Label id="Etichetta"runat="server" />
<ASP:TextBox id="CasellaTesto"runat="server"Columns="30" />
<br><br>
<ASP:Button id="InviaTesto"runat="server"OnClick="VisualizzaTesto" />
<br><br>
<ASP:Label id="Testo"runat="server" />
</body>
</form>
<html>

<SCRIPT LANGUAGE="C#" RUNAT="server">
void VisualizzaTesto(object sender,EventArgse) {
Testo.Text=CasellaTesto.Text.Trim().Length==0 ?"Non hai inserito alcun carattere." :"I
caratteri che hai inserito sono: "+CasellaTesto.Text;}

voidPage_Load(object source,EventArgse) {
Etichetta.Text="Inserisci dei caratteri:";
InviaTesto.Text="Invia >>";
}
</SCRIPT>

ASP.NET: esempio di pagina con code behind (1)
<%@ PageInherits="Esempio.aspx.cs" Src=“esempio" %>

<html>
<head>
<title>ASP.NET Page -Code Behind</title>
</head>
<form runat="server">
<body>
<ASP:Label id="Etichetta"runat="server" />
<ASP:TextBox id="CasellaTesto"runat="server"Columns="30" />
<br><br>
<ASP:Button id="InviaTesto"runat="server"OnClick="VisualizzaTesto" />
<br><br>
<ASP:Label id="Testo"runat="server" />
</body>
</form>
<html> ASPX page

La parte di layout è identica alla precedente.

ASP.NET: esempio di pagina con code behind (2)
usingSystem;
usingSystem.Web.UI;
usingSystem.Web.UI.WebControls;

public class Esempio : Page {
protected LabelEtichetta, Testo;
protected TextBox CasellaTesto;
protected Button InviaTesto;

protected void VisualizzaTesto(object sender,EventArgse) {
Testo.Text=CasellaTesto.Text.Trim().Length==0 ? "Non hai inserito alcun carattere." :
"I caratteri che hai inserito sono: "+CasellaTesto.Text;
}

protected voidPage_Load(object source,EventArgse) {
Etichetta.Text="Inserisci dei caratteri:";
InviaTesto.Text="Invia >>"; ASPX.CS page
}
}

ASP.NET: ereditarietà
Il Code Behind non è un’appendice della pagina ma la classe da cui
viene ereditata la pagina
public Event EventHandler Load
System.Web.UI.Page public bool IsPostBack {get;}
.dll
public HttpRequest {get;}
public HttpResponse {get;}

Public txtName as S.W.U.TextBox
.VB Public Class Codice Sub Page_Load(x,y)
Inherits S.W.U.Page Response.Write “x”
End Sub
La classe contiene le interfacce
della classe base + txtName

.aspx <asp:TextBox Id=“txtName” />
@Page Inherits=“Codice” La pagina eredita la Classe Codice
Quindi le nuove proprietà, eventi
e metodi rispetto a Page

ASP.NET: sintassi (1)
Direttive:
<%@Page language=“VB“%>

Blocchi di codice dichiarativo:
<script runat=“server“ [language = ...]>
[ lines of code ]
</script>

Blocchi di codice:
<%
[ inline code or expression ]
%>

ControlliHTML:
<HTMLtagrunat=“server“ [attribute = ...]>
</HTMLtag>

ASP.NET: sintassi controlli server (web control) (2)
Controlli dati server:
<ASP:TextBoxid=“MyTb1“ runat=“server“>

Proprietà lato server:
<ASP:TextBoxmaxlength=“80“ runat=“server“>

Subpropery:
<ASP:Label font-size=“14“ runat=“server“>

Controllo gestione lato server eventi:
<ASP:Button OnClick=“MyClick“ runat=“server“>

Identificatori di oggetti server-side
<object id=“id“ runat=“server“ identifier=“idName“>

Include server-side


Commentiserver-side
<%--comment block--%>

ASP.NET: elementi di una pagina
Ogni pagina ASP.NET ha tipicamente le seguenti sezioni:

• Page directives (@Page, @Register, @Assembly, @Import…):
impostazione dell’ambiente, registrazione controlli, caricamento assembly
non ancora nella GAC, registrazione namespace, indicazione del linguaggio
utilizzato;

• Code section: gestori dei controlli server side della pagina; può essere
inline o separato

• Script lato client, ad esempio javascritp;

• Page layout: lo scheletro della pagina
• Controlli (runat=server)
• Controlli HTML, stessa API dei tag HTML;
• Controlli Web, stessa funzionalità, API astratta;
• Literals (puro testo);
• Espressioni (<%..%>, data binding).

ASP.NET: elementi di una pagina (2)
Vediamo un esempio di uso delle direttive

<%@Page Language=“VB” Explicit=“True” %>
Codice VB (uno solo per pagina)
Dichiarazione variabili obbligatoria
<%@Assembly name=“GestioneCorsi” %> (abilitare sempre)
<%@Import namespace=“Corsi” %>
Referenzia l’Assembly
GestioneCorsi.dll
---codice---
Queste direttive corrispondono a
Vbc.exe /optionexplicit+
/r:GestioneCorsi.dll ElencoCorsi_aspx

ASP.NET: tanti tipi di file ma… tutto testo
ASP.NET prevede una serie di estensioni per identificare file con
funzionalità diverse:
• .aspx: file asp.net standar;
• .ascx: file di controlli custom;
• .asmx: web services;
• .cs, vb: file di codice code-behind;
• machine.config: file di configurazione del framework:
• web.config: file di configurazione;
• global.aspx:

Tutti questi file sono semplici file di testo, editabili con il notepad!

ASP.NET: vediamo un esempio più concreto (1)
<html>
<script language=“VB“ runat=server>
Sub SubmitBtn_Click(SenderAs Object, E As EventArgs)
Message.Text = “Hi “ & Name.TextEnd Sub
</script>

<body>
<form action=“thisfile.aspx“ method=post runat=server>
<h3> Name:
<asp:textbox id=“Name“ runat=server/>
<asp:button type=submit text=“LookUp“OnClick=“SubmitBtn_Click“
runat=server/>
<p>
<asp:label id=“Message“ runat=server/>
</p>
</form>
</body>
</html>

in questo caso, vista la semplicità, usiamo codice inline

ASP.NET: vediamo un esempio più concreto (2)

ASP.NET: il modello di esecuzione
Client Server

IIS
ASP.NET RUNTIME

Parse .aspx file

Generate page class

Instantiate controls

Response

ASP.NET: processo di compilazione (1)

ASPX Generazione Code-
Parsing (2) (3) behind
Engine file

Request (1) ASPX Class
File Creazione File
Istanza (2b) su
Request (1b)
Disco

Response (5) Page
Response (3b) Class Istanza, Ese
cuzione e
Rendering
(4)

ASP.NET: processo di compilazione (2)
• Supporto per la compilazione del sorgente just-in-time e tutti gli
elementi relativi vengono compilati in un assembly (single o multiple
file)
• Auto compilazione per .aspx .ascx .asmx .ashx
• L’assembly generato viene memorizzato in una directory dietro le
quinte
• Reference automatica agli assembly comuni
• Gli altri assembly sono referenziabili con direttive nella pagina
• Shadow-copying per DLL (sovrascrivibili)
ASSEMBLY 1

come di consueto per la
MyApp.dll
piattaforma dotNet (e non Pic1.jpg
solo) ogni assembly ASSEMBLY 2

contiene un file manifest

Shared name
metadata MyApp.dll
che descrive: lista dei file
dell’assembly, informazioni metadata

sui tipi, nomi, …

ASP.NET: gestione della richiesta dal Server (1)
HTTP Request ASP.NET non usa ISAPI/ASP
.ASPX ISAPI extension redirige le richieste sul worker
.ASMX process
.ASHX
.DISCO
.SOAP

ISAPI
ASP.NET
Extension ASP.DLL
ASPNET_ISAPI.DLL
Pipeline
Manager Named
Pipe

INETINFO.exe
INETINFO.exe ASPNET_WP.EXE
Worker Process


Application Application Web Garden
Pool 1 Pool 2

WWW
INETINFO Service W3WP.exe W3WP.exe W3WP.exe
ASP.NET ISAPI ISAPI ASP.NET ISAPI
Process Mgr
Config Mgr

CLR Application Extensions CLR Application
Domain (ASP, etc.) Domain

metabase CLR Application CLR Application
Domain ISAPI Filters Domain

HTTP.sys

Architettura interna di IIS 6

 Le richieste sono processate nella pipeline all’interno del Worker Thread
 La pipeline contiene classi HttpRuntime
 I Moduli sono “interceptor” opzionali
 HttpContext è la classe accessibile nella pipeline

ASP.NET worker thread 1

HttpRuntime HTTP Handler
Modulo 1 Modulo 2
Class Pagina1.aspx

ASP.NET worker thread 2

HttpRuntime HTTP Handler
Modulo 1 Modulo 2
Class Pagina2.aspx

ASPNET_WP.EXE

Proprietà della classe HTTPContex
Tipo Nome Identificatore Descrizione
HttpContext Current Contesto corrente

HttpRequest Request Richiesta Http

HttpResponse Response Risposta Http

HttpServerUtility Server URL Cracking

HttpSessionState Session Sessione per client

HttpApplicationState Application Property Bag applicativa

HttpApplication ApplicationInstance Contesto Applicativo

IHttpHandler Handler Handler della chiamata

IDictionary Items Property Bag per richiesta

Exception Error Primo errore incontrato

IPrincipal User Security ID del chiamante

ASP.NET: ciclo di vita di una pagina (intro)
Una pagina aspx ha un proprio ciclo di vita (stati in cui si trova la pagina
durante l’esecuzione) a cui corrispondono una serie di eventi gestibili per
personalizzarne il funzionamento:

• PreInit (si verifica prima dell’inizialiazzazione): serve per
• usare la proprietà IsPostBack
• creare controlli dinamici
• applicare temi e pagine master dinamicamente
• leggere e scrivere profili utente
• Init (la pagina è inizializzata): leggere e inizializzare le proprietà dei
controlli
• Load: leggere e aggiornare le proprietà dei controlli
• PreRender: apportare modifiche ai contenuti della pagina
• UnLoad (la pagina è scaricata dalla memoria): operazioni di
chiusura finale

ASP.NET: eventi, server round trip (1)
event
Web Client message Server

Parse Message
Event
chiama un
appropriato
event handler

Event Handler

response

Control Events Page_Load
1. Change Events Textbox1_Changed
Gli eventi si verificano
sul browser (lato client) 2. Action Events Button1_Click
ma vengono
Page_Unload
gestiti lato server
con l’invio di messaggi

ASP.NET: gli eventi, server round trip (2)
Con i controlli messi a disposizione da ASP.NET si possono costruire
interfacce web che si comportano in modo simile alle interfacce utente
delle comuni applicazioni stand-alone.

Ogni interazione con il browser (e.g., pressione di un pulsante, selezione di
una voce da un menu a tendina) corrisponde ad un evento gestibile sul
server .server

L’interazione avviene tramite un round-trip, i.e., una richiesta POST inviata
al server. Quest’ultimo, dopo aver elaborato

ASP.NET: Debugging: lato Server e lato Client, Tracing
Il Debugging la Server viene abilitato nel file <system.web>
di configurazione web.confg inserendo la …
seguente istruzione: <compilation debug=“true” />
…

Il Debugging lato client è più complicato da impostare:
• Abilitare il browser

•Quindi o si fa partire il debugger da IE e poi si mette il breakpoint sul javascript;
• o da Visual Studio ci si “attacca” al processo IE (funzionalità non supportata nella
versione “Express”);

Un metodo molto efficace, infine, è l’utilizzo dell’istruzione “debugger;” nel codice Javascrip.
Attenzione però a non lasciarla in produzione!

Il Tracing si può abilitare a livello di Applicazion (web.config) e di Pagina.
Attraverso la proprietà pageOutput si abilita l’output sulla pagina o richiamando trace.axd

<trace enabled="true" pageOutput="false" />
<%@ Page Language="C#" ... Trace="true"%>


HTML & WEB Controls

ASP.NET: Controlli lato Server
I controlli lato server sono molteplici e normalmente vengono
raggruppati logicamente in “famiglie”.
I controlli sono contenuti nel namespace: System.Web.UI.Control e
di due tipi:

HTML Control (namespace System.web.ui.control.HTMLControl)
• Si mappanodirettamente in elementiHTML
• Attributi HTML
• Esempi: HtmlAnchor(<a>), HtmlTable(<table>)

Web Controls (namespace System.web.ui.control.WebControl)
• Controlli astratti: non c’è mapping uno a uno con i controlli
HTML server
• Modello oggetti tipizzati
• Identificazione automatica del browser
• Esempio: TextBox(<asp:textbox>)

ASP.NET: controlli lato Server, HtmlControl

ASP.NET: controlli lato Server, WebControl

ASP.NET: HTML Control vs. Web Control
<input type=“text” value=“default” runat=“server” id=“txtName” >
• Mappano i tag HTML 1:1
• Lavorano bene con gli Editor attuali
• Ma il modello ad oggetti non è strongly-typed

•Ad esempio
•txtName.Value = “Roberto”
•txtName.SetAttribute("bgcolor", "red")

<asp:TextBox runat=“server” id=“txtName” Text=“default”></asp:TextBox>
• Modello ad oggetti consistente e strongly-typed
• txtName.Text = “Roberto”
• txtName.BackColor = Color.Red
• Miglior supporto per VS.NET Designer
• Rendering differente per browser
• Esempio: Label
• Funzionalità differenti per browser
• Esempio: Validation Control

ASP.NET: lo stato dei controlli server
In precedenza facendo un richiamo sui protocolli abbiamo sottolineato come il protocollo
HTTP sia stateless ovvero senza stato.
Come fa all’ora un’applicazione asp.net a mantenere traccia dello stato dei suoi controlli
server?

Ebbene il sistema si chiama VIEWSTATE, per ricostruire in modo trasparente il contesto
della richiesta, .NET mette a disposizione l’oggetto System.Web.UI.StateBag, che permette
di codificare in un campo nascosto (__VIEWSTATE) lo stato corrente della pagina. Esempio:

<html>
<head>
<title>ASP.NET Page -Code Behind</title>
</head>
<form name="_ctl0"method="post" action="esempio2.aspx"id="_ctl0">
<input type="hidden"name="__VIEWSTATE“
value="dDw0NTEzMTYzODY7dDw7bDxpPDE+Oz47bDx0PDtsPGk8MT47aTw1PjtpPDc+Oz47b
Dx0PHA8cDxsPFRleHQ7PjtsPEluc2VyaXNjaSBkZWkgY2FyYXR0ZXJpOjs+Pjs+Ozs+O3Q8cD
xwPGw8VGV4dDs+O2w8SW52aWEgXD5cPjs+Pjs+Ozs+O3Q8cDxwPGw8VGV4dDs+O2w8SS
BjYXJhdHRlcmkgY2hlIGhhaSBpbnNlcml0byBzb25vOiBzZHNkOz4+Oz47Oz47Pj47Pj47PvzsJ
FVQPE7eYg9Hq1xLtjUAVgxW" />

Il ViewState è utilizzabile anche programmaticamente
ViewState.Add(“NomeUtente”, “Mauro”) e disattivato a livello di pagina <%@ Page ...
EnableViewState="false"%>.
In tal caso, però, ad ogni iterazione i controlli perderanno il proprio stato

ASP.NET: Postback
Il Postback è un evento che scatta la seconda volta che si arriva su una
pagina.

Il Postback si verifica in seguito ad una POST HTTP:
• Submit di un bottone
• Controlli server-side possono avere la proprietà AutoPostBack
abilitata, utile per popolare altri controlli o disabilitarli

L’uso più comune di questo evento è l’ottimizzare del codice eseguito
nella pagina. Ad esempio: accedo una sola volta alle risorse costose
(database).
protected void Page_Load(..)
{
if (Page.IsPostBack == false)
• Creazione di un sito web {
• Posizionamento dei controlli // E’ il primo accesso alla pagina
• View State // Accesso al database
• Code-behind }
• Post-back }

ASP.NET: i Validatori
I Validatori sono controlli per la validazione dei controlli lato server in
grado automaticamente di rilevare se il browser supporta la validazione
lato client.

Tra di essi si annoverano:
• RequiredFieldValidator
• CustomValidator (richiamo funzione JavaScript)
• ValidatorSummary (message box)
• RangeValidator
• RegularExpressionValidator
• CompareValidator

Demo

ASP.NET: Data Control
Grazie ai DataControl (ed il sottosistema Ado.Net 2) è possibile lavorare
in modo versatile con dati provenienti da qualsiasi fonte dati e scrivendo
una quantità di codice minimale.

• GridView
• DataList
• DetailsView
• ListView
• Repeater

Demo

ASP.NET: Navigation
I Navigation Control permettono di realizzare velocemente varie
tipologie di menù per navigare nelle varie pagine del sito ed evidenziare
la posizione di navigatore attuale.
Per utilizzarli è necessario creare il file sitemap.xml che si collega
automaticamente ad essi.

• SiteMapPath
• Menu
• TreeView

Demo

ASP.NET: le Web Part
Attraverso le Web Part è possibile creare pagine web contenenti aree modificabili
dall’utente, come ad esempio accade per la pagina personalizzata di Google o di
Live:

Controlli fondamentali sono:
• WebPartManager, deve essere presente in ogni pagina che utilizza le Web Part;
• WebPartZone, identifica l’area in cui è possibile spostare un Controllo (anche User Control)
• CatalogZone, indispensabile per il ripristino delle WebPart chiuse o l’apertura di nuove

Demo

ASP.NET: Controlli per la gestione degli Utenti (1)
Con la versione 2 di ASP.NET fanno la loro comparsa una nutrita serie di componenti server
dedicati alla gestione degli Utenti.

Prima di vederli all’opera attraverso una demo è necessario affrontare l’argomento
Memebership e Role Management.

ASP.NET prevede due possibilità di autenticazione:
•Da Internet
•Da una rete LAN (Local Area Network)

Nel prosieguo ci riferiremo sempre all’autenticazione da Interent in
quanto quella da rete Lan si basa sulle funzinalità di autenticazione
proprie di Windows.
La nuova release di ASP.NET ha introdotto inoltre:

•Servizio delle appartenenze per la gestione degli utenti e delle
credenziali utente;
•Servizio di gestione dei ruoli per l'applicazione della protezione
basata sui ruoli.

Demo

ASP.NET: Controlli per la gestione degli Utenti (2), Strumento di
Amministrazione Sito Web
Per la configurazione di tutti gli aspetti relativi alla sicurezza della nostra applicazione
Web, Visual Studio introduce lo Strumento Amministrazione sito Web.
Si tratta di una pratica Web Application Visual Studio che permette di gestire in modo
guidato gran parte delle impostazioni di sicureazza della nostra applicazione.

Se non specificato diversamente tutti i dati relativi agli utenti, ai ruoli ai profili e alle altre
impostazioni vengono salvate in un
SQLServer DB dal nome: ASPNETDB
contenuto nella solita directory
App_Data.

Per ogni nuova impostazione
di sicurezza relativa ad una sottoarea
viene creato un apposito file web.confing.

E’ utile notare come sia il DB che i file di
Configurazione non sono direttamente
visibili nel Solution Explorer di VS.

Demo

ASP.NET: Profili
ASP.NET offre la gestione automatizzata dei Profili Utenti, sia per gli Utenti registrati sia
per quelli anonimi (che poi è possibile salvare nel caso in cui l’utente si registri).

I Profili permettono di salvare in modo automatizzato le impostazioni dell’utente, in modo da
fornire aspetti personalizzati della Web Application.
Per abilitare un profilo è necessario aggiungere un codice simile al seguente al file
web.config della root.
<profile>
<properties>
<add name="FirstName" allowAnonymous="true" />
<add name="LastName" allowAnonymous="true" />
<add name="FirstVisit" type="System.DateTime" allowAnonymous="true" />
</properties>
</profile>

Sarà poi possibile accedere al valore (lettura/modifica) dalla web form attraverso
la sintassi: Profile.Oggetto

Demo


Master Page & Temi

ASP.NET: Master Page (2)
• Le pagine master definiscono la struttura e dei place holder
(<asp:ContentPlaceHolder>)

• Le pagine “figlie” referenziano la master e creano il contenuto (<asp:Content>)
• Le pagine master sono trasparenti all’utente, il quale invoca solo le pagine
content

• La proprietà Page.Master permette di ottenere un riferimento alla
pagina Master dalla pagina Figlia.

• Page.Mater è usata per avere accesso programmatico al contenuto
della pagina Master:
•Usare FindControl per weak typing;
•Usare public property nella master Page per strong typing.

Usiamo FindControl:
Controllo dichiarato nella
<asp:Label ID="Title" RunAt="server" /> pagina master

Accesso dalla pagina
figlia
((Label) Master.FindControl ("Title")).Text = "Orders";

Usiamo una proprietà Strong Typed:
<asp:Label ID="Title" RunAt="server" /> nella Pagina Master
.
.
.
<script language="C#" runat="server">
public string TitleText
Master.TitleText = "Orders";
{
get { return Title.Text; }
set { Title.Text = value; }
}
</script>

Master.TitleText = "Orders"; nella Pagina Figlia

ASP.NET: demo Master Page

• Creazione di un sito ex-novo
• Aggiunta una pagina master
• Aggiunta di una pagina che usa il template della pagina master
• Controllo della pagina master dalla pagina content con weak typing

ASP.NET: Temi (CSS e Skin)
I Temi definiscono la grafica della pagina, disponibili a partire dalla versione 2.0 di
ASP.Net, e:
• Sono un superset dei CSS (Cascading Style Sheets)
• Assegnano un insieme di stili e attributi visuali agli elementi personalizzabili del sito
• Sono strettamente legati ai temi di XP: impostare un tema è rapido e facile come
impostare una proprietà
• Si applicano a controlli individuali, a pagine o siti

I Temi si dividono, a seconda del proprio scope, in:
• Temi Locali: sono nella directory App_Themes
• Temi Globali: sono visti da tutte le applicazioni web della macchina e si trovano sotto
la cartella App_Themes del framewok;

e possono includere:
• File CSS: definizioni di stili da applicare agli elementi di un file HTML (richiedono
HTML 3.2>);
• Skin: set di proprietà e template che si possono applicare a uno o più controlli server
side;
• Immagini;
• Template.

ASP.NET: Temi: creazione di CSS
Si usa un tool integrato nell’ ambiente, che si attiva dal menu “Stili” dopo
avere aggiunto un file CSS.

ASP.NET: Temi: file di Skin
I File di Skin definiscono la grafica dei Controlli Server.

Per applicarli a tutti i controlli dello stesso tipo in una pagina:
• Creo una cartella per ogni skin sotto App_Themes;
• Imposto lo skin nella direttiva di pagina StylesheetTheme;

Se, invece, si desidera applicare lo Skin solo ad uno specifico controllo
definisco nel file di Skin uno SkinID
< asp:label runat="server" backColor="Yellow" SkinId="lblTitolo" />

che poi lo applico al controllo inserito nella pagina.


Deployment

ASP.NET: Deployment di una web application
Spesso sottovalutato il Deployment di un’applicazione è una fase fondamentale.

Questo perché è il primo approccio con il nostro applicativo è proprio la fase di Setup che se
risulta ostica e complicata facilmente porta il committente a desistere dall’impresa ed
archiviare direttamente il nostro applicativo.

Nel caso di una Web Application ASP.Net abbiamo principalmente quattro modalità di deploy:
1. XCOPY Deployment
2. Copy Web Site
3. Publish Web Site
4. SETUP Projects

Ognuna delle tre tecniche ha diversi vantaggi dipendenti
dall’ambito di utilizzo del nostro prodotto e da chi
deve effettuare il setup della nostra applicazione.

ASP.NET: XCopy Deployment
La tecnica più semplice per effettuare il Deploy è quella di copiare i file della vostra web
application sul server di rilascio ed impostare una Virtual Directory.

Il settaggio della Virtual Directory è richiesto anche da altre tecniche di deploy e viene
effettuata attraverso la Internet Information Manager Microsoft Management Consol (MMC)
accessibile dal Pannello di Controllo.
Normalmente la copia dell’intera struttura di directory viene effettuato attraverso il copiando
XCopy, da qui il nome della tecnica stessa.

Non effettua
compilazione

ASP.NET: Copy Web Site
Copy Web Site è una nuova tecnica di deployment introdotta con ASP.Net 2 e Visual Studio
2005 accessibile dal menu Website -> Copy Web Site... Menu option.

Rispetto alla “tecnica” xcopy questa permette di scegliere agevolmente la destinazione
scegliendo tra:
• Folder Locale;
• Directory Virtuale di IIS
• Sito accessibile in FTP;
• Sito accessibile in HTTP:

Non effettua
compilazione

ASP.NET: Deployment con compilazione
Le due tecniche viste precedentemente non prevedono la Compilazione della web application.

Questo comporta fondamentalmente due problematiche:
• Deploy del codice sorgente in chiaro;
• Mancanza di verifica degli errori rilevabili dal compilatore;
• Relativa lentezza alla prima esecuzione dell’applicazione;

Per compilare una web application possiamo utilizzare 2 tecniche:
1. Precompilare il tutto attraverso il comando aspnet_compiler, con un’istruzione simile
alla seguente: aspnet_compiler -p "C:MyDevelopmentWebSite1" -v / C:Staging

2. Usare Visual Studio 2005, selezionando Publish Web Site dal menu Build

Compilazione

ASP.NET: Web Application Setup Project (1)
Se si desidera realizzare un vera e propria procedura guidata per l’installazione della web
application, è possibile ricorre al template Web Setup Project aggiungendolo alla vostra
Solution. Scenario tipico di utilizzo è l’installazione su più nodi di un Web Server Cluster.

Per fare ciò:

1. Selezionate:
• File, New Project (nuovo progetto)
• Setup and Deployment
• Web Setup Project

2. A questo punto Visual Studio vi mostrerà la seguente finestra:

Compilazione

3. Aggiungiamo la web application al progetto:
• Cliccate con il tasto destro nella Solution Explorer
• Scegliete Add.. e poi Project Output

a questo punto si aprirà la seguente finestra in cui specificare
il progetto di origine:

4. Impostiamo le proprietà del progetto premendo F4 una volta selezionato nella Solution
Explorer
Property Purpose
Author, Description, Manufacturer,
Use all of these properties to identify / describe your
ManufacturerUrl, ProductName, Subject,
application and yourself.
Title, and Version
Here you can specify the icon to be displayed beside
AddRemoveProgramsIcon your application in Windows Control Panel's Add
Remove Programs.
Specify here whether or not a check is to be
DetectNewerInstalledVersion performed to determine the existence of a new
version already installed of your web application.
Specify here whether you need an older version of
RemovePreviousVersions your web application to be removed if a newer
version is being installed.

Some web applications requires the Internet
Information Service to be stopped and then
RestartWWWService
restarted after the deployment of the application.
Use this property to control such behavior.

5. Eseguire la compilazione del Setup Project per ottenere il packaging MSI da distribuire.

A questo punto siamo pronti a distribuire la nostra web application con un Setup che somiglia
in tutto e per tutto a Setup di una classica Windows Application:

Tra l’altro il Setup aggiunge anche l’opzione di Add/Remove nel pannello di Controllo di
Windows.

ASP.NET: Conclusioni
Quanto visto finora rappresenta una sintesi delle caratteristiche del
framework ASP.NET 2.

Lungi dal trattare tutti gli argomenti e soprattutto dal trattarli in modo
completo ed approfondito (servirebbe un corso universitario!), quanto
esposto ha l’obiettivo di rendere un’idea generale dell’infrastruttura web di
Microsoft in modo da permettere al Developer di effettuare scelte mirate e
dare le basi per tutti gli approfondimenti necessari.

Asp net (versione 1 e 2)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Asp net (versione 1 e 2)

Semelhante a Asp net (versione 1 e 2) (20)

Mais de Felice Pescatore

Mais de Felice Pescatore (20)

Asp net (versione 1 e 2)