
guide
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Ottenere URL amichevoli e facilmente indicizzabili con la nuova versione di Web Forms
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à.
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.
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:
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:
PercorsoIscritti
laurea
, un parametro chiamato anno
{*vincoli}
serve a stabilire che i parametri {laurea}
e {anno}
, sono elementi della collezione chiamata vincoli
. Questo può servire poi in fase di lettura dei parametri.true
indica che desideriamo applicare la verifica dei vincolianno
(numerico di 4 cifre) e laurea
(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.
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.
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 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.
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
.
Se vuoi aggiornamenti su ASP.NET Routing: URL amichevoli con Web Form 4.0 e Visual Studio 2010 inserisci la tua email nel box qui sotto:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
La tua iscrizione è andata a buon fine. Se vuoi ricevere informazioni personalizzate compila anche i seguenti campi opzionali:
Compilando il presente form acconsento a ricevere le informazioni relative ai servizi di cui alla presente pagina ai sensi dell'informativa sulla privacy.
Il progetto DVLUP, i nuovi device Nokia Lumia e la migrazione Android su Nokia X.
Tutti i linguaggi per diventare uno sviluppatore di app per Android.
Come creare applicazioni per il Web con PHP e MySQL per il DBMS.
Tutte le principali tecnologie per diventare uno sviluppatore mobile per iOS.
I fondamentali per lo sviluppo di applicazioni multi piattaforma con Java.
Diventare degli esperti in tema di sicurezza delle applicazioni Java.
Usare Raspberry Pi e Arduino per avvicinarsi al mondo dei Maker e dell’IoT.
Le principali guide di HTML.it per diventare un esperto dei database NoSQL.
Ecco come i professionisti creano applicazioni per il Cloud con PHP.
Lo sviluppo professionale di applicazioni in PHP alla portata di tutti.
Come sviluppare applicazioni Web dinamiche con PHP e JavaScript.
Fare gli e-commerce developer con Magento, Prestashop e WooCommerce.
Realizzare applicazioni per il Web utilizzando i framework PHP.
Creare applicazioni PHP e gestire l’ambiente di sviluppo come un pro.
Percorso base per avvicinarsi al web design con un occhio al mobile.
Realizzare siti Web e Web application con WordPress a livello professionale.
Come realizzare un redirect tramite le principali tecnologie web, da HTML a JavaScript, passando per PHP e i linguaggi di programmazione lato server.
LiteDB è un database embedded NoSQL, comodo da utilizzare in progetti .NET di piccole dimensioni: ecco come utilizzarlo con C#.
Le sessioni tecniche e le interviste ai protagonisti dell’edizione 2015 del più grande evento italiano dedicato alle tecnologie .net …e non solo!
Una guida per apprendere e migliorare le tecniche di programmazione di app destinate al mercato di Windows Store con C# e XAML, per raggiungere il livello di preparazione delle certificazioni Microsoft