5
guide
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
ASP.NET Routing: URL amichevoli con Web Form 4.0 e Visual Studio 2010
Ottenere URL amichevoli e facilmente indicizzabili con la nuova versione di Web Forms
- 17 Febbraio 2010
Presentando le novità di ASP.NET 4.0, abbiamo accennato alla possibilità di effettuare il routing degli indirizzi anche per le applicazioni Web Form (su ASP.NET MVC ad esempio era già possibile).
Il Routing, è quel meccanismo che ci permette di associare alle pagine url semplificati, facili da ricordare per gli utenti e soprattutto meglio indicizzabili dai motori di ricerca.
Inoltre ci permette di nascondere i nomi dei file che effettivametne elaborano la richiesta e di migliorare la significato semantico degli indirizzi.
In questo articolo esamineremo un semplice esempio di routing, realizzando una piccola applicazione Web Form 4.0, con Visual Studio 2010.
L’applicazione sarà composta di due pagine web, per semplicità.
Figura 1. Esempio di routing tra sole due pagine
La pagina default.aspx conterrà alcuni link che puntano a diversi percorsi nel sito. Per mostrare le potenzialità del Routing, faremo in modio che ciascun link richiami in realtà la stessa pagina, che chiamiamo target.aspx.
Per iniziare l’esempio, pensiamo di costruire il sito di un’università e che le nostre pagine servano alla ricerca degli iscritti delle diverse facoltà e per i relativi anni accademici.
Dopo aver creato il nostro sito web vuoto con Visual Studio 2010, creiamo le due pagine default.aspx e target.aspx, andiamo sulla prima e inseriamo un primo HyperLink.
Il nostro primo link punterà ad una pagina che mostra i dettagli della facoltà di informatica. Normalmente nella proprietà NavigateUrl inseriremmo il link passaremmo il parametro del corso di laurea con una querystring come questa:
~/target.aspx?laurea=inf;
Definiamo invece il nostro link in questo modo:
<asp:HyperLink ID="link1" runat="server"
NavigateUrl="~/dettagliLaurea/INF">
Facoltà di Informatica
</asp:HyperLink>
Ne inseriamo un’altro dove puntiamo all’elenco degli iscritti e un terzo in cui specifichiamo anche l’anno accademico:
<asp:HyperLink ID="link2" runat="server"
NavigateUrl="~/elencoIscritti/">
Iscritti al corso di laurea in Informatica
</asp:HyperLink>
<br />
<asp:HyperLink ID="link3" runat="server"
NavigateUrl="~/elencoIscritti/FIS/2008">
Iscritti al corso di laurea in Fisica nell'a.a. 2008
</asp:HyperLink>
Al posto delle solite querystring, possiamo utilizzare questi percorsi più significativi, proprio grazie al Routing, che chiamerà in causa le pagine relative a ciascun indirizzo. Nel nostro caso mandiamo tutte le richieste alla pagina target.aspx, che poi avrà il compito di reagire a seconda del caso.
Registrare un percorso
Abbiamo visto che il Routing non consiste solo nell’assegnare a file fisici indirizzi diversi (URL Rewrite), ma anche nel mappare dinamicamente interi percorsi, grazie ai quali realizzare le richieste e passare anche dei parametri.
I dati relativi ai percorsi sono contenuti in una RouteTable che contiene tutti i percorsi attivi nell’applicazione (memorizzati nella collection Routes di tipo RouteCollection).
Cominciamo con il registrare questi percorsi (routes) in modo tale da poterli utilizzare all’interno della nostra applicazione. Per farlo apriamo il file Global.asax (se non c’è lo creiamo) ed importiamo lo spazio dei nomi System.Web.Routing, che ci servirà per manipolare gli oggetti di cui abbiamo parlato:
<%@ Import Namespace="System.Web.Routing" %>
Poi scriviamo un semplice metodo RegistraPercorsi in cui aggiungere i nostri percorsi a quelli dell’applicazione e lo richiamiamo nel metodo Application_Start:
void Application_Start(object sender, EventArgs e)
{
// passiamo la collection dei percorsi al nostro metodo
RegistraPercorsi(RouteTable.Routes);
}
A questo punto dedichiamoci al nostro metodo che piazziamo in fondo al Global.asax. Iniziamo con il definire una regola per il nostro primo link:
void RegistraPercorsi (RouteCollection routes)
{
routes.MapPageRoute("", "dettagliLaurea/{laurea}", "~/target.aspx");
}
Il sistema è molto semplice, chiamiamo il metodo MapPageRoute indicando:
- il nome della regola di mapping (che abbiamo lasciato vuota)
- un’espressione in cui mettiamo le parti variabili dell’URL tra parentesi graffe, che diventeranno i parametri della chiamata
- la pagina reale di destinazione
In breve, quando clicchiamo sul primo link del nostro esempio, chiamiamo la pagina default.aspx e le passiamo il parametro laurea.
Questa regola è molto semplice ma potrebbe essere troppo potente. Potremmo voler circoscrivere i nostri indirizzi, per evitare malfunzionamenti dell’applicazione. Possiamo inserire una serie di vincoli come quelli che scriviamo in questa seconda regola:
routes.MapPageRoute("PercorsoIcritti",
"elencoIscritti/{laurea}/{anno}/{*vincoli}",
"~/target.aspx", true,
new RouteValueDictionary {
{ "laurea", "INF" },
{ "anno", DateTime.Now.Year.ToString() } },
new RouteValueDictionary {
{ "laurea", "[a-z]{3}" },
{ "anno", @"d{4}" } }
);
Esaminiamo i parametri anche questa volta, abbiamo:
- un percorso nominato
PercorsoIscritti - una URL con un parametro chiamato
laurea, un parametro chiamatoanno - la sintassi
{*vincoli}serve a stabilire che i parametri{laurea}e{anno}, sono elementi della collezione chiamatavincoli. Questo può servire poi in fase di lettura dei parametri. - il
trueindica che desideriamo applicare la verifica dei vincoli - il primo dizionario per i valori di default, laurea sarà INF e l’anno quello in corso
- l’ultimo parametro è un dizionario con le regole per i parametri
anno(numerico di 4 cifre) elaurea(alfanumerico di 3 caratteri)
È necessario nominare un percorso solo quando c’è una possibile ambiguità con altri percorsi, nel nostro caso l’abbiamo fatto per completezza espositiva.
Creare i link associati ai percorsi
Per creare dei link che sfruttino il routing, esistono tre metodi. Uno è quello che abbiamo già utilizzato nel nostro esempio e consiste nell’esplicitare i percorsi:
NavigateUrl="~/dettagliLaurea/INF"
NavigateUrl="~/elencoIscritti/"
NavigateUrl="~/elencoIscritti/FIS/2008"
Nella prima istruzione abbiamo esplicitato nella proprietà NavigateUrl il percorso dettagliLaurea e gli abbiamo passato il valore INF per il parametro laurea.
Nella seconda proprietà NavigateUrl abbiamo il percorso elencoIscritti senza parametri. Per default vengono passati i valori INF a laurea e l’anno corrente a anno.
Nella terza istruzione abbiamo esplicitato il percorso elencoIscritti al quale abbiamo passato i valori FIS per laurea e 2008 per l’anno accademico.
Un secondo modo di associare un percorso ad un link consiste nel far generare automaticamente la URL all’interno dei markup. Vediamo un esempio:
<asp:HyperLink ID="HyperLink4" runat="server"
NavigateUrl="<%$RouteUrl:laurea=INF%>">
Dettagli Laurea in Informatica
</asp:HyperLink>
<br />
<asp:HyperLink ID="HyperLink5" runat="server"
NavigateUrl="<%$RouteUrl:routename=PercorsoIcritti%>">
Elenco degli iscritti al corso di laurea in Informatica nell'a.a. in corso
</asp:HyperLink>
<br />
<asp:HyperLink ID="HyperLink6" runat="server"
NavigateUrl="<%$RouteUrl:laurea=FIS,anno=2008,routename=PercorsoIcritti%>">
Elenco degli iscritti al corso di laurea in Fisica nell'a.a. 2008
</asp:HyperLink>
Si valorizza la proprietà NavigateUrl usando l’espressione RouteUrl nella quale possiamo esplicitare il nome del percorso e/o i parametri.
Questo metodo presenta un vantaggio: non è necessario andare a modificare gli hyperlink nel caso in cui modifichiamo l’ordine o la posizione dei parametri nei percorsi.
Il terzo modo consiste nell’associare un percorso ad un link da codice. Vediamo un esempio:
using System.Web.Routing;
protected void Page_Load(object sender, EventArgs e)
{
// altro codice
RouteValueDictionary parameters = new RouteValueDictionary {
{"laurea", "FIS" },
{ "anno", "2008" }
};
VirtualPathData vpd = RouteTable.Routes.GetVirtualPath(null,
"PercorsoIcritti",
parameters);
link7.NavigateUrl = vpd.VirtualPath;
}
Per prima cosa dobbiamo importare lo spazio dei nomi System.Web.Routing, dopodiché nel Page_Load creiamo una istanza dell’oggetto VirtualPathData al quale passiamo una istanza dell’oggetto RouteValueDictionary che contiene i parametri del percorso. Infine associamo alla proprietà NavigateUrl di link7 il percorso virtuale appena creato.
L’accesso ai parametri
Come abbiamo detto, nelle pagine web invocate tramite Routing abbiamo accesso ai valori dei parametri. Questo può essere fatto in due modi: direttamente, nel markup della pagina, o da codice.
Vediamo un esempio di accesso tramite markup:
corso di laurea in: <asp:Label ID="Label1"
Text="<%$RouteValue:laurea%>"
runat="server"></asp:Label>
, a.a.: <asp:Label ID="Label2" runat="server"></asp:Label>
Attraverso l’espressione RouteValue accediamo al valore del parametro laurea.
Vediamo un esempio di accesso da codice:
Label2.Text = Page.RouteData.Values["anno"].ToString();
La proprietà Text della etichetta Label2 viene valorizzata utilizzando l’oggetto RouteData per accedere al valore del parametro anno.
Testiamo l’applicazione
Testiamo l’applicazione e verifichiamo che gli URL generate funzionino. Per effettuare prove veloci possiamo utilizzare anche l’applicazione allegata all’articolo.
Clicchiamo su tutti i link presenti nella prima pagina. Viene caricata la pagina target.aspx ma nella barra indirizzi del browser troviamo gli URL con la seguente forma:
http://[server]/[applicazione]/DettagliLaurea/xxx http://[server]/[applicazione]/ElencoIscritti/xxx/yyyy
dove xxx è il parametro laurea e yyyy è il parametro anno.
Figura 2. Pagina ‘target.aspx’
Facciamo una ultima prova e scriviamo nel browser il seguente indirizzo:
http://[server]/[applicazione]/ElencoIscritti/FISICA/08
Quello che otteniamo è un errore, perché ASP.NET non associa all’URL un percorso in quanto il percorso PercorsoIscritti accetta solo valori di tre caratteri per il parametro laurea e numeri di 4 cifre per il parametro anno.
Nel progetto in allegato si può trovare anche un semplice esempio con Button e Response.Redirect.
