ASP.NET Slackers All concepts covered

Change the Permissions Given to ASP.NET Code

2008-10-20T17:38:00.001+05:30

ASP.NET code doesn't run under the IIS authenticated user or the anonymous IUSR_[ServerName] account. Part of the reason is that this account usually won't have sufficient privileges for ASP.NET code, which needs to be able to create and delete temporary files to manage the Web page compilation process.

By default, ASP.NET pages run using the local ASPNET account, which has a carefully limited set of privileges. If you need your ASP.NET code to perform something that is not allowed by default for the local account (writing to the server hard drive or the event log, for example), you can explicitly grant these rights to the ASPNET process. You can also change the setting by editing the machine.config file and modifying the <processModel> tag. You can set the userName and password attributes to any arbitrary user, or you can make use of the built-in local ASPNET process (set userName to Machine and password to AutoGenerate) or local system account (set userName to System and password to AutoGenerate). Because the local system has full rights to the computer, using this account is never recommended except for testing purposes. The ASP.NET account settings are global, and all Web applications will share the account that you specify.

You can also change the account used to execute certain applications or specific code by using impersonation. For example, to configure a single Web application to run under a different user account, add the <identity> tag to the Web.config file, as shown here:


<configuration>
  <system.web>
    <!-- Other settings omitted. -->

    <identity impersonate="true" name="domain\user" password="pwd"/>

  </system.web>
</configuration>

You can also instruct the Web application to use the identity that was authenticated by IIS, which will be the anonymous IUSR_[ServerName] account if you aren't using Windows authentication. Simply add the <identity> tag without supplying any user credentials:


<identity impersonate="true"/>

Remember, for this type of impersonation to work, the user account will require read/write access to the Temporary ASP.NET Files directory where the compiled ASP.NET files are stored. This directory is located under the path C:\[WindowsDirectory]\Microsoft.NET\Framework\[version]\Temporary ASP.NET Files.

Finally, you can also use impersonation programmatically, to change the account used to execute a particular section of code. The following code snippet shows a brief example that works in conjunction with Windows authentication. Provided IIS has authenticated the user, that user identity will be assumed when the WindowsIdentity.Impersonate method is used. To use this code, you must import the System.Security.Principal namespace.


if (User.GetType() == typeof(WindowsPrincipal)) {

    WindowsIdentity id = (WindowsIdentity)User.Identity;
    WindowsImpersonationContext impersonate = id.Impersonate();

    // (Now perform tasks under the impersonated ID.)

    // Revert to the original ID as shown below.
    impersonate.Undo();
} else {

    // User is not Windows authenticated.
    // Throw an error to or take other steps.
}

ASP.Net Enabling Web Site Debugging

2008-10-20T17:36:00.001+05:30

The "unable to start debugging" error signals that Visual Studio .NET was able to compile the Web application but can't execute it in debug mode. Unfortunately, this problem can arise for different reasons, including the following:

IIS, the Windows component that hosts Web applications, is not installed or is installed incorrectly.

The user running Visual Studio .NET is not a member of the Debugger Users group for the Web server.

The user running Visual Studio .NET doesn't have permissions to debug the ASP.NET process. For example, if the ASP.NET process is running under the local system account, the user must have Administrator privileges to debug it.

The Web server is running a version of Windows that doesn't support debugging, such as Microsoft Windows NT and Windows XP Home Edition. (Windows 2000, Windows XP Professional, Windows XP Server, and Windows Server 2003 all support debugging.)

The Web application doesn't have a Web.config file, or the Web.config file doesn't enable debugging.

You're running Visual Studio .NET, and you haven't enabled Integrated Windows authentication for the virtual directory.

The first step that you should take when diagnosing why you can't debug a Web application is to check that IIS is installed on the Web server. To do so, open http://localhost/localstart.asp in your browser. (localhost is an alias for the current computer.) If the test page doesn't appear, IIS is not installed or is not enabled. You can also attempt to start your Web application without debugging by selecting Debug | Start Without Debugging from the Visual Studio .NET main menu. If this test is successful, IIS is correctly installed.

If you installed IIS after you installed Visual Studio .NET or the .NET Framework, you might need to "repair" the .NET Framework by using the original setup CD or DVD. To start this process, type the following command at the command line (or in the Run window), using the Visual Studio .NET DVD. (It's split into two lines below because of page constraints, but it should be entered on a single line.)


<DVD Drive>:\wcu\dotNetFramework\dotnetfx.exe /t:c:\temp 
  /c:"msiexec.exe /fvecms c:\temp\netfx.msi"

If you're using the CD version of Visual Studio .NET, use the following command line with the Windows Component Update disc:


<CD Drive>:\dotNetFramework\dotnetfx.exe /t:c:\temp 
  /c:"msiexec.exe /fvecms c:\temp\netfx.msi"

If IIS is properly installed, the next step is to validate your Web application's Web.config file. The Web.config file should follow the structure shown here:


<configuration>
   <system.web>
      <compilation defaultLanguage="c#"
debug="true" >

   <!-- Other settings omitted. -->

   </system.web>
</configuration>

By default, Visual Studio .NET adds the compilation tag to the automatically generated Web.config file with the debug attribute set to true.

The next step is to verify the IIS configuration. Problems will occur if you fail to create the required virtual application directory or if you try to run a Web application after you've removed or modified the virtual directory. To correct these problems, modify the virtual directory settings in IIS Manager by selecting Control Panel | Administrative Tools | Internet Information Services from the Start menu. Verify that the virtual application directory exists and that it's configured as a Web application. (You can see virtual directory settings by right- clicking the directory and choosing Properties.) For example, in the screen shot shown in the below figure, the virtual directory exists but is not configured as a Web application. To resolve this problem, you simply need to click the Create button in the Application Settings section.

One other IIS configuration problem that can occur in Visual Studio .NET is a failure to authenticate. Visual Studio .NET attempts to access the local Web server using Integrated Windows authentication, even if you have anonymous authentication enabled for the virtual directory. This means that your virtual directory must allow both anonymous and Integrated Windows authentication. To allow both authentication methods, follow these steps:

In IIS Manager, right-click the virtual directory for your application and choose Properties. (Alternatively, you can configure authentication for all directories if you right-click the Web Sites folder and choose Properties.)

Select the Directory Security tab.

In the Anonymous access and authentication control section, click the Edit button.

In the Authentication Methods dialog box, under Authenticated access, select Integrated Windows authentication, as shown in below figure.

Click OK to apply your changes.

ASP.NET Web Service Creation

2008-10-16T13:08:00.001+05:30

To illustrate creating a Web service, this simple example takes a string and returns a

message.To do this, you type in the following code and save it as code01vb.asmx

<%@ WebService Language="vb" Class="codevb" %>

Imports System.Web.Services

Imports System.Text

Public Class code01vb

<WebMethod()> _

Public Function GreetCustomer(ByVal person as String) As String

Dim output As StringBuilder = New StringBuilder()

output.Append("Welcome to Cook Center Mr/Mrs.")

output.Append(Person)

output.Append(" , Hope you are enjoying our examples!!" )

GreetCustomer = output.ToString()

End Function

End Class

Now, you save this file in some Web directory.This is all that is required to create a Web

service! To see how it works, open the file in a Web browser. Microsoft provides a default

test page feature in the .NET Framework for its Web services. In that page, you will see

a GreetCustomer function. Click it, and it will take you to another page.There, you

enter some text and press Invoke. A new window opens with the output in XML

format.

In this class, you create a Web method called GreetCustomer. By adding the <WebMethod()> attribute to a method

within a .ASMX file, you create a Web service. Here, the Key attribute is <WebMethod>.

This WebMethod attribute indicates to the .NET Framework that the specified method

should be made accessible via standard Internet protocols.These Web service methods

should be defined as public, which indicates that they can be accessible from outside

parent class.This Web method has various attributes. This example uses the description

attribute.The following properties are defined for the WebMethod attribute:

BufferResponse-Specifies whether the response for this Web method should be buffered. By default, it is set to True.

CacheDuration-This specifies the number of seconds the Web method response is stored in cache.

Description-Specifies the user-friendly description of the publicWeb method.

EnableSession-Specifies whether session state is enabled for the Web method. Default setting is false.

MessageName-Specifies an alias name for a Web method.This MessageName attribute allows you to provide different names for overloaded methods.

TransactionOption-Specifies the Enterprise service transaction support for the Web method.

ASP.NET Stack Collection

2008-10-16T13:01:00.001+05:30

First, you create a new object of type

System.Collections.Stack called myStack .You

then add items to the stack by using the Push method and passing in the object you

want to add to the top of the stack.You can then retrieve items from the top of the stack .

(remember a stack is last-in-first-out, or LIFO) by using the Pop method.The item is

returned as type of object, so if you need to convert it into a string, as in the following

example, you simply call the ToString() method. Otherwise, you'll need to cast it to

the type of object that you need.

In <script runat="server" /> block or codebehind:

'Make sure System.Collections is imported

Sub Page_Load(sender As Object, e As EventArgs)

Dim myStack As New Stack()

myStack.Push("One")

myStack.Push("Two")

myStack.Push("Three")

While myStack.Count > 0

Response.Write(myStack.Pop().ToString() & "<br>")

End While

End Sub

For more info see:

Stack class-http://msdn.microsoft.com/library/en-us/cpref/html/

frlrfSystemCollectionsStackClassTopic.asp

ASP.NET Queue Collection

2008-10-16T12:56:00.001+05:30

Create a new object of type

System.Collections.Queue called myQueue. Add items to

the queue by using the EnQueue method and passing in the object you want to add to

the queue.You can then retrieve items from the front of the queue (remember a queue

is first-in-first-out, or FIFO) by using the DeQueue method.The item is returned as type

of object, so if you need to convert it into a string as in the following example, you simply

call the ToString() method. Otherwise, you'll need to cast it to the type of object

that you need.

In <script runat="server" /> block or codebehind:

'Make sure System.Collections is imported

Sub Page_Load(sender As Object, e As EventArgs)

Dim myQueue As New Queue()

myQueue.Enqueue("One")

myQueue.Enqueue("Two")

myQueue.Enqueue("Three")

While myQueue.Count > 0

Response.Write(myQueue.Dequeue().ToString() & "<br>")

End While

End Sub

ASP.NETHashTable Collection

2008-10-16T12:51:00.001+05:30

You create a new object of type

System.Collections.HashTable called myHash.

Then, you add keys to the hash table by using the add method and passing in the

name and value of each key.You can then retrieve the values of each key by using

myHash("KeyName").The value is returned as type of object, so if you need to convert it

into a string, as in the following example, you simply call the ToString() method.

Otherwise, you'll need to cast it to the type of object that you need.

The ASPX page is as follows:

<%@Import namespace="System.Collections"%>

<%@Import namespace="System.Drawing"%>

<HTML>

<body>

<asp:Label ID="MyLabel" Runat="server">Sample Text</asp:Label><br>

</form>

</body>

</HTML>

In <script runat="server" /> block or codebehind:

Sub Page_Load(sender As Object, e As EventArgs)

Dim myHash As New Hashtable()

myHash.Add("Red", "#FF0000")

myHash.Add("Green", "#00FF00")

myHash.Add("Blue", "#0000FF")

MyLabel.BackColor=ColorTranslator.FromHtml(myHash("Blue").ToString())

MyLabel.ForeColor=ColorTranslator.FromHtml(myHash("Red").ToString())

End Sub

ASP.NET Creating Custom Collection

2008-10-16T12:46:00.001+05:30

A custom collection class allows the use of the

For Each syntax (foreach in C#) to

loop through a set of custom typed items.The custom collection class must internally

keep references to the items with an array or other type of collection (ArrayList,

HashTable).The .NET Framework then requires the following two interfaces to be

implemented in order to support the For Each syntax:

System.Collections.IEnumerable

Function GetEnumerator() As IEnumerator

System.Collections.IEnumerator

Sub Reset()

Function MoveNext() As Boolean

ReadOnly Property Current As Object

In <script runat="server" /> block or codebehind:

Sub Page_Load()

Dim _customCollection As CustomCollection

Dim _customItem As CustomItem

Dim _index As Integer

_customCollection = New CustomCollection(10)

For Each _customItem In _customCollection

_index = _customItem.Index

End Sub

Custom Collection defined in CustomCollection.vb

Public Class CustomCollection

Implements IEnumerable, IEnumerator

Private customItems() As CustomItem

Private currentIndex As Integer = -1

Public Sub New(ByVal Count As Integer)

Dim index As Integer

ReDim customItems(Count - 1)

For index = 0 To Count - 1

customItems(index) = New CustomItem(index)

End Sub

#Region "Implementation of IEnumerable"

Public Function GetEnumerator() As Ienumerator

➥Implements IEnumerable.GetEnumerator

Return CType(Me, IEnumerator)

End Function

#End Region

#Region "Implementation of IEnumerator"

Public Sub Reset() Implements IEnumerator.Reset

currentIndex = -1

End Sub

Public Function MoveNext() As Boolean Implements IEnumerator.MoveNext

If currentIndex < customItems.Length - 1 Then

currentIndex = currentIndex + 1

Return True

Else

Return False

End If

End Function

Public ReadOnly Property Current() As Object

➥Implements IEnumerator.Current

Get

Return customItems(currentIndex)

End Get

End Property

#End Region

End Class

Custom Item defined in CustomItem.vb

Public Class CustomItem

Private _index As Integer

Public ReadOnly Property Index() As Integer

Get

Return _index

End Get

End Property

Public Sub New(ByVal Index As Integer)

_index = Index

End Sub

End Class

This implementation uses a simple array of the CustomItem type and offers nothing

beyond the For Each support. It can be easily extended to support additional array or

ArrayList methods, such as Count/Length and Item.The base collection type can also

be changed to ArrayList or HashTable for further functionality.

This implementation of the CustomItem type is no more than a contrived example

with a single property of Index. It should be extended to include the various properties

and methods relevant to the actual custom item.The construction of the item, or set of

items, can also come from an external data store.

How to Declare Collections in ASP.NET

2008-10-16T12:00:00.001+05:30

The .NET Framework includes a number of commonly used collections.They are found in the

System.Collections namespace, and can hold any object type, which means they

can hold any type, because in .NET, all types inherit from object.This example demonstrates

this using a simple array list.

Sub Page_Load (Sender As Object, E As EventArgs)

Dim al As New ArrayList(5)

al.Add("one")

al.Add(2)

al.Add(False)

al.Add(New System.Object())

Response.Write("Successfully added " & al.Count & _

" different types of objects to an ArrayList.")

End Sub

Declaring and using collections in .NET is very straightforward. Later in this chapter,

you'll learn how to use some of the different collections included in the framework, as

well as how to create your own strongly typed collections.

Load User Controls Programmatically

2008-10-10T00:00:00.001+05:30

User controls are self-contained groups of controls. Like Web forms, user controls consist of a layout portion that defines the contained controls (.ascx file) and a code-behind portion with the event-handling logic (.cs file). User controls allow you to reuse common interface elements on multiple pages and build complex interfaces out of smaller building blocks. One useful characteristic of user controls is that they can be loaded programmatically, which allows you to create a highly configurable interface that you can tailor dynamically according to the user. You simply load the control, configure its properties, and then add it to another container control.

The basic solution could be implemented in a more object-oriented way by creating a custom user control that encapsulates the dynamic graphic. The user control could allow the page to set the text, font, colors, and so on through various properties. Here's an example of what the custom control would look like:


using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Drawing;
using System.Drawing.Drawing2D;

public class DynamicGraphicControl : System.Web.UI.UserControl {

    // (Designer code omitted.)

    private string imageText = "";
    public string ImageText {
        get {
            return imageText;
        }
        set {
            imageText = value;
        }
    }

    private Font textFont;
    public Font TextFont {
        get {
            return textFont;
        }
        set {
            textFont = value;
        }
    }

    private Size imageSize;
    public Size ImageSize {
        get {
            return imageSize;
        }
        set {
            imageSize = value;
        }
    }

    private Color foreColor;
    public Color ForeColor {
        get {
            return foreColor;
        }
        set {
            foreColor = value;
        }
    }

    private Color backColor;
    public Color BackColor {
        get {
            return backColor;
        }
        set {
            backColor = value;
        }
    }

    private Color borderColor;
    public Color BorderColor {
        get {
            return borderColor;
        }
        set {
            borderColor = value;
        }
    }

    private void Page_Load(object sender, System.EventArgs e) {

        if (ImageText == "")
            return;

        // Create an in-memory bitmap where you will draw the image. 
        Bitmap bitmap = new Bitmap(ImageSize.Width, ImageSize.Height);

        // Get the graphics context for the bitmap.
        Graphics graphics = Graphics.FromImage(bitmap);

        // Set the background color and rendering quality.
        // This color will become the border
        graphics.Clear(BorderColor);
        graphics.SmoothingMode = SmoothingMode.AntiAlias;

        // Paint a rectangle.
        graphics.FillRectangle(new SolidBrush(BackColor), 5, 5, 
          ImageSize.Width - 10, ImageSize.Height - 10);

        // Set the alignment for the text.
        StringFormat stringFormat = new StringFormat();
        stringFormat.Alignment = StringAlignment.Center;
        stringFormat.LineAlignment = StringAlignment.Center;

        // Paint the text.
        graphics.DrawString(ImageText, TextFont, new SolidBrush(ForeColor), 
          new Rectangle(0, 0, ImageSize.Width, ImageSize.Height), 
          stringFormat);

        // Render the image to the HTML output stream.
        bitmap.Save(Response.OutputStream, 
        System.Drawing.Imaging.ImageFormat.Gif);

        graphics.Dispose();
        bitmap.Dispose();
    }
}

The Web form loads this user control in the Page.Load event handler. The user control is placed in a Panel control container. The LoadControl method returns a generic Control object, which the code casts to the appropriate user control class.


using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Drawing;

public class DynamicControlTest : System.Web.UI.Page {

    protected System.Web.UI.WebControls.Panel pnl;

    // (Designer code omitted.)

    private void Page_Load(object sender, System.EventArgs e) {

        // Load the control. 
        DynamicGraphicControl ctrl;
        ctrl = (DynamicGraphicControl)
          Page.LoadControl("DynamicGraphicControl.ascx");

        // Configure the control properties.
        ctrl.ImageText = "This is a new banner test";
        ctrl.ImageSize = new Size(300, 200);
        ctrl.TextFont = new Font("Verdana", 24, FontStyle.Bold);
        ctrl.BackColor = Color.Olive;
        ctrl.ForeColor = Color.LightYellow;
        ctrl.BorderColor = Color.OrangeRed;

        // Add the control to the page.
        pnl.Controls.Add(ctrl);
    }
}

In Visual Studio .NET, the user control class is always available because classes are compiled into a single .dll assembly. If the user control is not a part of the project, however, you won't have the required user control class and you won't be able to access any of the user control's properties or methods. To remedy this problem, you can define a base class or an interface that defines the basic functionality you need to be able to access in any of your custom user controls.

Technorati : Loading User Controls ASP.NET

Dynamically Render an Image

2008-10-09T23:56:00.001+05:30

You can draw dynamic graphics using the same GDI+ code in a Web application that you'd use in a Windows-based application. The only difference is how you render the final graphic. There are basically two approaches that you can use.

You can stream the binary contents of the image directly to the OutputStream property of the HttpResponse object. This is a good approach if you need to generate a wide range of images and don't want to clutter the server hard drive with image files that won't be used again. It's also the best choice if you need to create dynamic images that are tailored to match user input.

You can save the image to the Web server's file system and use an HTML <img> tag to display the created image. This is a good choice if you need to create a graphic that will be reused because it will avoid the overhead of continuously re-creating the graphic.

This post explores both approaches. First we'll consider how to dynamically create an image without saving it to a file. In this example, the goal is to create a simple banner

You'll notice that the only user-supplied value in this example is the banner text itself, which is supplied through the query string. The font, colors, and dimensions are hard-coded (although they could easily be set based on other query string parameters or Web.config defaults).

Here's the full page code:


using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Drawing;
using System.Drawing.Drawing2D;

public class DynamicGraphic : System.Web.UI.Page {

    // (Designer code omitted.)

    private void Page_Load(object sender, System.EventArgs e) {
    
        // Get the text from the query string.
        // If no text is supplied, choose a default.
        string text = "";
        if (Request.QueryString["image"] == null) {
        
            Response.Redirect(Request.Url + "?image=" +
            Server.UrlEncode("This is a test image"));
        }
        else {
            text = Server.UrlDecode(Request.QueryString["image"]);
        }

   // Create an in-memory bitmap where you will draw the image. 
            // The Bitmap is 300 pixels wide and 200 pixels high.   
            int width = 300, height = 200;
            Bitmap bitmap = new Bitmap(width, height);

            // Get the graphics context for the bitmap.
            Graphics graphics = Graphics.FromImage(bitmap);

            // Set the background color and rendering quality.
            // This color will become the border
            graphics.Clear(Color.OrangeRed);
            graphics.SmoothingMode = SmoothingMode.AntiAlias;

            // Paint a rectangle.
            graphics.FillRectangle(new SolidBrush(Color.Olive), 5, 5, 
              width - 10, height - 10);

            // Choose a font and alignment for the text.
            Font fontBanner = new Font("Verdana", 24, FontStyle.Bold);
            StringFormat stringFormat = new StringFormat();
            stringFormat.Alignment = StringAlignment.Center;
            stringFormat.LineAlignment = StringAlignment.Center;

            // Paint the text.
            graphics.DrawString(text, fontBanner, new 
            SolidBrush(Color.LightYellow), new Rectangle(0, 0, width, height), 
              stringFormat);

            // Render the image to the HTML output stream.
            bitmap.Save(Response.OutputStream, 
              System.Drawing.Imaging.ImageFormat.Gif);

            graphics.Dispose();
            bitmap.Dispose();
        }
    }
}

When you save an image to the response stream, you replace any other output. Therefore, you can't use this technique with a page that also includes Web controls or static HTML content. Thus, if you want to use a page that combines dynamically generated images and Web controls, you need to wrap the dynamically generated image in a control or write the image to the hard drive before displaying it.

If you want to save the file to the hard drive, you move the image generation code into a separate method, which we'll call GenerateBanner. Then, in the Page.Load event handler, you begin by checking to see whether the file already exists by using the static File.Exists method. If the file doesn't exist, you generate it in memory by calling GenerateBanner and save it using the Bitmap.Save method. Otherwise, you simply load the image directly.

The following code shows the basic approach you must take:


using System;
using System.IO;
using System.Web;
using System.Web.UI.WebControls;
using System.Drawing;
using System.Drawing.Drawing2D;

public class DynamicGraphic : System.Web.UI.Page {

    protected System.Web.UI.WebControls.Image imageControl;

    // (Designer code omitted.)

    private Bitmap GenerateBanner() {
    
        // Create the image using the same code as in the previous example.
        // (Code omitted.)
    }    

    private void Page_Load(object sender, System.EventArgs e) {
    
        // Set the filename based on the image text.
        // We assume this only includes characters that are
        // legal for a filename.
        string fileName = Request.QueryString["image"] + ".gif";

        Bitmap bitmap = null;

        // Check if an image with this text already exists.
        if (File.Exists(fileName)) {

            // Load the existing image.
            try {
                bitmap = new Bitmap(fileName);
            }catch {
                bitmap = GenerateBanner();
            }
        }
        else {
            bitmap = GenerateBanner();

            // Save the image.
            bitmap.Save(fileName, System.Drawing.Imaging.ImageFormat.Gif);
        }

        // Display the image by setting an Image property.
        imageControl.ImageUrl = fileName;
    }
}

Technorati : Rending Image in ASP.NET

Add Controls to Web Form Dynamically

2008-10-09T23:51:00.001+05:30

You can use a technique to add Web controls to a Web page that's similar to the way you would add Windows controls to a form, but there are some differences, including the following:

Dynamically added controls will exist only until the next postback. If you need them, you must re-create them when the page is returned. This requirement doesn't prevent you from writing code that handles their events, however.

Dynamically added controls aren't as easy to position. Typically, you'll use literal controls containing HTML code (such as the line break <br>) to separate more than one dynamically created control.

Dynamically created controls should be placed in a container control (such as a Panel or a LiteralControl) rather than directly on the page itself, which makes it easier to position them.

If you want to interact with the control later, you should give it a unique ID. You can use this ID to retrieve the control from the Controls collection of its container.

The best place to generate new controls is in the Page.Load event handler, which ensures that the control will be created each time the page is served. In addition, if you're adding an input control that uses view state, the view state information will be restored to the control after the Page.Load event fires. That means a dynamically generated text box will retain its text over multiple postbacks, just like a text box that's defined in the .aspx file. Similarly, because the Page.Load event always fires before any other events take place, you can re- create a control that raises server-side events and its event-handling code will be triggered immediately after the Page.Load event. For example, this technique allows you to dynamically generate a button that can respond to user clicks.

The following example demonstrates all these concepts. It generates three dynamic server controls (two buttons and a text box) and positions them using literal controls that act as separators. The buttons are connected to distinct event handlers. The text box is given a unique identifier so that its text can be retrieved later, in response to the button clicks.

The full code is shown here:


using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.Security;

public class DynamicControls : System.Web.UI.Page {

    protected System.Web.UI.WebControls.Label lblMessage;
    protected System.Web.UI.WebControls.Panel pnl;

    // (Designer code omitted.)

    private void Page_Load(object sender, System.EventArgs e) {
    
        // Create a dynamic button.
        Button dynamicButton = new Button();
        dynamicButton.Text = "Dynamic Button A";

        // Connect an event handler.
        dynamicButton.Click += new EventHandler(cmdDynamicA_Click);

        // Add the button to a Panel.
        pnl.Controls.Add(dynamicButton);
            
        // Add a line break separator.
        pnl.Controls.Add(new LiteralControl("<br>"));

        // Create a second dynamic button.
        dynamicButton = new Button();
        dynamicButton.Text = "Dynamic Button B";
        dynamicButton.Click += new EventHandler(cmdDynamicB_Click);
        pnl.Controls.Add(dynamicButton);

        // Add a line break separator.
        pnl.Controls.Add(new LiteralControl("<br><br>"));

        // Create a dynamic textbox.
        TextBox dynamicText = new TextBox();
        pnl.Controls.Add(dynamicText);

        // Assign a unique ID so the textbox can be retrieved
        // from the control collection later.
        dynamicText.ID = "DynamicText";
    }

    private void cmdDynamicA_Click(object sender, System.EventArgs e) {
    
        lblMessage.Text = "Clicked A";
        GetText();
    }
    
    private void cmdDynamicB_Click(object sender, System.EventArgs e) {
    
        lblMessage.Text = "Clicked B";
        GetText();
    }

    private void GetText(){
        lblMessage.Text += "<br><br>";

        foreach (Control ctrl in pnl.Controls){
            if (ctrl.ID == "DynamicText"){
                lblMessage.Text += "TextBox contains: " +
                  ((TextBox)ctrl).Text;
            }
        }
    }
}

If you need to dynamically create complex layouts that include some prebuilt control "groups," you might prefer to use user controls and load them dynamically into a page.

Technorati : Adding Controls ASP.NET form

Perform Selective Input Validation

2008-10-09T23:46:00.001+05:30

The ASP.NET validation controls are an ideal solution for quickly validating forms. They work well as long as you want to validate an entire page at a time. If you want to validate only part of a form, or you want to make a programmatic decision about whether to validate a control (perhaps based on the validation success or value of another control), you'll need to use selective validation.

The first step in selective validation is to disable the EnableClientScript property of every validation control on your page. Otherwise, validation will be performed at the client through JavaScript, the page won't be posted back if it contains invalid values, and your event handling code won't be executed. Once you've made this change, you can validate the page one control at a time using the BaseValidator.Validate method, or you can validate the entire page using the Page.Validate method.

The following example uses server-side validation with two validators: a RangeValidator and a RegularExpressionValidator (which validates an e-mail address). If validation fails, the code steps through the collection of validators on the form using the Page.Validators property. Every time the code finds a failed validator, it finds the corresponding control using the Page.FindControl method and then displays the offending value (a trick that's not possible with automatic validation).


using System;
using System.Web;
using System.Web.UI.WebControls;

public class SelectiveValidation : System.Web.UI.Page {

    protected System.Web.UI.WebControls.TextBox txtNumber;
    protected System.Web.UI.WebControls.TextBox txtEmail;
    protected System.Web.UI.WebControls.Label lblCustomSummary;
    protected System.Web.UI.WebControls.RegularExpressionValidator
      validatorEmail;
    protected System.Web.UI.WebControls.RangeValidator validatorNumber;
    protected System.Web.UI.WebControls.Button cmdValidate;

    // (Designer code omitted.)

    private void cmdValidate_Click(object sender, System.EventArgs e) {
    
        // Validate the page.
        this.Validate();

        if (!Page.IsValid) {
        
            lblCustomSummary.Text = "";
            foreach (BaseValidator validator in this.Validators) {
            
                if (!validator.IsValid) {
                
                    TextBox invalidControl = (TextBox)
                      this.FindControl(validator.ControlToValidate);

                    lblCustomSummary.Text +=
                      "The page contains the following error: <b>" +
                      validator.ErrorMessage + "</b>.<br>" +
                      "The invalid input is: <b>" +
                      invalidControl.Text + "</b>." + "<br><br>";
                }
            }

        }else {
            lblCustomSummary.Text = "Validation succeeded.";
        }
    }
}

Use Forms Authentication

2008-10-06T13:02:00.006+05:30

To prevent users from accessing certain pages unless they have first authenticated themselves with a custom logon page.

Forms authentication is a flexible security model that allows you to prevent unauthenticated users from accessing certain pages. You write the code that performs the authentication, and ASP.NET issues a cookie to authenticated users. Users without the cookie are redirected to a login page when they try to access a secured page.

To implement forms authentication, you must take the following steps:

Configure forms authentication using the <authentication> tag in the application's Web.config file.
Restrict anonymous users from a specific page or directory using Web.config settings.
Create the logon page, and add your authentication logic, which leverages the FormsAuthentication class from the System.Web.Security namespace.

The first step is to configure the Web.config in the root application directory to enable forms authentication, as shown in the following code. You also need to specify your custom login page (where unauthenticated users will be redirected) and a time-out after which the cookie will be removed. The authentication cookie is automatically renewed with each Web request.






<authentication mode="Forms">
<forms loginUrl="login.aspx" timeout="30" />
</authentication>

Next you need to add an authorization rule denying anonymous users. The easiest way to secure pages is to create a subdirectory with its own Web.config file. The Web.config file should refuse access to anonymous users, as shown here:

  


<authorization>
<deny users="?" />
</authorization>

Now ASP.NET will automatically forward unauthenticated requests for pages in this subdirectory to the custom logon page.

Another option is to specifically deny access to specific pages in the current directory by using the <location> tag:

  




<location path="SecurePage.aspx">
<system.web>
<authorization>
<deny users="?" />
</authorization>
</system.web>
</location>

You can also deny specific users by entering a comma-separated list of user names instead of the wildcard (?) character, which simply means "all anonymous users."

You need to create the logon page. Your logon page can authenticate the user using a hard-coded password (suitable for simple tests), a server-side database, or any other type of custom authentication logic. Once the user has been successfully authenticated, call the static FormsAuthentication.RedirectFromLoginPage method with the username. This method simultaneously sets the forms authentication cookie and redirects the user to the originally requested page.

Here's a rudimentary logon page that simply checks for a specific password when the user clicks a logon button:

using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Web.Security;

public class LoginPage : System.Web.UI.Page {

protected System.Web.UI.WebControls.Label lblStatus;
protected System.Web.UI.WebControls.Button cmdLogin;
protected System.Web.UI.WebControls.TextBox txtPassword;
protected System.Web.UI.WebControls.TextBox txtName;

// (Designer code omitted.)

private void cmdLogin_Click(object sender, System.EventArgs e){
if (txtPassword.Text.ToLower() == "secret") {
FormsAuthentication.RedirectFromLoginPage(txtName.Text, false);

}else {
lblStatus.Text = "Try again.";
}
}
}

To test this page with the sample code that accompanies the book, request SecurePage.aspx, which is placed in a secured directory. You'll be redirected to login.aspx, and provided you submit the correct password, you'll be returned to SecurePage.aspx.

Technorati : Forms Authentication

Using IIS Authentication

2008-10-06T12:52:00.003+05:30

To prevent users from accessing certain pages unless they have been authenticated against a Windows user account on the server.

IIS and ASP.NET use a layered security model. When a user requests an ASP.NET Web page over HTTP, the following steps take place:

IIS attempts to authenticate the user. If anonymous access is enabled, IIS automatically logs the user on as the anonymous user (typically the IUSR_[ServerName] account). Otherwise, it requests authentication credentials that it will use to log the user on with another Windows account.
Provided IIS can authenticate the user successfully, it passes the request to ASP.NET with information about the authenticated user. ASP.NET can then use its own security services based on the settings in the Web.config file (for example, denying specific users or groups access to certain pages or directories). In addition, your code can restrict actions programmatically by checking the user information.
If the ASP.NET code accesses any system resources (for example, tries to open a file or connect to a database), the Windows operating system performs its own security checks. Usually, the ASP.NET application code won't actually run under the account of the authenticated user. Thus, these security checks are made against the ASP.NET process account (which is configured using the machine.config file).

The first step to use IIS authentication is to disable anonymous access for the virtual directory. To do so, start IIS Manager (select Settings | Control Panel | Administrative Tools | Internet Information Services from the Start Menu). Then right-click a virtual directory or a subdirectory inside a virtual directory, and choose Properties. Select the Directory Security tab, as shown in below figure.

Next, click the Edit button to modify the directory security settings. The window shown below figure will appear. In the bottom half of the window, you can enable one of the Windows authentication methods. However, none of these methods will be used unless you explicitly clear the Anonymous Access check box.

You can enable more than one authentication method, in which case the client will use the strongest supported method. If anonymous access is enabled, it's always used. The different authentication methods are described in Table 7. 2.

Table 7.2: Types of Authentication
Mode	Description
Anonymous	The client is not required to submit any information. Users are logged in using the preset anonymous account (typically IUSR_[ServerName]).
Basic	Basic authentication is a part of the HTTP 1.0 standard, and it is supported by almost all browsers and Web servers. When using basic authentication, the browser presents the user with a login box with a user name and password field. This information is then transmitted to IIS, where it is matched with a local Windows user account. Basic authentication should always be combined with SSL because it doesn't encrypt the logon information before transmitting it.
Digest	Digest authentication sends a digest (also known as a cryptographic hash) over the network. Thus, it's much more secure than Basic authentication because intercepted logon information can't be reused. The primary disadvantage is that Digest authentication is supported only by Internet Explorer 5.0 and later versions. Also, your Web server needs to use Active Directory or have access to an Active Directory server.
Integrated	Integrated Windows authentication is the best choice for most intranet scenarios. When using integrated authentication, Internet Explorer sends the logon token for the current user automatically, provided it is on a trusted domain. Integrated authentication is supported only on Internet Explorer 2.0 and later and can't work over proxy servers.

Once you've enabled the appropriate virtual directory security settings, you should make sure that the Web.config file is set to use Windows authentication. In a Visual Studio .NET project, this is the default setting.

<configuration>
<system.web>
<!-- Other settings omitted. -->
<authentication mode="Windows" />
</system.web>
</configuration>

At this point, your virtual directory will require user authentication and your Web application will be able to retrieve the user information. In addition, you can add authorization rules that prevent certain users or groups from accessing Web pages or subdirectories. You do this by adding <allow> and <deny> tags to the <authorization> section of the Web.config file. For example, you can create a subdirectory with the following Web.config file contents:

<configuration>
<system.web>

<authorization>
<deny roles="Guest,Associate" />
<allow users="matthew" />
<deny users="*" />
</authorization>

</system.web>
</configuration>

ASP.NET examines rules in the order they appear and stops when it finds a match. In this example, users in the Guest or Associate groups will automatically be denied. The user matthew will be permitted (unless he's a member of one of the previously forbidden groups). All other users will be denied. In this case, these are local groups and user accounts. If you want to refer to a domain account, use the pathlike syntax [DomainName]\[UserName] instead.

Notice that in this example, the Web.config file doesn't contain an <authentication> section. This omission is because the authentication is configured in the Web.config file in the Web application directory. Subdirectories can set their own authorization rules, but they can't change the mode of authentication.

Another option is to deny access to specific pages using the <location> attribute:

<configuration>  
<system.web>
<!-- Other settings omitted. -->
</system.web>

<location path="SecurePage.aspx">
<system.web>
<authorization>
<deny roles="Guest" />
</authorization>
</system.web>
</location>

</configuration>

Finally, you can write your own authorization logic by examining the user identity in your Web page code using the Page.User property, which provides a WindowsPrincipal object. You can retrieve the user name from the WindowsPrincipal.Identity.Name property, and you can test group membership using the WindowsPrincipal.IsInRole method. The following Web page code demonstrates these techniques:

using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Web.Security.Principal;

public class WindowsSecurityTest : System.Web.UI.Page {

protected System.Web.UI.WebControls.Label lblMessage;

// (Designer code omitted.)

private void Page_Load(object sender, System.EventArgs e) {

// Get the IIS-authenticated identity.
WindowsIdentity identity = (WindowsIdentity)User.Identity;

// Test if it is an Administrator.
bool isAdmin = User.IsInRole(@"BUILTIN\Administrators");

// Display some information about the identity.
lblMessage.Text = "You have reached the secured page, " +
User.Identity.Name + "." +
"<br><br>Authentication Type: " +
identity.AuthenticationType.ToString() +
"<br>Anonymous: " + identity.IsAnonymous.ToString() +
"<br>Authenticated: " + identity.IsAuthenticated.ToString() +
"<br>Guest: " + identity.IsGuest.ToString() +
"<br>System: " + identity.IsSystem.ToString() +
"<br>Administrator: " + isAdmin.ToString();
}
}

Technorati : IIS Authentication

Allow User to Upload File

2008-10-06T12:48:00.001+05:30

Because ASP.NET executes on the server, there is no way to access any of the resources on the client computer, including files. However, you can use the System.Web.UI.HtmlControls.HtmlInputFile control to allow a user to upload a file. This control renders itself as the HTML <input type="file"> element, which is displayed as a Browse button and a text box that contains a filename. The user clicks the Browse button and chooses a file. This step takes place automatically and doesn't require any custom code. The user must then click another button (which you must create) to start the actual upload process.

Before you can create a working file upload page, you need to take these steps:

You must set the encoding type of the form to multipart/form-data. To make this change, find the <form> tag in your .aspx file and modify it as shown here:

You need to add the HtmlInputFile control. In Microsoft Visual Studio .NET, you'll find this control under the HTML tab of the Toolbox, with the name File Field. Once you've added this control, you must right-click it and choose Run As Server Control, which creates the required <input type="file" runat="server"> tag.

You must add another button that actually starts the file transfer using the specified file by calling the HtmlInputFile.PostedFile.SaveAs method.

Figure 7.3 shows a sample page that allows file uploading. It includes an HtmlInputFile control and uses the following code:


using System;
using System.Web;
using System.Web.UI.WebControls;
using System.IO;

public class UploadPage : System.Web.UI.Page {

    protected System.Web.UI.WebControls.Label lblInfo;
    protected System.Web.UI.WebControls.Button cmdUpload;
    protected System.Web.UI.HtmlControls.HtmlInputFile FileInput;

    // (Designer code omitted.)

    private void cmdUpload_Click(object sender, System.EventArgs e) {

        if (FileInput.PostedFile.FileName == "") {

            // No file was submitted.
            lblInfo.Text = "No file specified.";

}else {

            try {

                if (FileInput.PostedFile.ContentLength > 1048576) {

                    // Forbid files larger than one megabyte.
                    lblInfo.Text = "File is too large.";

                }else {
                    
                    // The saved file will retain its original filename.
                    string fileName = 
                      Path.GetFileName(FileInput.PostedFile.FileName);

                    // The ASP.NET process must have rights for the location
                    // where it is attempting to save the file, or an
                    // "access denied" exception will occur.
                    FileInput.PostedFile.SaveAs(fileName);
                    lblInfo.Text = "File " + fileName + " uploaded.";
                }
            }catch (Exception err) {

                lblInfo.Text = err.Message;
            }
        }
    }
}




The code can check various properties of the submitted file, including its size, before saving it, which allows you to prevent a denial of service attack that tricks an ASP.NET application into filling the hard disk with large files. However, this code doesn't prevent a user from submitting the file in the first place, which can still slow down the server and be used to launch a different type of denial of service attack-one that works by tying up all free ASP.NET worker threads. To prevent this type of attack, use the <httpruntime> tag in the Web.config file to specify a maximum file size. Specify the maximum, in kilobytes, using the maxRequestLength attribute.


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.web>

    <httpRuntime maxRequestLength="4096" />
<!-- Other settings omitted. -->

  </system.web>
</configuration>




If you don't specify a maximum length, the default value of 4096 (4 megabytes) will apply. If the user attempts to submit a file that's too large, an exception will be thrown immediately when the page is posted back.

Technorati : Uploading a File

Programmatically Set Control Focus

2008-10-06T12:45:00.001+05:30

The ASP.NET Web controls don't provide any way to programmatically set control focus. They do provide a TabIndex property that allows you to set the tab order, but this property applies only to Microsoft Internet Explorer and can't be used to programmatically set the focus to the control of your choice. To overcome this limitation, you need to add a little snippet of JavaScript code.

The following subroutine generalizes this task. It accepts a reference to any control object, retrieves the associated client ID (which is the ID that the JavaScript code must use to refer to the control), and then builds and registers the startup script for setting the focus.


private void SetFocus(Control ctrl) {

    // Define a JavaScript statement that will move focus to
    // the desired control.
    string setFocus = "<script language='javascript'>" +
        "document.getElementById('" + ctrl.ClientID +
        "').focus();</script>";

    // Add the JavaScript code to the page.
    this.RegisterStartupScript("SetFocus", setFocus);
}

If you add this subroutine to a Web form, you can call SetFocus as needed. Here's an example that sets the focus when the page first loads:


private void Page_Load(object sender,
  System.EventArgs e) {

    if (!this.IsPostBack) {
        // Move to a specific text box the first time the page loads.
        SetFocus(TextBox1);
    }
}

Technorati : Setting Control Focus

Pop-Up Window with JavaScript

2008-10-02T16:45:00.001+05:30

Because all ASP.NET code executes on the server, there is no way to show a new window from your C# page code. You can add URL hyperlinks to a page that will automatically open in a new window by setting the target attribute of the anchor tag to _blank, but this still doesn't give you the ability to control the window size or style.

The solution is to use client-side JavaScript code to open the secondary window. The secondary window itself could be an HTML page, an ASP.NET page, an image file, or any other type of resource that can be opened in the client's browser. To open a secondary window, you use the window.open function and specify three parameters. The first parameter is the link for the new page, the second is the frame name of the window, and the third is a comma- separated string of attributes that configure the style and size of the pop-up window. These attributes can include the following:

The height and width attributes, which are set to pixel values.

The toolbar, menuBar, and scrollbars attributes, which can be set to yes or no depending on whether you want to display these elements.

The resizable attribute, which can be set to yes or no depending on whether you want a fixed or resizable window border.

The following example shows how you can configure an ASP.NET Button so that it opens a second ASP.NET page in a pop-up window when clicked. Typically, you would add this code to the Page.Load event handler.


string popupScript = "window.open('PopUp.aspx', " +
  "'CustomPopUp', " +
  "'width=200, height=200, menubar=yes, resizable=no')";

cmdPopUp.Attributes.Add("onClick", popupScript);

Here's the code you would use to show a pop-up window automatically when the page is displayed. This code would also go in the Page.Load event handler.


string popupScript = "<script language='javascript'>" +
  "window.open('PopUp.aspx', " +
  "'CustomPopUp', " +
  "'width=200, height=200, menubar=yes, resizable=no')" +
  "</script>";

Page.RegisterStartupScript("PopupScript", popupScript);

Technorati : ASP.NET Pop up window

Respond to Client-Side Events with JavaScript

2008-10-02T16:43:00.001+05:30

ASP.NET includes a rich programming model. Unfortunately, once a page is rendered to HTML, you can't execute any more .NET code without first triggering a postback to the server. This limitation greatly reduces the effectiveness of validation code and other niceties that can support polished interactive Web pages.

Of course, there's no reason that you can't mingle client-side JavaScript functionality with your .NET code. Although .NET doesn't include any object interface for creating JavaScript, you can manually inject it into the page. One way to do this is simply to set a control attribute. For example, you can create a text box that displays a message box when it loses focus by including the following JavaScript code:


TextBox1.Attributes.Add("onBlur", "alert('The text box has lost focus!');");

The TextBox tag will be rendered to HTML like this:


<input name="TextBox1" type="text" id="TextBox1"
 onBlur="alert('The text box has lost focus!');"  ... />

In this case, you're using the built-in JavaScript alert function and the JavaScript onBlur event, which fires when a control loses focus. Most HTML elements support a small number of events, and some of the most useful include the following:

onFocusOccurs when a control receives focus

onBlurOccurs when focus leaves a control

onClickOccurs when the user clicks a control

onChangeOccurs when the user changes the value of certain controls

onMouseOverOccurs when the user moves the mouse pointer over a control

Another approach to adding JavaScript code is to define a JavaScript function in a .NET string variable and then to instruct ASP.NET to insert it into the rendered Web form where it can be used. If you follow this approach, any control can call the function in response to a JavaScript event.

The following example demonstrates this technique with a simple Web page that includes a table and an image. As the user moves the mouse over the cells in the table, two custom JavaScript functions are used, one that highlights the current cell and one that removes the highlight from the previous cell. In addition, the highlighting function changes the image URL depending on which table column is currently selected. If the user hovers the mouse over the first column, an animated GIF of a happy face is shown. If the user hovers the mouse over the second or third column, an animated GIF of a book with a flashing question mark is shown instead.


using System;
using System.Web;
using System.Web.UI.WebControls;

public class JavaScriptTest : System.Web.UI.Page {

    protected System.Web.UI.WebControls.Table Table1;
    protected System.Web.UI.WebControls.Image Image1;

    // (Designer code omitted.)

    private void Page_Load(object sender, System.EventArgs e) {

        // Define the JavaScript functions.
        string highlightScript = 
            "<script language=JavaScript> " +
            "function HighlightCell(cell) {" +
            "cell.bgColor = '#C0C0C0';" +
            "if (cell.cellIndex == 0)"+
            "{document.Form1.Image1.src='happy_animation.gif';}"+
            "else {document.Form1.Image1.src='question_animation.gif';}" +
            ";}" +
            "</script>";

        string unhighlightScript = 
            "<script language=JavaScript> " +
            "function UnHighlightCell(cell) {" +
            "cell.bgColor = '#FFFFFF';" +
            "}" +
            "</script>";

        // Insert the function into the page (it will appear just after
        // the <form runat=server> tag.
        // Note that each script block is associated with a string name.
        // This allows multiple controls to register the same script block,
        // while ensuring it will only be rendered in the final page once.
        if (!this.IsClientScriptBlockRegistered("Highlight")) {
            Page.RegisterClientScriptBlock("Highlight", highlightScript);
        }

        if (!this.IsClientScriptBlockRegistered("UnHighlight")) {
            Page.RegisterClientScriptBlock("UnHighlight", unhighlightScript);
        }

        // Set the attributes of every cell in the table.
        foreach (TableRow row in Table1.Rows) {

            foreach (TableCell cell in row.Cells) {

            cell.Attributes.Add("onMouseOver", "HighlightCell(this);");
            cell.Attributes.Add("onMouseOut", "UnHighlightCell(this);");
        }
    }
}

Technorati : ASP.NET Client Side Events with JS

Creating Stateful Page Member Variables

2008-10-02T16:42:00.001+05:30

ASP.NET provides several state mechanisms, as described in previous post. However, none of these can be used automatically-they all require manual code to serialize and retrieve information. You can add a layer of abstraction by performing this serialization and retrieval once. The rest of your code can then interact directly with the member variables.

In order for this approach to work, you need to read variable values at the start of every postback. The Page.Load event is an ideal choice for this code because it always fires before any other control events. You can use a Page.Load event handler to pre-initialize all your variables. In addition, you need to store all variables before the page is sent to the user, after all processing is complete. In this case, you can respond to the Page.PreRender event, which fires after all event handlers, just before the page is converted to HTML and sent to the client.

The following page shows an example of how you might persist one Page member variable (named memberValue).


using System;
using System.Web;
using System.Web.UI.WebControls;

public class StatefulMembers : System.Web.UI.Page {

    // (Designer code omitted.)

    private int memberValue = 0;

    private void Page_Load(object sender, System.EventArgs e) {

        // Reload all member variables.
        if (ViewState["memberValue"] != null) {
            memberValue = (int)ViewState["memberValue"];
        }
    }

    private void StatefulMembers_PreRender(object sender, 
      System.EventArgs e) {

        // Save all member variables.
        ViewState["memberValue"] = memberValue;

        // Display value.
        lblCurrent.Text = memberValue.ToString();
    }

    // (Other event handlers can now work with memberValue directly.)
}

Technorati : ASP.NET Stateful Page Member

Storing Information Between Postbacsk

2008-10-02T16:38:00.001+05:30

ASP.NET is a stateless programming model. Every time a postback is triggered, your code loads into memory, executes, and is released from memory. If you want to keep track of information after your code has finished processing, you must use some form of state management.

ASP.NET provides several ways to store information, or state, between requests. The type of state you use determines how long the information will live, where it will be stored, and how secure it will be. The below table lists the various state options provided by ASP.NET. This table doesn't include the Cache object, which provides temporary storage and is described in the previous post. You can also use other, custom, approaches, such as hidden fields or a back-end database.

Table : Types of State Management
Type of State	Allowed Data	Storage Location	Lifetime	Security
View State	All serializable .NET data types.	A hidden field in the current Web page.	Lost when the user navigates to another page.	By default, it's insecure. However, you can use page directives to enforce encryption and hashing to prevent data tampering.
Query String	String data only.	The browser's URL string.	Lost when the user enters a new URL or closes the browser. However, it can be stored in a bookmark.	Clearly visible and easy for the user to modify.
Session State	All serializable .NET data types.	Server memory (can optionally be configured for an external process or database).	Times out after a predefined period (usually 20 minutes, but this period can be altered globally or programmatically).	Secure because data is never transmitted to the client.
Custom Cookies	String data only.	The client's computer (in memory or a small text file, depending on its lifetime settings).	Set by the programmer. Can be used in multiple pages and can persist between visits.	Insecure, and it can be modified by the user.
Application State	All serializable .NET data types.	Server memory.	The lifetime of the application (typically, until the server is rebooted). Unlike other methods, application data is global to all users.	Secure because data is never transmitted to the client.

The syntax for different data-storing methods is similar. Data is stored in a collection object and indexed using a string name.

The below figurehows a Web page that performs a test of several different forms of session state. When the user clicks the Store Data button, a new System.DateTime object is created and stored in page view state, session state, and a custom cookie. When the user clicks the Get Data button, this information is retrieved and displayed. Finally, the Clear Data button removes information from all types of state.

Here's the page code:

using System;
using System.Web;
using System.Web.UI.WebControls;
using System.Web.SessionState;

public class TestState : System.Web.UI.Page {

protected System.Web.UI.WebControls.Button cmdClear;
protected System.Web.UI.WebControls.Button cmdStore;
protected System.Web.UI.WebControls.Button cmdGetData;
protected System.Web.UI.WebControls.Label lblData;

// (Designer code omitted.)

private void cmdStore_Click(object sender, System.EventArgs e) {

// Create a test object.
DateTime now = DateTime.Now;

// Store the object in view state.
ViewState["TestData"] = now;

// Store the object in session state.
Session["TestData"] = now;

// Store the object in a cookie.
// Check if the cookie already exists (named Recipe07-02).
if (Request.Cookies["Recipe07-02"] == null) {

// Create the cookie.
HttpCookie cookie = new HttpCookie("Recipe07-02");

// The cookie can only store string data.
// It can store multiple values, each with a different key.
cookie["TestData"] = now.ToString();

// (You can modify additional Cookie properties to change
//  the expiry date.)

// Attach the cookie to the response.
// It will be submitted with all future requests to this site
// until it expires.
Response.Cookies.Add(cookie);
}
}

private void cmdGetData_Click(object sender, System.EventArgs e) {

lblData.Text = "";

// Check for information in view state.
if (ViewState["TestData"] != null) {

DateTime data = (DateTime)ViewState["TestData"];
lblData.Text += "<b>View state data:</b> " +
data.ToString() + "<br>";

}else {

lblData.Text += "No view state data found.<br>";
}

// Check for information in session state.
if (Session["TestData"] != null) {

DateTime data = (DateTime)Session["TestData"];
lblData.Text += "<b>Session state data:</b> " +
data.ToString() + "<br>";

}else {

lblData.Text += "No session data found.<br>";
}

// Check for information in a custom cookie.
HttpCookie cookie = Request.Cookies["Recipe07-02"];
if (cookie != null) {

string cookieData = (string)cookie["TestData"];
lblData.Text += "<b>Cookie data:</b> " +
cookieData + "<br>";

}else {

lblData.Text += "No cookie data found.<br>";
}
}

private void cmdClear_Click(object sender, System.EventArgs e) {

ViewState["TestData"] = null;
Session["TestData"] = null;
// (You can also use Session.Abandon to clear all session
//  information.)

// To clear a cookie you must replace it with
// a cookie that has an expiration date that has already passed.
HttpCookie cookie = new HttpCookie("Recipe07-02");
cookie.Expires = DateTime.Now.AddDays(-1);
Response.Cookies.Add(cookie);
}
}

One type of state that this page doesn't demonstrate is the query string. The query string requires a page redirect and is ideal for transferring information from one page to another. To set information, you must redirect the user to a new page and add the query string arguments to the end of the URL. You can use the HttpServerUtility.UrlEncode and UrlDecode methods to ensure the string data is URL legal. This method properly escapes any special characters.

DateTime now = DateTime.Now;
string data = Server.UrlEncode(now.ToString());
Response.Redirect("newPage.aspx?TestData=" + data);

To retrieve this information, you can use the HttpResponse.QueryString collection:

// Check for information in the query string.
if (Request.QueryString["TestData"] != null) {

string data = Request.QueryString["TestData"];
data = Server.UrlDecode(data);
lblData.Text += "<b>Found query string data:</b> " + data + "<br>";
}

Technorati : ASP.NET information Passing

Redirect the User to Another Page

2008-10-02T16:32:00.001+05:30

The easiest way to redirect a user from one Web page to another is to use the HttpResponse.Redirect method and supply a new URL. You can access the current HttpResponse object through the HttpContext object or by using the Reponse property of a Page or a Control object. Here's an example of an event handler that redirects the user in response to a button click:


private void cmdRedirect_Click(object sender, System.EventArgs e) {

    Response.Redirect("newpage.aspx");
}

The Redirect method works with relative URLs to resources in the same virtual directory, and with fully qualified URLs. URLs can point to other ASP.NET pages, other types of documents (such as HTML pages or images), and other Web servers.

The Redirect method sends a redirect instruction to the browser. The browser then requests the new page. The result is that the browser has to make two roundtrips to the Web server, and the Web server has to handle an extra request. A more efficient option is available through the HttpServerUtility.Transfer method, which transfers execution to a different ASP.NET page on the same Web server. Here's an example:


private void cmdRedirect_Click(object sender, System.EventArgs e) {

    Server.Transfer("newpage.aspx");
}

The Transfer method doesn't require an extra trip to the client, but it won't work if you need to transfer execution to another server or another type of resource other than a Web form (including a classic ASP page).

Technorati : ASP.NET Redirecting User

You can stream the binary data returned by SQL Server directly using the

2008-09-29T14:07:00.001+05:30

You can stream the binary data returned by SQL Server directly using the

Response.BinaryWrite

method. Do this after retrieving the data from the database.

In <script runat="server" /> block or codebehind:

Sub Page_Load(sender As Object, e As EventArgs)

Dim connectionString as String = "Your connection string"

Dim objConnection as New SqlConnection(connectionString)

Dim commandText as String = "SELECT Image FROM imageTable"

Dim objCommand as New SqlCommand(commandText, objConnection)

Dim objReader as SqlDataReader

Try

objConnection.Open()

objReader = objCommand.ExecuteReader()

If objReader.Read() Then

Response.ContentType = "image/jpeg"

Response.BinaryWrite( CType(objReader("Image"), Byte()) )

End If

Catch exc as Exception

Response.Write( exc.ToString() )

Finally

If Not objConnection Is Nothing Then

If objConnection.State = ConnectionState.Open Then

objConnection.Close()

End If

If Not objReader Is Nothing Then

objReader.Close()

End If

End Try

End Sub

Comments

This code will display the contents of the first record in the imageTable. In the example

code, the Image field in the SQL Server contains the binary data that is written out with

the Response.BinaryWrite method.

Response.ContentType should be set to the appropriate MIME-type of the image

that you are trying to display.This can be stored in the database as well and retrieved

along with the image data.

Technorati : Displaying an Image from SQL Server

Inserting an Image into SQL Server

2008-09-29T14:03:00.001+05:30

You must properly set up the SQL Server database table to accept images, as well as provide

a way on your Web Form to upload an image and send it to the SQL Server.

The table that will store the image must utilize the

image data type on a column that

will store the image. In the following examples, the name of this column is called Image.

In the .ASPX file:

<asp:button runat="server" id="UploadButton" OnClick="UploadImage" />

</form>

In <script runat="server" /> block or codebehind:

Sub UploadImage(sender As Object, e As EventArgs)

Dim connectionString As String = "Enter your Connection String"

Dim imageStream As Stream = ImageFile.PostedFile.InputStream

Dim byteData(ImageFile.PostedFile.ContentLength) As Byte

Dim objConn As New SqlClient.SqlConnection(ConnectionString)

Dim cmdText As String = "INSERT INTO sql_images(Image) VALUES(@image)"

Dim objCommand As New SqlClient.SqlCommand(cmdText, objConn)

Dim objParam As New SqlClient.SqlParameter("@image", SqlDbType.Image)

imageStream.Read(byteData, 0, imageFile.PostedFile.ContentLength)

objParam.Value = byteData

objCommand.Parameters.Add(objParam)

Try

objConn.Open()

objCommand.ExecuteNonQuery()

Catch exc as System.Exception

ErrorLabel.Text = exc.ToString()

Finally

objConn.Close()

imageStream.Close()

End Try

End Sub

Note that you must include the System.Data namespace for this code to compile.

Comments

The <form> tag has an additional attribute called enctype.This attribute allows binary

data to be passed through the form (which is needed for the image).

In the code, the submitted image file is broken into a byte array (imgdata) and then

used as the value of the SqlParameter that is passed in as the image (imgparam, @image).

Executing a Stored Procedure with No Results Returned

2008-09-29T14:02:00.001+05:30

' Set up the connection / command

Dim connectionString as String = "server=.;database=Northwind;

Trusted_Connection=true"

Dim connection As New SqlConnection(connectionString)

Dim command As New SqlCommand("IncrementDownloads", connection)

command.CommandType = CommandType.StoredProcedure

' Execute, but don't return any results

connection.Open()

command.ExecuteNonQuery()

connection.Close()

Comments

There are many cases, especially when using stored procedures, where it is unnecessary

to return a result set from the database. In those cases, the

SqlCommand provides a simple

ExecuteNonQuery() method that can be used to run the results on the database.This

method doesn't return a result set-if one is returned it's simply ignored.

This technique is also useful when executing non-SELECT SQL scripts, such as

UPDATE, INSERT, and DELETE, where returning a result set serves no purpose.

When working with a datareader, make sure to close the connection. Unlike a

dataset, the connection stays open until you close it.

Using a Tool to Create a Data Access Layer

2008-09-29T14:00:00.001+05:30

There are quite a few data access code generators available for .NET, with widely varying

costs and feature sets.This example demonstrates LLBLGen, an open source data tier

generator that supports a wide array of options for the created files. It generates stored

procedures for insert, update, select, and delete for the tables selected, and then creates

VB or C# classes to call these procedures. It is available at

http://www.sd.nl/

software/.This section uses version 1.2, released in November 2002.

To use LLBLGen, simply start the program and provide the connection information

for your database, as below figure shows.

Next, choose the tables and views for which you want to generate data access classes, as shown in below figure

Now, choose the options you want for your .NET classes, including naming conventions,

namespaces, language, and method of storing the connection string. Below figure shows the available options.

Do the same thing for the SQL procedures-pick which ones you want to generate, choose a common name prefix for them, and pick other options as described in below figure.

Finally, generate the code! Choose the output paths for the .NET source files and the T-SQL script file, and watch as it generates your code for you.Below figure concludes this example, showing how a successful code generation should end.

Using Microsoft’s Data Access Application

2008-09-29T13:53:00.001+05:30

The first step is to reference the data, SQLClient, and data access application block

namespaces. Add the following statements to the top of your data access client

source file:

<%@ Page Language="VB" ClassName="Recipe1001vb" %>

<%@ import Namespace="System.Data" %>

<%@ import Namespace="System.Data.SqlClient" %>

<%@ import Namespace="Microsoft.ApplicationBlocks.Data" %>

Next, you have to place the following code inside a method. Page_Load will do fine for

this example:

Sub Page_Load(sender As Object, e As EventArgs)

Dim dataSet As DataSet

'parameter value variables

Dim beginningDate As string = "1/1/1996"

Dim endingDate As string = "12/31/1996"

Try

Dim connectionString As string = _

"Integrated Security=yes;Initial Catalog=Northwind;Data Source=(local)"

Dim arParams(1) As SqlParameter

arParams(0) = New SqlParameter("@Beginning_Date", beginningDate)

arParams(1) = New SqlParameter("@Ending_Date", endingDate)

dataSet = SqlHelper.ExecuteDataset(connectionString, _

CommandType.StoredProcedure, "Employee Sales by Country", arParams)

'bind dataSet to a WebControl and call Page.DataBind()

Catch exception As Exception

'An error occurred - were your connection string,

'stored procedure name and parameters correct?

'you could display the error via a WebControl or throw an exception here

End Try

End Sub 'Page_Load

Comments

This is a simple example-it barely scratches the surface of data access application

block functionality.There's support for performing transactional updates and fetching

XML as well as data-readers and caching parameters for multiple calls to a given stored

procedure.

The SqlHelper object manages just about everything for you. In order to achieve the

same result in ADO.NET, you would need SqlConnection, SqlCommand, and

SqlDataAdapter objects in addition to what you've declared here. Connection management

is improved as well because the SqlConnection is created internally to the object.

There is no need you for to close the connection-the object handles closing the connection

as it goes out of scope.

Finally, take the opportunity to examine the source code for the application block.

There are many examples of best practices in the source code that you might want to

apply to your own projects!

Connecting to an ODBC Datasource

2008-09-27T16:32:00.003+05:30

Dim connectString As string = "DSN=myDSN;Uid=user;Pwd=pass"

Dim myConn As Microsoft.Data.Odbc.OdbcConnection = _

New Microsoft.Data.Odbc.OdbcConnection( connectString )

Try

myConn.Open()

'do something and then be sure to close the connection...

Finally

If Not myConn Is Nothing Then

myConn.Close()

End If

End Try

Comments

According to Carsten Thomsen, author of Database Programming in C#:

The OdbcConnection class, which uses the Platform Invoke feature, is roughly twice as fast for

standard applications than the OleDbConnection.The latter uses COM, which is chatty, and

hence has more server round-trips. So unless your application is shipping large amounts of data

(hundreds of thousands of rows or more) per data request, you should at least consider using

the OdbcConnection class. SqlConnection is roughly 20 percent faster than

OdbcConnection.

Technorati : Connecting to ODBC DB

Connecting to MySQL Database

2008-09-27T16:31:00.001+05:30

You can use the OleDB provider that ships with the .NET Framework. In this case, your

code would look something like this:

Dim connectString As string = _

"Provider=MySQLProv;Data Source=mydb;User Id=user;Password=pass"

Dim myConn As System.Data.OleDb.OleDbConnection = _

New System.Data.OleDb.OleDbConnection( connectString )

Try

myConn.Open()

`dosomething and then be sure to close the connection...

Finally

If Not myConn Is Nothing Then

myConn.Close()

End If

End Try

Another option is to use the MySQL data provider by eInfoDesigns (which I have only

minimally examined). In which case, your code would look like so:

Dim connectString As string = _

"Data Source=server;Database=mydb;User ID=user;

->Password=pass;Command Logging=false"

Dim myConn As eInfoDesigns.dbProvider.MySqlClient.MySqlConnection = _

New eInfoDesigns.dbProvider.MySqlClient.MySqlConnection( connectString )

Try

myConn.Open()

'do something and then be sure to close the connection...

Finally

If Not myConn Is Nothing Then

myConn.Close()

End If

End Try

Comments

You can access most datasources with the OleDB data provider, although it's not the

most efficient way to do so.You get better performance using a custom data provider

dedicated to that particular datasource. Although Microsoft does not support a custom

MySQL data provider, third-party software vendors are beginning to supply these.

Technorati : Connecting to MySQL DB

Connecting to a Microsoft Access Database

2008-09-27T16:28:00.001+05:30

To connect to a Microsoft Access database, you must include the

System.Data.OleDb

namespace because all the ASP.NET classes that are required to connect to datasources

through an OleDB connection are located in this namespace.The ASPX page looks as

follows:

<html>

<head>

<title>Connecting to a Microsoft Access Database<title>

</head>

<body>

<h3>Connecting to a Microsoft Access Database</h3>

<p>

<asp:DataGrid id="dg1" runat="server"></asp:DataGrid>

</p>

<p>

<asp:Literal id="ltlError" runat="server"></asp:Literal>

</p>

</form>

</body>

</html>

Add the following code within the <script> tags:

Public Sub Page_Load(Source As Object, E As EventArgs)

Dim ConnectionString As String

ConnectionString =

"Provider=Microsoft.Jet.OleDb.4.0;Data Source=" & _

Server.MapPath("Northwind.mdb") & ";"

Dim QuerySQL As String

QuerySQL = "SELECT * FROM Shippers"

Dim objConn As New OleDbConnection(ConnectionString)

Dim objCmd As OleDbCommand

objCmd = New OleDbCommand

objCmd.CommandText = QuerySQL

objCmd.Connection = objConn

Try

objConn.Open()

dg1.DataSource = objCmd.ExecuteReader()

dg1.DataBind()

Catch Err As Exception

ltlError.Text = Err.ToString()

Finally

objConn.Close()

End Try

End Sub

Comments

First, you must create a connection string that includes the driver and the source path of

the source database. In this example, this has been assigned to the string type variable

named ConnectionString. Remember that if you are using Microsoft Access 97, the

connection string is going to be as follows:

"Provider=Microsoft.Jet.OleDb.3.75;Data Source=" & _

Server.MapPath("Northwind.mdb") & ";"

Whereas when using Microsoft Access 2000 and XP, the string is as demonstrated in the

code.You must create the Connection and Command objects as well.The Connection

object's constructor is provided with ConnectionString, which contains the connection

string.The Command object's instance is assigned the query and the connection that it

will use to access the datasource.

Having established the basic settings for the Connection and the Command objects,

you enclose the rest of the code within a Try/Catch/Finally block to capture any type

of errors that arise. Afterwards, within the Try/Catch block, you open the connection

and call the ExecuteReader method of the command object.This method executes the

specified query text and returns the results to the DataGrid control that has been

assigned to it.

When you view the page in the browser, you will see all the records from the database

table specified in the query.

Technorati : Connecting to MS Access DB

Connecting to Oracle

2008-09-27T16:26:00.001+05:30

Use the .NET data provider for Oracle, which is in the

System.Data.OracleClient

namespace. This data provider does not come with .NET 1.0, but must be downloaded

separately. Working with Oracle connections is similar to working with SQL Server connections,

as the following code demonstrates:

Dim connectString As string =

"Data Source=Oracle-Test;User ID=user;Password=pass"

Dim myConn As OracleConnection = New OracleConnection( connectString )

Try

myConn.Open()

//do something and then be sure to close the connection...

Finally

If Not myConn Is Nothing Then

myConn.Close()

End Try

Comments

As with the SqlClient data provider, the Oracle data provider offers significant performance

benefits over the OleDB connection method.

Technorati : Connecting to Oracle

Connecting to SQL Server

2008-09-27T16:24:00.001+05:30

Use the SQL Server .NET data provider in the

System.Data.SqlClient namespace to

connect to a Microsoft SQL Server 7.0 or 2000 database (for example, the Northwind

sample database).Your connection strings can take advantage of integrated security or

connect using a given SQL login and password.

First, you need to reference the SqlClient namespace. Add the following statement

to the top of your data access client source file to reference the System.Data.SqlClient

namespace:

Imports System.Data.SqlClient

Next, you need to create the connection, use it, and clean up inside a method. For

example, you can place the following in Page_Load:

Dim connectString As string =

➥"Integrated Security=yes;Initial Catalog=Northwind;Data Source=(local)"

Dim sqlConn As SqlConnection = New SqlConnection( connectString )

Try

sqlConn.Open()

'do something and then be sure to close the connection...

Finally

If Not sqlConn Is Nothing Then

sqlConn.Close()

End If

End Try

Here's an alternative version of an integrated security connection string.This will look

familiar if you build your connection strings using Universal Data Link (.UDL) files.

This VB.NET example explicitly references the Security Support Provider Interface

(SSPI) for the integrated security string and sets the connection string via the

ConnectionString property:

Dim sqlConn As SqlConnection = New SqlConnection()

sqlConn.ConnectionString = "Integrated Security=SSPI;Initial

➥Catalog=Northwind;Data Source=(local)"

Try

sqlConn.Open()

'do something and then be sure to close the connection...

Finally

If Not sqlConn Is Nothing Then

sqlConn.Close()

End If

End Try

As mentioned, you might also define a connection string that uses a specific SQL Server

logon ID. Using the first example, only the connection string changes:

connectString =

"User ID=user;Password=pass;Initial Catalog=Northwind;Data Source=(local)"

Now, let's say you want to create a connection to a remote database server. In this case,

you need to specify the SQL Server logon ID and password again. Using the

ConnectionString property, the connection string will look similar to this:

sqlConn.ConnectionString = "User ID=user;Password=pass;

Network Library=DBMSSOCN;Data Source=192.168.1.1,1433"

Of course, you have to change the IP address to match your configuration.

Comments

The most important point to remember is this: if you open a connection you must

remember to close it.You cannot rely on ADO.NET's garbage collector to do it for you

in a timely manner. If you neglect to close your connections, you will likely run out of

available connections in short order! The best way to ensure that connections are properly

closed is to wrap their usage in Try/Catch/Finally blocks. Also, in addition to the

techniques you've just seen, SqlConnection can also be created implicitly by certain

ADO.NET objects like the dataset.

Technorati : Connecting to SQL Server

Catching Exceptions

2008-09-25T12:59:00.001+05:30

In <script runat="server" /> block or codebehind:

Private Sub Page_Load(Source As Object, E As EventArgs)

Dim _Connection As New

➥SqlConnection("Server=localhost;Database=pubs;uid=sa;pwd=;")

Dim _Command As New SqlCommand("Select * From Authors", _Connection)

Try

'_Connection.Open commented to cause an exception

'_Connection.Open()

DG1.DataSource = _Command.ExecuteReader(CommandBehavior.CloseConnection)

DG1.DataBind()

Catch _Error As Exception

MessageLabel.Text = _Error.Message

Finally

_Connection.Close()

End Try

End Sub

You can also provide multiple Catch statements, as shown here:

Private Sub Page_Load(Source As Object, E As EventArgs)

'Error has been produced in the connection

'string by writing "Server=localhos" (no 't')

Dim _Connection As New

➥SqlConnection("Server=localhos;Database=pubs;uid=sa;pwd=;")

Dim _Command As New SqlCommand("Select * From Authors", _Connection)

Try

_Connection.Open()

DG1.DataSource = _Command.ExecuteReader(CommandBehavior.CloseConnection)

DG1.DataBind()

Catch _SqlError As SqlException

MessageLabel.Text = _SqlError.Message

Catch _Error As Exception

MessageLabel.Text= _Error.Message

Finally

_Connection.Close()

End Try

End Sub

Comments

The Try/Catch/Finally block is the best approach towards error handling. It provides a

structured error-handling technique that was not available in previous versions of Visual

Basic.The Try block is provided with the code that is to be run.The Catch block is for

catching the exceptions raised by any line of code in the Try block.The Finally block

is executed under both conditions-either when the Try section successfully executes or

when an error occurs and is passed to the Catch block. It is for this reason that the

Close() method of the connection object has been coded in the Finally block, so as to

ensure that under both cases (whether successful or unsuccessful), the connection to the

data store is closed.

Multiple Catch statements can also be provided to capture different types of errors

raised by objects. In the second code listing, the exceptions that would be related to

SqlClient objects are going to be captured by the Catch statement having an object of

the SqlException class. All other exceptions are caught by the second catch statement

provided in the Try block.

The order of the Catch statements is very important. Make sure you put the more

generalized Catch exceptions after the more specific exceptions. For example, in the second

code listing, SqlException is a subclass of Exception, and so is more specific.Thus,

its Catch block occurs above the more generic exception's Catch block. If the order

were reversed, the SqlException Catch block would never be reached, because the

exception block would always catch a SqlException that was thrown.

Technorati : Catching Exceptions in ASP.NET

Handling Page Level Errors

2008-09-25T12:57:00.001+05:30

The Page_Error() event, exposed by the Page object, can be used to catch errors on a

page level.The following code demonstrates how you can use this event for page level

error handling.

In <script runat="server" /> block or codebehind:

Private Sub Page_Load(Source As Object, E As EventArgs)

Dim _Connection As New

➥SqlConnection("Server=localhost;Database=pubs;uid=sa;pwd=;")

Dim _Command As New SqlCommand("Select * From Authors", _Connection)

'_Connection.Open() causes an exception

DG1.DataSource = _Command.ExecuteReader(CommandBehavior.CloseConnection)

DG1.DataBind()

_Connection.Close()

End Sub

Public Sub Page_Error(Source As Object, E As EventArgs)

Response.Write(Server.GetLastError.ToString())

Server.ClearError()

End Sub

Comments

The demonstrated code tries to execute a query without having an open connection to

the datasource.This raises an exception, which is captured by the Page_Error() event of

the Page object itself.Within the Page_Error event, the code displays the error message

by calling the GetLastError method of the Server object.This returns an exception

object that is generated by the error. Note that the data access technique used in this

code is not a good approach for connecting to datasources; it has been adopted here

only for demonstrating the Page_Error event.You should always use the

Try/Catch/Finally statements for interacting with datasources.

Errors can also be handled at the application level using the Application_Error

event found in global.asax.

Technorati : Handling Page Level Errors in ASP.NET

Raising Exceptions

2008-09-25T12:55:00.001+05:30

Private Sub Page_Load(Source As Object, E As EventArgs)

Dim _Connection As New

➥SqlConnection("Server=localhost;Database=pubs;uid=sa;pwd=;")

Dim _Command As New SqlCommand("Select * From Authors", _Connection)

Try

_Connection.Open()

DG1.DataSource = _Command.ExecuteReader(CommandBehavior.CloseConnection)

DG1.DataBind()

Catch _Error As Exception

Throw New Exception("Whoops.... You've got an error in the code!")

Finally

_Connection.Close()

End Try

End Sub

The Throw statement here creates a new exception and raises it, replacing the original

exception object.The error message that will appear on the page in this case is the one

that has been provided as an argument to the constructor of the Exception object.

The original error message can also be passed to the Throw statement in order to

show the details.You can achieve this by passing the Exception object as a second argument

to the constructor of the newly raised exception.

Catch _Error As Exception

Throw New Exception("Whoops.... You 've got an error in the code!", _Error)

Your exception message has been replaced by the original one, but your exception message

still appears.Where? Check out the Stack Trace section.

Comments

The Throw statement can be used to explicitly throw an exception or to rethrow a

caught exception.The new exception being raised is provided with a customized statement,

so as to hide error details and display a more simplified error message to the viewer.

You can also pass along the original exception object to the raised exception.This can

be useful because it allows a friendly error message to be displayed to the user, but keeps

the detailed information for debugging purposes.

Technorati : Raising Exceptions in ASP.NET

Enabling Page Level Tracing

2008-09-25T12:53:00.001+05:30

In order for page level tracing to be enabled, you need to add the

Trace attribute to the

@ Page directive.

<%@ Page Language="VB" Trace="true"%>

The default value of the Trace attribute is false, which means that it is disabled. In

order to enable it, you simply set its value to true. In <script runat="server" />

block or codebehind:

Private Sub Page_Load(Source As Object, E As EventArgs)

Trace.Write("Page_Load", "Declaring and initializing variables.")

Dim _A As Integer = 10

Dim _B As Integer = 20

Trace.Write("Page_Load", "Applying add operation.")

_A += _B

Trace.Write("Page_Load", "Variable values changed.")

Trace.Write("_A", _A)

Trace.Write("_B", _B)

End Sub

Trace.Write can accept up to three arguments-the first one is the category for the

message, the second is the actual message to display, and the third is the exception

information displayed after the message.The following listing demonstrates all three

arguments:

...

Try

'code goes here

Catch _Error As Exception

Trace.Write("Category", "Message", E)

End Try

Comments

In order to display Trace messages from your code, use either the Trace.Write() or the

Trace.Warn() statement.The difference between the two is that Trace.Warn shows the

output text in red, indicating a warning, whereas Trace.Write() shows output in black

text. Both methods accept the same number and type of arguments.

You can also use the Trace.IsEnabled Boolean property to test whether tracing is

enabled prior to performing an expensive operation, such as looping through all values

on the page as part of a Trace output operation.

Note that to access tracing outside of a page, such as in a custom control, you must

refer to the current Web context by using System.Web.HttpContext.Current.Trace()

instead of just Trace() or Page.Trace().

Technorati : Page Level Tracing in ASP.NET

Logging Error Details

2008-09-24T12:24:00.001+05:30

Create an object of type

System.Diagnostics.EventLog.Then begin the try/catch

block and enter the code you suspect is causing the error. Create a catch block to run if

an error occurs and assign the exception to the ex variable. Inside the block, create a

new EventLog instance. Set the log to send the error to, and enter your application name

as the source. Finally, write the exception to the event log.

In <script runat="server" /> block or codebehind:

Sub Page_Load(sender As Object, e As EventArgs)

Dim a as Integer=0

Dim myEventLog as System.Diagnostics.EventLog

Try

a=1/a

Catch ex as Exception

myEventLog=new System.Diagnostics.EventLog()

myEventLog.Log="Application"

myEventLog.Source="Recipe0902"

myEventLog.WriteEntry(ex.ToString())

End Try

End Sub

You also can handle errors on an application error by modifying the Application_Error

event handler in the global.asax file. Use Server.GetLastError() to get a reference to

the exception that was thrown.

In the global.asax file:

Sub Application_Error(ByVal sender As Object, ByVal e As EventArgs)

Dim myEventLog As System.Diagnostics.EventLog

Dim ex As Exception = Server.GetLastError()

myEventLog = New System.Diagnostics.EventLog()

myEventLog.Log = "Application"

myEventLog.Source = "Recipe0902"

myEventLog.WriteEntry(ex.ToString())

End Sub

Comments

Catching and keeping a log of errors that occur can greatly decrease the amount of time

you spend supporting an application. Note:The ASP.NET account does not have access

to write to the event log by default.To run this example, you need to do one of the

following:

1. Modify the processModel element in machine.config to set ASP.NET to run as

the System account.

2.Add the ASP.NET account to the local Administrators group.

3. Use regedt32 to grant the ASP.NET account write access to the

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog key.

Configuring a Default Error Page in ASP.NET

2008-09-24T12:22:00.001+05:30

In the web.config file, locate the

customErrors section. Set the mode to on and set the

URL for the default redirect.

The web.config file is as follows:

In <script runat="server" /> block or codebehind:

Sub Page_Load(sender As Object, e As EventArgs)

Dim a as Integer=1/0

End Sub

The error handler page is as follows:

<html>

<body>

An error has occurred in this application.

</form>

</body>

</html>

Comments

Whenever an unhandled error occurs anywhere in your application, the users are directed

to your custom error screen.This is an important part of creating a professional and

secure Web site. Note that the contents of the web.config file are case sensitive.

Technorati : Data Access

Perform Custom Authentication on Each Request

2008-09-22T22:47:00.001+05:30

The application event,

Application_AuthenticateRequest, which is defined in

global.asax, is used to perform custom authentication on every request to an application.

It is the perfect place to add custom checks to determine whether the users should be

given access to a particular resource, or to determine which resources the user should be

able to access. In the following example, the list of roles the user belongs to is retrieved

and stored in the HttpContext collection, which is available for the life of each request.

Individual resources can then use the list to determine whether the users should have

access to them.

In global.asax (or its codebehind), do the following:

Sub Application_AuthenticateRequest(ByVal sender As Object sender,

➥ByVal e As EventArgs)

If Request.IsAuthenticated = True Then

Dim roles() As String

' get this user's roles (left out)

' store roles in Context for the rest of this request

Context.Items.Add("SecurityRoles", roles)

End If

End Sub

Technorati : Security - Custom Auth

Creating a Simple Forms Authentication Logout Page

2008-09-22T22:46:00.001+05:30

Place a LinkButton control on the page and assign it the text of

Logout. Place a Literal

control on your page and title it message.This will be populated with a message telling

the users they have logged out and including the code to redirect them to another page.

The ASPX page is as follows:

<p align="center"><asp:LinkButton ID="Logout" Runat="server" OnClick="Logout_

➥Click">Logout</asp:LinkButton></p>

In <script runat="server" /> block or codebehind:

private void Logout_Click(object sender, System.EventArgs e)

{

System.Web.Security.FormsAuthentication.SignOut();

Message.Text="You have been logged out.";

Message.Text+="<meta http-equiv=\"Refresh\"

➥content=\"3;URL=http://aspalliance.com\" />";

}

Comments

On the Logout button Click event, do the following:

n Call System.Web.Security.FormsAuthentication.SignOut().This method

forces a log out by removing the authentication ticket and session cookies.

n Add text to the Message literal control to let the users know they have been

logged out.

n Add a Meta tag to the Message literal control to redirect the users to another page.

If you want to send the users back to the login page, you can redirect them to any

page in the application. Forms authentication will force the users to log in first

(assuming the page requires an authenticated user).

Technorati : Security - Logout Form

Creating a Simple Forms Authentication Login Page

2008-09-22T22:44:00.001+05:30

Place two TextBox controls for the username and password on the page. Set the

TextMode property of the password TextBox control to

Password. Add a Button control

to perform the login, and a Label control to provide feedback to the users.

The ASPX page is as follows:

<tr>

</tr>

<tr>

</tr>

<tr>

<td>Password:</td>

<td><asp:TextBox ID="Password" Runat="server"

TextMode="Password" /></td>

</tr>

<tr>

<td colspan="2" align="center"><asp:Button ID="Login"

Text="Login" Runat="server" OnClick="Login_Click"/></td>

</tr>

</table>

<br>

<asp:Label ID="Message" Runat="server" ForeColor="#FF0000"></asp:Label>

</p>

In <script runat="server" /> block or codebehind:

Private Sub Login_Click(sender as Object, e as System.EventArgs)

If UserName.Text="johndoe" AND Password.Text="password" Then

System.Web.Security.FormsAuthentication.RedirectFromLoginPage(

➥UserName.Text, False)

Else

Message.Text="Invalid Username/Password combination"

End If

End Sub

Comments

On the Login button Click event, you simply add code to verify the user ID and

password are correct.You will most likely want to query a database or check another

source to verify the password instead of hard coding the logins in your code. If the

password is correct, you call System.Web.Security.FormsAuthentication.

RedirectFromLoginPage to send the users to the page they had originally requested.

Pass this function the name of the user who has logged in for use later in your application,

and pass it a boolean of whether to persist the cookie across browser sessions (many

not correct, you display an error to the users.

Requiring Authentication to Access Files and Folders

2008-09-20T20:29:00.001+05:30

Define separate location sections in the web.config file with unique authorization

settings:

1. <location path="file">

2. <location path="folder">

In the web.config file in Web application's root folder:

<?xml version="1.0" encoding="utf-8" ?>

<system.web>

</authentication>

</authorization>

</system.web>

<system.web>

</authorization>

</system.web>

</location>

<system.web>

</authorization>

</system.web>

</location>

</configuration>

Each sub-folder of the Web application can have its own web.config file that specifies its

authorization settings. Individual files however can only have unique authorization settings

specified with the use of the location section. Note that authentication, unlike

authorization, is an application-wide setting that cannot be overridden for files or

folders.

Configuring Windows Authentication

2008-09-20T20:27:00.001+05:30

Open the web.config file. Find the authentication tag under

system.web and set the

mode to Windows.This is the default setting if you created the web.config file in Visual

Studio.

The web.config file is as follows:

<system.web>

<system.web>

You must also configure IIS to require authentication.To do this, follow these steps:

1. Open Administrative Tools from either the Start menu or the Control Panel

(depending on the OS).

2. Open Internet Information Services.

3. Branch out the tree to find your Web application folder.

4. Right-click your Web application folder and choose Properties.

5. Click the Director Security tab.

6. Click the Edit button in the Authentication Control section.

7. Uncheck the Anonymous Access box and make sure Integrated Authentication

(Challenge Response) option is checked.

8. If you want to allow the users to type their passwords if IIS Challenge Response

fails, check Basic Authentication.

9. Click both OK buttons and close IIS.

Configuring Forms Authentication

2008-09-20T20:20:00.001+05:30

The forms authentication setup process is done in the

<authentication> part of your

web.config file. As with all XML documents, the web.config file's contents are case

sensitive.

Here's the application's web.config file:

<system.web>

<forms name="CookBookForm"

loginUrl="login.aspx"

protection="All"

timeout="30"

path="/" />

</authentication>

</system.web>

</configuration>

Comments

The <forms> tag in web.config provides all the configuration necessary to provide forms

authentication for your application.

This tag includes the following options:

n name-This sets the name of the HTTP cookie that will be sent. If you have multiple

applications on the same server with forms authentication set up, you must

make this value unique in each one of them.

n loginUrl-This sets the location where the users are redirected for login (or any

other action) if they are not authenticated and try to access a secure page.

n protection-This specifies the level of protection to place on the cookie.You

can set this to All, None, Encryption or Validation, the default (and recommended)

is All.

n timeout-This sets the amount of time (in minutes) that a cookie remains valid,

after it was last requested, before it expires.

n path-This sets the path for the cookies to use; default is a backslash.This provides

additional protection because the client browser will not send the cookie if

there is a path mismatch.This value is case-sensitive to some browsers.

Reading and Storing Data in ViewState

2008-09-18T21:04:00.001+05:30

The ViewState collection provides an easy way to maintain values on a particular Web

Form across postbacks.This collection is stored as a hidden form field, and thus all data

stored in ViewState is passed to and from the client on every request.You access it using

syntax similar to what you have seen for the Session and Application collections:

ViewState("UserName")="UserNameTextBox.Text"

UserNameLabel.Text = ViewState("UserName")

Comments

By default,Web controls that do not post back values will maintain their state automatically

using ViewState.This can be controlled individually for each control or globally for

each page by setting

EnableViewState to true or false as desired (either for a given

control or in the page directive).The amount of space a control occupies in ViewState

can easily be determined from the control tree section of the trace output.

Reading and Storing Data in Cookies

2008-09-18T20:49:00.001+05:30

You can store small pieces of user-specific information in the user's Cookies collection

on the user's local machine, assuming the local browser supports cookies and the user has

not disabled this feature.You can use cookies to hold data for as long as the current

browser window is open, or you can give them an expiration date some time in the

future.The first variety is called an in-memory cookie, because they are never written to

the user's hard drive.The second variety is referred to as a persistent cookie, because

these cookies persist across browser and even machine restarts.

There are several ways to work with cookies in ASP.NET.The simplest uses syntax

very similar to that used for the Application and Session collections:

'write a cookie

Response.Cookies("UserName").Value = UserNameTextBox.Text

'read a cookie

UserNameLabel.Text = Request.Cookies("UserName").Value

In addition, you can give the cookies an expiration date, which will cause them to be

persisted to the user's hard drive.To delete these (and other) cookies, simply set their

expire date to any past date, as shown:

'persist a cookie

Response.Cookies("UserName").Expires =

➥

System.DateTime.Now.AddDays(1) ' persist for 1 day

'delete a cookie

Response.Cookies("UserName").Expires = System.DateTime.Now.AddDays(-1)

Comments

Cookies can be a great place to store small pieces of data that are needed from page to

page.They do not have the overhead of sessions, and they can span multiple user visits

over large time periods.They can also span applications within the same domain (for

example, yahoo.com). Not all users will accept cookies, however. It's best to test for this

by writing a test cookie and attempting to read it back on a subsequent request. Cookies

can store only small amounts of text data, with an upper limit of less than 4KB, which

includes the data and the keys used to extract the data (for example, UserName in the

previous example).

Reading and Writing Values to the Session Object

2008-09-18T20:48:00.001+05:30

You can store user-specific information, such as a user's name, in the Session collection.

Because the Session collection is user specific, it should not be written to by multiple

threads concurrently.Therefore, you do not need to use locks around your writes, as you

must with the Application collection . Otherwise, the syntax is similar:

Session("UserName")=UserNameTextBox.Text

UserNameLabel.Text = Session("UserName")

Comments

By default, the Session collection holds data for 20 minutes after the last request to an

application by a particular user.You can adjust this time period in the application's con-

figuration . Because data stored in sessions can grow linearly with the

number of users, and because it persists for quite some time after each user leaves, it can

quickly impede scalability if it is used to store large amounts of data. It should therefore

be used sparingly.

Reading and Writing Values to the Application Object

2008-09-18T20:43:00.001+05:30

You can store the name of the server in application state using

Application("ServerName") ="WebFarm1"

.You can retrieve it and display its value by

using MyLabel.Text=Application("ServerName").ToString(). Because it returns the

server name as an object, you need to convert it to a string using the .ToString()

method before assigning it to MyLabel.Text.The ASPX page is as follows:

<html>

<body>

<asp:Label ID="MyLabel" Runat="server"/>

</form>

</body>

</html>

In <script runat="server" /> block or codebehind:

Sub Page_Load(sender As Object, e As EventArgs)

Application.Lock()

Application("ServerName")="WebFarm1"

Application.UnLock()

MyLabel.Text=Application("ServerName").ToString()

End Sub

Comments

Application state is useful for storing values that you need to access throughout your

application. Once a value is added to application state, it exists for the life of the application.

Because multiple pages can attempt to write to the Application collection simultaneously,

it must be locked using Application.Lock prior to any writes.The lock is

released using Application.UnLock.The only time locking isn't necessary is in code

that isn't executed by multiple page requests, such as in Application_Start in the

global.asax.

Configuring Sessions in your ASP.NET Application

2008-09-18T20:25:00.001+05:30

All of the configuration is provided by the

<sessionState> element in the web.config

file; all you have to do is alter the appropriate attributes.

There are several ways to store session information; these are described next.To disable

Session state, add this to web.config:

<system.web>

</system.web>

</configuration>

To enable local storage of Session state, add this to web.config:

<system.web>

<sessionState mode="InProc"

cookieless="true"

timeout="10" />

</system.web>

</configuration>

The InProc setting sets it so that the information is stored locally (the default).

Cookieless can be set to true or false and tells ASP.NET whether to use cookies

when storing session information. Timeout sets the time in minutes that sessions will

expire if they remain unused.

To enable storage of Sessions on a state server add this to web.config:

<system.web>

<sessionState mode="StateServer"

stateConnectionString="tcpip=127.0.0.1:42424" />

</system.web>

</configuration>

This tells ASP.NET to use a state server at the specified address (stateConnectionString).

The state server is found at %SYSTEMROOT%\Microsoft.NET\Framework\version\

aspnet_state.exe.This server then listens on port 42424 over TCP/IP; you can use

this port to store your session information.

To enable storage of Sessions on a SQL Server, add this to web.config:

<system.web>

<sessionState mode="SQLServer"

sqlConnectionString="data source=localhost;user id=sa;

➥password=securepassword;" />

</system.web>

</configuration>

This method tells ASP.NET to use SQL Server to store the information.To set up a

SQL Server to store session information, you must run the InstallSqlState.sql file located

in %SYSTEMROOT%\Microsoft.NET\Framework\version\ on the SQL Server (there is an

UninstallSqlState.sql file to uninstall it as well).

Configuring Application Error Handling

2008-09-18T20:15:00.001+05:30

The web.config file includes a

<customErrors ...> section that controls how the application

responds to errors on its pages. A typical customErrors section follows:

</customErrors>

The settings are case-sensitive.The first attribute, mode, can be On, Off, or RemoteOnly.

The first two are self-explanatory; the third redirects errors only for non-local users, so

that a local developer can still debug problems without being routed to the "friendly"

error page.The second attribute, defaultRedirect, specifies the page to which any

request that results in an unhandled exception is sent. If it is not set but custom errors

are on, users will see a generic error message (instead of the detailed exception information).

Optionally, specific redirects can be set up for individual error codes by adding

<error ...> elements within the customErrors element. Each of these can specify a

statusCode, such as 404, that maps to a file not found error code, or 500, for a generic

application error. Each error code can be mapped to its own specific error page by setting

the path to the page in the redirect attribute.

Comments

Setting up friendly default error pages for ASP.NET applications and their common

errors is fairly straightforward. It is useful to have the default error page write to a log

with details of the request or URL that caused the problem. It can also be useful to log

which files users are requesting that are resulting in 404s, and ideally to have the 404

error page automatically redirect users to new locations of old resources.

Note, however, that these error pages handle requests only for resources that the

ASP.NET engine is registered to handle. So a request for a missing .ASPX file would

result in the 404 page being called, but by default a request for a nonexistent .HTM or

.GIF file would not. Additional file types can be associated with the ASP.NET process in

IIS, but this imposes a performance penalty. Note that most of this functionality is also

available within IIS.

Configuring Application Debugging

2008-09-18T20:10:00.001+05:30

The web.config file includes a

<compilation ...> section that sets whether debug

mode is set for an ASP.NET application. A typical compilation section follows:

<compilation

defaultLanguage="vb"

debug="true"

Setting debug="true" (which is case-sensitive) enables debug mode for your application.

This means the .PDB file for your assembly will be copied to the application's /bin

folder, which means detailed debug information (stack trace, line numbers, and so on)

will be provided in response to exceptions. Note that there is a significant performance

penalty to application running in debug mode. Individual pages can also be set up to run

in debug mode by setting debug="true" in the individual page directive.

Configuring Application Tracing

2008-09-18T20:08:00.001+05:30

The web.config file includes a

<trace ...> section that is used to set up tracing options

for an ASP.NET application. A typical trace section follows:

<trace

enabled="false"

requestLimit="10"

pageOutput="false"

traceMode="SortByTime"

localOnly="true"

This example demonstrates all of the fields available to modify application tracing.The

first field controls whether tracing is enabled.This defaults to false and can be overridden

at the individual page level.The second item, requestLimit, controls how many

requests' trace results should be stored on the server. Once filled, this queue will not

accept new entries until the queue is deleted (which can be done from the trace.axd

page).The third attribute, pageOutput, controls whether trace output should be displayed

on every page in the application.When set to false, trace output is available only from

the trace.axd URL (for example, http://mydomain/myapplication/trace.axd).

Individual pages can override this setting by explicitly setting trace="true" or

trace="false" in their page directive.

The fourth attribute, traceMode, simply controls the ordering of the trace messages in

the Trace Information section of the trace output.The allowable options are SortByTime

(the default) and SortByCategory. Finally, the last attribute, localOnly, enables application

tracing only for requests originating from the local machine when set to true. Note

that these items are case-sensitive.

Comments

Tracing can provide a powerful way to debug applications. By using the trace.axd URL

for trace output, developers can pull important details about a production ASP.NET

application without interfering with current users. However, be careful that you do not

place sensitive information in trace statements or collections that are exposed by the

trace output (Application, Session, Forms, Cookies, QueryString, and so on), because by

default anybody can access the trace.axd URL and access this data. Note that you can

change the name of the trace.axd file by changing its name in the machine.config file.

Creating Custom Application Settings in the web.config File

2008-09-18T20:06:00.001+05:30

The web.config file has a predefined section for application settings, called

appSettings

.This section can be placed in any .config file, and must reside with the

<configuration> section.The following is an example of a simple web.config file:

</appSettings>

</configuration>

Values can be retrieved using the Configuration API. However, all values are returned as

string types:

Dim pageSize As Integer

pageSize = CType(ConfigurationSettings.ApplicationSettings("PageSize"),

Integer)

Comments

Storing common values within configuration, such as database connection strings, is a

common feature that many applications take advantage of. Requiring developers to

write customer configuration section handlers to store simple values is overkill; hence

the existence of the <appSettings/> section.

Any simple data that you need stored in a central location and that must be available

anywhere within your Web application is a good candidate for the <appSettings/>

section. For other more complicated configuration data structures, you'll probably want

to create a custom configuration section handler.

Storing and Reading Custom Settings from the web.config File

2008-09-18T20:03:00.001+05:30

ASP.NET provides two ways to store information within the configuration file.The first

is to store simple name/value settings within an

<appSettings /> section,

The second is to create a custom configuration section that can store data

in any format.

In order to implement a custom configuration section handler, you must implement a

custom class that implements IConfigurationSectionHandler.The following is a partial

code sample for the new configuration section handler used for the ASP.NET

forums:

Imports System

Imports System.Collections

Imports System.Collections.Specialized

Imports System.Xml

Imports System.Configuration

Imports System.Web.Configuration

Namespace AspNetForums.Configuration

' *********************************************************************

' ForumsConfigurationHandler

' Class used by ASP.NET Configuration to load ASP.NET Forums configuration.

' ***********************************************************************/

Class ForumsConfigurationHandler

Implements IConfigurationSectionHandler

Public Overridable Overloads Function Create(ByVal parent As Object,

➥ ByVal configContext As Object, ByVal node As XmlNode) As Object

➥Implements IConfigurationSectionHandler.Create

Dim config As New ForumConfiguration(CType(parent,

ForumConfiguration))

config.LoadValuesFromConfigurationXml(node)

Return config

End Function

End Class

' *********************************************************************

' ForumConfiguration

' Class used to represent the configuration data for the ASP.NET Forums

' ***********************************************************************/

Public Class ForumConfiguration

Dim _pageSize As Integer = 25

' *****************************************************************

' ForumConfiguration

' Internal constructor for creating a new instance.

' ******************************************************************/

Public Sub New(ByVal parent As ForumConfiguration)

' Place holder for future work

End Sub

' *********************************************************************

' LoadValuesFromConfigurationXml

' Loads the forums configuration values.

' ******************************************************************/

Sub LoadValuesFromConfigurationXml(ByVal node As XmlNode)

Dim attributeCollection As XmlAttributeCollection = node.Attributes

' Get the attributes of the <forums> element

_pageSize =

Int32.Parse(attributeCollection("defaultPageSize").Value)

End Sub

' Properties

Public ReadOnly Property PageSize() As Integer

Get

Return _pageSize

End Get

End Property

End Class

End Namespace

This configuration section handler is compiled and then registered within an application.

It can then be used within web.config:

<section name="forums"

type="AspNetForums.Configuration.ForumsConfigurationHandler, AspNetForums" />

</sectionGroup>

</configSections>

<system.web>

</system.web>

</configuration>

Comments

This code example shows how you can create a custom configuration section. It's obviously

not a simple task. However, for controlling exactly how the configuration information

represents the data stored in the configuration file, it is the only option. If having a

custom configuration section seems to you like too much work just to store application

items, you're not alone.

Customizing Output for a Device

2008-09-18T19:45:00.001+05:30

The web.config file is as follows:

</deviceFilters>

The ASPX page is as follows:

<mobile:Form id="Form1" runat="server">

Header visible only in HTML Browsers

<BR>

<HR>

</HeaderTemplate>

<HR>

Footer visible only in HTML Browsers

</FooterTemplate>

</Choice>

<mobile:Label id="Lable1" runat="server" >Powered by

ASP.NET Visible on non-HTML browsers</mobile:Label>

</Choice>

</DeviceSpecific>

<mobile:Label id="Label1" runat="server">Content of Mobile

Form visible in all devices</mobile:Label>

</mobile:Form>

Comments

It want is possible to provide a richer user experience by optimizing the output of a specific

device.You can do this by configuring device filters in your application's web.config

file. Using the results of that filter test, you can enable content to be rendered on a

device-specific basis. As shown in the previous web.config file, the first device filter provides

HTML 3.2 support and the second provides WML 1.1 support.

All mobile controls support the capability to use a DeviceSpecific/Choice filter to

customize the output.The

mobile:Form control (which is a templated control) supports

header and footer templates as well. Combining these two features in the previous example

allows you to include a header and footer on browsers that support HTML.The

device that passes the isHTML32 test will be sent HTML content, and all other devices

are sent the content in the default <Choice> filter.

Displaying ObjectList Information in a Table

2008-09-18T19:44:00.001+05:30

The ASPX page is as follows:

<mobile:Form id="Form1" runat="server">

<mobile:ObjectList id="ObjectList1" runat="server"

LabelStyle-StyleReference="title"

CommandStyle-StyleReference="subcommand" >

</mobile:ObjectList>

</mobile:Form>

Sub Page_Load

' Code here to retrieve Book Listing

' Fields returned are

' - BookName

' - BookCategory

' - BookISBN

ObjectList1.DataSource = myBookList

ObjectList1.LabelField = "BookName"

ObjectList1.TableFields= "BookName;BookCategory;BookISBN"

ObjectList1.DataBind()

End Sub

Comments

The ObjectList control is the mobile control equivalent to the ASP.NET DataGrid.The

default display of the ObjectList in all devices is a single column listing of links.You designate

the field to be displayed as the link using the LabelField property. Clicking on

the link takes you to another screen that displays all fields for that item.

On mobile devices that have browsers that support HTML markup, it is possible to

display the initial listing in a tabular format by using the TableFields property. As

shown in this example, you need to separate each field that is to be displayed by a semicolon.

The first item in the TableField list is designated as the LabelField. Note that on

devices that do not support HTML markup, the ObjectList provides the default display.

Configuring Automatic Paging of Content

2008-09-18T19:42:00.001+05:30

The ASPX page is as follows:

<mobile:Form id="Form1" Paginate="true" runat="server">

<mobile:List id="List1" runat="server"></mobile:List>

</mobile:Form>

Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs)

If Not IsPostBack

Dim count AS Integer

For count = 1 To 100

Dim listItem = New MobileListItem(count.ToString())

List1.Items.Add(listItem)

End If

End Sub

Comments

Because the screens of mobile devices are typically small and cannot display large

amounts of data,ASP.NET mobile controls provide the capability to automatically paginate

across large amounts of data by splitting them into multiple screens.The form control

is an example of a mobile control that contains this functionality.

By setting the Paginate property of the form control, you enable this capability.The

control automatically inserts navigation constructs that are appropriate for the device in

question.This enables the users to page back and forth between multiple screens of data.

The TextView, List, and the ObjectList controls also support internal pagination.

Navigation in a Mobile Web Form

2008-09-18T19:41:00.001+05:30

The ASPX page is as follows:

<mobile:Form id="Form1" runat="server">

<mobile:Label id="Label1" runat="server">This is Form1</mobile:Label>

<mobile:Link id="Link1" runat="server"

NavigateUrl="#Form2">Go To Form2</mobile:Link>

<mobile:Link id="Link2" runat="server"

NavigateUrl="#Form3">Go To Form3</mobile:Link>

</mobile:Form>

<mobile:Form id="Form2" runat="server">

<mobile:Label id="Label2" runat="server">This is Form2</mobile:Label>

<mobile:Link id="Link3" runat="server"

NavigateUrl="#Form1">Go To Form1</mobile:Link>

<mobile:Link id="Link4" runat="server"

NavigateUrl="#Form3">Go To Form3</mobile:Link>

</mobile:Form>

<mobile:Form id="Form3" runat="server">

<mobile:Label id="Label3" runat="server">This is Form3</mobile:Label>

<mobile:Command id="Command1" onclick="Command1_Click"

runat="server">Go To Form1</mobile:Command>

<mobile:Command id="Command2" onclick="Command2_Click"

runat="server">Go To Form2</mobile:Command>

</mobile:Form>

void Command1_Click(Object sender, EventArgs e) {

ActiveForm = Form1;

}

void Command2_Click(Object sender, EventArgs e) {

ActiveForm = Form2;

}

Comments

Mobile ASP.NET Web Forms, unlike ASP.NET Web Forms, can have multiple form elements.

By default, the first form on a mobile page becomes the active form.The

<mobile:Link> control allows you to navigate from one form to another within a page.

The target of the link is set by the NavigateUrl property and takes the form of

#FormID, where FormID is the ID of the form that you want to navigate to.

You can also programmatically make a form active by using the ActiveForm property

as shown in Form3.

Creating a Mobile Web Form

2008-09-18T19:38:00.001+05:30

To declare an ASP.NET mobile page (a mobile Web Form), simply create a file with an

.ASPX extension and place it in a Web folder.The ASPX page must contain the following

directives and at least one

form element:

<%@ Page Inherits="System.Web.UI.MobileControls.MobilePage" %>

<%@ Register TagPrefix="mobile" Namespace="System.Web.UI.MobileControls"

Assembly="System.Web.Mobile" %>

<mobile:Form id="Form1" runat="server">Hello</mobile:Form>

<mobile:Form id="Form2" runat="server">World</mobile:Form>

Comments

ASP.NET pages that use mobile controls must inherit from System.Web.UI.

MobileControls.MobilePage. Just like with a regular Web Form, you can also set

optional parameters such as Language in the Page directive.The second directive associates

the mobile prefix with the mobile control namespace.

Note that HTML constructs such as <HTML> and <BODY> are not present, as these tags

do not render properly in a mobile device that does not support HTML. One key difference

between a regular Web Form and a mobile Web Form is that you can have more

than one form control in a mobile Web Form.This allows a single Web Form to display

multiple screens in a mobile device using form elements.

Finally, note that mobile controls support are built into ASP.NET v1.1, which should

make the @ Register directive unnecessary.

Implementing a CallBack when a Cached

2008-09-18T19:36:00.001+05:30

The capability to call a method whenever an item expires from the cache allows you to

build systems that can intelligently add data back into the cache.

Shared reason As CacheItemRemovedReason

Dim onRemove As CacheItemRemovedCallback

Public Shared Sub ItemRemovedCallback(key As String,

value As Object,

removedReason As CacheItemRemovedReason)

' Reason why the item was removed

reason = removedReason

' Reinsert the item into the Cache, but change the value

Cache.Insert(key, "Item re-inserted")

End Sub

Public Sub Page_Load(sender As Object, e As EventArgs)

onRemove = New CacheItemRemovedCallback(

AddressOf Me.ItemRemovedCallback)

' Add an item to the Cache with the callback

If Is Nothing(Cache("Key1")) Then

Cache.Insert("Key1", "In the Cache", Nothing,

DateTime.Now.AddSeconds(10),

TimeSpan.Zero, CacheItemPriority.Low, onRemove)

End If

' Set the label value

Label1.Text = Cache("Key1")

End Sub

</Script>

Value of the Cache: <asp:label id="Label1" runat="server" />

Comments

The capability of a function to be called when an item is removed from the cache is

very powerful. It allows you to reinsert the item or to report a reason as to why the item

was removed.

The only caveat is that during the time between when the item is removed from the

cache, yet before the callback function is called, another request might ask for the item

from the cache and would not find it. Regardless, it's still a very powerful technique for

controlling how items are removed from the cache.

Using HttpContext for Per-Request Caching

2008-09-18T19:34:00.001+05:30

Storing data within

HttpContext.Current.Items allows for data to exist for the duration

of the request and to be automatically discarded when the request is complete.

Public Function GetUserInfo(string username) As User

' Let's not go to the database each time we need the user's info

' the userKey is a unique value that identifies the user, such as the

' username

If (HttpContext.Current.Items(username) Is Nothing) Then

// Hang on to the data for this request only

HttpContext.Current.Items(username) = Provider.GetUserInfo(username);

End If

Return CType(HttpContext.Current.Items(username), User);

End Function

To see this code in action, see Users.cs class in the ASP.NET forums source code.

Comments

In some specialized cases, you want to cache some data only for the duration of the

request. A great example of this is in the ASP.NET forums (source code available at

www.asp.net).

The forums make use of personalization within each server control. A single page

may be composed of 10-12 server controls. Rather than each server control retrieving its

own set of data from the database, the code can reliably call the GetUserInfo() function

repeatedly. If the item is not found in the HttpContext.Items collection-a special dictionary

that exists for the duration of the request-it is created from the database and

added to HttpContext.Items.

This technique is very powerful because it allows your code to remain modular and

to take advantage of a caching technique to improve performance.

Varying Output Caching by HTTP Headers

2008-09-18T19:33:00.001+05:30

As demonstrated in Sections 4.6 and 4.7, it is possible to be very explicit about how

pages can be output cached.The last technique for controlling how pages can be cached

involves varying by HTTP headers presented by the client browser:

<%@OutputCache Duration="60" VaryByParam="none"

VaryByHeader="Accept-Language" %>

[content]

' Note, this only works for pages and not user controls

Sub Page_Load(object As Sender, e As EventArgs)

Response.Cache.SetExpires(DateTime.Now.AddSeconds(100))

Response.Cache.SetCacheability(HttpCacheability.Public)

Response.Cache.SetValidUntilExpires(true)

Response.Cache.VaryByHeaders("Accept-Language") = true;

End Sub

</script>

[content]

Comments

All browsers send over headers that provide information about the browser, or other relevant

information pertinent to the request. As discussed in Section 4.7, browsers provide

a user/agent header that allows ASP.NET to generate different content based on the

browser type. In addition to the user/agent header, several other headers are sent over

that you can vary by.The most common is the

Accept-Language header.

The Accept-Language header provides information about the language the client

prefers. For example, for United States English, the value is EN-US, whereas a request

from the United Kingdom might be EN-EN, France is FR-FR, and Japan is JP-JP.

When the output cache is varied by the Accept-Language header, different localized

versions of the page can be stored and served from the cache-assuming you've written

the code to do so.

Varying Output Caching by Browser

2008-09-18T19:32:00.001+05:30

You can vary by browser the output cache for pages using two techniques; only the

@OutputCache

directive is supported for User Control caching:

<%@OutputCache Duration="60" VaryByParam="none"

VaryByCustom="browser" %>

[content]

' Note, this only works for pages and not user controls

Sub Page_Load(object As Sender, e As EventArgs)

Response.Cache.SetExpires(DateTime.Now.AddSeconds(100))

Response.Cache.SetCacheability(HttpCacheability.Public)

Response.Cache.SetValidUntilExpires(true)

Response.Cache.SetVaryByCustom("browser")

End Sub

</script>

[content]

Comments

ASP.NET server controls can render different content depending upon the user/agent

presented to the server during the request. All browsers present a user/agent that allows

the server addressing the request to know the capabilities of the browser.This is regardless

of whether the browsers are desktop browsers such as IE, Netscape, or Opera, or

mobile/device browsers, such as the browser found in a RIM device, cellular phone, or

handhelds.

Many ASP.NET server controls can render different content that is better suited to

the browser type making the request. A great example of this capability is existence of IE

Web Controls and ASP.NET Mobile controls (both available at www.asp.net).These

controls intelligently detect the browser type.When desktop browsers are used, HTML is

rendered.When mobile browsers are used,WML is rendered.

Varying the cache by browser allows for the ASP.NET cache to store different versions

of the requested page in the cache based on the type of browser making the

request.The only caveat is that only the browser type and major version number-IE

6.0, for example-are tracked. For example, versions 4.0, 4.1, and 4.5, of Netscape

browsers would all resolve to one entry within the cache.

Varying Output Caching by Parameter(s)

2008-09-18T19:30:00.000+05:30

There are two techniques for varying by parameters in pages; partial page caching only

supports the

@OutputCache directive.

<%@OutputCache Duration="60" VaryByParam="productId" %>

[content specific to the product id value]

' Note, this only works for pages and not user controls

Sub Page_Load(object As Sender, e As EventArgs)

Response.Cache.SetExpires(DateTime.Now.AddSeconds(100))

Response.Cache.SetCacheability(HttpCacheability.Public)

Response.Cache.SetValidUntilExpires(true)

Response.Cache.VaryByParams("productId") = True

End Sub

</script>

[content specific to the product id value]

Dynamic pages usually accept parameters and potentially display different output determined

by these parameters. A common example is a page used to display product information,

such as products.aspx?productId=10.

The page is passed a single parameter, the product ID, and the content is retrieved for

that particular product. Output caching allows you to cache the results of a dynamically

generated page so you don't need to execute the page on each request.Varying the output

cache by parameters allows you to cache multiple views of the page based on parameters

that affect the output, such as a products.aspx page that accepts a productId

parameter.

Multiple parameters can be specified using the @OutputCache directive by using a

semicolon to separate items. For example, if you were generating output based on the

productId and the salesId, you could specify the following:

<%@OutputCache Duration="60" VaryByParam="productId;salesId" %>

Using the @OutputCache directive, it is also possible to vary all parameters.This isn't a

recommended approach, but if you're not sure how many parameters you depend upon,

using VaryByParam = "*" will vary by all parameters. Conversely, using VaryByParam =

"none" will vary by no parameters.

Creating a Cache Dependency

2008-09-18T19:29:00.001+05:30

As discussed in Section 4.3, the cache allows for items to be inserted or added to the

Cache along with several other parameters, such as time-based constraints or an instance

CacheDependency.

Sub Page_Load(object As Sender, e As EventArgs)

Dim stringArray As string {"Rob", "Steve", "Mike", "Anne"}

' Time based dependency for 60 minutes

Cache.Insert("myArray-Time", stringArray, Nothing,

DateTime.Now.AddMinutes(60), TimeSpan.Zero)

' File based dependency

Dim fileDep = New CacheDependency(Server.MapPath("Products.xml"))

Cache.Insert("myArray-File", stringArray, fileDep)

' Key based dependency

Cache.Insert("myKey", "key for dependencies")

Dim keyDep = New CacheDependency(Nothing, "myKey")

Cache.Insert("myArray-Key", stringArray, fileDep)

End Sub

</script>

Comments

In the previous examples, three types of dependencies are created:

n Time-Time-based dependencies specify that an item is to remain in the cache

for the specified duration of time.This is the same functionality found when using

the @OutputCache directive and setting the Duration attribute.

n File-File-based dependencies specify that an item is to remain in the cache until

the named file changes.Any output cached page is automatically made dependent

upon itself. However, it's possible-as demonstrated in this example-to use this

same functionality for entries within the Cache API.

n Key-Key-based dependencies specify that an item is to remain in the cache until

a related cache key changes.This is very powerful because any running ASP.NET

code can affect the cache key to enforce this relationship. For example, cascading

relationships can be established whereby one cache entry is changed or removed

and multiple other cache entries are affected.

Dependencies provide a simple but powerful programming model for controlling

removal of resources from the cache when other resources change.

Retrieving Data from the Cache

2008-09-18T19:26:00.001+05:30

Retrieving objects stored within the cache is simple; there are two options for doing so:

Dictionary style-Using patterns similar to that of Session and Application.

Cache.Get() API-The Get() method accepts a single parameter that fetches the

value of the named key.

Given the example used in Section 4.3 that added a dataset into the cache using the key

MyProducts, you could retrieve this value from the Cache:

' Get a value from the cache

Sub Page_Load(object As Sender, e As EventArgs)

Dim ds As DataSet

If (Cache("MyProducts") Is Not Nothing) Then ' Uses Dictionary style API

ds = CType(Cache.Get("MyProducts"), DataSet) ' Uses Get() method

End If

End Sub

</script>

Comments

Getting items stored within the cache is very simple. Although both techniques-dictionary

style and Get()-are used in this example, the dictionary style access is the one

most frequently used.

Inserting Data into the Cache

2008-09-18T19:24:00.001+05:30

There are several ways to add items into the Cache API:

Dictionary style-Similar to the way the Session or Application API is used.

Insert method-Inserts the named item into the cache and allows for additional

parameters that specify other cache behavior, such as when the item should be

removed from the cache.

Add method-Same as insert, but adds the item only if it did not already exist.

In the following examples, products is assumed to be a dataset. However, it could be

any .NET class.

' Add an item using the dictionary style API

Cache("MyProducts") = products

' Insert an item using the overloaded Insert method

Cache.Insert("MyProducts", products)

' Insert an item and specify a cache dependency

Cache.Insert("MyProducts", products, cacheDependency)

' Insert an item and specify that the item exists for only 60 minutes

Cache.Insert("MyProducts", products, Nothing,

DateTime.Now.AddMinutes(60), TimeSpan.Zero)

' Insert an item and specify that the item exists for only 60 minutes, has a

' high priority and specify a callback function called when the item is

' removed from the cache

Cache.Insert("MyProducts", products, Nothing, DateTime.Now.AddMinutes(60),

TimeSpan.Zero, CacheItemPriority.High, cacheCallBack)

' Add an item using the Add method

Cache.Add("MyProducts", products, cacheDependency,

DateTime.Now.AddMinutes(60), TimeSpan.Zero,

CacheItemPriority.High, cacheCallBack)

Comments

The Cache API, accessible simply as the Cache property within an ASP.NET page, is the

underlying data store used by page output caching, partial page caching, and Web service

caching.There are many cases when caching the output of the page is not desirable, but

data can still be reused. One example is a listing of products or reports.The data is stored

in memory, but options within the page determine how the data is displayed.

Something to keep in mind when using the cache is that it is scavenging.As memory is

needed, items are removed from the cache using an LRU (least recently used) algorithm.

Therefore, before using an item from the cache it is always wise to verify that the item

exists and is not Nothing:

If (Cache("MyProducts") Is Not Nothing)

… Insert into the cache

End If

The various parameters accepted by Insert() and Add() provide control over how the

cache stores data.You can provide a CacheDependency, which then enforces a relationship

between the item stored within the cache and either a file or cache key.When the

file or cache key changes, the related entry within the cache is removed. It is also possible

to specify time-based constraints using a fixed point in time or a sliding window of

time. It's possible to control the priority of items stored within the cache using the

CacheItemPriority enumeration-this affects how the scavenging algorithm removes

items. Finally, you can specify a callback function that the cache will call when an item is

removed.

Partial Page Output Caching Using VaryByControl

2008-09-18T19:20:00.000+05:30

The

VaryByControl directive provides a helpful shortcut to vary the User Controls output

by a contained control.

<%@ Imports Namespace="System.Data.SqlClient" %>

<%@ OutputCache Duration="60" VaryByControl="SortBy" %>

Sub Page_Load (sender As object, e As EventArgs)

Dim connection As New SqlConnection([your connection string])

Dim command As New SqlCommand("BookSelection", connection)

' Mark as a stored procedure

command.CommandType = CommandType.StoredProcedure

' Set up a SQL parameter for the book type selected

command.Parameters.Add("@BookType",

➥SqlDbType.NVarChar, 25).Value =

➥SortBy.SelectedItem.Value

' Execute

connection.Open()

BookListing.DataSource = command.ExecuteReader()

BookListing.DataBind()

connection.Close()

End Sub

</script>

Please select the types of books you are interested in:

<asp:DropDownList AutoPostBack="true" id="SortBy" runat="server" >

<asp:listitem >Technology</asp:listitem>

<asp:listitem >Fiction</asp:listitem>

<asp:listitem >Non-Fiction</asp:listitem>

</asp:DropDownList>

<br>

<asp:DataGrid runat="server" id="BookListing" />

</form>

Comments

Consider a User Control that displays a list of the top 10 books with a SortBy

DropDownList containing Technology, Fiction, and Non-Fiction.Whenever a user

changes a value in the DropDownList the server returns data filtered by the value of

SortBy.

The content generated by the User Control can be varied just as you can vary page

output cached responses. However, within a User Control, the name of the control,

SortBy, is namespaced to the name of the containing control-UserControl1:SortyBy.

This allows multiple Top10 User Controls to be hosted in the same page without experiencing

naming collisions.

For example, if you had two of these User Controls on your page, they might have

the IDs Top10Books1 and Top10Books2. Top10Books1:SortBy and Top10Books2:

SortBy are treated as separate drop-down controls.The VaryByControl option simply

allows you to avoid typing VaryByParam="Top10Books2:SortBy"-instead simply type

VaryByControl="SortBy".

Page Output Caching

2008-09-18T19:17:00.001+05:30

Page output caching can be accomplished declaratively using a page @

OutputCache

directive or programmatically using the Response.Cache API.The following code samples

are equivalent:

Sub Page_Load (sender As object, e As EventArgs)

Response.Cache.SetExpires(DateTime.Now.AddSeconds(100))

Response.Cache.SetCacheability(HttpCacheability.Public)

Response.Cache.SetValidUntilExpires(true)

' Set the timestamp

timestamp.Text = DateTime.Now.ToString()

End Sub

</script>

<asp:Label id="timestamp" runat="server" />

<%@ OutputCache Duration="100" VaryByParam="none" %>

Sub Page_Load(sender As Object, e As EventArgs)

timestamp.Text = DateTime.Now.ToString()

End Sub

</script>

<asp:Label id="timestamp" runat="server" />

Comments

As you can clearly see in the code sample, the page @OutputCache directive is much easier

to implement. However, the lower-level Response.Cache API provides more flexibility

when necessary. In either case, the content for the response is generated once and

stored in memory before being sent back to the client.The contents are never written to

disk, but instead are kept in memory within the application using the Cache API.

In the @OutputCache directive example, the Duration and VaryByParam attributes are

required (if they are not specified, an exception is thrown detailing the requirements of

these attributes).The Duration attribute is a time dependency, in seconds, used to control

the lifetime of the cached response in memory.The VaryByParam attribute specifies

which parameters (in the Request.Params collection) should cause separate versions of

the page to be stored in the cache.

The SetValidUntilExpires() method on Response.Cache is used to control a

nuance of HTTP caching. By default, this method is set to true when using the

@OutputCache directive. Conversely, the default is false when using the

Response.Cache API. SetValidUntilExpires() controls how ASP.NET honors cache

invalidation headers sent by browsers.When users click the Refresh button in the browser,

the browser sends an HTTP header to the server specifying that the requested content

cannot come from a cache.When SetValidUntilExpires() is true, the HTTP

cache invalidation request sent by the browser is ignored and the request can be served

from the cache; when false, the HTTP cache invalidation request is honored and the

request is removed from the cache. It's recommended to always set this to true to guarantee

that the server can respond from the cache, otherwise a simple refresh in the

browser can remove the item from the cache.

Installing a Component in the Global Assembly Cache (GAC)

2008-09-16T23:50:00.000+05:30

The Global Assembly Cache in the .NET Framework provides a central place for registering
assemblies. Registered assemblies are then available to all applications, including
the development environments like Visual Studio.NET and Web Matrix.The process of
adding an assembly to the Global Assembly Cache can be compared to the process of
registering COM components in the server, as is done in the case of Windows DNA
applications.The first step involved in adding an assembly is to strong-name the assembly. A strong
name is basically assigned to an assembly or a component to distinguish it from other
assemblies and components existing in the GAC. A strong name consists of an assembly
identity (name, version, and so on), a public key, and a digital signature.Assigning a strong name to an assembly ensures that it is unique, has version protection,
and has code integrity. Assigning a strong name to an assembly is not a difficult task.

You can use the sn.exe utility to generate strong names, which are then added to the
code of the assembly. For example, to create a strong name for an assembly named sample.
dll, you would write the following in the command prompt:
c:\MyAssembly>sn -k sample.snk

This would generate a strong name keypair and store it in a file named sample.snk.The
file extension can be anything, but.SNK is normally used as a convention.The -k option
creates a strong name keypair.There are other options that you can search for in MSDN.
The second step is to associate the generated strong name file with the assembly.Add
the following code to your assembly to associate the strong name. By default,Visual
Studio .NET projects include skeleton declarations of these attributes in the AssemblyInfo file.

Imports System.Reflection
<assembly: AssemblyKeyFile(“sample.snk”)>
Note here that the information regarding the file containing the strong name keypair is
placed in the code file before any namespace declaration. Also, you must import the
System.Reflection namespace in order for the statement to work, otherwise the compiler
will not recognize the <assembly: AssemblyKeyFile(“sample.snk”)> statement.
After compiling the assembly with the statements containing the strong name information
being added to it, you now have to place the assembly into the GAC.You can do
this manually by simply copying and pasting the assembly into the GAC, which is located
at C:\WINNT\ASSEMBLY\.

You can also use the gacutil.exe utility, installed with the .NET Framework. In order
to add an assembly, you write the following on the command prompt:
gacutil /i sample.dll
The /i option is for installation. In order to remove an assembly from the GAC, you can
use the same utility, as follows:
gacutil /u sample.dll
The /u option is for uninstalling or removing an assembly from the cache.Typing
gacutil /? lists all of its options.

Data-binding a TreeView Control

2008-09-16T23:34:00.000+05:30

If you have not worked with the TreeView control before, refer to section 3.8 for basic
TreeView information. First, you need to add the TreeView to your page and set the
treenodesrc property to the XML file that you’ll be creating.
<mytree:treeview runat=”server” id=”myTree” treenodesrc=”cars.XML”>
</mytree:treeview>

The next thing you need to do is create your XML file that you will use to bind the
TreeView to:
<?xml version=”1.0” encoding=”utf-8” ?>
<TREENODES>
<treenode text=”Cars”>
<treenode text=”Ford” />
<treenode text=”Toyota” />
<treenode text=”Infiniti” />
</treenode>
</TREENODES>
When the page loads, the TreeView will generate its nodes from the XML file.

It is not possible to directly data-bind a dataset to the TreeView Web Control.The data
must first be translated to XML.You can use response.write, which writes the XML,
or use XSLT to transform the dataset into the correct XML.When using XSLT, you can
specify the XSLT file using the TreeNodeXsltSrc property of the TreeView. In addition
to using XML to define the actual nodes of the TreeView, you can also use XML to
define the style types by using the TreeNodeTypeSrc property of the TreeView control.

Using the ToolBar IE Web Control

2008-09-16T23:33:00.000+05:30

Using the TabControl and PageView IE Web Controls

2008-09-16T23:32:00.000+05:30

The first step is to install the IE Web Controls from Microsoft.The link to download and
install these controls is as follows: http://msdn.microsoft.com/downloads/samples/
internet/default.asp?url=/downloads/samples/internet/asp_dot_net_
servercontrols/webcontrols/default.asp

Next, you need to add a reference to the Web Controls on your page:
<%@ Register TagPrefix=”ieControls”
Namespace=”Microsoft.Web.UI.WebControls”
Assembly=”Microsoft.Web.UI.WebControls” %>
<%@ import namespace=”Microsoft.Web.UI.WebControls” %>
Then you add your tabstrip.This is the control that generates the tabs that users click to
change pages:
<IECONTROLS:TABSTRIP id=”myTabStrip” runat=”server” TargetID=”myMultiPage”
Orientation=”Vertical”>
<IECONTROLS:Tab Text=”Tab 1”></IECONTROLS:Tab>
<IECONTROLS:TabSeparator></IECONTROLS:TabSeparator>
<IECONTROLS:Tab Text=”Tab 2”></IECONTROLS:Tab>
<IECONTROLS:TabSeparator DefaultStyle=”height:100%;”>
</IECONTROLS:TabSeparator>
</IECONTROLS:TABSTRIP>
Lastly, you need to add your multipage control that contains the different pages that will
be viewed when users select each tab:
<IECONTROLS:MULTIPAGE id=”myMultiPage” runat=”server”>
<IECONTROLS:PAGEVIEW>
Page 1
</IECONTROLS:PAGEVIEW>
<IECONTROLS:PAGEVIEW>
Page 2
</IECONTROLS:PAGEVIEW>
</IECONTROLS:MULTIPAGE>

Notice that there is a property on the tabstrip control called TargetID.This must be set
to the ID of the multipage control that will be working with the tabstrip.When the
users click on the tab, the tabstrip will then tell the PageView to show the corresponding
page.When working with the multipage control, you can add any type of ASP.NET
or HTML between the opening and closing PageView tags. In this example, the tabstrip
is running vertically, but you can also set this value to horizontal.To do so, you simply
need to set the Orientation property to horizontal.

Dynamically Adding Controls to a Web Form

2008-09-16T19:10:00.000+05:30

You can add controls to any class that exposes a Controls() collection property by
using the Class.Controls.Add() method. In this example, the user chooses which control
should be added to the page. The PlaceHolder control can be used to specify
exactly where on a Web Form you want your new control to appear, but otherwise is
not necessary for this technique to work.

The ASPX page is as follows:
<form id=”code0307” method=”post” runat=”server”>
<asp:DropDownList id=”DropDownList1” runat=”server”>
<asp:ListItem Value=”Simple Text Control (code0301)”>
Simple Text Control (code0301)</asp:ListItem>
<asp:ListItem Value=”RainbowLabel (code0302)”>RainbowLabel
(code0302)</asp:ListItem>
</asp:DropDownList>
<asp:Button id=”Button1” runat=”server” Text=”Select”
onclick=”Button1_Click”></asp:Button>
<p>
<asp:PlaceHolder id=”PlaceHolder1” runat=”server”></asp:PlaceHolder>
</p>
</form>
In <script runat=”server” /> block or codebehind:
Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
‘ Initialize Placeholder
PlaceHolder1.Controls.Clear()
Select Case DropDownList1.SelectedIndex
Case 0:
Dim SimpleText As AspNetCookbook.code0301vb = _
New AspNetCookbook.code0301vb()
SimpleText.Text = “This is the simple text control from Code 3.01.”
PlaceHolder1.Controls.Add(SimpleText)
Exit Select
Case 1:
Dim RainbowText As AspNetCookbook.RainbowLabel = _
New AspNetCookbook.RainbowLabel()
RainbowText.Text = “This is the RainbowText control from code 3.02.”
PlaceHolder1.Controls.Add(RainbowText)
Exit Select
End Select
End Sub

Creating a Templated Control

2008-09-12T16:06:00.000+05:30

This example creates a simple templated control. It displays the current time on the server
on which it runs and allows you to add dynamic text and so on.
First, the main control class, DateTimeControl:
Imports System
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.ComponentModel
Namespace AspNet
<ToolboxData(“<{0}:DateTimeControl runat=server></{0}:DateTimeControl>”), _
ParseChildren(True)> _
Public Class DateTimeControl
Inherits Control
Implements INamingContainer
Private _template As ITemplate
Private _container As DateTimeContainer
Private _text As String
<TemplateContainer(GetType(DateTimeContainer))> _
Public Overridable Property Template() As ITemplate
Get
Return _template
End Get
Set(ByVal Value As ITemplate)
_template = Value
End Set
End Property
Public Overridable ReadOnly Property Container() As DateTimeContainer
Get

Return _container
End Get
End Property
Public Overridable Property Text() As String
Get
Return _text
End Get
Set(ByVal Value As String)
_text = Value
End Set
End Property
Public Overridable ReadOnly Property DateTime() As String
Get
Return System.DateTime.Now.ToShortTimeString()
End Get
End Property
Protected Overrides Sub OnDataBinding(ByVal e As EventArgs)
EnsureChildControls()
MyBase.OnDataBinding(e)
End Sub ‘OnDataBinding
Protected Overrides Sub CreateChildControls()
If Not (Template Is Nothing) Then
_container = New DateTimeContainer(Text, DateTime)
Template.InstantiateIn(Container)
Controls.Add(Container)
Else
Controls.Add(New LiteralControl(“” + [Text] + “ “ + DateTime))
End If
End Sub
End Class
Now let’s take a look at the container control DateTimeContainer. It enables you to use
<%# Container.Text %> and so forth.
Public Class DateTimeContainer
Inherits Control
Implements INamingContainer
Private _text As String
Private _dateTime As String
Public Sub New(ByVal text As String, ByVal dateTime As String)

Me._text = text
Me._dateTime = dateTime
End Sub ‘New
Public ReadOnly Property Text() As String
Get
Return _text
End Get
End Property
Public ReadOnly Property DateTime() As String
Get
Return _dateTime
End Get
End Property
End Class
End Namespace

This control allows you to add a template and thus choose how you want the data to be
presented.The control is built using two classes—DateTimeControl is the actual control
you add to the page and DateTimeContainer is the container control that holds the
actual template data. Use of a container class is, strictly speaking, not necessary if you
don’t want to use custom properties. If you just want to display static content, you can
instantiate the control in a Panel control or a similar control.

Creating a Data-bound Control

2008-09-12T16:04:00.000+05:30

This example shows you how to create a simple and original data-bound custom server
control—a data-bound bulleted list.The CustomBulletedList class is as follows:

Imports System
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.ComponentModel
Imports System.Collections
Imports System.Text
Public Class CustomBulletedList
Inherits System.Web.UI.WebControls.WebControl
Private _html As New StringBuilder()
Private _dataSource As IEnumerable
Public Property DataSource() As IEnumerable
Get
Return _dataSource
End Get
Set(ByVal value As IEnumerable)
_dataSource = value
End Set
End Property
Private Sub CreateBulletedList()
Dim dataSource As IEnumerable = Nothing
Try
dataSource = Me._dataSource
Catch
End Try
If Not (dataSource Is Nothing) Then
_html.Append(“<ul>”)
Dim dataObject As Object
For Each dataObject In dataSource
_html.Append(“<li>”)
_html.Append(dataObject)
_html.Append(“</li>”)
Next dataObject
_html.Append(“</ul>”)
End If
End Sub

Public Overrides Sub DataBind()
MyBase.OnDataBinding(EventArgs.Empty)
CreateBulletedList()
End Sub
Protected Overrides Sub Render(ByVal output As HtmlTextWriter)
output.Write(_html)
End Sub
End Class
To use this control, you need to do the following:
<%@ Page Language=”VB” %>
<%@ Register TagPrefix=”AspNet” Namespace=”AspNet”
Assembly=”AspNet” %>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN” >
<html>
<head>
<title>Data Bound Controls</title>
</head>
<body>
<script language=”vb” runat=”server”>
Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)
listControl.DataSource = New String() {“Test 1”, “Test 2”, “Test 3”}
listControl.DataBind()
End Sub
</script>
<AspNet:CustomBulletedList id=”listControl” runat=”server”/>
</body>
</html>

This control allows you to data-bind any data source that is derived from IEnumerable
to it—the content will be listed in bulleted format. Overriding the DataBind method is
the critical point in this control.When this method is called, it is trying to bind to the
data source and call the CreateBulletedList method.
CreateBulletedList loops through all of the data objects in the data source and
saves them to be outputted as bulleted lines.
By overriding the Render method, you can control the rendering of the control, and
render it exactly as you see fit.You should always opt for this approach when performance
is an issue (and when isn’t it?), because it is much faster than overriding the
CreateChildControls method.
One last point you should take note of is that you should always use a StringBuilder
instead of a regular string as the HTML output source. Using regular string objects will
seriously degrade the performance of your custom control.

Creating a Composite Control

2008-09-12T16:02:00.000+05:30

This example shows you how to create a very simple yet useful composite control.The
control is a composition of a TextBox and a validator, and the control can be used to validate
email addresses.The EmailTextBox class is as follows:
Imports System
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.ComponentModel
Imports System.ComponentModel.Design
Namespace AspNetPublic Class EmailTextBox
Inherits System.Web.UI.WebControls.WebControl
Implements INamingContainer
Private textBox As textBox
Private validator As RegularExpressionValidator
Public Property Text() As String
Get
EnsureChildControls()
Return textBox.Text
End Get
Set(ByVal Value As String)
EnsureChildControls()
textBox.Text = Value
End Set
End Property
Public Property ErrorMessage() As String
Get
EnsureChildControls()
Return validator.ErrorMessage
End Get
Set(ByVal Value As String)
EnsureChildControls()
validator.ErrorMessage = Value
End Set
End Property
Public Overrides ReadOnly Property Controls() As ControlCollection
Get
EnsureChildControls()
Return MyBase.Controls
End Get
End Property
Protected Overrides Sub CreateChildControls()
Controls.Clear()
textBox = New TextBox
validator = New RegularExpressionValidator
Controls.Add(textBox)
Controls.Add(validator)
textBox.ID = “Email1”
validator.ControlToValidate = textBox.ID
‘A typical email address regular expression
validator.ValidationExpression = “^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}
\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\.)+))
([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$”
End Sub
End Class
End Namespace
To use this control, you need to do the following:
<%@ Page language=”VB” %>
<%@ Register TagPrefix=”AspNet” Namespace=”AspNet”
Assembly=”AspNet” %>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN” >
<html>
<head>
<title>code0304</title>
</head>
<body>
<form id=”Form1” method=”post” runat=”server”>
<AspNet:EmailTextBox
ID=”EmailTextBox1”
ErrorMessage=”You must provide a valid email address!”
runat=”server”
/>
</form>
</body>
</html>

This control validates the input in the TextBox. If the input is not a valid email address
an error message appears. Controls like this one are useful on pages that contain a lot of
user input that needs to be validated.You can easily extend this control to use several
validator types, allow the page developer to define his/her own validation expression,
and so on.

Creating ViewState-Enabled Control Properties

2008-09-12T15:59:00.000+05:30

This example shows you how to create properties for your controls that retain their state
using ViewState.
The ViewStateControl class:

Imports System
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.ComponentModel
Public Class ViewStateControl
Inherits System.Web.UI.WebControls.WebControl
Public Property [Text]() As String
Get
Dim _text As String = CStr(ViewState(“Text”))
If _text Is Nothing Then
Return String.Empty
Else
Return _text
End If
End Get
Set(ByVal Value As String)
ViewState(“Text”) = Value
End Set
End Property
Protected Overrides Sub Render(ByVal writer As HtmlTextWriter)
writer.Write([Text])
End Sub
End Class
To use this control, you need to do the following:
<%@ Page language=”VB” %>
<%@ Register TagPrefix=”AspNet” Namespace=”AspNet”
Assembly=”AspNet” %>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN” >
<html>
<head>
<title>code0303</title>
</head>
<body>
<script language=”VB” runat=”server”>
Sub Page_Load(Sender As Object, E As EventArgs)
If Not IsPostBack Then
Dim RandomGenerator As Random
RandomGenerator = New Random(DateTime.Now.Millisecond)
ViewStateControl1.Text = RandomGenerator.Next(1,100)
End If

End Sub
</script>
<form id=”Form1” method=”post” runat=”server”>
<AspNet:ViewStateControl id=”ViewStateControl1” runat=”server”/>
<asp:linkbutton text=”PostBack test” runat=”server”/>
</form>
</body>
</html>

This control property called Text will retain its state on postbacks—as you see, it is quite
easy to get properties to retain their state by using the ViewState property, and this
technique is recommended for most Web Control properties.

Extending Existing Web Controls

2008-09-11T17:18:00.000+05:30

This example shows how to extend the functionality of an existing control—the Label
control—and turn it into a RainbowLabel.This is accomplished through the use of
inheritance—RainbowLabel is a subclass of the System.Web.UI.WebControls.Label class.
The RainbowLabel class is as follows:
Imports System
Imports System.Web.UI
Imports System.Web.UI.WebControls
Imports System.ComponentModel
Public Class RainbowLabel
Inherits System.Web.UI.WebControls.Label
Public Property EnableRainbowMode() As Boolean
Get
If ViewState(“EnableRainbowMode”) Is Nothing Then
Return True
Else
Return Boolean.Parse(CStr(ViewState(“EnableRainbowMode”)))
End If
End Get
Set(ByVal Value As Boolean)
ViewState(“EnableRainbowMode”) = Value
End Set
End Property
Protected Overrides Sub Render(ByVal output As HtmlTextWriter)
If EnableRainbowMode Then
output.Write(ColorizeString([Text]))
Else
output.Write([Text])
End If
End Sub ‘Render
Private Function ColorizeString(ByVal input As String) As String
Dim output As New System.Text.StringBuilder(input.Length)
Dim rand As Random = New Random(DateTime.Now.Millisecond)
Dim i As Integer
For i = 0 To input.Length - 1
Dim red As Integer = rand.Next(0, 255)
Dim green As Integer = rand.Next(0, 255)
Dim blue As Integer = rand.Next(0, 255)
output.Append(“<font color=””#”)
output.Append(Convert.ToString(red, 16))
output.Append(Convert.ToString(green, 16))
output.Append(Convert.ToString(blue, 16))
output.Append(“””>”)
output.Append(input.Substring(i, 1))
output.Append(“</font>”)
Next i
Return output.ToString()
End Function
End Class
To use this control, you need to do the following:
<%@ Page language=”VB” %>
<%@ Register TagPrefix=”AspNetCookbook” Namespace=”AspNetCookbook”
Assembly=”AspNetCookbook” %>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN” >
<html>
<head>
<title>03 Custom Controls - 02 Extending Existing Web Controls</title>
</head>
<body>
<form id=”Form1” method=”post” runat=”server”>
<AspNetCookbook:RainbowLabel text=”This is a rainbow colored test string”
runat=”server”/><br />
<AspNetCookbook:RainbowLabel EnableRainbowMode=”false”
text=”This is a test string” runat=”server”/>
</form>
</body>
</html>

This control creates a rainbow-ish pattern in the text it displays.This is accomplished by
encapsulating each character in <font> tags.The color on each character is randomized.
Although perhaps not the most useful control, it does demonstrate how easy it is to
extend the functionality of existing Web Controls. It is worth noting that the Label control
should not be overlooked as a powerful control on which to build—the validation
controls all inherit from the simple Label control.

Declaring a Simple Custom Control

2008-09-11T17:16:00.000+05:30

This example demonstrates how easy it is to create custom controls in ASP.NET, especially
when compared to COM components.You simply create a class that inherits from
System.Web.UI.Control or System.Web.UI.WebControls.WebControl and give it
whatever properties and methods you need. In Visual Studio .NET, you would normally
do this by creating a new Web Control Library project.You override its Render()
method to control its output, and you have a very simple yet powerful tool for encapsulating
and reusing user interface logic.
The code0301vb class is as follows:
Imports System.ComponentModel
Imports System.Web.UI
Namespace AspNetCookbook
<DefaultProperty(“Text”), ToolboxData(“<{0}:code0301vb
runat=server></{0}:code0301vb>”)> Public Class code0301vb
Inherits System.Web.UI.WebControls.WebControl
Dim _text As String
<Bindable(True), Category(“Appearance”),
DefaultValue(“”)> Property [Text]() As String
Get
Return _text
End Get
Set(ByVal Value As String)
_text = Value
End Set
End Property
Protected Overrides Sub Render(
ByVal output As System.Web.UI.HtmlTextWriter)
output.Write([Text])
End Sub
End Class
End Namespace
To reference a custom control on a Web Form, you need to add a Register directive to
the page, and specify three parameters.The TagPrefix is used for all controls from this
namespace and assembly when they are declared on the page, and can be anything but
asp, which is reserved for the built-in Web Controls that ASP.NET provides. Next, the
namespace in which the controls reside must be specified. Finally, the name of the
assembly, without any path information or the .DLL extension, is specified for the
Assembly parameter. An example of this follows:
<%@ Page language=”VB” %>
<%@ Register TagPrefix=”AspNetCookbook” Namespace=”AspNetCookbook”
Assembly=”codeVB” %>
...
<form id=”Form1” method=”post” runat=”server”>
<AspNetCookbook:code0301vb id=”code0301vb1” runat=”server” />
</form>

Note that in Visual Studio .NET, a default namespace with the same name as the project
is automatically prefixed to all Visual Basic class names.This is a frequent source of confusion
and is inconsistent with how default namespaces are handled in C#, where they
are inserted into each class file as a visible namespace.You can turn off this default
behavior by setting the default namespace to an empty string in the Project Properties
dialog box.You can determine the full namespace of a class by using the ILDASM.EXE
command-line tool on the generated assembly, or by going into the class view utility in
Visual Studio .NET.

Programmatically Accessing Properties of a Late-Bound User Control

2008-09-11T17:14:00.000+05:30

In this example, you have a simple greeting User Control that exposes two properties
and a method.You set one property using late binding and the other property using
reflection.You then invoke the method using reflection.The User Control uses these
properties to display a Label that holds a combination of these values.The code for the
User Control is available from this book’s support Web site.When you declare the User
Control on the page, you also set its username property declaratively—this property will
be overridden at runtime by the code in Page_Load().

The ASPX page:
<form id=”Test” method=”post” runat=”server”>
<uc1:Recipe0208vb id=”Recipe0208vb1” runat=”server”
username=”Steve”></uc1:Recipe0208vb>
</form>

In <script runat=”server” /> block or codebehind:
Protected Recipe0208vb1 As Object
Private Sub Page_Load(ByVal sender As System.Object, _
ByVal e As System.EventArgs) Handles MyBase.Load
‘Late binding call will override declarative setting
‘Only works in VB, not C#
Recipe0208vb1.UserName = “Rob”
‘Reflection
Dim myControl As Control = Page.FindControl(“Recipe0208vb1”)
Dim myControlType As Type = myControl.GetType()
Dim GreetingProperty As PropertyInfo =
myControlType.GetProperty(“Greeting”)
GreetingProperty.SetValue(myControl, “Guten Tag, “, Nothing)
Dim MessageMethod As MethodInfo = myControlType.GetMethod(“AddMessage”)
Dim Params() As Object = New Object()
{“This message was added using reflection!”}
MessageMethod.Invoke(myControl, Params)
End Sub

There are two ways to do this.The first one only works in Visual Basic and uses late binding.
It works only when Option Strict is turned off, and allows variables declared as
Object to use methods and properties that are not known at compile time. In general, it
is not a good idea to use late binding if you can avoid it. However, one of the advantages
of VB over C# is that it supports late binding, which provides a much simpler mechanism
than reflection for tasks like the one described in this section.
The second technique uses a process called reflection, which uses classes found in the
System.Reflection namespace.The net effect is the same as with late binding, but the
calls are much more explicit, and there is a lot more code. Because reflection is built into
the .NET Framework, it will work with any .NET language.

Sharing User Controls Across Application Domains

2008-09-11T17:12:00.000+05:30

By design, User Controls are inaccessible outside of the application domain in which
they reside.This is for security reasons. However, this can be a limitation if you want to
share User Controls across several applications on a server. A fairly straightforward
workaround exists, which involves setting up a virtual directory within each application
that needs to use the User Controls, and mapping that virtual directory to a single physical
directory containing the User Controls.This solution is better than simply copying
the User Controls from application to application, because that would quickly turn into
a maintenance nightmare.

These steps were developed by readers of AspAlliance.com, and were first published
in the article listed at the end of this section.
1. Create a Web application project to hold the User Controls, and place the shared
User Controls in this project.
2. Create a virtual directory in each application that needs to use these shared User
Controls.This is done in the IIS manager by right-clicking on the application and
choosing New,Virtual Directory. Browse to the folder created for the Web application
in Step 1, and name the directory the same as that folder.
3. Create a reference from each application that needs the shared controls to the
shared controls.This is done in Visual Studio .NET from within the Solution
Explorer by right-clicking and choosing Add Reference. Browse to the bin folder
of the project created in Step 1 and select the DLL from that folder. (It should
have the same name as the project by default.)
4. Drag-and-drop will not work for these shared User Controls in VS.NET. Instead,
you must manually type the <%@ Register %> directive and specify the Src of the
User Control, referring to the virtual directory you set up

Raising Events from a User Control

2008-09-08T22:58:00.000+05:30

User Controls support events using the same syntax as other classes in the .NET
Framework. Simply declare the event using the following syntax.In the User Control’s <script runat=”server” /> block or codebehind:
Public Event MultipleReached(ByVal sender As Object, ByVal e As EventArgs)
Public Overridable Sub OnMultipleReached(ByVal e As EventArgs)
RaiseEvent MultipleReached(Me, e)
End Sub
The page can wire up the event by specifying a function for the OnMultipleReached
attribute of the User Control, as follows.The ASPX page:
<uc1:Recipe0206vb id=”Recipe0206vb1” runat=”server” Multiple=”5”
OnMultipleReached=”MultipleReached”></uc1:Recipe0206vb>
The User Control needs to raise the event by calling OnMultipleReached, which in this
case it does every Nth time a counter is incremented.
In the User Control’s <script runat=”server” /> block or codebehind:

‘ if number of hits is a multiple of Multiple, raise event
If Application(“count”) Mod Multiple = 0 Then
OnMultipleReached(EventArgs.Empty)
End If

Finally, in the page, you can specify which action to take in response to the event that
the event handler function specified.
In <script runat=”server” /> block or codebehind:
Sub MultipleReached(ByVal sender As Object, ByVal e As EventArgs)
Message.Text=”Congratulations! You were the 5th visitor!”
End Sub

The syntax for raising and handling events is quite different for C# than for VB.NET.
The C# version of this technique is available from this book’s Web site.

Dynamically Adding User Controls to a Web Form

2008-09-08T22:52:00.000+05:30

You simply load the User Control into a Control object and add it to the page (or
other control inherited from System.Web.UI.Control). In <script runat=”server”>
or codebehind:
Sub Page_Load(sender as object, e as EventArgs)
Dim sampleControl as Control = LoadControl(“recipe0201vb.ascx”)
Controls.Add(sampleControl)
End Sub

You can also add an @ Reference directive at the top of the page to tell ASP.NET to
dynamically compile and link the control at runtime. In the ASPX page:
<%@ Reference Control=”recipe0201vb.ascx” %>

The LoadControl function takes the virtual path to the User Control (specified as the
parameter) and returns a Control object.This object can then be loaded onto the page
with Controls.Add(control As System.Web.UI.Control).The Controls.Add function
is also a member of any other control that inherits from System.Web.UI.Control.
This technique can allow you to dynamically create your entire Web site.The
IBuySpy portal sample application makes extensive use of this technique.

Partial Page Output Caching in ASP.NET

2008-09-01T13:14:00.004+05:30

<%@ OutputCache Duration=”60” VaryByParam=”none” %>
<script runat=”server”>
Sub Page_Load(sender As Object, e As EventArgs)
timestamp.Text = DateTime.Now.ToString()
End Sub
</script>
<asp:Label id=”timestamp” runat=”server” />
Caching the entire contents of a page is not always desirable. Examples include:
n An application that executes per requested business logic
n An application that displays user-specific content (personalization)
Examples such as these are bad candidates for page output caching because the content
can be reused only by the same user. Good candidates for partial page output caching
include any dynamically generated content shared by all users, such as a menu or content
served from a database.

Dynamically Adding User Controls to a Web Form in ASP.NET

2008-09-01T13:14:00.003+05:30

You simply load the User Control into a Control object and add it to the page (or
other control inherited from System.Web.UI.Control). In <script runat=”server”>
or codebehind:
Sub Page_Load(sender as object, e as EventArgs)
Dim sampleControl as Control = LoadControl(“codevb.ascx”)
Controls.Add(sampleControl)
End Sub
You can also add an @ Reference directive at the top of the page to tell ASP.NET to
dynamically compile and link the control at runtime. In the ASPX page:
<%@ Reference Control=”codevb.ascx” %>

The LoadControl function takes the virtual path to the User Control (specified as the
parameter) and returns a Control object.This object can then be loaded onto the page
with Controls.Add(control As System.Web.UI.Control).The Controls.Add function
is also a member of any other control that inherits from System.Web.UI.Control.
This technique can allow you to dynamically create your entire Web site.The
IBuySpy portal sample application makes extensive use of this technique.

Getting and Setting User Control Properties in ASP.NET

2008-09-01T13:13:00.001+05:30

User Control public properties can be set declaratively or programmatically from the
page that contains them.Their values can also be read and used by the containing page.
Full-property declaration should be used as a best practice, but for quick-and-dirty work,
you might use public variables instead.
The User Control (code0203vb.ascx) is as follows:
<%@ Control Language=”vb” %>
<script runat=”server”>
Private _title As String
Private _author As String
Private _renderDate As DateTime = System.DateTime.Now
Public Property Title() As String
Get
Return _title
End Get
Set
_title = value
End Set
End Property
Public Property Author() As String
Get
Return _author
End Get
Set
_author = value
End Set
End Property
Public ReadOnly Property RenderDate() As DateTime
Get
Return _renderDate
End Get
End Property
Private Sub Page_Load(sender As Object, e As EventArgs)
TitleLabel.Text = Title
AuthorLabel.Text = Author
End Sub
</script>
<h1><asp:Label id=”TitleLabel” runat=”server” /></h1>
<h3><asp:Label id=”AuthorLabel” runat=”server” />
</h1>
This User Control is for a header of a story. It includes input parameters for the title and
author of the story. It also exposes a readonly property for RenderDate that the calling
page can use if it chooses to do so.The following page uses this control. It demonstrates
how to set its Title property declaratively (in the HTML tag for the control) and how
to set its Author property programmatically. It also reads the RenderDate and displays it
in a Label.The ASPX page (code0203vb.aspx) is as follows:
<%@ Page Language=”VB” %>
<%@ Register TagPrefix=”uc1” TagName=”header” Src=”code0203vb.ascx” %>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.0 Transitional//EN” >
<HTML>
<HEAD>
<title>User Controls</title>
<Script Runat=”Server”>
Private Sub Page_Load(sender As Object, e As System.EventArgs)
header1.Author = “Snoopy”
FooterLabel.Text = “Rendered “ + header1.RenderDate
End Sub ‘Page_Load
</Script>
</HEAD>
<body>
<form id=”dependingdropdowns” method=”post” runat=”server”>
<uc1:header id=”header1” runat=”server”
Title=”A Tale of Mystery”></uc1:header>
<p>It was a dark and stormy night.</p>
<hr />
<asp:Label ID=”FooterLabel” Runat=”server” />
</form>
</body>
</HTML>

Note: that these examples do not use codebehind files, so all class members are available
locally. It is sometimes necessary to use reflection to access properties of User Controls
that do not use codebehind from pages that do use codebehind.