While testing, you can have emails sent to a folder on your computer instead of an SMTP server.
Put this in your web.config:
<specifiedPickupDirectory pickupDirectoryLocation="c:\Temp\" />
HttpContext.Current always gives you access to the current context's Request/Response/etc., even
when you don't have access to the Page's properties (e.g., from a loosely-coupled
You can continue executing code on the same page after redirecting the user to another one by calling
Response.Redirect(url, false )
You don't need .ASPX files if all you want is a compiled Page (or any IHttpHandler). Just set the path and
HTTP methods to point to the class in the <httpHandlers> element in the
A Page object can be retrieved from an .ASPX file programmatically by calling PageParser.GetCompiledPageInstance(virtualPath,aspxFileName,Context)
Add this to your web.config for much faster compilation (post 3.5SP1).
Retail mode at the machine.config level:
This overrides the web.config settings to enforce debug to false, turns custom errors
on and disables tracing. No more forgetting to change attributes before publishing
- just leave them all configured for development or test environments and update
the production retail setting. Of course, you still want to build in Release
You can use:
To get the value of a control before viewstate is initialized (Control.Text etc will be empty at this point). This is useful for code in Init.
You can use ASP.NET AJAX callbacks to web methods placed in ASPX pages. You can decorate a static method with the [WebMethod()]
and [ScriptMethod()] attributes. For example:
public static List<string> GetFruitBeginingWith(string letter)
List<string> products = new List<string>()
"Apple", "Banana", "Blackberry", "Blueberries", "Orange", "Mango", "Melon", "Peach"
return products.Where(p => p.StartsWith(letter)).ToList();
Now, in your ASPX page you can do this:
<form id="form1" runat="server">
<asp:ScriptManager ID="ScriptManager1" runat="server" EnablePageMethods="true" />
<input type="button" value="Get Fruit" onclick="GetFruit('B')" />
alert("You got fruit: " + result);
Check to see if the client is still connected, before starting a long-running task:
// long-running task
Tag mapping allows you to swap compatible controls at compile time on every page
in your web application. A useful example is if you have a stock ASP.NET control,
such as a DropDownList, and you want to replace it with a customized control
that is derived from DropDownList. This could be a control that has been customized
to provide more optimized caching of lookup data. Instead of editing every web
form and replacing the built in DropDownLists with your custom version, you can
have ASP.NET in effect do it for you by modifying web.config:
You can use ASP.NET Comments within an .aspx page to comment out full parts of a page including server controls.
And the contents that is commented out will never be sent to the client.
<asp:Button runat="server" id="btnOne"/>
The Code Expression Builder
Text = '<%$ Code: GetText() %>'
Text = '<%$ Code: MyStaticClass.MyStaticProperty %>'
Text = '<%$ Code: DateTime.Now.ToShortDateString() %>'
MaxLenth = '<%$ Code: 30 + 40 %>'
The real beauty of the code expression builder is that you can use databinding like
expressions in non-databinding situations. You can also create other Expression
Builders that perform other functions.
<add expressionPrefix="Code" type="CodeExpressionBuilder" />
The cs class that makes it all happen:
public class CodeExpressionBuilder : ExpressionBuilder
public override CodeExpression GetCodeExpression(
return new CodeSnippetExpression(entry.Expression);
This is great for determining which scripts to output (min or full versions) or anything
else you might want in dev, but not in production.
MaintainScrollPositionOnPostback attribute in the @Page directive. It is used to
maintain scroll position of an aspx page across postbacks.
Run ASP.Net outside of IIS or Visual Studio:
The whole runtime is packaged up and ready to be hosted in any process that wants
to give it a try. Using ApplicationHost, HttpRuntime and HttpApplication classes,
you too can grind up those .aspx pages and get shiny HTML output from them.
HostingClass host = ApplicationHost.CreateApplicationHost(typeof(HostingClass),
And your hosting class:
public class HostingClass : MarshalByRefObject
public void ProcessPage(string url)
using (StreamWriter sw = new StreamWriter("C:\temp.html"))
SimpleWorkerRequest worker = new SimpleWorkerRequest(url, null, sw);
It indicates whether current request is coming from Local Computer or not.
if( Request.IsLocal )
By default web form page inherits from System.Web.UI.Page class. There is a way to constraint any page to inherit from a base class. Simply add
a new line on your web.config:
<pages pageBaseType="MyBasePageClass" />