Embed Size (px)
Citation preview
Personnaliser le comportement de votre site
Ceci est une documentation préliminaire, traduite par Christine Dubois (Agilcom) et sujette à
changement
Dans ce chapitre, vous allez apprendre à configurer l'ensemble d’un site ou un dossier tout entier, au
lieu d’appliquer des configurations page par page.
A la fin de ce chapitre, vous saurez :
• Comment définir des valeurs pour toutes les pages d’un site.
• Comment définir des valeurs pour toutes les pages d’un dossier.
• Comment exécuter du code avant et après le chargement d'une page.
• Comment ASP.NET utilise le routage pour vous permettre d'utiliser des URL plus lisibles.
Ajouter du code de démarrage à un site web
La plupart du code que vous écrivez et des paramètres que vous configurez sont dans des pages
individuelles. Par exemple, si une page envoie un message électronique, la page contient
généralement tout le code qui est nécessaire pour initialiser les paramètres d'envoi d’un email (pour
le serveur SMTP) et pour l'envoi de l'e-mail en lui-même.
Toutefois, dans certaines situations, vous pouvez vouloir exécuter du code avant l’exécution de
n'importe quelle page du site. C’est très utile pour configurer des valeurs qui peuvent être utilisées
n'importe où dans le site (on parle de valeurs globales.) Autre exemple, certains assistants vous
demandent de leur fournir des valeurs telles que des paramètres de messagerie ou des clés de
compte. Il peut s’avérer utile de conserver ces paramètres dans des valeurs globales.
Pour créer des variables globales, le principe consiste à créer une page nommée _AppStart.cshtml à
la racine du site. Si cette page existe, elle est exécutée la première fois que n'importe quelle page du
site est demandée. C’est pourquoi c'est l’endroit idéal pour exécuter du code définissant les valeurs
globales (_AppStart.cshtml étant préfixé par un trait de soulignement, ASP.NET ne renvoie jamais
directement la page à un navigateur, même si les utilisateurs la demande explicitement).
Le schéma suivant montre comment fonctionne la page _AppStart.cshtml. Quand une page est
demandée, et qu’il s’agit de la toute première demande d’une page du site, ASP.NET vérifie si une
page _AppStart.cshtml existe. Si c'est le cas, le code de la page _AppStart.cshtml s'exécute, puis c’est
le tour de la page demandée.
Définir des valeurs globales dans votre site web
1. Dans le dossier racine d'un site web WebMatrix, créez un fichier nommé _AppStart.cshtml.
Le fichier doit être à la racine du site.
2. Remplacez son contenu par ce qui suit :
@{ AppState["customAppName"] = "Application Name";
}
Ce code stocke une valeur dans le dictionnaire AppState, qui est automatiquement disponible pour
toutes les pages du site.
Remarque : Soyez prudent lorsque vous placez du code dans le fichier _AppStart.cshtml car si une
erreur devait se produire lors de l’exécution du code de ce fichier, le site ne démarrerait pas.
3. Dans le dossier racine, créez une nouvelle page nommée AppName.cshtml.
4. Remplacez son contenu par ce qui suit:
<!DOCTYPE html> <html> <head> <title>Show Application Name</title> </head> <body> <h1>@AppState["customAppName"]</h1> </body> </html>
Ce code extrait la valeur du dictionnaire AppState que vous avez définie dans la page
_AppStart.cshtml.
5. Exécutez la page AppName.cshtml dans un navigateur. (Assurez-vous que la page est bien
sélectionnée dans l'espace de noms Files avant de l'exécuter.) La page affiche la valeur
globale.
Définir des valeurs pour les assistants
Une autre utilisation intéressante du fichier _AppStart.cshtml consiste à y définir des valeurs
utilisées par les assistants que vous utilisez dans votre site et qui doivent être initialisées.
Prenons l’exemple de l'assistant ReCaptcha, qui nécessite de configurer des clés publique et
privée pour votre compte reCAPTCHA. Au lieu de définir ces clés sur chaque page où vous
souhaitez utiliser l'assistant ReCaptcha, il suffit de les définir une seule fois dans le fichier
_AppStart.cshtml pour qu’elles deviennent automatiquement disponibles pour l'ensemble des
pages de votre site. Les paramètres d’envoi d’email via un serveur SMTP sont un autre exemple
de valeurs pouvant être définies dans le fichier _AppStart.cshtml, comme vous l'avez vu dans le
chapitre 16 – Gestion de la sécurité et de membres de votre site.
La procédure qui suit illustre comment configurer les clés ReCaptcha d’une manière globale.
(Pour en savoir plus sur l’assistant ReCaptcha, voir le chapitre 16 – Gestion de la sécurité et de
membres de votre site)
1. Ajoutez la bibliothèque ASP.NET Web Helpers à votre site Web, comme décrit dans le
chapitre 1, si vous ne l’avez pas déjà fait.
2. Enregistrez votre site Web sur ReCaptcha.Net (http://recaptcha.net). Une fois enregistré,
vous recevrez une clé publique et une clé privée.
3. Si vous ne possédez pas déjà un fichier _AppStart.cshtml, dans le dossier racine d'un site web
créez en un.
4. Ajoutez le code suivant dans le fichier _AppStart.cshtml et supprimez tout le reste:
@{
// Définition des clés publiques et privés PublicKey et PrivateKey.
//Récupérez ces deux clés sur le site
//ReCaptcha.Net (http://recaptcha.net).
ReCaptcha.PublicKey = "";
ReCaptcha.PrivateKey = "";
}
5. Configurez les deux propriétés PublicKey et PrivateKey en utilisant vos propres clés publique
et privée.
6. Enregistrez le fichier _AppStart.cshtml puis fermez-le.
7. Dans le dossier racine du site web, créez une nouvelle page nommée Recaptcha.cshtml.
8. Remplacez son contenu par ce qui suit :
@{ var showRecaptcha = true; if (IsPost) { if (ReCaptcha.Validate()) { @:Your response passed! showRecaptcha = false; } else{ @:Your response didn't pass! } }
}
<!DOCTYPE html> <html> <head> <title>Testing Global Recaptcha Keys</title> </head> <body> <form action="" method="post"> @if(showRecaptcha == true){ if(ReCaptcha.PrivateKey != ""){ <p>@ReCaptcha.GetHtml()</p> <input type="submit" value="Submit" /> } else { <p>Vous pouvez obtenir deux clés privée et publique sur le site ReCaptcha.Net (http://recaptcha.net). Ensuite ajoutez les clés au fichier _AppStart.cshtml.</p> } } </form> </body>
</html>
9. Exécutez la page Recaptcha.cshtml dans un navigateur. Si la valeur PrivateKey est valide, la
page affiche le contrôle reCAPTCHA et un bouton. Si les clés n’étaient pas définies d’une
manière globale dans le fichier _AppStart.html, la page afficherait une erreur.
10. Saisissez les deux mots pour effectuer le test. En cas d’échec, un message d'erreur s’affiche
et le contrôle reCAPTCHA est réaffiché à nouveau.
Exécuter du code avant et après les fichiers d’un dossier
De la même manière que vous avez utilisé _AppStart.cshtml pour écrire du code qui s’exécute
avant les pages d’un site, vous pouvez écrire du code qui s'exécute avant (et après) n'importe
quelle page d’un dossier particulier. Cela peut s’avérer très utile, par exemple pour appliquer une
mise en page identique pour toutes les pages d’un même dossier, ou pour vérifier qu'un
utilisateur est connecté avant de lancer une page d’un dossier.
Pour gérer des pages d’un même dossier, le principe consiste à écrire du code dans un fichier
nommé _PageStart.cshtml. Le schéma suivant montre comment fonctionne la page
_PageStart.cshtml. Quand une page est demandée, ASP.NET vérifie d'abord si une page
_AppStart.cshtml existe et si tel est le cas, il l’exécute. Ensuite, ASP.NET vérifie si une page
_PageStart.cshtml existe, et si tel est le cas, il l’exécute à son tour. Enfin, il exécute la page
demandée.
A l'intérieur de la page _PageStart.cshtml, vous pouvez spécifier où vous souhaitez
qu’intervienne le traitement de la page demandée en incluant un appel à la méthode RunPage.
Cela permet d'exécuter du code avant l'exécution de la page demandée, puis après l’exécution
de celle-ci. Si vous n'incluez pas d’ordre RunPage, l’intégralité du code de la page
_PageStart.cshtml s'exécute, puis la page demandée s'exécute à son tour automatiquement.
ASP.NET vous permet de créer une hiérarchie de fichiers _PageStart.cshtml. Vous pouvez ainsi
placer un fichier _PageStart.cshtml à la racine du site et dans n’importe quel sous-dossier. Quand
une page est demandée, le fichier _PageStart.cshtml au plus haut niveau dans le site (le plus
proche de la racine du site) s'exécute, suivi par le fichier _PageStart.cshtml situé dans le premier
sous-dossier, et ainsi de suite en suivant la structure de dossiers jusqu'à atteindre le sous-dossier
qui contient la page demandée. Une fois que tous les fichiers _PageStart.cshtml correspondant à
la structure de dossier de la page ont été exécutés, la page demandée est exécutée à son tour.
Par exemple, vous pourriez avoir la combinaison suivante de fichiers _PageStart.cshtml et
default.cshtml :
@* /_PageStart.cshtml *@ @{ PageData["Color1"] = "Red"; PageData["Color2"] = "Blue"; }
@* /myfolder/_PageStart.cshtml *@ @{ PageData["Color2"] = "Yellow"; PageData["Color3"] = "Green"; }
@* /myfolder/default.cshtml *@ @PageData["Color1"] <br/> @PageData["Color2"] <br/>
@PageData["Color3"]
Lorsque vous exécutez la page default.cshtml, vous obtenez :
Red
Yellow
Green
Exécuter du code d'initialisation pour toutes les pages d’un dossier
Une utilisation intéressante des fichiers _PageStart.cshtml consiste à configurer une mise en page
identique pour tous les fichiers d’un dossier unique.
1. Dans le dossier racine, créez un nouveau dossier nommé InitPages.
2. Dans le dossier InitPages de votre site, créez un fichier nommé _PageStart.cshtml et
remplacez son contenu par ce qui suit:
@{ // Configuration de la mise en page pour toutes les pages d’un dossier. Layout = "/Shared/_Layout1.cshtml";
// Configuration d’une variable pour toutes les pages d’un dossier. PageData["MyBackground"] = "Yellow";
}
3. A la racine du site, créez un dossier nommé Shared.
4. Dans le dossier Shared, créez un fichier nommé _Layout1.cshtml et remplacez son contenu
par le suivant :
@{ var backgroundColor = PageData["MyBackground"]; }
<!DOCTYPE html> <html> <head> <title>Page Title</title> <link type="text/css" href="/Styles/Site.css" rel="stylesheet" /> </head> <body> <div id="header"> Using the _PageStart.cshtml file </div> <div id="main" style="background-color:@backgroundColor"> @RenderBody() </div> <div id="footer"> © 2010 Contoso. All rights reserved </div> </body> </html>
5. Dans le dossier InitPages, créez un fichier nommé Content1.cshtml et remplacez son contenu
par le suivant :
<p>This is content page 1.</p>
6. Dans le dossier InitPages, créer un autre fichier nommé Content2.cshtml et remplacez son
contenu par ce qui suit:
<p>This is content page 2.</p>
7. Exécutez Content1.cshtml dans un navigateur.
Lorsque la page Content1.cshtml s'exécute, le fichier _PageStart.cshtml définit la mise en page
(Layout) et une couleur (PageData ["MyBackground"]). Dans le fichier Content1.cshtml, la mise
en page et la couleur ainsi définies sont appliquées.
8. Affichez Content2.cshtml dans un navigateur.
La présentation est la même puisque les deux pages utilisent la mise en page et la couleur
initialisées dans _PageStart.cshtml.
Utiliser _PageStart.cshtml pour gérer les erreurs
Un autre exemple d’utilisation du fichier _PageStart.cshtml consiste à l’utiliser pour gérer les erreurs
de programmation (exceptions) pouvant se produire dans n'importe quelle page .cshtml d’un dossier.
La procédure qui suit en donne un exemple :
1. Dans le dossier racine, créez un dossier nommé InitCatch.
2. Dans le dossier InitCatch de votre site, créez un fichier nommé _PageStart.cshtml et
remplacez son contenu par ce qui suit :
@{ try { RunPage(); } catch (Exception ex) { Response.Redirect("/Error.cshtml?source=" + HttpUtility.UrlEncode(Request.AppRelativeCurrentExecutionFilePa
th)); } }
Dans ce code, on exécute la page demandée explicitement en appelant la méthode RunPage à
l'intérieur d'un bloc try. Si des erreurs de programmation se produisent dans la page demandée, le
code à l'intérieur du bloc catch est exécuté. Dans le cas présent, le code fait une redirection vers une
page (Error.cshtml) en passant en paramètre de l’URL le nom du fichier qui est à l’origine de l'erreur.
(Vous allez créer cette page dans la suite de cette procédure)
3. Dans le dossier InitCatch de votre site, créez un fichier nommé Exception.cshtml et remplacez
son contenu par ce qui suit:
@{ var db = Database.Open("invalidDatabaseFile"); }
Pour les besoins de l’exemple, cette page génère délibérément une erreur en essayant d'ouvrir un
fichier de base de données qui n'existe pas.
4. Dans le dossier racine, créez un fichier nommé Error.cshtml et remplacez son contenu par ce
qui suit:
<!DOCTYPE html> <html> <head> <title>Error Page</title> </head> <body> <h1>Error report</h1> <p>An error occurred while running the following file:
@Request["source"]</p> </body> </html>
L’expression @Request["source"] dans le code de la page, récupère la valeur de l'URL et l'affiche.
5. Dans la barre d'outils, cliquez sur Save.
6. Exécutez Exception.cshtml dans un navigateur.
Comme une erreur se produit dans Exception.cshtml, la page _PageStart.cshtml redirige l’utilisateur
vers la page Error.cshtml qui affiche le message.
Pour plus d'informations sur la gestion des exceptions, voir le chapitre 2 - Introduction à la
programmation Web ASP.NET avec la syntaxe Razor.
Utiliser _PageStart.cshtml pour limiter l'accès à un dossier
Vous pouvez également utiliser le fichier _PageStart.cshtml pour limiter l'accès à tous les fichiers
d’un dossier.
1. Créez un nouveau site Web en utilisant l’option Site From Template.
2. Dans la liste des modèles disponibles, sélectionnez Starter Site.
3. Dans le dossier racine, créez un dossier nommé AuthenticatedContent.
4. Dans le dossier AuthenticatedContent, créez un fichier nommé _PageStart.cshtml et
remplacez son contenu par ce qui suit:
@{ Response.CacheControl = "no-cache";
if (!WebSecurity.IsAuthenticated) { Response.Redirect("/Account/Login"); } }
La première ligne de code consiste à empêcher que tous les fichiers du dossier soient mis en cache.
(C’est nécessaire pour des scénarios tels que des ordinateurs grand public, pour lesquels vous ne
voulez pas que des pages mises en cache pour un utilisateur soient disponibles pour le prochain
utilisateur) Ensuite, le code détermine si l'utilisateur s’est authentifié sur le site avant de l’autoriser à
afficher l'une des pages du dossier. Si l'utilisateur n'est pas connecté, le code le redirige vers la page
de connexion.
5. Créez une nouvelle page dans le dossier AuthenticatedContent nommée Page.cshtml.
6. Remplacez son contenu par le suivant :
@{ Layout = "/_SiteLayout.cshtml"; Page.Title = "Authenticated Content"; }
<!DOCTYPE html> <html> <head> <meta charset="utf-8" /> </head> <body> Thank you for authenticating! </body> </html>
7. Exécutez Page.cshtml dans un navigateur. Le code vous redirige vers une page de connexion.
Vous devez d'abord vous inscrire avant de vous connecter. Une fois inscrit et connecté, vous
pouvez accéder à la page et afficher son contenu.
Créer des URL plus lisibles et facilement interrogeables
Le choix des URL des pages de votre site peut avoir un impact sur le bon fonctionnement de celui-ci.
Par exemple, une URL « conviviale » peut simplifier la manière dont les gens utilisent le site. Cela
peut également aider à l'optimisation pour les moteurs de recherche (techniques appelées search-
engine optimization ou SEO). Les sites web ASP.NET incluent la possibilité d'utiliser automatiquement
des URL conviviales.
A propos de routage
ASP.NET vous permet de créer des URL significatives qui décrivent les actions des utilisateurs au lieu
de simplement pointer vers un fichier sur le serveur. Comparez les URL suivantes d’un blog fictif :
http://www.contoso.com/Blog/blog.cshtml?categories=hardware
http://www.contoso.com//Blog/blog.cshtml?startdate=2009-11-01&enddate=2009-11-30
http://www.contoso.com/Blog/categories/hardware/
http://www.contoso.com/Blog/2009/November
Dans les deux premiers exemples, un utilisateur doit savoir que le blog est accessible en utilisant la
page blog.cshtml, et doit construire une chaîne de requête qui obtient la bonne catégorie ou la
bonne plage de dates. La deuxième série d'exemples est beaucoup plus facile à comprendre et à
créer.
Les URL du premier exemple pointent directement vers un fichier spécifique (blog.cshtml). Si pour
une raison quelconque le blog est déplacé vers un autre dossier sur le serveur, ou si le blog est réécrit
et utilise une autre page, les liens ne sont plus corrects. Le deuxième ensemble d'URL ne pointe pas
vers une page spécifique, donc même si la mise en œuvre ou l'emplacement du blog change, les URL
restent encore valables.
Dans ASP.NET, il est facile de créer des URL conviviales comme celles des exemples ci-dessus, car
ASP.NET utilise le routage. Le routage crée un lien logique entre une URL et une page(s)
susceptible(s) de répondre à la demande. Parce que la liaison est logique (et non physique, lié à un
fichier spécifique), le routage permet de définir les URLs d’un site avec un maximum de souplesse.
Fonctionnement du routage
Lorsqu’ASP.NET traite une demande, il lit l’URL afin de déterminer comment l'acheminer. ASP.NET
essaie de faire correspondre les différents segments de l'URL avec des fichiers sur le disque, en allant
de gauche à droite. S'il trouve une correspondance, le reste de l'URL est transmis à la page en tant
qu’information concernant le chemin d'accès (path information). Par exemple, imaginez la structure
de dossier suivante dans un site Web:
Et imaginez que quelqu'un fait une demande en utilisant cette URL:
http://www.contoso.com/a/b/c
La recherche va s’effectuer comme ceci:
1. Existe-t-il un fichier avec le chemin et le nom /a/b/c.cshtml? Si oui, exécutez sans
transmettre d’information. Sinon ...
2. Existe-t-il un fichier avec le chemin et le nom /a/b.cshtml /? Si oui, utilisez-le et transmettez
au fichier l’information c. Sinon ...
3. Existe-t-il un fichier avec le chemin et le nom /a.cshtml? Si c'est le cas, exécutez la page et
passer l’information b/c à la page.
Si la recherche n'a trouvé aucune correspondance exacte pour les fichiers .cshtml dans les dossiers
spécifiés, ASP.NET procède à la recherche des fichiers eux-mêmes :
1. /a/b/c/default.cshtml (aucune information de chemin)
2. /a/b/c/index.cshtml (aucune information de chemin).
Remarque: en clair, les demandes de pages spécifiques (c’est-à-dire, qui comprennent l’extension de
fichier .cshtml) fonctionnent exactement comme vous le souhaitez. Une demande telle que
http://www.contoso.com/a/b.cshtml exécutera la page b.cshtml.
A partir d'une page, vous pouvez récupérer les informations du chemin d’accès via la propriété de la
page UrlData, qui est un dictionnaire. Imaginez que vous ayez un fichier nommé
ViewCustomers.cshtml et que votre site reçoive la requête suivante :
http://mysite.com/myWebSite/ViewCustomers/1000
Comme décrit dans les règles ci-dessus, la demande atteindra votre page. A l'intérieur de la page,
vous pouvez utiliser le code suivant pour obtenir et afficher les informations de chemin (dans ce cas,
la valeur «1000»):
<!DOCTYPE html> <html> <head> <title>URLData</title> </head> <body> Customer ID: @UrlData[0].ToString() </body> </html>
Remarque: Puisque le routage ne comporte pas les noms de fichiers complets, il peut y avoir
ambiguïté si vous avez des pages qui ont le même nom mais des noms de fichiers d’extensions
différentes (par exemple MyPage.cshtml et MyPage.html). Pour éviter les problèmes de routage, il
est préférable de vous assurer que votre site ne comporte pas de pages dont les noms ne diffèrent
que par l’extension.
