dotnet

How to track visitors to your site in ASP.NET & C# - 2

2008-03-11T05:57:00.000-07:00

Code to log the IP address & DNS name for visitors to each page
Once you have published a site in ASP.NET, you'd like to know who are your visitors. One way is to check your event log on the host server. Another option is to write your own code. You'd basically like to log the IP address, and DNS name for the visitor, and it would be nice to know which page they are visiting.
To log the ip address using ASP.NET, you can call:
Request.ServerVariables["HTTP_X_FORWARDED_FOR"]
Another usefull variable is
Request.ServerVariables["REMOTE_ADDR"]
A combination of the two can be done as follows:
private string IpAddress()
{
string strIpAddress;
strIpAddress = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (strIpAddress == null)
{
strIpAddress = Request.ServerVariables["REMOTE_ADDR"];
}
return strIpAddress;
}
Next, you'd want to log the DNS name. To do so, you can call:
Dns.GetHostByAddress(string ipAddress)
And log the HostName property returned by the call. Now to log the address of the page being requested, you can call:
Request.Url.ToString()
So to combine all these together, here is the code to build a visitors.log file:
// Track Visitors
string ipAddress = IpAddress();
string hostName = Dns.GetHostByAddress(ipAddress).HostName;
StreamWriter wrtr = new StreamWriter(Server.MapPath("visitors.log"), true);
wrtr.WriteLine(DateTime.Now.ToString() + " " + ipAddress + " " + hostName + " " + Request.Url.ToString());
wrtr.Close();
The next question is what part of your ASP.NET page can you put the above code? There are two possible places, the first would be in the Application.BeginRequest event handler, the second can be in the Master page Load event. Here is how to do it in the Load event:
using System;
using System.Configuration;
using System.Net;
using System.IO;
namespace MyWebSite
{
public partial class DefaultMasterPage : System.Web.UI.MasterPage
{
protected void Page_Load(object sender, EventArgs e)
{
// Track Visitors
string ipAddress = IpAddress();
string hostName = Dns.GetHostByAddres(ipAddress).HostName;
StreamWriter wrtr = new StreamWriter(Server.MapPath("visitors.log"), true);
wrtr.WriteLine(DateTime.Now.ToString() + " " + ipAddress + " " + hostName + " " + Request.Url.ToString());
wrtr.Close();
}
private string IpAddress()
{
string strIpAddress;
strIpAddress = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (strIpAddress == null)
{
strIpAddress = Request.ServerVariables["REMOTE_ADDR"];
}
return strIpAddress;
}
}
}
Once you start getting some visitors, the result visitors.log file would look something like this:
4/2/2007 8:47:34 PM 74.6.67.155 lj612164.inktomisearch.com http://www.mycsharpcorner.com/Post.aspx?postID=22
4/2/2007 8:53:05 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Default.aspx?categoryID=18
4/2/2007 9:02:41 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Default.aspx
4/2/2007 10:06:20 PM 69.117.147.109 ool-4575936d.dyn.optonline.net http://www.mycsharpcorner.com/Post.aspx?postID=15
4/2/2007 10:12:23 PM 72.30.216.102 lm502014.inktomisearch.com http://www.mycsharpcorner.com/Post.aspx?postID=22
4/2/2007 11:04:24 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Post.aspx?postID=15
4/2/2007 11:08:22 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Post.aspx?postID=23
Happy Programming!

How to track visitors to your site in ASP.NET & C#

2008-03-11T05:54:00.000-07:00

Once you have published a site in ASP.NET, you'd like to know who are your visitors. One way is to check your event log on the host server. Another option is to write your own code. You'd basically like to log the IP address, and DNS name for the visitor, and it would be nice to know which page they are visiting.
To log the ip address using ASP.NET, you can call:
Request.ServerVariables["HTTP_X_FORWARDED_FOR"]
Another usefull variable is
Request.ServerVariables["REMOTE_ADDR"]
A combination of the two can be done as follows:
private string IpAddress()
{
string strIpAddress;
strIpAddress =
Request.ServerVariables ["HTTP_X_FORWARDED_FOR"];
if (strIpAddress == null)
strIpAddress = Request.ServerVariables["REMOTE_ADDR"];
return strIpAddress;
}
Next, you'd want to log the DNS name. To do so, you can call:
Dns .GetHostByAddress( string ipAddress);
And log the HostName property returned by the call. Now to log the address of the page being requested, you can call:
Request.Url.ToString();
So to combine all these together, here is the code to build a visitors.log file:
// Track Visitors
string ipAddress = IpAddress();
string hostName = Dns .GetHostByAddress(ipAddress).HostName;
StreamWriter wrtr = new StreamWriter( Server.MapPath(
"visitors.log" ), true );
wrtr.WriteLine( DateTime .Now.ToString() + " " + ipAddress
+ " " + hostName + " " + Request.Url.ToString());
wrtr.Close();
The next question is what part of your ASP.NET page can you put the above code? There are two possible places, the first would be in the Application.BeginRequest event handler, the second can be in the Master page Load event. Here is how to do it in the Load event:
using System;
using System.Configuration;
using System.Net;
using System.IO;

namespace MyWebSite
{
public partial class DefaultMasterPage : System.Web.UI.MasterPage
{
protected void Page_Load( object sender, EventArgs e)
{
// Track Visitors
string ipAddress = IpAddress();
string hostName = Dns .GetHostByAddres(ipAddress).HostName;
StreamWriter wrtr = new StreamWriter (Server.MapPath( "visitors.log" ), true );
wrtr.WriteLine( DateTime .Now.ToString() + " " + ipAddress + " " + hostName + " " + Request.Url.ToString());
wrtr.Close();
}
private string IpAddress()
{
string strIpAddress;
strIpAddress = Request.ServerVariables[ "HTTP_X_FORWARDED_FOR" ];
if (strIpAddress == null )
strIpAddress = Request.ServerVariables[ "REMOTE_ADDR" ];
return strIpAddress;
}
}
}
Once you start getting some visitors, the result visitors.log file would look something like this:4/2/20078:47:34 PM 74.6.67.155 lj612164.inktomisearch.com http://www.mycsharpcorner.com/Post.aspx?postID=22
4/2/20078:53:05 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Default.aspx?categoryID=18
4/2/20079:02:41 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Default.aspx
4/2/200710:06:20 PM 69.117.147.109 ool-4575936d.dyn.optonline.net http://www.mycsharpcorner.com/Post.aspx?postID=15
4/2/200710:12:23 PM 72.30.216.102 lm502014.inktomisearch.com http://www.mycsharpcorner.com/Post.aspx?postID=22
4/2/200711:04:24 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Post.aspx?postID=15
4/2/200711:08:22 PM 66.249.66.35 crawl-66-249-66-35.googlebot.com http://www.mycsharpcorner.com/Post.aspx?postID=23
And now you can know who comes to visit your ASP.NET Page.

Use ASP.NET 2.0 Web Parts and Membership stuff with SQL Server 2000

2008-01-28T21:38:00.000-08:00

By default ASP.NET 2.0 Web Parts uses SQL Express. To use this stuff with SQL Server 2000 you must configure the aspnetdb database on your SQL Server 2000 database server. Fortunately for us, Microsoft has created a utility to automate the process.

Follow these steps to setup the aspnetdb database:

run the utility - C:\WINDOWS\Microsoft.NET\Framework\v2.0.50215\aspnet_regsql.exe (this was written with ASP.NET 2.0 Beta 2 (v2.0.50215) as a reference, so with the final release of .NET 2.0 the version number will be different.)

Select the “Configure SQL Server for application services” option and click “Next”.

Enter your server name, login credentials and the name of the database to create/edit with the aspnetdb stuff.(The database will hold your login and personalization data, so if you don't have complete control over the database server (if you use a remote hosting service like I do) you will want to point this utility to the database you are going to use for your web site. You know, keep all your sites data in the same database. This is the same database that the Membership Provider uses to store user credentials.)

Add the following stuff to your web sites Web.config file (this stuff tells ASP.NET to use your SQL Server 2000 database instead of SQL Express):

Integrated Development Environment (IDE) Integration

2008-01-25T00:00:00.000-08:00

Microsoft® Visual SourceSafe™ version control software provides integration with the Microsoft Visual Basic® (Enterprise and Professional editions) programming system and with the Microsoft Developer Studio®, so you can enjoy the advantages of source code control—team coordination and version tracking—without having to leave your IDE.

Visual SourceSafe and Visual Basic

Visual Basic is rapidly moving from being a simple stand-alone development tool to being a powerful client-server corporate application development environment. New needs come with that growth: the need to coordinate large teams of programmers working together and the need to track Visual Basic code like any other mission-critical data that runs a company, in short, the need for version control.

At the same time, Visual Basic has built its reputation around an interface which is easy to learn and easy to use. If version control adds a new burden to developers, many of them simply will not use it and there will be no benefits at all! That's why checking forms in and out of Visual SourceSafe has to be just as easy as modifying those forms in Visual Basic. And that's why Visual SourceSafe 4.0 integrates directly into the Visual Basic IDE.

Figure 1. SourceSafe integrated into Visual Basic

Without leaving Visual Basic, you can check a form out, modify that form, and check it back in. Without ever looking at the Visual SourceSafe Explorer, you can view the changes you made to a form, the history of a basic module, or even see a list of all the projects that are sharing a VISUAL BASIC class. And if you check out a .FRM file, the .FRX file "tags along" automatically, so just as always, you don't need to worry about it.

Of course, the Visual SourceSafe Explorer is still available for advanced features such as branching and merging. But most users will never have to leave Visual Basic to enjoy all the benefits of coordinated team development and version tracking.

Visual SourceSafe and Microsoft Developer Studio

The Microsoft Developer Studio is the new IDE that combines award-winning products such as Visual C++®, Visual Test, and Microsoft Fortran PowerStation. Users of these products not only enjoy the fastest path to Windows® development, powerful automated testing, and Microsoft technical information—they also have the benefit of using all these products inside one integrated shell. And now, with Visual SourceSafe 4.0, the ability to check your source files in and out is literally "at your fingertips" in the same common shell!

Figure 2. Visual SourceSafe integrated into the Developer Studio

As an example, imagine running the Visual C++ debugger to track down a problem reported by a tester or customer. You pull down the Tools menu, choose Get from SourceControl, and get all the files in the project, just to make sure you are up-to-date with everyone's changes. Then you debug and find the problem. You right-click on the file and choose Check Out to tell Visual SourceSafe you will be making changes. You edit the file, fix the problem, and use the right mouse button again to choose Check In and publish your changes for the rest of the group.

But why was this problem not caught? Switching to Microsoft Visual Test, you use the Visual SourceSafe Get command again to get the test scripts, and discover a missing test case. So you create the new test case and add it to Visual SourceSafe, along with a comment explaining the bug that this test will trap. During this entire session, you have not left the Developer Studio window.

Visual SourceSafe 4.0 integrates with the Developer Studio and with Visual Basic 4.0 Professional and Enterprise editions. Visual SourceSafe is not a part of most of these products (it is a part of Visual Basic Enterprise Edition), and must be acquired separately. Visual SourceSafe can also be used with many other development environments, including (but not limited to) the Microsoft Visual FoxPro® database management system and Microsoft Office, by performing all Visual SourceSafe commands directly in the Visual SourceSafe Explorer.

Visual SourceSafe and Visual FoxPro

Microsoft FoxPro has long been recognized as the fastest, most powerful database development tool. With Visual FoxPro 3.0 developers could tap into the versatility of Object Oriented programming and client-server functionality. Now Visual FoxPro 5.0 adds yet another dimension that developers have requested—team based application development.

With just a few mouse clicks, a developer can join a multideveloper project and from then on, all changes, whether they add files to the project or modify existing files, can be coordinated from within the Visual FoxPro IDE.

Figure 3. Visual SourceSafe integrated into Visual FoxPro

In a team environment, having a project—a .PJX in FoxPro terminology—under SourceSafe control means that:

All developers on the team can add files to, or remove them from, the PJX. By choosing Update Project List from the project menu, a developer both makes any changes he or she has made to the PJX available to all the other developers on the team and receives an updated version of the project, reflecting changes other developers have made.

Two or more developers can work on the same program (PRG) simultaneously. If, for example, two developers have checked out the same program, and both have modified it, unaware of each other's changes, Visual SourceSafe will alert the one who checks in the program last, prompting him or her to resolve any conflicts between the different versions.

Of course team development is just one of the many uses of SourceSafe integration. If you are an individual developer you will want to take advantage of other features including:

Maintaining a history of files, so you can compare the current version of a file with previous versions.

Labeling Projects enables you to take a snapshot of a project at a given stage in the development cycle and give it a meaningful name (foe example, "Beta 1") before you continue development

Sharing files means that if you have a file containing commonly used routines that you include in multiple projects (typically known as a library or procedure file), changes made in any copy of that file are automatically propagated to all other copies.

Calling a stored procedure from ASP.Net

2008-01-21T22:49:00.000-08:00

Calling a stored procedure from ASP.Net

With ASP.Net 2.0 available now, I wanted to create an ASP.Net page that would pass parameters to a SQL Server stored procedure to insert data into a database. I've read that this can be done now with controls and almost no understanding of coding, but I wanted to do it manually. It surprised me that I couldn't find a decent online sample from Google, which motivated me to put together this short article.

I guess I'm from the "old school" because I learned coding without a fancy GUI and I still have a tendency to lean that direction when possible. The latest version of Visual Studio is a great tool, but I still like to understand what's going on rather than just dragging and dropping controls onto a page. Perhaps with some more time I'll give up on this way of thinking, but for now I still like to hand-code at times.

With ASP.Net 2.0 available now, I wanted to create an ASP.Net page that would pass parameters to a SQL Server stored procedure to insert data into a database. I've read that this can be done now with controls and almost no understanding of coding, but I wanted to do it manually. It surprised me that I couldn't find a decent online sample from Google, which motivated me to put together this short article.

I am using Visual Studio 2005 to create my test page. I set up a page with nothing more than a submit button and then started adding code to the submit function in the associated .vb code file.
The first thing I had to do was add "Imports System.Data.SqlClient" to the very top of the file. Without that the data objects weren't being recognized.

After that imports statement is added, the rest isn't too complex.

I created a variable to hold my connection string represented by below (put your real connection string here). I then created a SQL connection based on the connection string, and also created a SQL Command based on that SQL Connection. When creating the SQL Command you need to pass the name of the stored procedure ("Insert_Test" in this case) and the name of the connection object.

The next thing you need to do is tell the command that it is going to be calling a stored procedure. You do this by setting the Command Type to Data.CommandType.StoredProcedure (VS's intellisense makes it really easy to find what you need if you don't remember exactly what you need to type).

Next I added a parameter to the SQL Command object providing the name of the parameter and also the data type and size. After the parameter is added the value needs to be specified. Until you specify the value, no data is actually set, so be sure to perform this step. In this sample I'm only sending one parameter value but I could have just as easily sent 20 if needed.
Lastly I open the connection, execute the stored procedure (automatically passing the parameters defined), and close the connection.

Here is the entire subroutine with the code I used:

Protected Sub Btn1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Btn1.Click
Dim sConnStr As String = {MyConnectionString}
Dim cnBKTest As New SqlConnection(sConnStr)
Dim cmdTest As New SqlCommand("Insert_Test", cnBKTest)
cmdTest.CommandType = Data.CommandType.StoredProcedure
cmdTest.Parameters.Add(New SqlParameter("@TestParam", Data.SqlDbType.VarChar, 10))
cmdTest.Parameters("@TestParam").Value = "Testing"
cnBKTest.Open()
cmdTest.ExecuteNonQuery()
cnBKTest.Close()
End Sub

That's it! It really isn't very hard, but since I couldn't find an online sample I wound up fussing with this for about an hour. Hopefully this will give someone else a good start and save them from wasting time scratching their heads like I did.
~Brad
Brad Kingsley is founder and president of ORCS Web, Inc. - a company that provides managed hosting services for clients who develop and deploy their applications on Microsoft Windows platforms.

ASP.NET Popup Dialog - Confirm Delete - Javascript - DataGrid Example

2008-01-01T21:01:00.000-08:00

Awhile back I wrote a post called ASP.NET Popup Dialog - Confirm Delete - Javascript.
The example was pretty simple, but it did not cover how to handle the situation in the case of a datagrid, and I have had numerous requests for an example using a datagrid. Personally, I don't use DataGrids that much, because I prefer the unlimited flexibility I get from a DataReader or DataList, but below is a very simple and quick example I created this morning to help those who sent me a request.
I used in-line coding (by hand - no intellisense ;) for the example to make it simple to follow and cut-and-paste, but in my daily work I always use code-behind (Note that in-line coding may make a comback in ASP.NET 2.0 - good or bad). The example just binds 3 contacts via an ArrayList to a datagrid. Although the datagrid has a “ButtonColumn“ that you could use for firing the “delete“ command, I like using images, so I went ahead and just made a template column with an ImageButton.
The main pieces here are the ItemCreated and ItemCommand events fired by the DataGrid. When the DataGrid is creating the items, we find the Delete Button (btnDelete) in the item and attach the onclick event to it to invoke the popup dialog. When an event is fired within the DataGrid (clicking of the btnDelete Image Button), the ItemCommand event fires (only if you choose OK from the confirm delete dialog) and calls the DeleteContact_Click handler which does a real quick and dirty delete of the contact using the ItemIndex (note this is a hack just to show you how it works).
I tested the code and it works fine. Here is the online example. Again, this is only 1 way you could pull this off and I did this quick and dirty just to show an example similar to the previous article. I hope it helps those who sent me requests...

For Code Click Here to Download:

Ground Up : Master Pages in ASP.NET 2.0

2007-12-19T02:31:00.001-08:00

Introduction:

Master pages are a new cool feature that has been added to the Asp.net 2.0, known as "Whidbey". A Web application has to look consistent and for that every page must be like the every other page. In Asp.net 1.1 we used Cascading Style Sheets to make a common template for all the pages and than we simply copy and paste the html source of one page to the other to make it consistent.
Asp.net 2.0 introduces master pages that are used to make the pages of the website consistent. In this article we will see how to set up master pages and how we can use master pages in our .aspx pages.

Adding a Master page (Sample1.master):

Adding a master page to your web application is straight forward. Just right click on the project and select "Add New Item" and than select "Master Page". This will add the master page to your project. Now if you see your master page in the design window you will see something like this: The master page already has the contentplaceholder control which is used to hold and display your contents. Let's delete that contentplaceholder and add it by our self. In this case we will create two content place holders. One will be on the left and other one on the right.

After you insert the contentplaceholder control inside your table your master page will look something like this:

Click on the area of the contentplaceholder and write some text.

Okay let's now make a page which can use this master page.

Using the master page in your aspx pages (Sample1.aspx):

Just add a new aspx page and name it as "Sample1.aspx". Now you want to use the Sample1.master file in your aspx page. Just go to the html view of your page and add a MasterPageFile attribute in the page directive and delete all the other html that is written in the aspx page. The MasterPageFile attribute denotes that the Page is inheriting from the master page.

After marking the attribute if you view your page it will look something like this:

Check to see if your content1 and content2 is inheriting from the master cause if they are not than it means that you are making custom contentplaceholder controls. Just right click on the Content and select smart tag and reference to the master so it will populate the boxes with the data extracted from the master pages. Now if you run the Sample1.aspx page you will see the content will be coming from the master file. NOTE: Don't forget to build your application after making changes in the master file. In the above example I Introduced you to the master pages with displaying simple text in the content pages. Let's see what else we can do using the master pages.

Adding other controls in Master pages (Sample2.aspx):

We are not only limited to adding text in the master pages but we can easily add any other server or html control in it. Let's add some controls to the master page. In this example I have added some hyperlinks and a image control to the master page. Your master page will look something like this after adding controls.

Now the cool thing is that you don't have to do anything to make this appear on the aspx page since you have already made a reference to the master page in your aspx page using the "MasterPageFile" attribute in the page directive. So, once you run the page you will see hyperlinks and the image on your aspx page.

Setting content section to be custom section (Sample3.aspx and Sample3.master):

Sometimes we don't want to add all the information from the master pages. Consider a content section which is not same for all the pages. This can be the detail on the page like about the company or the contacts of the company. In this example we will see that how we can enter our own contents which are not same for all the pages. Up till now you might be pretty comfortable in making the master pages. Let's make the master page which looks something like this:

As you can see its pretty simple master page. The left content consists of the menu which contains the hyperlinks. The right content contains the calendar control and the middle content is left blank.
Once you reference this master page in your aspx page you will see something like this when you run the page (Don't forget to build the application first when running).
As you can see the middle section is black. Now go back to the aspx page design view and right click on the middle section and select show smart tag and select "create custom content". This will allow you to enter the information in the middle content place holder control.

Now, as you see in the above image that the content you entered in the custom content section are added to the page rather than the contents from the master file.

Nesting Master Pages (SiteMaster.master,SectionMaster.master,Sample4.aspx):

You can also nest one master to the other. We will have to switch to code for this feature since the visual designer does not give you the facility to nest master pages.
So, this means that we have to write code to achieve this so lets do it.

SiteMaster.master:

The Site master master page will only contain the ContentPlaceHolder control which will display a heading saying that it is a site master page and not a section page.

SectionMaster.master:

Now, lets see the section master page which will inherit from the sitemaster page. <%@ Master MasterPageFile="~/SiteMaster.master" Language="C#" CompileWith="SectionMaster.master.cs" ClassName="SectionMaster_master" %>

See the first line, you will find it amazing but yes you can do like this. You can inherit or nest one master page inside the other. Now let's see the webform which uses all this nested master pages. In the next line we included the Content place holder control from the site master control.

Sample4.aspx:

Click Here to Download the Source Code

Caching Overview

2007-11-27T01:42:00.000-08:00

Caching is a technique widely used in computing to increase performance by keeping frequently accessed or expensive data in memory. In the context of a Web application, caching is used to retain pages or data across HTTP requests and reuse them without the expense of recreating them.

ASP.NET has three kinds of caching that can be used by Web applications:

Output caching, which caches the dynamic response generated by a request.
Fragment caching, which caches portions of a response generated by a request.
Data caching, which caches arbitrary objects programmatically. To support this, ASP.NET provides a full-featured cache engine that allows programmers to easily retain data across requests.

Output caching is useful when the contents of an entire page can be cached. On a heavily accessed site, caching frequently accessed pages for even a minute at a time can result in substantial throughput gains. While a page is cached by the output cache, subsequent requests for that page are served from the output page without executing the code that created it

Sometimes it is not practical to cache an entire page - perhaps portions of the page must be created or customized for each request. In this case, it is often worthwhile to identify objects or data that are expensive to construct and are eligible for caching. Once these items are identified, they can be created once and then cached for some period of time. Additionally, fragment caching can be used to cache regions of a page's output.

Choosing the time to cache an item can be an interesting decision. For some items, the data might be refreshed at regular intervals or the data is valid for a certain amount of time. In that case, the cache items can be given an expiration policy that causes them to be removed from the cache when they have expired. Code that accesses the cache item simply checks for the absence of the item and recreates it, if necessary.

The ASP.NET cache supports file and cache key dependencies, allowing developers to make a cache item dependent on an external file or another cache item. This technique can be used to invalidate items when their underlying data source changes.

Fixing the Global.asax in ASP.NET 2.0

2007-11-20T22:03:00.000-08:00

For some reason ASP.NET 2.0 has gone away from the code behind model to the script model for its Global.asax pages. I ran into this when looking at loading configuration data into global statics on application start in a web service.

When I created a default web service project with Visual Studio 2005 first I found no global.asax page was created. Why its not there by default I do not know as you could easily remove it if not needed, and a empty skeletal one has no performance impact anyway.

To add a global.asax, (or web.config for that matter), simply right click the web site or web server project in your solution explorer, select Add New Item from the context menu and then choose Global Application Class (or Web Configuration File for a web.config).

Happy that I finally had a Global.asax in my project, I opened it only to find that there was no class present! With the scripting page model you get a skeletal global.asax something similar to:

The problem as i see it is two fold.

Firstly there is no class object that can be easily referenced from elsewhere in your application. If you were to load configuration information in the application_start event and store it in a global static, you cannot access that static from elsewhere in your application there is no class name to reference by.

Secondly, as there is no class in the global.asax, you cant use "using" statements in the code easily. There may be a way to do this but it doesnt instantly come to hand. If you place a using before the script tag, the keyword isnt recognised. If you place a using after the script tag its not allowed as you are already inside an implicit class!

After a roam on the internet I came up with an excellent reply post by Scott Allen that showed that you can switch back to the code behind model using the inherits attribute to the Application tag:

<%@ Application Language="C#" Inherits="Global" %>

The only other step is to copy the code within the script tag to a normal class file called Global.cs which you add to the project. Then delete the script tag. An example follows:

Thus I now have simple and consistant use of the using keyword along with a class that is accessible from the rest of the web service to get at preloaded configuration information. My config value in this example can now be access by :

Global.ConfigKeyValue

All this is of course still possible within the script model. You dont have to use using statements and can explicitly denote classes. You also can probably store configuration items into the application cache collection instead of your own statics. However, when migrating some older applications that were written using statics, the fact that you can still use the code behind model is quite usefull. Personally I prefer the older method as it provides consistenct and I dont think a dynamic recompile on changing global.asax values is that useful or even appropriate.

But I am interested in knowning the rationale for why the VS2005 ASP team have gone down this change path.

Create a scrollable Gridview in asp.net 2.0

2007-05-24T00:48:00.000-07:00

Introduction

Using Javascript's cloneNode ,we can clone a table's header,so we can make a gridview to be scrollable.This method isn't set some long css.

In asp.net 2.0's Page_Load event,we must add style for GridView, and this MUST for IE and Firefox can work! protected void Page_Load( object sender, EventArgs e )
{
if (!IsPostBack)
{
GridView1.Attributes.Add("style", "table-layout:fixed");
GridView1.DataSource = CreateDataSource();
GridView1.DataBind();
}
}
Next,we must add some javascript for it:function start()
{
var t = document.getElementById("");
var t2 = t.cloneNode(true)
for(i = t2.rows.length -1;i > 0;i--)
t2.deleteRow(i)
t.deleteRow(0)
a.appendChild(t2)
}
window.onload = start

Specifying Paging Behavior in a DataGrid Control

2006-12-14T23:01:00.000-08:00

Automatic versus Manual Paging
The page displayed by the grid is determined by its CurrentPageIndex property. The built-in controls set this property automatically; if you are providing custom navigation controls, you set this yourself. After the CurrentPageIndex is set, the grid should be re-bound to the data source. The grid will recreate the entire data set and automatically move to the appropriate place in the data set. It then displays enough rows to make up one page of the grid.
If you are working with a large data set, recreating the entire data set each time users navigate to a new page can degrade performance. In this case, you might prefer to get data in page-size "chunks" — that is, retrieve just a page worth of records at a time. To do that, you turn off the automatic paging feature of the grid so that it does not assume that it is working with the entire data set. You then manually get the correct number of rows to fill the grid.
For details, see Creating Manual Paging below.
Using the Built-In Paging Controls
To use default paging, you set properties to enable paging, set the page size, and specify the style of the paging controls. Paging controls are LinkButton controls. You can choose from these types:
Next and previous buttons. The button captions can be any text you want.
Page numbers, which allow users to jump to a specific page. You can specify how many numbers are displayed; if there are more pages, an ellipsis ( ... ) is displayed next to the numbers.
You must also create an event-handling method that responds when users click a navigation control.
To use the built-in paging controls
Set the control's AllowPaging property to true.
Set the PageSize property to the number of items to display per page.
To set the appearance of the paging buttons, include a element into the page as a child of the DataGrid control. For syntax, see DataGrid Control Syntax.
Create a handler for the grid's PageIndexChanged event to respond to a paging request. The DataGridPageChangedEventsArgs enumeration contains the NewPageIndex property, which is the page the user would like to browse to. Set the grid's CurrentPageIndex property to e.NewPageIndex, then rebind the data.
The following code snippet shows the typical logic for the PageIndexChanged event handler.
void setPage ( object src, DataGridPageChangedEventArgs e ) {
// set CurrentPageIndex to the page the user clicked.
myGrid.CurrentPageIndex = e.NewPageIndex;
// fetch and rebind the data.
BindGrid ( );
}Sub setPage ( src As Object, e As DataGridPageChangedEventArgs )
' set CurrentPageIndex to the page the user clicked.
myGrid.CurrentPageIndex = e.NewPageIndex
' fetch and rebind the data.
BindGrid ( )
End Sub

Providing Custom Navigation Controls
You can provide your own navigation buttons and manipulate the CurrentPageIndex property of the DataGrid. The DataGrid will still take care of breaking the data source into appropriate pages and displaying the selected page.
When you create manual paging, you can use any way you like to set the pager style that the grid should display.
To provide custom navigation controls
Add server controls to the Web Forms page that the user can use to navigate. For example, you may want to create ImageButton controls with forward and reverse images on them.
In the event handlers for the navigation controls, set the DataGrid control's CurrentPageIndex property to the page to go to, and then rebind the grid to the data source.
The below snippet shows how you can create code for a custom navigation panel that allow the user to go to the first, last, previous, or next page. The paging elements are defined as controls whose CommandArgument property is set to indicate what page they go to. All four buttons call the following method when they are clicked.
void setPageCustom ( object src, EventArgs e ) {
// used by custom paging UI
string direction = ( ( Button ) sender ).CommandArgument;
switch ( direction ) {
case ( "first" ) :
myGrid.CurrentPageIndex = 0;
break;
case ( "prev" ) :
if ( myGrid.CurrentPageIndex > 0 )
myGrid.CurrentPageIndex --;
break;
case ( "next" ) :
if ( myGrid.CurrentPageIndex < ( myGrid.PageCount - 1 ) ) myGrid.CurrentPageIndex ++; break; case ( "last" ) : myGrid.CurrentPageIndex = ( myGrid.PageCount - 1 ); break; } BindGrid ( ); }Sub setPageCustom ( src As Object, e As EventArgs ) ' used by custom paging UI Dim direction As String = CType ( sender, Button ).CommandName Select Case direction Case "first" myGrid.CurrentPageIndex = 0 Case "prev" myGrid.CurrentPageIndex = _ Math.Max ( 0, myGrid.CurrentPageIndex - 1 ) Case "next" myGrid.CurrentPageIndex = _ Math.Min ( myGrid.PageCount - 1, myGrid.CurrentPageIndex + 1 ) Case "last" myGrid.CurrentPageIndex = myGrid.PageCount - 1 End Select BindGrid ( ) End Sub
Creating Manual Paging
By default, the DataGrid control recreates the data set each time the user navigates to a new page and then calculates which rows to display for the requested page. This may not be efficient, however, in applications that need to access large data sets.
By using the AllowCustomPaging property of the DataGrid, you can have complete control over which records are displayed. Custom paging improves performance by reducing the amount of data moved around in the system, since you can retrieve just one page of data at a time from the data source.
To do so, you turn off automatic paging, then take responsibility in your own code to get just the data for a single page. To create manual paging
To be supplied.
It is common to set this value by querying the data source the first time the page is run, as in the following example:
[ Visual Basic ]
[ C# ]
void Page_Load ( object src, EventArgs e ) {
if ( !IsPostBack ) {
int TotalRowCount=0;
// Query data source here and get the count of all rows you might display
myGrid.VirtualItemCount = TotalRowCount;
}
myGrid.DataBind ( );
} -->
The following examples demonstrate two different ways of using the AllowCustomPaging property to enable custom paging. One uses an autoincrement data model, and the other uses a data source with primary keys.

DataList Paging

2006-11-10T06:47:00.000-08:00

Unlike the DataGrid, the DataList has no inbuilt paging mechanism. As with most things in .NET, however, where there is a will, there is a way.
The secret to implementing paging in the DataList control lies not in the control itself, but in the DataAdapter's Fill method which can be overloaded in several different ways. One way to overload it is to pass the arguments DataSet, starting record, number of records, and the table name or index. Number of records is analogous to "page size" in a DataGrid. Starting record is the "index" of the current starting record. For example, if our page size is 10 and we are on the first page of records, then starting record would be 0 and our 10 displayed rows would be 0 through 9. If the NextPage button is clicked, then starting record would be 10 and displayed rows would be 10 through 19, etc. All we need then is a mechanism for specifying page size (number of records) and current index (starting record). Page size is normally a static value that can be specified once in the program. Starting record (current index) will change from page to page and must be tracked within our code-behind logic.
We will use three invisible label controls on the .aspx page to store total record count, current index, and page size. The .aspx page is presented below. I used images (VCR buttons) for the paging mechanism. I needed an html element where I could include an OnServerClick event and I wanted to make the images appear as links (cursor = hand). The easiest way to do this was to use links to a bookmark at the top of the page. The rest of the markup should be self evident.

The code-behind page is shown in two parts below. This first part shows the Page_Load event and the BindTheData subroutine. Since the data must be bound to the DataList control with each page change it is convenient, and more efficient to move the data binding to a routine of its own. It is in the latter third of the BindTheData code that we make use of overloading the Fill method of the DataAdapter. That is done with the line:

dataAdapter.Fill (dataSet, Cint(lblCurrentIndex.Text), CInt(lblPageSize.Text), "Customers") ;

The above line is saying Fill the DataSet, with data beginning at record zero (since CurrentIndex happens to be 0 the first time through), with 10 rows (our specified page size), from the table "Customers". As we click the next and previous page buttons CurrentIndex will change appropriately and the correct page of data will be displayed.

Imports System.Data
Imports System.Data.SqlClient
Imports System.Configuration
Imports Microsoft.VisualBasicPublic
Class PagingDataList : Inherits System.Web.UI.Page
Protected lblCurrentIndex As System.Web.UI.WebControls.Label
Protected lblRecordCount As System.Web.UI.WebControls.Label
Protected dtlCustomers As System.Web.UI.WebControls.DataList
Protected lblPageSize As System.Web.UI.WebControls.Label
Protected lblCounts As System.Web.UI.WebControls.Label

Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)
If Not Page.IsPostBack() Then
BindTheData()
End If
End Sub

Private Sub BindTheData()
Dim objConn As New SqlConnection(ConfigurationSettings.AppSettings("NorthwindConnection"))
Dim strSql As String = "SELECT CompanyName, ContactName, ContactTitle, Country, Phone FROM Customers"
Dim dataAdapter As New SqlDataAdapter(strSql, objConn)
Dim dataSet As New DataSet()
If Not Page.IsPostBack() Then
dataAdapter.Fill(dataSet)
lblRecordCount.Text = CStr(dataSet.Tables(0).Rows.Count)
dataSet = Nothing
dataSet = New DataSet()
End If
dataAdapter.Fill (dataSet, Cint(lblCurrentIndex.Text), CInt(lblPageSize.Text), "Customers")
dtlCustomers.DataSource = dataSet.Tables("Customers").DefaultView
dtlCustomers.DataBind()
objConn.Close()
ShowCounts()
End Sub

The remainder of the code-behind page is shown below. The first four routines are for handling the button click on our First, Previous, Next, and Last navigation links. Essentially all they do is set the correct value for CurrentIndex. The Previous and Next routines simple increment or decrement the CurrentIndex by the PageSize as appropriate. First and Last are special cases in that First just always sets CurrentIndex to 0, while Last subtracts PageSize from RecordCount. The last routine (ShowCounts) just updates our status line showing which of how many pages we are currently displaying.

Public Sub ShowFirstPage(ByVal s As System.Object, ByVal e As System.EventArgs)
lblCurrentIndex.Text = "0"
BindTheData()
End Sub

Public Sub ShowPreviousPage(ByVal s As System.Object, ByVal e As System.EventArgs)
lblCurrentIndex.Text = Cstr(Cint(lblCurrentIndex.Text) - CInt(lblPageSize.Text))
If CInt(lblCurrentIndex.Text) < text = "0" text =" CStr(CInt(lblCurrentIndex.Text)" intmod =" CInt(lblRecordCount.Text)"> 0 Then
lblCurrentIndex.Text = Cstr(CInt(lblRecordCount.Text) - intMod)
Else
lblCurrentIndex.Text = Cstr(CInt(lblRecordCount.Text) - CInt(lblPageSize.Text))
End If
BindTheData()
End
Sub Private Sub ShowCounts()
lblCounts.Text = "Total Rows: " & lblRecordCount.Text
lblCounts.Text += " Page: "
lblCounts.Text += CStr(CInt(CInt(lblCurrentIndex.Text) / CInt(lblPageSize.Text)+1))
lblCounts.Text += " of " If (CInt(lblRecordCount.Text) Mod CInt(lblPageSize.Text)) > 0 Then
lblCounts.Text += CStr(Fix(CInt(lblRecordCount.Text) / CInt(lblPageSize.Text)+1))
Else
lblCounts.Text += CStr(Fix(lblRecordCount.Text) / CInt(lblPageSize.Text))
End If
lblCounts.Text += " "
End Sub
End Class

A fair amount of code has been presented to implement paging in the DataList control, but I think if you will run the program and then take a careful look at each section of code at a time, you will understand that the process is really not all that complicated. Please be advised that one drawback of this method is that all rows of data from the table are being brought back with each page change. We are only displaying the specific rows we want. For a large table this could become unweildy. Good luck!