Pagina personale di:
Carlo Vecchio
appunti di C#, R, SQL Server, ASP.NET, algoritmi, numeri
Vai ai contenuti

ASP.NET - Fondamenti

ASP.NET

Ciclo di vita di una form
   •   Una Web Form, vive per pochi istanti.
   •   Quando arriva una richiesta al Web Server:
       1. È creata una istanza della Web Form.
       2. Sono processati gli eventi.
       3. È generato il codice HTML e inviato al client.
       4. L'istanza della Web Form (sul server) è distrutta.
   •   Quindi: le variabili a livello di form sono create e inizializzate ogni volta che una form viene aggiornata
.
   •   Per esempio, una variabile contatore che si incrementa al click di un bottone, ripartirà sempre dal valore iniziale.
   •   Esempio, il Button1 incrementa il valore del numero contenuto nella TextBox1 (da inizializzare a "0").

   protected void Button1_Click(object sender, EventArgs e)
   {
       
int numClick = Convert.ToInt32(TextBox1.Text) + 1;
       TextBox1.Text = numClick.ToString();
   }

   •   Quello che succede è che il valore della TextBox1 viene incrementato e poi ripristinato al valore iniziale.
   •   Per correggere, basta aggiungere nell'evento Page_Load() le seguenti righe.

   protected void Page_Load(object sender, EventArgs e)
   {
       
if (!IsPostBack)
       {
           TextBox1.Text =
"0";
       }
   }

   •   L'evento Page_Load() viene eseguito ogni volta che avviene il PostBack della pagina, ma l'inizializzazione della TextBox1 avviene solo una volta.
   •   I controlli ASP.NET (è quindi la TextBox1) fanno uso del ViewState per preservare i dati (in questo caso il valore della TextBox1) tra i PostBack.

   •   I dati sono ripristinati dal ViewState ai controlli nell'evento Page_Init() che avviene prima dell'evento Page_Load(). Sono quindi disponibili anche a tutti gli altri eventi della pagina.

Eventi in ASP.NET
Tipi di Eventi
Si possono classificare gli eventi in tre categorie:
   •   Eventi dell'Applicazione
   •   Eventi della Pagina
   •   Eventi del Controllo

Eventi dell'Applicazione
Nel file Global.asax ci sono:
   •   Gli Application Events: per inizializzare i dati per tutte le sessioni.
   •   I Session Events: per inizializzare i dati della singola sessione.
   •   Il file Global.asax, normalmente va aggiunto a mano al progetto (Click destro sul progetto, "Aggiungi -> Nuovo elemento).
   •   Una volta aggiunto, si hanno a disposizione gli eventi dell'applicazione e delle sessione.
   •   Deve essere nella cartella principale del progetto.

Eventi della Pagina
   •   Gli eventi della pagina possono essere aggiunti scrivendoli nella forma 'Page_Event()'. ASP.NET li riconosce se c'è la direttiva di pagina 'AutoEventWireup'.

Eventi ordinati, escluso l'evento Error che avviene al momento dell'errore.
   •   PreInit
: avviene prima dell'inizializzazione della pagina. Già da questo evento si possono leggere le proprietà 'IsPostBack', 'IsCallback' e 'IsCrossPagePostBack'. In questo evento si possono impostare la Master Page e i temi e si possono creare i controlli dinamicamente.
   •   Init
: avviene dopo l'inizializzazione di tutti i controlli della WebForm dal ViewState. Utilizzare questo evento per leggere o impostare le proprietà dei controlli.
   •   InitComplete
: avviene dopo l'inizializzazione della pagina.
   •   Preload
: avviene dopo il caricamento del ViewState dei controlli e della pagina.
   •   Load
: avviene prima della Load di tutti i controlli della WebForm. In questo evento impostare le proprietà dei controlli e le connessioni ai database.
   •   Control Events
: dopo la Load della pagina, avvengono gli eventi dei controlli.
   •   LoadComplete
: avviene appena finiti gli eventi dei controlli.
   •   PreRender
: avviene appena prima di iniziare il Render. In questo evento fare gli ultimi cambiamenti al contenuto della pagina.
   •   PreRenderComplete
: viene appena finito il Render.
   •   Unload
: avviene per tutti i controlli e poi per la pagina. In questo evento chiudere tutti i file e le connessioni ai database.
   •   Error
: avviene in caso di errore.

   •   Notare che i Controls Events avvengono dopo il Page_Load().

Eventi del Controllo
Sono di tre tipi:
   •   PostBack Events
: inviati al Web Server immediatamente per essere processati. Es.: click su un bottone.
   •   Cached Events:
salvati nel ViewState per essere processati non appena avviene un PostBack. Es.: change di una TextBox. Possono essere convertiti in eventi PostBack, impostando la proprietà "AutoPostBack=true" (Attenzione: in questo caso l'evento inizia quando il controllo perde il focus).
   •   Validation Events
: avvengono sul client prima che la pagina sia inviata al server per il PostBack. Sono utilizzati dai controlli di validazione.

ViewState, SessionState, ApplicationState
ViewState
Caratteristiche del View State:
   •   È disponibile solo nella WebForm stessa.
   •   È memorizzato nella pagina stessa in un campo nascosto chiamato "__ViewState" codificato in base64.
   •   È perso se si chiude il Browser o se si naviga fuori dal WebForm.
   •   Serve essenzialmente per tenere i valori dei controlli tra i vari PostBack.

   •   Impostare il ViewState:

   ViewState["myVar"
] = "Ciao!";

    •   Leggere il ViewState:

   string s = (string) ViewState["myVar"];

SessionState
Note:
   •   Lo stato di una Sessione è tenuto tramite i Cookies.
   •   Quindi se si aprono più pagine con lo stesso browser, queste vedranno gli stessi Cookies e quindi le stesse variabili di Sessione.
   •   Chiudendo tutte le pagine, verranno cancellati i Cookies e le variabili saranno create nuovamente.
   •   Diversi Browser, utilizzano diversi Cookies.

Caratteristiche del Session State:
   •   Sono variabili disponibili tra tutte le pagine di una Sessione (quindi di un singolo utente).
   •   È memorizzato nel Web Server.
   •   È cancellato quando termina la sessione (per default dopo 20 minuti, configurabile nel file 'web.config
').

   •   Impostare il SessionState:

   Session["myVar"
] = "Ciao!";

   •   Leggere il SessionState:

   string s = (string) Session["myVar"];

ApplicationState
Caratteristiche dell'Application State:
   •   Sono variabili condivise tra tutte le pagine di tutte le sessioni.
   •   Sono memorizzate nel Web Server.
   •   Sono cancellate quando viene riavviato il Web Server.

   •   Impostare l’ApplicationState:

   Application["myVar"
] = "Ciao!";

   •   Leggere l’ApplicationState

   string s = (string) Application["myVar"];

Path sul Server
   •   Quando una applicazione è installata sul WebServer è utile ricavare il path fisico dell’applicazione, per poter accedere facilmente alle sue sottocartelle. Lo si fa con ‘Server.MapPath()’.

   // Path della pagina corrente
   Response.Write(Server.MapPath(
"."));
   
// Path padre della pagina corrente
   Response.Write(Server.MapPath(
".."));
   
// Path della radice dell'applicazione
   Response.Write(Server.MapPath(
"~"));

© 2020 Carlo Vecchio
Torna ai contenuti