标签：
This article explains how to make site-side settings for pages in an ASP.NET Web Pages (Razor) website.
What you‘ll learn:
For much of the code that you write in ASP.NET Web Pages, an individual page can contain all the code that‘s required for that page. For example, if a page sends an email message, it‘s possible to put all the code for that operation in a single page. This can include the code to initialize the settings for sending email (that is, for the SMTP server) and for sending the email message.
However, in some situations, you might want to run some code before any page on the site runs. This is useful for setting values that can be used anywhere in the site (referred to as global values.) For example, some helpers require you to provide values like email settings or account keys. It can be handy to keep these settings in global values.
You can do this by creating a page named _AppStart.cshtml in the root of the site. If this page exists, it runs the first time any page in the site is requested. Therefore, it‘s a good place to run code to set global values. (Because_AppStart.cshtml has an underscore prefix, ASP.NET won‘t send the page to a browser even if users request it directly.)
The following diagram shows how the _AppStart.cshtml page works. When a request comes in for a page, and if this is the first request for any page in the site, ASP.NET first checks whether a _AppStart.cshtml page exists. If so, any code in the _AppStart.cshtml page runs, and then the requested page runs.
@{
AppState["customAppName"] = "Application Name";
}
This code stores a value in the AppState dictionary, which is automatically available to all pages in the site. Notice that the _AppStart.cshtml file does not have any markup in it. The page will run the code and then redirect to the page that was originally requested.
Note Be careful when you put code in the _AppStart.cshtml file. If any errors occur in code in the _AppStart.cshtml file, the website won‘t start.
<!DOCTYPE html>
<html>
<head>
<title>Show Application Name</title>
</head>
<body>
<h1>@AppState["customAppName"]</h1>
</body>
</html>
This code extracts the value from the AppState object that you set in the _AppStart.cshtml page.
A good use for the _AppStart.cshtml file is to set values for helpers that you use in your site and that have to be initialized. Typical examples are email settings for the WebMail helper and the private and public keys for theReCaptcha helper. In cases like these, you can set the values once in the _AppStart.cshtml and then they‘re already set for all the pages in your site.
This procedure shows you how to set WebMail settings globally. (For more information about using the WebMailhelper, see Adding Email to an ASP.NET Web Pages Site.)
WebMail settings to the _AppStart.cshtml file:
@{
// Initialize WebMail helper
WebMail.SmtpServer = "your-SMTP-host";
WebMail.SmtpPort = 25;
WebMail.UserName = "your-user-name-here";
WebMail.Password = "your-account-password";
WebMail.From = "your-email-address-here";
}
Modify the following email related settings in the code:
your-SMTP-host to the name of the SMTP server that you have access to.your-user-name-here to the user name for your SMTP server account.your-account-password to the password for your SMTP server account.your-email-address-here to your own email address. This is the email address that the message is sent from. (Some email providers don‘t let you specify a different From address and will use your user name as the From address.)
For more information about SMTP settings, see Configuring Email Settings in the article Sending Email from an ASP.NET Web Pages (Razor) Site and Issues with Sending Email in the ASP.NET Web Pages (Razor) Troubleshooting Guide.
@{
var message = "";
try{
if(IsPost){
WebMail.Send(
to: Request.Form["emailAddress"],
subject: Request.Form["emailSubject"],
body:Request.Form["emailBody"]
);
message = "Email sent!";
}
}
catch(Exception ex){
message = "Email could not be sent!";
}
}
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>Test Email</title>
</head>
<body>
<h1>Test Email</h1>
<form method="post">
<p>
<label for="emailAddress">Email address:</label>
<input type="text" name="emailAddress" />
</p>
<p>
<label for="emailSubject">Subject:</label>
<input type="text" name="emailSubject" />
</p>
<p>
<label for="emailBody">Text to send:</label><br/>
<textarea name="emailBody" rows="6"></textarea>
</p>
<p><input type="submit" value="Send!" /></p>
@if(IsPost){
<p>@message</p>
}
</form>
</body>
</html>
The important part of this example is that the settings that you don‘t usually change — like the name of your SMTP server and your email credentials — are set in the _AppStart.cshtml file. That way you don‘t need to set them again in each page where you send email. (Although if for some reason you need to change those settings, you can set them individually in a page.) In the page, you only set the values that typically change each time, like the recipient and the body of the email message.
Just like you can use _AppStart.cshtml to write code before pages in the site run, you can write code that runs before (and after) any page in a particular folder run. This is useful for things like setting the same layout page for all the pages in a folder, or for checking that a user is logged in before running a page in the folder.
For pages in particular folders, you can create code in a file named _PageStart.cshtml. The following diagram shows how the _PageStart.cshtml page works. When a request comes in for a page, ASP.NET first checks for a_AppStart.cshtml page and runs that. Then ASP.NET checks whether there‘s a _PageStart.cshtml page, and if so, runs that. It then runs the requested page.
Inside the _PageStart.cshtml page, you can specify where during processing you want the requested page to run by including a RunPage method. This lets you run code before the requested page runs and then again after it. If you don‘t include RunPage, all the code in _PageStart.cshtml runs, and then the requested page runs automatically.
ASP.NET lets you create a hierarchy of _PageStart.cshtml files. You can put a _PageStart.cshtml file in the root of the site and in any subfolder. When a page is requested, the _PageStart.cshtml file at the top-most level (nearest to the site root) runs, followed by the _PageStart.cshtml file in the next subfolder, and so on down the subfolder structure until the request reaches the folder that contains the requested page. After all the applicable _PageStart.cshtml files have run, the requested page runs.
For example, you might have the following combination of _PageStart.cshtml files and Default.cshtml file:
@* ~/_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"]
When you run /myfolder/default.cshtml, you‘ll see the following:
Red
Yellow
Green
A good use for _PageStart.cshtml files is to initialize the same layout page for all files in a single folder.
@{
// Sets the layout page for all pages in the folder.
Layout = "~/Shared/_Layout1.cshtml";
// Sets a variable available to all pages in the folder.
PageData["MyBackground"] = "Yellow";
}
@{
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">
© 2012 Contoso. All rights reserved
</div>
</body>
</html>
<p>This is content page 1.</p>
<p>This is content page 2.</p>
When the Content1.cshtml page runs, the _PageStart.cshtml file sets Layout and also setsPageData["MyBackground"] to a color. In Content1.cshtml, the layout and color are applied.
The layout is the same, because both pages use the same layout page and color as initialized in_PageStart.cshtml.
Another good use for the _PageStart.cshtml file is to create a way to handle programming errors (exceptions) that might occur in any .cshtml page in a folder. This example shows you one way to do this.
@{
try
{
RunPage();
}
catch (Exception ex)
{
Response.Redirect("~/Error.cshtml?source=" +
HttpUtility.UrlEncode(Request.AppRelativeCurrentExecutionFilePath));
}
}
In this code, you try running the requested page explicitly by calling the RunPage method inside a try block. If any programming errors occur in the requested page, the code inside the catch block runs. In this case, the code redirects to a page (Error.cshtml) and passes the name of the file that experienced the error as part of the URL. (You‘ll create the page shortly.)
@{
var db = Database.Open("invalidDatabaseFile");
}
For purposes of this example, what you‘re doing in this page is deliberately creating an error by trying to open a database file that doesn‘t exist.
<!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>
In this page, the expression @Request["source"] gets the value out of the URL and displays it.
Because an error occurs in Exception.cshtml, the _PageStart.cshtml page redirects to the Error.cshtml file, which displays the message.
For more information about exceptions, see Introduction to ASP.NET Web Pages Programming Using the Razor Syntax.
You can also use the _PageStart.cshtml file to restrict access to all the files in a folder.
@{
Response.CacheControl = "no-cache";
if (!WebSecurity.IsAuthenticated) {
var returnUrl = "~/Account/Login?ReturnUrl=" + Request.Url.LocalPath;
Response.Redirect(returnUrl);
}
}
The code starts by preventing all files in the folder from being cached. (This is required for scenarios like public computers, where you don‘t want one user‘s cached pages to be available to the next user.) Next, the code determines whether the user has signed in to the site before they can view any of the pages in the folder. If the user is not signed in, the code redirects to the login page. The login page can return the user to the page that was originally requested if you include a query string value named ReturnUrl.
@{
Layout = "~/_SiteLayout.cshtml";
Page.Title = "Authenticated Content";
}
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
</head>
<body>
Thank you for authenticating!
</body>
</html>
Customizing Site-Wide Behavior for ASP.NET Web Pages (Razor) Sites
标签：
原文地址：http://www.cnblogs.com/imust2008/p/4520659.html
