1. Introduction
2. Enable the tracing at page level using the Page Directives
3. Enable the Tracing at Application Level using the Configuration Option ( config.web )
4. References:

Introduction

Tracing is the new functionality added to the Asp.net. It allows you to view Diagnostic Information about a single request for an ASP.NET page, simply by enabling it for your page or application level.

Other smart thing about tracing is, they are automatically removed from the application when it is deployed to production servers. The trace information can be viewed in two ways:

• One way is, ASP.NET appends the trace information at the end of the Page
• Other is, saved to the application’s trace.axd file

In this tutorial I will show how to enable the tracing at page level and application level in the following sections as follows:

• Enable the tracing at Page Level using the Page Directives
• Enable the tracing at Application Level using the Configuration Option

Enable the tracing at page level using the Page Directives

Page directives are very useful, these are instructions that ASP.NET uses when processing a request for an ASP.NET resource. They can also be used to override or apply configuration settings for an ASP.NET page. Note that, Page directives must be the first element on a page.

We can add the page directives using the <%@  %>. as follows:

Enable the Tracing at Application Level using the Configuration Option ( config.web )

ASP.NET uses XML configuration file called config.web to set configuration settings for ASP.NET applications. Configuration file sets the default ASP.NET configuration, and in Beta 1 is known as the root configuration file. Changes made within this file affect all of our ASP.NET Web application.

To add application level tracing, first open the config.web file and find the <trace> as follows:

Enabled argument enables the tracing by setting its value as true. The other interesting option is, we can sort the trace output by time and Category by setting the pageoutput argument to SortByTime and SortByCategory respectively.

References:

http://msdn.microsoft.com/en-us/library/ms972204.aspx

1. Introduction
2. Using the Java Script history.go and History Forward Method
3. Remove the page from history using the java script
4. Remove the tool bar of the Browser
5. Using Sessions
6. Using the HttpCachePolicy Class
7. Conclusion

Introduction

Recently I worked on a banking project in asp.net. Here, I came across a situation like, “we should not allow the user to go back to the previous page”. At first glance, we feel like doing this is very simple. But, believe me, it is really hell. Problem with this is that there is no way of truly disabling the back button.

As I suffered with this issue, after a good research I thought of investing some time to write this tutorial to help some one who is like me. In this tutorial, I will explain different ways to prevent user going back and I will try list out their drawbacks also. But, remember this, I am saying again, there is no way to truly disable the back button.

For the sake this tutorial, we will create two pages called firstpage.aspx and other as secondpage.aspx. On the Fristpage.aspx add a Hyperlink then, catch the on_click event of the HyperLink and add the following line to it:

Now, when the user clicks on the link, he will be re-directed to the second page.

Using the above two pages I will explain the different approaches by dividing them into following sections:

• Using the java script history.go and history forward method
• Remove the page from history using the java script
• Remove the tool bar of the browser
• Using sessions
• Using the HttpCachePolicy Class

Using the Java Script history.go and History Forward Method

We can use java script client side code to prevent users going back. The history.go is first kind of these methods, add this on the page load of the tag as follows:

FirstPage.aspx

Other java script method called as history.forward can be as follows:

Now, every time when the user goes backs to the FirstPage, it will be automatically redirected to second page.

Drawbacks of this approach are, these are implemented on the client and in JavaScript, if the user disables the java script then this approach will not work.

Remove the page from history using the java script

Instead of the above methods, we can directly remove the page from the history. Now, even if the users press the back button as the page is not their history, user cannot go to the previous page. Looks interesting right!! And it is simple also as follows:

Drawbacks are same as the first approach that we are using on the client and in JavaScript, if the user disables the java script then this approach will not work.

Remove the tool bar of the Browser

We can remove the tool bar of browser by opening a new window and referring it to self. No tool bar means no buttons, no navigation etc. this approach may help in some situations. This can be done as follows:

First to create the new window and refer to self , we have add the following lines of code, I am placing them in a function as follows:

And I calling this function from the Firstpage.aspx of link’s on_click event as follows:

Using Sessions

Till now, all approaches are on the client side, for these kinds of securities we cannot trust them. Suppose, if the user remembers the URL and enters the URL directly then, the above approaches will not work. So the other option is keeping these securities on the server side using the sessions.

We should keep track of the user page as session variables and when the user request for the page, first we have to check in the session variables whether the user already visited that page, if not, then only allow him to view that page as follows:

Drawbacks of this method are, if we have lot of pages on the server then the memory used by session increases for every user. Another drawback is, if the user disables or do not support cookies, then this will not work.

Using the HttpCachePolicy Class

In asp.net there is a class called HttpCachePolicy which contains methods for setting cache-specific HTTP headers and for controlling the ASP.NET page output cache. We can use this function in our asp pages to prevent caching, so that their will no pages to go back.(Smart One, Right!!) This can be implemented usually in the page_init as follows:

Conclusion

I explained varies ways to prevent the users to go back to the previous page. But, every approach has limitations. Keep one thing in mind that there is no perfect approach to solve this problem.

1. Introduction
2. Open the child window
3. Update the child window text box from the parent window
4. Update the Parent window text box from the child window

Introduction

Recently for one my asp project, I have to open pop windows from the parent window and have to set values from child window to parent and vice versa. Of course, doing this kind of things is very simple. But, I did not found enough tutorial on this so thought of investing some time to write tutorial on this topic.

In this tutorial their will be a textbox and button controls on the parent and child windows, if we enter a value and press button, the value in the text box will be displayed/updated in the other window.

Parent window have a textbox and two button control, where one button control open the child window and other button updates the text box value to the child window (with the caption update the child window). Now in the page load function, we will add code to call the javascipt functions as follows:

Child windows also have one textbox and one button controls. And we are adding following code on the page_load event:

As you observed there are three functions, openChildWindow(), UpdatechildWindow(), UpdateParentWindow(), these functions are coded in the javascirpt. I will explain them in the following sections:

• Open the child window
• Update the child window text box from the parent window
• Update the Parent window text box from the child window

Open the child window

We called a java script function in the parent window to open the child window, that is openChildWindow() as follows:

Window.open javascript function opens the child window. Here we opened child window with ChildWindow.aspx.

Update the child window text box from the parent window

To update the child window from the parent, we need access to the child window and as well, access to child window controls. We can do that as follows:

We are access the child window using the variable “childwindow” variable which we initialized when are opening the child window in the OpenChildWindow () function.

Update the Parent window text box from the child window

When we open the child window from the parent using the window.open, a new property is created in the child that is window.opener property. With this property we can access the parent window or the creator window from the child window.

1. Introduction
2. Change the style of label control using the CssClass property
3. Hide or display the label control using the style property

Introduction

HTML tags define the content of the document. To format the content, new HTML tags and attributes are introduced, but, later on, it become hard to manage them. As we all know that, it is always good to separate the document content from its presentation, this can be achieved using the style sheets.

Styles sheets define HOW HTML elements are to be displayed, just like the font tag and the color attribute in HTML 3.2. Styles are normally saved in external .css files.

Now, the topic is about controls. Some times we may need to change the appearance of controls dynamically at run time. For example, at runtime I want to apply style sheets to a control to change it appearance.

By keeping these kinds of requirements in mind, Microsoft developed in addition to the appearance properties (like Bold, size) and style objects (like FontInfo), two new properties which allow you to manipulate CSS styles more directly as follows:

1. CssClass
2. Style

In this tutorial I will try to explain how to use these two properties with examples in the following sections:

• Change the style of label control using the CssClass Property
• Hide or Display the label Control using the Style Property

Change the style of label control using the CssClass property

First we will look at the HTML part of the code, so that we can discuss about it:

Did you observed that with in the <style > tags there is a css style which contains .CssStyle1, .CssStyle2 and with in the body we have label and button controls, where Label control have CssClass property set with the “CssClass1” style sheet and the button control’s “onlick” event have a call back function called “Button_click”.

Now, when the user press the button, “Button_Click” event is fired and in this function we change the style sheet of the label control dynamically using the CssClass property as follows:

How simple it is right!! Using the style properties is also simple. I will explain it in the below section.

Hide or display the label control using the style property

HTML part of the code is same as the above but, in this example we will use style property of the control as follows:

The <head> tag just have title and with in body of the html we have a label and button control.Where the button control “onclick” event have a call back function called “Button_click”.

In the Button_click function, we will show or hide the label control using the style property as follows:

1. Introduction
2. Loading the user Controls Dynamically
3. Using the PlaceHolders and Panel Controls, to display the user controls, where ever you need
4. Accessing the properties of the dynamically loaded User Control

Introduction

User control are powerful, they can divide the code and helps us to reuse them. Normally we can use the UserControl’s in two ways:

1. Placing the user control by dragging and dropping it to a page at the design time:  If you drag and drop the user control, it adds following two important lines to your code:    <%@ Register TagPrefix=”uc1″ TagName=”HeaderUserControl” Src=”example.ascx” %>   This includes the example user control from the example.ascx.    The example control is then positioned on the page using the following tag:
   1.  
   2. <uc1:ExampleUserControl id="Example1" runat="server"></uc1:ExampleUserControl>
2. Other is, loading them dynamically when ever needed:
   Some times you may need to load the user control at runtime or dynamically. For this purpose there is a method called LoadControl.  This function has a straightforward syntax - it takes a single argument - the virtual path to the user control page.In this tutorial I will try to explain in detail about loading user controls dynamically.

Loading the user controls is simple but, it is not easy to make the dynamically loaded controls working properly, if we missed some key points. So, in this tutorial, I will try to explain the things by dividing it into following sections:

• Loading the user Controls Dynamically
• Using the PlaceHolders and Panel Controls, to display the user controls, where ever you need
• Accessing the properties of the dynamically loaded User Control

Loading the user Controls Dynamically

As I said, there is method called LoadControl(), which loads the usercontrols dynamically as follows:

LoadControl takes just single argument that is the virtual path of the user control. Some people asked me on forums like, why cannot we use new operator to create an instance of the user control? The answer is simple, if we create an instance of the user control only an instance of the control is created but, not all the child controls on the UserControl.

Once, we load the user control, it should be added to page control collection as follows:

Using the PlaceHolders and Panel Controls, to display the user controls, where ever you need

Above section, helped us to load the control and add it to the controls collectins. But, the drawback is that, we cannot control, where the UserControl actually appear on the page. So, I prefer, always using PlaceHolders and Panel controls. We can add them to the page by just dragging and dropping it on page. Adding the loaded control to them is simple as follows:

Accessing the properties of the dynamically loaded User Control

I accept that, their will be multiple ways do to a same job. Here, I am accessing the properties of the UserControl by casting the UserControl to its class as follows:

Note that, the above code should be placed in the code-behind file of web form.

Above code snippets, first loads the usercontrol, casts the loaded usercontrol generic one to the example control and then, we are accessing the properties of controls. At last, we are adding the example1 to controls collection.

1. Introduction
2. How to add the DropDownList to the DataGrid
3. Bind the Datagrid Control to the Data Source
4. Populate the DropDownList with XML file
5. Populate the DropDownList from the Database

Introduction

DataGrid is very useful control. It is a full-featured data-bound control that displays data in tabular format, and provides the ability to sort, select, edit, and delete records from its associated data source.

On other end, DropDownList control lists the values in the drop down fashion. Some times, we have to use DropDownList controls in the DataGrid . Suppose, to select the country of the employee or user, it is good if we have drop down lists which lists all the countries.

In this tutorial I will try to explain the following things:

• How to add the DropDownList to the DataGrid
• Bind the Datagrid Control to the Data Source
• Populate the DropDownList with XML file
• Populate the DropDownList from the Database

How to add the DropDownList to the DataGrid

Adding the DropDownList to the Datagrid is simple, first add template columns to DataGrid and then, add the DropDownList control to the template. I will try to explain in step by step manner as follows:

1. Drag and drop DataGrid onto the web form.
2. Right click on DataGrid -> select Property Builder.
3. In Property Builder, select Columns.
4. Add two bound columns and
5. Add one template column. (Remember to add bound columns first and than the template column.)
6. Uncheck Create columns automatically.
7. In the same window, click on the bound column appearing on the right window and set its header text to “Employee ID” and DataField to “EmpID”. Click on the second bound column appearing in the right window and set header text to “Employee Name” and DataField to “EmpName”

Adding the DropDownList controls to templates

1. Now, to add the DropDownList, simple right click on DataGrid and select the option Edit template.
2. In the item template, just drag and drop a DropDownList in item template.

Bind the Datagrid Control to the Data Source

Above create Datagrid control has three columns EmpId, EmpName and Countries. Leave the countries column for now, I will explain it another two sections. Now, we need fill the EmpId and EmpName columns from the data base table employee. To fill the data grid from the data base, it is best to go with binding to the data source as follows:

We are creating the dataset and filling it with the result of adapter (ad). Now, the important thing is we are setting the data source to the dataset (ds) and we are calling DataBind() method to bind the DataSet with DataGrid. The Datagrid control automatically populates the grid control with records of the employee table.

Populate the DropDownList with XML file

We have populated the empid and empname from the database. Now, the other column is the countries, we have an xml file called countires.xml as follows:
Countries.xml

We have to get country details from this xml file and populate the DropDownList in the DataGrid. There is name space called System.XML which helps us to parse and work with the XML files as follows:

We are creating the xml document and loading the xml file into it. At last, we are getting the list of nodes from the xml file.

Now, the question is how to access and populate the DropDownList in the Datagrid. It is simple,

FillCountries() method reads the xml file and adds new list item to DataGrid DropDownList control.

Populate the DropDownList from the Database

Compared to xml approach this database is where simple. Just get the dataset and set this dataset as datasource property of the DropdownList control as follows:

We have another important step here, search for the DropDownList in the aspx HTML page and modify it has follows:

See the data source property of the DropDownList, we are assigning it with the return data set from the FillCountries method. As we set the DataSource property, DropDownList automatically, fetches and fills the countries details as list items in the DropDownList control.

1. Introduction
2. Using the Xml Data Source control
3. Using System.XML namespace methods

Introduction

eXtended Markup Language(XML) is a specification for create custom markup languages. In simple, xml allows you to define our own tags to represent the data in what ever way we want. Below is the simple XML file,
Countries.xml

The xml file contains countries information “country name” within the tag. We use this xml file thru out this tutorial. Populating the DropDownList control using xml files can be done in different ways in this tutorial, I will try explain the following ways populate it:

• Using the Xml Data Source control
• Using System.XML namespace methods

Using the Xml Data Source control

This is very simple, create a DropDownlist and XmlDatasource controls and just bind them. I will try to give the detailed steps of how to do this:

• Drop a DropDownlist control onto your ASP page.
• Drop an XML datasource control onto your ASP page.
• Copy the above countries.xml file into your project (preferably into your app_data folder).
• Click on the XML datasource smart tag (the small arrow) and wire-up the datasource to your XML File Note: You have to do a refresh on your project files by Right Clicking on your folder or Root Folder in the solution explorer followed by refresh before the XML file will been seen by the XML datasource.
• Bind the DropDownlist control datasource to your XML datasource
• Enjoy, we have done our job!!

Using System.XML namespace methods

I like doing the things programmatically, now, the question is how to populate the DropDownList control from the xml file programmatically. There is name space called System.XML which helps us to parse and work with the XML files. Now, first see the example:

The above code snippet is easy to understand. First we are creating a Xmldocument instance and loaded it with the Countries.xml file. Now, we want to parse the XML file and get the “country names”, to do this, we need nodelist. The for each loop iterates thru the nodelist’s and populates the DropDownList control by adding them as items to it.

1. Introduction
2. XML Menu file
3. Using NameSpaces
4. Creating the DataSet and Caching it
5. Create the data list control
6. Binding the DataSet to the Data List Control
7. Using the Data List’s Hyper Control to Display the Menu

Introduction

Menus are used to navigate thru the web sites. There are many ways to create the menus, like, using menu control with XML or Sitemap data sources etc. Besides these all, there is another control called as, data list control. The DataList control is like the Repeater control, used to display a repeated list of items that are bound to the control. However, the DataList control adds a table around the data items by default. The DataList control may be bound to a database table, an XML file, or another list of items. In this tutorial we bind the XML Menu file with data list control.

Behind binding and displaying the xml menu, we will create dataset and cache them for future use, so, that it increases speed. Keeping all these things in mind I divided the tutorial into following sections:

• XML menu file
• Using namespaces
• Creating the DataSet and Caching it
• Create the Data List Control
• Binding the dataset to the Data List Control
• Using the Data List’s Hyper Control to Display the Menu

XML Menu file

Below is the sample xml file which contains MenuItem tag and it has other two sub tags in it, called as text and URL. Menu tag is used to identify the individual menu and it sub tags, text and URL is used for menu text and menu URL respectively. See the sample xml file as follows:

Using NameSpaces

In this tutorial we are using the dataset to retrieve the xml content and later we are binding the datasets with the data list. So to use the dataset, first we need to import the System.Data namespace as follows:

System.Data namespace has a class called Dataset, which we are using in this tutorial.

Creating the DataSet and Caching it

First we create a dataset and load the XML file to it as follows:

Menus are displayed every time when the user views the page. In the page_load function we creating dataset and reading the same file always. This increase the load time and we are unnecessary reading the xml file always which is an expensive operation. So, the better idea is to load file once and use it multiple times. This can be achieved by using the caches as follows:

See the above code, we modified it a little bit compared to it previous version. In this, first we are checking whether there is menu data set in cache array (with MENU_CACHE_KEY key), if it exists we are casting the Menu dataset from the cache array to our dataset “dsMenu”.

If the cache array does not have menu dataset key, we are loading the xml file into dataset “dsmenu” and inserting the dataset into the cache array for future use.

Create the data list control

We create a DataList in an .aspx page. See the below data list control, the contents are as follows:

• Data list takes the parameters id, which is used to identify the data list uniquely from the other controls and runat=”server” specifies that data list executes on the server.
• <HeaderTemplate> element are rendered first and only once within the output
• <ItemTemplate> element are repeated for each “record” in the DataSet,
• <FooterTemplate> element are rendered once within the output

We can add styles to the data list as parameters as follows:

Binding the DataSet to the Data List Control

We created the data list, data set and loaded the data set with xml, now, the other important step remain is, binding the data set with the data list control. This is done as follows:

DataBind() method binds the data source (which in our case is a xml data set) with the data list.

Using the Data List’s Hyper Control to Display the Menu

Now, the final part comes into picture, try to remember the data list control contents, there is element, which is repeated for each “record” in the DataSet. This is what we want to show the menu contents, Right!,

Menus are links, when the user clicks on it, we are moved to destined URL. So, for the purpose of this tutorial, we use Hyperlink control. It has text and NavigateUrl properties; we will set value of these properties from the xml data source as follows:

1. Introduction
2. Using the Application variables (Global.asax )
3. Using the text files (Not lose User Count Between Application Restarts)
4. Displaying the user count as a colorful image on the web sites

Introduction

Most of the web sites today using the hit count either to track the number of users (or) to display on the web sites to increase the popularity. There are many ways and each have pros and cons. In this article, I will try to show the different ways of counting and showing the number of users as follows:

• Using the Application variables(Global.asax)
• Using the text files
• Displaying the user count as a colorful image on the web sites

Using the Application variables (Global.asax )

Most of programmers, who think about counting number of users on the web site, first thing, that strikes in mind, are using the application variables to hold the user count. Because, it is simple to implement and can be accessed application wide. Let first see how to do this:

First open the global.asax file and go to session_start() function. Now add the following code:

Use the application state variable TOTALNUMBEROFUSERS to access the count and display it to the users in your asp pages. This seems to be simple but, this approach has a major drawback, like, if the application restarts, the count will be lost because, the application variables are initialized again when the application starts.

Using the text files (Not lose User Count Between Application Restarts)

As discussed, storing user count on application variables is not a good option. We need some way of storing the user count, so even if the application restarts, we can access user count. The simple solution is using the text files to store the user count as follows:

Put the above code in the page_load function, so when the page is loaded the function executes each time and updates the user count.

Displaying the user count as a colorful image on the web sites

The above section describes how to save and retrieve the hit counter from the text file. By using the same hit counter, I will try to show to how to create a image with the number of users as follows:
[Continuation of the above example]

1. Introduction
2. Using the NewGuid function
3. Generate the random password in our own way

Introduction

How to generate random passwords, I came across this question many times in forums. Recently again I came across this question, so I decided to write this article. This may help the required ones. Actually it is a simple task; usually there are two best or common methods to generate the random passwords as follows:

• Using the NewGuid function
• Generate the random password in our own way

Using the NewGuid function

NewGuid method is a member of the System.Guid structure, this generates a 32 bit hexadecimal string and it will globally unique. If you are familiar with the components then, you can refer this to the CLSIDs.

The result will be as follows:

Now, you can say like, how to use this crazy thing as the password. Let me explain it, every time when the new GUID is generated it will be unique. So, our passwords will be unique for all the users, so I think this is some what good option, right!! But, the problem is, the string is lengthy.

We will solve this problem by taking the required amount of characters from the generated GUID as follows:

Now, if the length is 8 , the return password from this function will be as follows:

It is a good and healthy password, cheers.

Generate the random password in our own way

Generating passwords with GUID is simple and effective but, some times their will be other things to consider like, if our password needs only alphabets, then GUID will not be the answer. Like this kind of custom rules, we need our own function to generate passwords. There are many ways to write this function, I will show an example how to write this:

Condition like, includes like no numbers, but only, combination of capital and small letters as follows:

We are using the string builder to reduce the memory usage and append the password string. In the for loop, we are taking a random alphabet from the string and appending to the password and then, we are taking the random alphabet from the string and converting it to upper case and appending to string.