Introduction To ASP and ASP.Net

What is ASP.Net?

ASP.Net is a web development platform, which provides a programming model, a comprehensive software infrastructure and various services required to build up robust web application for PC, as well as mobile devices.
ASP.Net works on top of the HTTP protocol and uses the HTTP commands and policies to set a browser-to-server two-way communication and cooperation.
ASP.Net is a part of Microsoft .Net platform. ASP.Net applications are complied codes, written using the extensible and reusable components or objects present in .Net framework. These codes can use the entire hierarchy of classes in .Net framework.
The ASP.Net application codes could be written in either of the following languages:

·         C#

·         Visual Basic .Net

·         Jscript

·         J#

ASP.Net is used to produce interactive, data-driven web applications over the internet. It consists of a large number of controls like text boxes, buttons and labels for assembling, configuring and manipulating code to create HTML pages.

ASP.Net Web Forms Model:

ASP.Net web forms extend the event-driven model of interaction to the web applications. The browser submits a web form to the web server and the server returns a full markup page or HTML page in response.
All client side user activities are forwarded to the server for stateful processing. The server processes the output of the client actions and triggers the reactions.
Now, HTTP is a stateless protocol. ASP.Net framework helps in storing the information regarding the state of the application, which consists of:

·         Page state

·         Session state

The page state is the state of the client, i.e., the content of various input fields in the web form. The session state is the collective obtained from various pages the user visited and worked with, i.e., the overall session state. To clear the concept, let us take up an example of a shopping cart as follows.
User adds items to a shopping cart. Items are selected from a page, say the items page, and the total collected items and price are shown in a different page, say the cart page. Only HTTP cannot keep track of all the information coming from various pages. ASP.Net session state and server side infrastructure keeps track of the information collected globally over a session.
The ASP.Net runtime carries the page state to and from the server across page requests while generating the ASP.Net runtime codes and incorporates the state of the server side components in hidden fields.
This way the server becomes aware of the overall application state and operates in a two-tiered connected way.

ASP.Net Component Model:

The ASP.Net component model provides various building blocks of ASP.Net pages. Basically it is an object model, which describes:

·         Server side counterparts of almost all HTML elements or tags, like <form> and <input>.

·         Server controls, which help in developing complex user-interface for example the Calendar control or the Gridview control.

ASP.Net is a technology, which works on the .Net framework that contains all web-related functionalities. The .Net framework is made of an object-oriented hierarchy. An ASP.Net web application is made of pages. When a user requests an ASP.Net page, the IIS delegates the processing of the page to the ASP.Net runtime system.
The ASP.Net runtime transforms the .aspx page into an instance of a class, which inherits from the base class Page of the .Net framework. Therefore, each ASP.Net page is an object and all its components i.e., the server-side controls are also objects.

Components of .Net Framework 3.5

Before going to the next session on Visual Studio.Net, let us look at the various components of the .Net framework 3.5. The following table describes the components of the .Net framework 3.5 and the job they perform:

Components and their Description

(1) Common Language Runtime or CLR It performs memory management, exception handling, debugging, security checking, thread execution, code execution, code safety, verification and compilation.Those codes which are directly managed by the CLR are called the managed code. When the managed code is compiled, the compiler converts the source code into a CPU independent intermediate language (IL) code. A Just in time compiler (JIT) compiles the IL code into native code, which is CPU specific.

(2) .Net Framework Class Library It contains a huge library of reusable types . classes, interfaces, structures and enumerated values, which are collectively called types.

(3) Common Language Specification It contains the specifications for the .Net supported languages and implementation of language integration.

(4) Common Type System It provides guidelines for declaring, using and managing types at runtime, and cross-language communication.

Metadata and Assemblies Metadata is the binary information describing the program, which is either stored in a portable executable file (PE) or in the memory. Assembly is a logical unit consisting of the assembly manifest, type metadata, IL code and set of resources like image files etc.

(5) Windows Forms This contains the graphical representation of any window displayed in the application.

(6) ASP.Net and ASP.Net AJAX ASP.Net is the web development model and AJAX is an extension of ASP.Net for developing and implementing AJAX functionality. ASP.Net AJAX contains the components that allow the developer to update data on a website without a complete reload of the page.

(7) ADO.Net It is the technology used for working with data and databases. It provides accesses to data sources like SQL server, OLE DB, XML etc. The ADO .Net allows connection to data sources for retrieving, manipulating and updating data.

(8) Windows Workflow Foundation (WF) It helps in building workflow based applications in Windows. It contains activities, workflow runtime, workflow designer and a rules engine.

(9)Windows Presentation Foundation It provides a separation between the user interface and the business logic. It helps in developing visually stunning interfaces using documents, media, two and three dimensional graphics, animations and more.

(10) Windows Communication Foundation (WCF) It is the technology used for building and running connected systems.

(11) Windows CardSpace It provides safety of accessing resources and sharing personal information on the internet.

(12) LINQ It imparts data querying capabilities to .Net languages using a syntax which is similar to the tradition query language SQL.

ASP.NET - Environment Setup

ASP.Net provides an abstraction layer on top of HTTP on which the web applications are built. It provides high-level entities like classes and components within an object-oriented paradigm.
The key development tool for building ASP.Net applications and front ends is Visual Studio. In these tutorials, we will work on Visual Studio 2008.
Visual Studio is an integrated development environment for writing, compiling and debugging the code. It provides a complete set of development tools for building ASP.Net web applications, web services, desktop applications and mobile applications.

The Visual Studio IDE:

The new project window allows choosing an application template from the available templates.

When you start a new web site, ASP.NET provides the starting folders and files for the site, including two files for the first web form of the site.
The file named Default.aspx contains the HTML and asp code that defines the form, and the file named Default.aspx.cs (for C# coding) or the file named Default.aspx.vb (for vb coding) contains the code in the language you have chosen and this code is responsible for the form's works.
The primary window in the Visual Studio IDE is the Web Forms Designer window. Other supporting windows are the Toolbox, the Solution Explorer, and the Properties window. You use the designer to design a web form, to add code to the control on the form so that the form works according to your need, you use the code editor.

Ways to work with views and windows:

The following are the ways to work with different windows:

·         To change the Web Forms Designer from one view to another, click on the Design or source button.

·         To close a window, click on the close button on the upper right corner and to redisplay, select it from the View menu.

·         To hide a window, click on its Auto Hide button; the window changes into a tab, to redisplay again click on the Auto Hide button again.

·         To size a wind just drag it.

Adding folders and files to your web site:

When a new web form is created, Visual Studio automatically generates the starting HTML for the form and displays it in Source view of the web forms designer. The Solution Explorer is used to add any other files, folders or any existing item on the web site.

·         To add a standard folder, right-click on the project or folder under which you are going to add the folder in the Solution Explorer and choose New Folder.

·         To add an ASP.Net folder, right-click on the project in the Solution Explorer and select the folder from the list.

·         To add an existing item to the site, right-click on the project or folder under which you are going to add the item in the Solution Explorer and select from the dialog box.

Projects and Solutions:

A typical ASP.Net application consists of many items: the web content files (.aspx), source files (e.g., the .cs files), assemblies (e.g., the .dll files and .exe files), data source files (e.g., .mdb files), references, icons, user controls and miscellaneous other files and folders. All these files that make up the website are contained in a Solution.
When a new website is created VB2008 automatically creates the solution and displays it in the solution explorer.
Solutions may contain one or more projects. A project contains content files, source files, and other files like data sources and image files. Generally the contents of a project are compiled into an assembly as an executable file (.exe) or a dynamic link library (.dll) file.
Typically a project contains the following content files:

·         Page file (.aspx)

·         User control (.ascx)

·         Web service (.asmx)

·         Master page (.master)

·         Site map (.sitemap)

·         Website configuration file (.config)

Building and Running a Project:

The application is run by selecting either Start or Start Without Debugging from the Debug menu, or by pressing F5 or Ctrl-F5. The program is built i.e. the .exe or the .dll files are generated by selecting a command from the Build menu.

ASP.NET - Life Cycle

ASP.Net life cycle specifies, how:

·         ASP.Net processes pages to produce dynamic output

·         The application and its pages are instantiated and processed

·         ASP.Net compiles the pages dynamically

The ASP.Net life cycle could be divided into two groups:

1.      Application Life Cycle

2.      Page Life Cycle

ASP.Net Application Life Cycle:

The application life cycle has the following stages:

·         User makes a request for accessing application resource, a page. Browser sends this request to the web server.

·         A unified pipeline receives the first request and the following events take place:

o    An object of the ApplicationManager class is created.

o    An object of the HostingEnvironment class is created to provide information regarding the resources.

o    Top level items in the application are compiled.

·         Response objects are created . the application objects: HttpContext, HttpRequest and HttpResponse are created and initialized.

·         An instance of the HttpApplication object is created and assigned to the request. The request is processed by the HttpApplication class. Different events are raised by this class for processing the request.

ASP.Net Page Life Cycle:

When a page is requested, it is loaded into the server memory, processed and sent to the browser. Then it is unloaded from the memory. At each of this steps, methods and events are available, which could be overridden according to the need of the application. In other words, you can write your own code to override the default code.
The Page class creates a hierarchical tree of all the controls on the page. All the components on the page, except the directives are part of this control tree. You can see the control tree by adding trace= "true" to the Page directive. We will cover page directives and tracing under 'directives' and 'error handling'.
The page life cycle phases are:

·         Initialization

·         Instantiation of the controls on the page

·         Restoration and maintenance of the state

·         Execution of the event handler codes

·         Page rendering

Understanding the page cycle helps in writing codes for making some specific thing happen at any stage of the page life cycle. It also helps in writing custom controls and initializing them at right time, populate their properties with view-state data and run control behavior code.
Following are the different stages of an ASP.Net page:

·         Page request . when ASP.Net gets a page request, it decides whether to parse and compile the page or there would be a cached version of the page; accordingly the response is sent

·         Starting of page life cycle . at this stage, the Request and Response objects are set. If the request is an old request or post back, the IsPostBack property of the page is set to true. The UICulture property of the page is also set.

·         Page initialization . at this stage, the controls on the page are assigned unique ID by setting the UniqueID property and themes are applied. For a new request postback data is loaded and the control properties are restored to the view-state values.

·         Page load . at this stage, control properties are set using the view state and control state values.

·         Validation . Validate method of the validation control is called and if it runs successfully, the IsValid property of the page is set to true.

·         Postback event handling . if the request is a postback (old request), the related event handler is called.

·         Page rendering . at this stage, view state for the page and all controls are saved. The page calls the Render method for each control and the output of rendering is written to the OutputStream class of the Page's Response property.

·         Unload . the rendered page is sent to the client and page properties, such as Response and Request are unloaded and all cleanup done.

ASP.Net Page Life Cycle Events:

At each stage of the page life cycle, the page raises some events, which could be coded. An event handler is basically a function or subroutine, bound to the event, using declarative attributes like Onclick or handle.
Following are the page life cycle events:

·         PreInit . PreInit is the first event in page life cycle. It checks the IsPostBack property and determines whether the page is a postback. It sets the themes and master pages, creates dynamic controls and gets and sets profile property values. This event can be handled by overloading the OnPreInit method or creating a Page_PreInit handler.

·         Init . Init event initializes the control property and the control tree is built. This event can be handled by overloading the OnInit method or creating a Page_Init handler.

·         InitComplete . InitComplete event allows tracking of view state. All the controls turn on view-state tracking.

·         LoadViewState . LoadViewState event allows loading view state information into the controls.

·         LoadPostData . during this phase, the contents of all the input fields defined with the <form> tag are processed.

·         PreLoad . PreLoad occurs before the post back data is loaded in the controls. This event can be handled by overloading the OnPreLoad method or creating a Page_PreLoad handler.

·         Load . the Load event is raised for the page first and then recursively for all child controls. The controls in the control tree are created. This event can be handled by overloading the OnLoad method or creating a Page_Load handler.

·         LoadComplete . the loading process is completed, control event handlers are run and page validation takes place. This event can be handled by overloading the OnLoadComplete method or creating a Page_LoadComplete handler.

·         PreRender . the PreRender event occurs just before the output is rendered. By handling this event, pages and controls can perform any updates before the output is rendered.

·         PreRenderComplete . as the PreRender event is recursively fired for all child controls, this event ensures the completion of the pre-rendering phase.

·         SaveStateComplete . state of control on the page is saved. Personalization, control state and view state information is saved. The HTML markup is generated. This stage can be handled by overriding the Render method or creating a Page_Render handler.

·         UnLoad . the UnLoad phase is the last phase of the page life cycle. It raises the UnLoad event for all controls recursively and lastly for the page itself. Final cleanup is done and all resources and references, such as database connections, are freed. This event can be handled by modifying the OnUnLoad method or creating a Page_UnLoad handler.

ASP.NET - First Example

An ASP.Net page is made of number of server controls along with the HTML controls, text and images. Sensitive data from the page and the states of different controls on the page are stored in hidden fields and forms the context of that page request.
ASP.Net runtime controls all association between a page instance and its state. An ASP.Net page is an object of the Page Class or inherited from it.
All the controls on the pages are also objects of the related control class inherited from a parent Control class. When a page is run an instance of the page object is created along with all its content controls.
An ASP.Net page is also a server side file saved with the .aspx extension. It is modular in nature and can be divided into the following core sections:

·         Page directives

·         Code Section

·         Page Layout

Page directives:

The page directives set up the environments for the page to run. The @Page directive defines page-specific attributes used by the ASP.Net page parser and compiler. Page directives specify how the page should be processed, and which assumptions are to be taken about the page.
It allows importing namespaces, loading assemblies and registering new controls with custom tag names and namespace prefixes. We will discuss all of these concepts in due time.

Code Section:

The code section provides the handlers for the page and control events along with other functions required. We mentioned that, ASP.Net follows an object model. Now, these objects raises events when something happens on the user interface, like a user clicks a button or moves the cursor. How these events should be handled? That code is provided in the event handlers of the controls, which are nothing but functions bound to the controls.
The code section or the code behind file provides all these event handler routines, and other functions used by the developer. The page code could be precompiled and deployed in the form of a binary assembly.

Page Layout:

The page layout provides the interface of the page. It contains the server controls, text, inline JavaScript and HTML tags:
The following code snippet provides a sample ASP.Net page explaining pafe directives, code section and page layout written in C#:

<!-- directives --> <% @Page Language="C#" %>   <!-- code section --> <script runat="server"> private void convertoupper(object sender, EventArgs e) {         string str = mytext.Value;         changed_text.InnerHtml = str.ToUpper(); } </script>   <!-- Layout --> <html> <head> <title> Change to Upper Case </title> </head> <body> <h3> Conversion to Upper Case </h3> <form runat="server">         <input runat="server" id="mytext" type="text" />         <input runat="server" id="button1" type="submit"     value="Enter..." OnServerClick="convertoupper"/> <hr /> <h3> Results: </h3> <span runat="server" id="changed_text" /> </form> </body> </html>

Copy this file to the web server's root directory. Generally it is c:\inetput\wwwroot. Open the file from the browser to run it and it should generate following result:

Using Visual Studio IDE:

Let us develop the same example using Visual Studio IDE. Instead of typing the code, you can just drag the controls into the design view:

The content file is automatically developed. All you need to add is the Button1_Click routine, which is as follows:

protected void Button1_Click(object sender, EventArgs e) {      string buf = TextBox1.Text;      changed_text.InnerHtml = buf.ToUpper(); }

The content file code is:

<%@ Page Language="C#" AutoEventWireup="true"                        CodeBehind="Default.aspx.cs"                        Inherits="firstexample._Default" %>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">   <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server">     <title>Untitled Page</title> </head> <body>    <form id="form1" runat="server">    <div>       <asp:TextBox ID="TextBox1" runat="server" Width="224px">       </asp:TextBox>       <br />       <br />       <asp:Button ID="Button1" runat="server" Text="Enter..."                   Width="85px" onclick="Button1_Click" />       <hr />       <h3> Results: </h3>       <span runat="server" id="changed_text" />    </div>    </form> </body> </html>

Run the example either from Debug menu, or by pressing Ctrl-F5 or by right clicking on the design view and choosing 'View in Browser' from the popup menu. This should generate following result:

ASP.NET - Event Handling

What is an Event?

Event is an action or occurrence like mouse click, key press, mouse movements, or any system generated notification. The processes communicate through events. For example, Interrupts are system generated events. When events occur the application should be able to respond to it.
In ASP.Net an event is raised on the client, and handled in the server. For example, a user clicks a button displayed in the browser. A Click event is raised. The browser handles this client-side event by posting it to the server.
The server has a subroutine describing what to do when the event is raised; it is called the event-handler. Therefore, when the event message is transmitted to the server, it checks whether the Click event has an associated event handler, and if it has, the event handler is executed.

Event Arguments:

ASP.Net event handlers generally take two parameters and return void. The first parameter represents the object raising the event and the second parameter is called the event argument.
The general syntax of an event is:

private void EventName (object sender, EventArgs e);

Application and Session Events:

The most important application events are:

·         Application_Start . it is raised when the application/website is started

·         Application_End . it is raised when the application/website is stopped

Similarly, the most used Session events are:

·         Session_Start . it is raised when a user first requests a page from the application

·         Session_End . it is raised when the session ends

Page and Control Events:

Common page and control events are:

·         DataBinding . raised when a control bind to a data source

·         Disposed . when the page or the control is released

·         Error . it is an page event, occurs when an unhandled exception is thrown

·         Init . raised when the page or the control is initialized

·         Load . raised when the page or a control is loaded

·         PreRender . raised when the page or the control is to be rendered

·         Unload . raised when the page or control is unloaded from memory

Event Handling Using Controls:

All ASP.Net controls are implemented as classes, and they have events which are fired when user performs certain action on them. For example, when a user clicks a button the 'Click' event is generated. For handling these events there are in-built attributes and event handlers. To respond to an event, the event handler is coded.
By default Visual Studio creates an event handler by including a Handles clause on the Sub procedure. This clause names the control and event that the procedure handles.
The asp tag for a button control:

<asp:Button ID="btnCancel" runat="server" Text="Cancel" />

The event handler for the Click event:

Protected Sub btnCancel_Click(ByVal sender As Object,                               ByVal e As System.EventArgs)                               Handles btnCancel.Click End Sub

An event can also be coded without a Handles clause. Then the handler must be named according to the appropriate event attribute of the control.
The asp tag for a button control:

<asp:Button ID="btnCancel" runat="server" Text="Cancel"                               Onclick="btnCancel_Click" />

The event handler for the Click event:

Protected Sub btnCancel_Click(ByVal sender As Object,                               ByVal e As System.EventArgs) End Sub

The common control events are:

Event	Attribute	Controls
Click	OnClick	Button, image button, link button, image map
Command	OnCommand	Button, image button, link button
TextChanged	OnTextChanged	Text box
SelectedIndexChanged	OnSelectedIndexChanged	Drop-down list, list box, radio button list, check box list.
CheckedChanged	OnCheckedChanged	Check box, radio button

Some events cause the form to be posted back to the server immediately, these are called the postback events. For example, the click events like, Button.Click. Some events are not posted back to the server immediately, these are called non-postback events.
For example, the change events or selection events, such as, TextBox.TextChanged or CheckBox.CheckedChanged. The nonpostback events could be made to post back immediately by setting their AutoPostBack property to true.

Default Events:

The default event for the Page object is the Load event. Similarly every control has a default event. For example, default event for the button control is the Click event.
The default event handler could be created in Visual Studio, just by double clicking the control in design view. The following table shows some of the default events for common controls:

Control	Default Event
AdRotator	AdCreated
BulletedList	Click
Button	Click
Calender	SelectionChanged
CheckBox	CheckedChanged
CheckBoxList	SelectedIndexChanged
DataGrid	SelectedIndexChanged
DataList	SelectedIndexChanged
DropDownList	SelectedIndexChanged
HyperLink	Click
ImageButton	Click
ImageMap	Click
LinkButton	Click
ListBox	SelectedIndexChanged
Menu	MenuItemClick
RadioButton	CheckedChanged
RadioButtonList	SelectedIndexChanged

Example:

This example has a simple page with a label control and a button control on it. As the page events like, Page_Load, Page_Init, Page_PreRender etc. takes place, it sends a message, which is displayed by the label control. When the button is clicked, the Button_Click event is raised and that also sends a message to be displayed on the label.
Create a new website and drag a label control and a button control on it from the control tool box. Using the properties window, set the IDs of the controls as .lblmessage. and .btnclick. respectively. Set the Text property of the Button control as 'Click'.
The markup file (.aspx):

<%@ Page Language="C#" AutoEventWireup="true"                           CodeBehind="Default.aspx.cs"                           Inherits="eventdemo._Default" %>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">   <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server">     <title>Untitled Page</title> </head> <body>     <form id="form1" runat="server">     <div>      <asp:Label ID="lblmessage" runat="server" >      </asp:Label>         <br />         <br />         <br />      <asp:Button ID="btnclick" runat="server" Text="Click"                  onclick="btnclick_Click" />     </div>     </form> </body> </html>

Double click on the design view to move to the code behind file. The Page_Load event is automatically created without any code in it. Write down the following self-explanatory code lines:

using System; using System.Collections; using System.Configuration; using System.Data; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq;   namespace eventdemo { public partial class _Default : System.Web.UI.Page {    protected void Page_Load(object sender, EventArgs e)    {      lblmessage.Text += "Page load event handled. <br />";      if (Page.IsPostBack)      {        lblmessage.Text += "Page post back event handled.<br/>";      }   }   protected void Page_Init(object sender, EventArgs e)   {     lblmessage.Text += "Page initialization event handled.<br/>";   }   protected void Page_PreRender(object sender, EventArgs e)   {     lblmessage.Text += "Page prerender event handled. <br/>";   }   protected void btnclick_Click(object sender, EventArgs e)   {     lblmessage.Text += "Button click event handled. <br/>";   } } }

Run the page. The label shows page load, page initialization and the page pre-render events. Click the button to see effect:

ASP.NET - Server Side

We have studied the page life cycle and how a page contains various controls. The page itself is instantiated as a control object. All web forms are basically instances of the ASP.Net Page class. The page class has the following extremely useful properties that correspond to intrinsic objects like:

·         Session.

·         Application

·         Cache

·         Request

·         Response

·         Server

·         User

·         Trace

We will discuss each of these objects in due time. In this tutorial we will explore the Server object, the Request object and the Response object.

The Server Object:

The Server object in Asp.Net is an instance of the System.Web.HttpServerUtility class. The HttpServerUtility class provides numerous properties and methods to perform various jobs.

Properties and Methods of the Server object:

The methods and properties of the HttpServerUtility class are exposed through the intrinsic Server object provided by ASP.NET.
The following table provides a list of the properties:

Property	Description
MachineName	Name of server's computer
ScriptTimeOut	Gets and sets the request time-out value in seconds.

The following table provides a list of some important methods:

Method	Description
CreateObject(String)	Creates an instance of the COM object identified by its ProgID (Programmatic ID)
CreateObject(Type)	Creates an instance of the COM object identified by its Type
Equals(Object)	Determines whether the specified Object is equal to the current Object
Execute(String)	Executes the handler for the specified virtual path in the context of the current request.
Execute(String, Boolean)	Executes the handler for the specified virtual path in the context of the current request and specifies whether to clear the QueryString and Form collections
GetLastError	Returns the previous exception.
GetType	Gets the Type of the current instance.
HtmlEncode	Changes an ordinary string into a string with legal HTML characters.
HtmlDecode	Converts an Html string into an ordinary string
ToString	Returns a String that represents the current Object
Transfer(String)	For the current request, terminates execution of the current page and starts execution of a new page by using the specified URL path of the page.
UrlDecode	Converts an URL string into an ordinary string
UrlEncodeToken	Works same as UrlEncode, but on a byte array that contains Base64-encoded data
UrlDecodeToken	Works same as UrlDecode, but on a byte array that contains Base64-encoded data
MapPath	Return the physical path that corresponds to a specified virtual file path on the server
Transfer	Transfers execution to another web page in the current application

The Request Object:

The request object is an instance of the System.Web.HttpRequest class. It represents the values and properties of the HTTP request that makes the page loading into the browser.
The information presented by this object is wrapped up by the higher level abstractions (the web control model), however, this object helps in checking some information like the client browser and cookies.

Properties and Methods of the Request Object:

The following table provides some noteworthy properties of the Request object:

Property	Description
AcceptTypes	Gets a string array of client-supported MIME accept types.
ApplicationPath	Gets the ASP.NET application's virtual application root path on the server.
Browser	Gets or sets information about the requesting client's browser capabilities.
ContentEncoding	Gets or sets the character set of the entity-body.
ContentLength	Specifies the length, in bytes, of content sent by the client.
ContentType	Gets or sets the MIME content type of the incoming request.
Cookies	Gets a collection of cookies sent by the client.
FilePath	Gets the virtual path of the current request.
Files	Gets the collection of files uploaded by the client, in multipart MIME format.
Form	Gets a collection of form variables.
Headers	Gets a collection of HTTP headers.
HttpMethod	Gets the HTTP data transfer method (such as GET, POST, or HEAD) used by the client.
InputStream	Gets the contents of the incoming HTTP entity body.
IsSecureConnection	Gets a value indicating whether the HTTP connection uses secure sockets (that is, HTTPS).
QueryString	Gets the collection of HTTP query string variables.
RawUrl	Gets the raw URL of the current request.
RequestType	Gets or sets the HTTP data transfer method (GET or POST) used by the client.
ServerVariables	Gets a collection of Web server variables.
TotalBytes	Gets the number of bytes in the current input stream.
Url	Gets information about the URL of the current request.
UrlReferrer	Gets information about the URL of the client's previous request that linked to the current URL.
UserAgent	Gets the raw user agent string of the client browser.
UserHostAddress	Gets the IP host address of the remote client.
UserHostName	Gets the DNS name of the remote client.
UserLanguages	Gets a sorted string array of client language preferences.

The following table provides a list of some important methods:

Method	Description
BinaryRead	Performs a binary read of a specified number of bytes from the current input stream.
Equals(Object)	Determines whether the specified Object is equal to the current Object. (Inherited from Object.)
GetType	Gets the Type of the current instance.
MapImageCoordinates	Maps an incoming image-field form parameter to appropriate x-coordinate and y-coordinate values.
MapPath(String)	Maps the specified virtual path to a physical path.
SaveAs	Saves an HTTP request to disk.
ToString	Returns a String that represents the current Object
ValidateInput	Causes validation to occur for the collections accessed through the Cookies, Form, and QueryString properties.

The Response Object:

The Response object represents the server's response to the client request. It is an instance of the System.Web.HttpResponse class.
In ASP.Net, the Response object does not play a vital role in sending HTML text to the client, because the server-side controls have nested, object oriented methods for rendering themselves.
However, the HttpResponse object still provides some important functionalities, like the cookie feature and the Redirect() method. The Response.Redirect() method allows transferring the user to another page, inside as well as outside the application. It requires a round trip.

Properties and Methods of the Response Object:

The following table provides some noteworthy properties of the Response object:

Property	Description
Buffer	Gets or sets a value indicating whether to buffer output and send it after the complete response is finished processing.
BufferOutput	Gets or sets a value indicating whether to buffer output and send it after the complete page is finished processing.
Charset	Gets or sets the HTTP character set of the output stream.
ContentEncoding	Gets or sets the HTTP character set of the output stream.
ContentType	Gets or sets the HTTP MIME type of the output stream.
Cookies	Gets the response cookie collection.
Expires	Gets or sets the number of minutes before a page cached on a browser expires.
ExpiresAbsolute	Gets or sets the absolute date and time at which to remove cached information from the cache
HeaderEncoding	Gets or sets an Encoding object that represents the encoding for the current header output stream.
Headers	Gets the collection of response headers.
IsClientConnected	Gets a value indicating whether the client is still connected to the server.
Output	Enables output of text to the outgoing HTTP response stream.
OutputStream	Enables binary output to the outgoing HTTP content body.
RedirectLocation	Gets or sets the value of the Http Location header.
Status	Sets the Status line that is returned to the client.
StatusCode	Gets or sets the HTTP status code of the output returned to the client.
StatusDescription	Gets or sets the HTTP status string of the output returned to the client.
SubStatusCode	Gets or sets a value qualifying the status code of the response.
SuppressContent	Gets or sets a value indicating whether to send HTTP content to the client.

The following table provides a list of some important methods:

Method	Description
AddHeader	Adds an HTTP header to the output stream. AddHeader is provided for compatibility with earlier versions of ASP.
AppendCookie	Infrastructure. Adds an HTTP cookie to the intrinsic cookie collection.
AppendHeader	Adds an HTTP header to the output stream.
AppendToLog	Adds custom log information to the Internet Information Services (IIS) log file.
BinaryWrite	Writes a string of binary characters to the HTTP output stream.
ClearContent	Clears all content output from the buffer stream.
Close	Closes the socket connection to a client.
End	Sends all currently buffered output to the client, stops execution of the page, and raises the EndRequest event.
Equals(Object)	Determines whether the specified Object is equal to the current Object
Flush	Sends all currently buffered output to the client.
GetType	Gets the Type of the current instance.
Pics	Appends a HTTP PICS-Label header to the output stream.
Redirect(String)	Redirects a request to a new URL and specifies the new URL.
Redirect(String, Boolean)	Redirects a client to a new URL. Specifies the new URL and whether execution of the current page should terminate.
SetCookie	Updates an existing cookie in the cookie collection.
ToString	Returns a String that represents the current Object.
TransmitFile(String)	Writes the specified file directly to an HTTP response output stream, without buffering it in memory.
Write(Char)	Writes a character to an HTTP response output stream.
Write(Object)	Writes an Object to an HTTP response stream.
Write(String)	Writes a string to an HTTP response output stream.
WriteFile(String)	Writes the contents of the specified file directly to an HTTP response output stream as a file block.
WriteFile(String, Boolean)	Writes the contents of the specified file directly to an HTTP response output stream as a memory block.

Example:

The following simple example has a text box control where the user can enter name, a button to send the information to the server and a label control to display the URL of the client computer.
The content file:

<%@ Page Language="C#" AutoEventWireup="true"                        CodeBehind="Default.aspx.cs"                        Inherits="server_side._Default" %>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">   <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server">     <title>Untitled Page</title> </head> <body>     <form id="form1" runat="server">     <div>     Enter your name:<br />         <asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>         <asp:Button ID="Button1" runat="server"                     OnClick="Button1_Click" Text="Submit" />         <br />         <asp:Label ID="Label1" runat="server"/>       </div>     </form> </body> </html>

The code behind for Button1_Click:

protected void Button1_Click(object sender, EventArgs e) {    if (!String.IsNullOrEmpty(TextBox1.Text))    {        // Access the HttpServerUtility methods through        // the intrinsic Server object.        Label1.Text = "Welcome, " +        Server.HtmlEncode(TextBox1.Text) +        ".<br/> The url is " +        Server.UrlEncode(Request.Url.ToString());     }   }

Run the page to see the following result

---

ASP.NET - Server Controls

Controls are small building blocks of the graphical user interface, which includes text boxes, buttons, check boxes, list boxes, labels and numerous other tools, using which users can enter data, make selections and indicate their preferences.
Controls are also used for structural jobs, like validation, data access, security, creating master pages, data manipulation.
ASP.Net uses five types of web controls, which are:

·         HTML controls

·         HTML Server controls

·         ASP.Net Server controls

·         ASP.Net Ajax Server controls

·         User controls and custom controls

ASP.Net server controls are the primary controls used in ASP.Net. These controls again could be grouped into the following categories:

·         Validation controls - these are used to validate user input and work by running client-side script

·         Data source controls - these controls provides data binding to different data sources

·         Data view controls - these are various lists and tables, which can bind to data from data sources for display

·         Personalization controls - these are used for personalization of a page according to the user's preference, based on user information

·         Login and security controls - these controls provide user authentication

·         Master pages - these provides consistent layout and interface throughout the application

·         Navigation controls - these helps in navigation, for example, the menus, tree view etc.

·         Rich controls - these implements special features, for example, AdRotator control, FileUpload control, Calendar control etc.

The basic syntax for using server controls is:

<asp:controlType  ID ="ControlID"                      runat="server"                      Property1=value1  [Property2=value2] />

However, visual studio has the following features, which helps in error free coding:

·         Dragging and dropping of controls in design view

·         IntelliSense feature that displays and auto-completes the properties

·         The properties window to set the property values directly

Properties of the Server Controls

The ASP.Net server controls with a visual aspect are derived from the WebControl class and inherit all the properties, events and methods of this class.
The WebControl class itself and some other server controls that are not visually rendered, e.g., the PlaceHolder control or XML control etc., are derived from the System.Web.UI.Control class.
ASP.Net server controls inherit all properties, events and methods of the WebControl and System.Web.UI.Control class.
The following table shows the inherited properties, which are common to all server controls:

Property	Description
AccessKey	Pressing this key with the Alt key moves focus to the control
Attributes	It's the collection of arbitrary attributes (for rendering only) that do not correspond to properties on the control.
BackColor	Background colour.
BindingContainer	The control that contains this control's data binding.
BorderColor	Border colour.
BorderStyle	Border style.
BorderWidth	Border width.
CausesValidation	Indicates if it causes validation.
ChildControlCreated	It indicates whether the server control's child controls have been created.
ClientID	Control ID for HTML markup.
Context	The HttpContext object associated with the server control.
Controls	Collection of all controls contained within the control
ControlStyle	The style of the Web server control.
CssClass	CSS class
DataItemContainer	Gets a reference to the naming container if the naming container implements IDataItemContainer.
DataKeysContainer	Gets a reference to the naming container if the naming container implements IDataKeysControl.
DesignMode	It indicates whether the control is being used on a design surface.
DisabledCssClass	Gets or sets the CSS class to apply to the rendered HTML element when the control is disabled.
Enabled	Indicates whether the control is grayed out
EnableTheming	Indicates whether theming applies to the control.
EnableViewState	Indicates whether the view state of the control is maintained.
Events	Gets a list of event handler delegates for the control.
Font	Font .
Forecolor	Foreground colour.
HasAttributes	Indicates whether the control has attributes set.
HasChildViewState	indicates whether the current server control's child controls have any saved view-state settings.
Height	Height in pixels or %.
ID	Identifier for the control.
IsChildControlStateCleared	Indicates whether controls contained within this control have control state.
IsEnabled	Gets a value indicating whether the control is enabled
IsTrackingViewState	It indicates whether the server control is saving changes to its view state.
IsViewStateEnabled	It indicates whether view state is enabled for this control.
LoadViewStateById	It indicates whether the control participates in loading its view state by ID instead of index.
Page	Page containing the control.
Parent	Parent control.
RenderingCompatibility	It specifies the ASP.NET version that rendered HTML will be compatible with.
Site	The container that hosts the current control when rendered on a design surface.
SkinID	Gets or sets the skin to apply to the control. (
Style	Gets a collection of text attributes that will be rendered as a style attribute on the outer tag of the Web server control.
TabIndex	Gets or sets the tab index of the Web server control.
TagKey	Gets the HtmlTextWriterTag value that corresponds to this Web server control.
TagName	Gets the name of the control tag.
TemplateControl	The template that contains this control.
TemplateSourceDirectory	Gets the virtual directory of the Page or control containing this control.
ToolTip	Gets or sets the text displayed when the mouse pointer hovers over the Web server control.
UniqueID	Unique identifier
ViewState	Gets a dictionary of state information that allows you to save and restore the view state of a server control across multiple requests for the same page.
ViewStateIgnoreCase	It indicates whether the StateBag object is case-insensitive.
ViewStateMode	Gets or sets the view-state mode of this control.
Visible	It indicates whether a server control is visible.
Width	Gets or sets the width of the Web server control.

Methods of the Server Controls

The following table provides the methods of the server controls:

Method	Description
AddAttributesToRender	Adds HTML attributes and styles that need to be rendered to the specified HtmlTextWriterTag.
AddedControl	Called after a child control is added to the Controls collection of the Control object.
AddParsedSubObject	Notifies the server control that an element, either XML or HTML, was parsed, and adds the element to the server control's control collection.
ApplyStyleSheetSkin	Applies the style properties defined in the page style sheet to the control.
ClearCachedClientID	Infrastructure. Sets the cached ClientID value to null.
ClearChildControlState	Deletes the control-state information for the server control's child controls.
ClearChildState	Deletes the view-state and control-state information for all the server control's child controls.
ClearChildViewState	Deletes the view-state information for all the server control's child controls.
CreateChildControls	Used in creating child controls.
CreateControlCollection	Creates a new ControlCollection object to hold the child controls.
CreateControlStyle	Creates the style object that is used to implement all style related properties.
DataBind	Binds a data source to the server control and all its child controls.
DataBind(Boolean)	Binds a data source to the server control and all its child controls with an option to raise the DataBinding event.
DataBindChildren	Binds a data source to the server control's child controls.
Dispose	Enables a server control to perform final clean up before it is released from memory.
EnsureChildControls	Determines whether the server control contains child controls. If it does not, it creates child controls.
EnsureID	Creates an identifier for controls that do not have an identifier.
Equals(Object)	Determines whether the specified Object is equal to the current Object.
Finalize	Allows an Object to attempt to free resources and perform other cleanup operations before the Object is reclaimed by garbage collection.
FindControl(String)	Searches the current naming container for a server control with the specified id parameter.
FindControl(String, Int32)	Searches the current naming container for a server control with the specified id and an integer
Focus	Sets input focus to a control.
GetDesignModeState	Gets design-time data for a control.
GetType	Gets the Type of the current instance.
GetUniqueIDRelativeTo	Returns the prefixed portion of the UniqueID property of the specified control.
HasControls	Determines if the server control contains any child controls.
HasEvents	Indicates whether events are registered for the control or any child controls.
IsLiteralContent	Determines if the server control holds only literal content.
LoadControlState	Restores control-state information.
LoadViewState	Restores view-state information.
MapPathSecure	Retrieves the physical path that a virtual path, either absolute or relative, maps to.
MemberwiseClone	Creates a shallow copy of the current object.
MergeStyle	Copies any nonblank elements of the specified style to the Web control, but will not overwrite any existing style elements of the control.
OnBubbleEvent	Determines whether the event for the server control is passed up the page's UI server control hierarchy.
OnDataBinding	Raises the data binding event.
OnInit	Raises the Init event.
OnLoad	Raises the Load event.
OnPreRender	Raises the PreRender event.
OnUnload	Raises the Unload event.
OpenFile	Gets a Stream used to read a file
RemovedControl	Called after a child control is removed from the Controls collection of the Control object.
Render	Renders the control to the specified HTML writer.
RenderBeginTag	Renders the HTML opening tag of the control to the specified writer.
RenderChildren	Outputs the content of a server control's children to a provided HtmlTextWriter object, which writes the content to be rendered on the client.
RenderContents	Renders the contents of the control to the specified writer.
RenderControl(HtmlTextWriter)	Outputs server control content to a provided HtmlTextWriter object and stores tracing information about the control if tracing is enabled.
RenderEndTag	Renders the HTML closing tag of the control into the specified writer.
ResolveAdapter	Gets the control adapter responsible for rendering the specified control.
SaveControlState	Saves any server control state changes that have occurred since the time the page was posted back to the server.
SaveViewState	Saves any state that was modified after the TrackViewState method was invoked.
SetDesignModeState	Sets design-time data for a control.
ToString	Returns a String that represents the current object.
TrackViewState	Causes the control to track changes to its view state so they can be stored in the object's view state property.

Example:

Let us look at a particular server control - a tree view control. A Tree view control comes under navigation controls. Other Navigation controls are: Menu control and SiteMapPath control.
Add a tree view control on the page. Select Edit Nodes... from the tasks. Edit each of the nodes using the Tree view node editor:

Once you have created the nodes, it looks like the following in design view:

The AutoFormat... task allows you to format the tree view:

Add a label control and a text box control on the page and name them lblmessage and txtmessage respectively.
Write few lines of code to ensure that when a particular node is selected, the label control displays the node text and the text box displays all child nodes under it, if any. The code behind file should look like this:

using System; using System.Collections; using System.Configuration; using System.Data; using System.Linq; using System.Web; using System.Web.Security; using System.Web.UI; using System.Web.UI.HtmlControls; using System.Web.UI.WebControls; using System.Web.UI.WebControls.WebParts; using System.Xml.Linq; namespace eventdemo {   public partial class treeviewdemo : System.Web.UI.Page   {     protected void Page_Load(object sender, EventArgs e)    {       txtmessage.Text = " ";    }    protected void TreeView1_SelectedNodeChanged(object sender,                                                 EventArgs e)    {    txtmessage.Text = " ";     lblmessage.Text = "Selected node changed to: " +                        TreeView1.SelectedNode.Text;     TreeNodeCollection childnodes =                        TreeView1.SelectedNode.ChildNodes;     if(childnodes != null)     {       txtmessage.Text = " ";       foreach (TreeNode t in childnodes)       {          txtmessage.Text += t.Value;       }     }    }   } }

Run the page to see the effects. You will be able to expand and control the nodes.

ASP.NET - HTML Server Controls

side processing. The HTML controls like the header tags, anchor tags and input elements are not processed by the server but sent to the browser for display.
They are specifically converted to a server control by adding the attribute runat="server" and adding an id attribute to make them available for server-side processing.
For example, consider the HTML input control:

<input type="text" size="40">

It could be converted to a server control, by adding the runat and id attribute:

<input type="text" id="testtext" size="40" runat="server">

Advantages of using HTML Server Controls

Although ASP.Net server controls can perform every job accomplished by the HTML server controls, the later controls are useful in the following cases:

·         Using static tables for layout purposes

·         Converting a HTML page to run under ASP.Net

The following table describes the HTML server controls:

Control Name	HTML tag
HtmlHead	<head>element
HtmlInputButton	<input type=button|submit|reset>
HtmlInputCheckbox	<input type=checkbox>
HtmlInputFile	<input type = file>
HtmlInputHidden	<input type = hidden>
HtmlInputImage	<input type = image>
HtmlInputPassword	<input type = password>
HtmlInputRadioButton	<input type = radio>
HtmlInputReset	<input type = reset>
HtmlText	<input type = text|password>
HtmlImage	<img> element
HtmlLink	<link> element
HtmlAnchor	<a> element
HtmlButton	<button> element
HtmlButton	<button> element
HtmlForm	<form> element
HtmlTable	<table> element
HtmlTableCell	<td> and <th>
HtmlTableRow	<tr> element
HtmlTitle	<title> element
HtmlSelect	<select> element
HtmlGenericControl	All HTML controls not listed

Example:

The following example uses a basic HTML table for layout. It uses some text boxes for getting input from the users like, name, address, city, state etc. It also has a button control, which is clicked to get the user data displayed on the last row of the table.
The page should look like this in the design view:

The code for the content page shows the use of the HTML table element for layout.

<%@ Page Language="C#" AutoEventWireup="true"                        CodeBehind="Default.aspx.cs"                        Inherits="htmlserver._Default" %>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">   <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server"> <title>Untitled Page</title> <style type="text/css">    .style1    {         width: 156px;    }    .style2    {       width: 332px;    } </style> </head> <body> <form id="form1" runat="server"> <div> <table style="width: 54%;"> <tr> <td class="style1">Name:</td> <td class="style2"> <asp:TextBox ID="txtname" runat="server" Width="230px"> </asp:TextBox> </td> </tr> <tr> <td class="style1">Street</td> <td class="style2"> <asp:TextBox ID="txtstreet" runat="server" Width="230px"> </asp:TextBox> </td> </tr> <tr> <td class="style1">City</td> <td class="style2"> <asp:TextBox ID="txtcity" runat="server" Width="230px"> </asp:TextBox> </td> </tr> <tr> <td class="style1">State</td> <td class="style2"> <asp:TextBox ID="txtstate" runat="server" Width="230px"> </asp:TextBox> </td> </tr> <tr> <td class="style1"> </td> <td class="style2"></td> </tr> <tr> <td class="style1"></td> <td ID="displayrow" runat ="server" class="style2"> </td> </tr> </table> </div> <asp:Button ID="Button1" runat="server"             onclick="Button1_Click" Text="Click" /> </form> </body> </html>

The code behind the button control:

protected void Button1_Click(object sender, EventArgs e) {         string str = "";         str += txtname.Text + "<br />";         str += txtstreet.Text + "<br />";         str += txtcity.Text + "<br />";         str += txtstate.Text + "<br />";         displayrow.InnerHtml = str; }

observe the followings

·         The normal HTML tags has been used for the page layout.

·         The last row of the HTML table is used for data display. It needed server side processing, so an ID attribute and the runat attribute has been added to it.

ASP.NET - Error Handling

Error handling in ASP.Net has three aspects:

1.      Tracing - tracing the program execution at page level or application level.

2.      Error handling - handling standard errors or custom errors at page level or application level

3.      Debugging - stepping through the program, setting break points to analyze the code

In this tutorial, we are going to discuss tracing and error handling and we will look into debugging in the next tutorial.
To understand the concepts, create the following sample application. It has a label control, a dropdown list and a link. The dropdown list loads an array list of famous quotes and the selected quote is shown in the label below. It also has a hyperlink which has a nonexistent link.

<%@ Page Language="C#"          AutoEventWireup="true"          CodeBehind="Default.aspx.cs"          Inherits="errorhandling._Default" %>   <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">   <html xmlns="http://www.w3.org/1999/xhtml" > <head runat="server">     <title>Tracing, debugging and error handling</title> </head> <body>     <form id="form1" runat="server">     <div>         <asp:Label ID="lblheading" runat="server"             Text="Tracing, Debuggin and Error Handling">         </asp:Label>         <br />         <br />         <asp:DropDownList ID="ddlquotes"         runat="server" AutoPostBack="True"         onselectedindexchanged="ddlquotes_SelectedIndexChanged">         </asp:DropDownList>         <br />         <br />         <asp:Label ID="lblquotes" runat="server">         </asp:Label>         <br />         <br />         <asp:HyperLink ID="HyperLink1" runat="server"         NavigateUrl="mylink.htm">Link to:</asp:HyperLink>     </div>     </form> </body> </html>

The code behind file:

public partial class _Default : System.Web.UI.Page {    protected void Page_Load(object sender, EventArgs e)    {       if (!IsPostBack)       {          string[,] quotes =         {         {"Imagination is more important than Knowledge.",          "Albert Einsten"},         {"Assume a virtue, if you have it not",          "Shakespeare"},         {"A man cannot be comfortable without his own          approval", "Mark Twain"},         {"Beware the young doctor and the old barber",          "Benjamin Franklin"},        {"Whatever begun in anger ends in shame",          "Benjamin Franklin"}      };      for (int i=0; i<quotes.GetLength(0); i++)         ddlquotes.Items.Add(new ListItem(quotes[i,0],         quotes[i,1]));      }    }    protected void ddlquotes_SelectedIndexChanged(object sender,                                                  EventArgs e)    {      if (ddlquotes.SelectedIndex != -1)      {        lblquotes.Text = String.Format("{0}, Quote: {1}",           ddlquotes.SelectedItem.Text, ddlquotes.SelectedValue);      }    } }

Tracing:

To enable page level tracing, you need to modify the Page directive and add a Trace attribute as:

<%@ Page Language="C#" AutoEventWireup="true"             CodeBehind="Default.aspx.cs"             Inherits="errorhandling._Default"             Trace ="true" %>

Now when you run the file, you get the tracing information:

It provides the following information at the top:

·         Session ID

·         Status Code

·         Time of Request

·         Type of Request

·         Request and Response Encoding

The status code sent from the server, each time the page is requested shows the name and time of error if any. The following table shows the common HTTP status codes :

Number	Description
Informational (100 - 199)
100	Continue
101	Switching protocols
Successful (200 - 299)
200	OK
204	No content
Redirection (300 - 399)
301	Moved permanently
305	Use proxy
307	Temporary redirect
Client Errors (400 - 499)
400	Bad request
402	Payment required
404	Not found
408	Request timeout
417	Expectation failed
Server Errors (500 - 599)
500	Internal server error
503	Service unavailable
505	HTTP version not supported

Under the top level information is the Trace log, which provides details of page life cycle. It provides elapsed time in seconds since the page was initialized.

The next section is control tree, which lists all controls on the page in a hierarchical manner:

Last in the Session and Application state summaries, cookies and headers collections, followed by list of all server variables.
The Trace object allows you to add custom information to the trace output. It has two methods to accomplish this: the Write method and the Warn method.
Change the Page_Load event handler to check the Write method:

protected void Page_Load(object sender, EventArgs e) {    Trace.Write("Page Load");    if (!IsPostBack)    {       Trace.Write("Not Post Back, Page Load");       string[,] quotes = .......................

Run to observe the effects:

To check the Warn method, let us forcibly enter some erroneous code in the selected index changed event handler:

try {    int a = 0;    int b = 9 / a; } catch (Exception e) {    Trace.Warn("UserAction", "processing 9/a", e); }

Try-Catch is a C# programming construct. The try block holds any code that may or may not produce error and the catch block catches the error. When the program is run, it sends the warning in the trace log.

Application level tracing applies to all the pages in the web site. It is implemented by putting the following code lines in the web.config file:

<system.web> <trace enabled="true" /> </system.web>

Error Handling:

Although ASP.Net can detect all runtime errors, still some subtle errors may still be there. Observing the errors by tracing is meant for the developers, not for the users.
Hence, to intercept such occurrence, you can add error handing settings in the web.config file of the application. It is application wide error handling. For example, you can add the following lines in the web.config file:

<configuration>         <system.web>         <customErrors mode="RemoteOnly"                defaultRedirect="GenericErrorPage.htm"> <error statusCode="403" redirect="NoAccess.htm"      /> <error statusCode="404" redirect="FileNotFound.htm" /> </customErrors> </system.web> <configuration>

The <customErrors> section has the possible attributes:

·         Mode: It enables or disables custom error pages. It has the three possible values:

• On: displays the custom pages.
• Off: displays ASP.Net error pages (yellow pages)
• remoteOnly: displays custom errors to client, display ASP.Net errors locally

·         defaultRedirect: It contains the URL of the page to be displayed in case of unhandled errors.

To put different custom error pages for different type of errors, the <error> sub tags are used, where different error pages are specified, based of the status code of the errors.
To implement page level error handling, the Page directive could be modified:

<%@ Page Language="C#" AutoEventWireup="true"             CodeBehind="Default.aspx.cs"             Inherits="errorhandling._Default"             Trace ="true"             ErrorPage="PageError.htm" %>

Because ASP.Net Debugging is an important subject in itself so we would discuss it in ASP.Net - Debugging tutorial separately