Professional ASP.NET 1.1 [Electronic resources]

Code-Behind

In the world of increasingly complex Web applications, it's often difficult to separate the different parts of the development process. Writing Web applications is hard enough without worrying about how to make them look good and stay maintainable over the years. Some companies have designers who create the look and feel of the site, allowing the programmers to concentrate on the coding. With the traditional ASP model, this is hard to achieve, as code and content are often intermixed.

The way to solve this problem in ASP.NET is by using Code-Behind, where the content (HTML and server controls) are in one file, and the server-side code in another. Not only does this allow different people to work on the same page at once, but it also enables either part to be redesigned (as long as the controls still stay the same) without affecting the other.

The code-behind model is no different in action to pages where the code is inline. Remember that an ASP.NET page and its associated files are compiled into an executable object. This object is essentially (as far as performance and use go) the same as any other page, allowing easier development with the same effect.

Code-Behind in Development Tools

The approach to use for code may depend on the tool used to create ASP.NET applications. For this book, most of the samples will show code inline, simply because it's easier to show, as well as being more convenient when using text editors such as Notepad.

Tools such as Visual Studio .NET take the opposite approach, using the code-behind model as default. One reason is that it allows a standard HTML designer to be used for designing the look and feel of the page, and a code editor to be used for the actual code. This gives the user the familiar feel (comparable to the Visual Basic 6 environment) of design and code windows.

Another reason is that Microsoft has taken the view that third parties may want to use write designers or code editors that integrate with .NET. The code-behind approach allows any HTML designer and any editor to be used (as long as it doesn't change ASP.NET controls).

Using Code-Behind

The principle of code-behind is to create a class for the code, and inherit this class from the ASP.NET Page object. This gives your class access to the page intrinsics, and allows it to interact with the postback architecture. You can then create the ASP.NET page and use a page directive to inherit from the newly created class.

There are some rules that you should follow to create the code-behind class, the first of which is to reference the required namespaces. At a minimum you need to reference

System and

System.Web.UI , although others may be required. For example, to reference controls on the page and to define the control types, you should reference

System.Web.UI.WebControls . Also include any other required namespaces, such as

System.Data.SqlClient for accessing SQL Server.

The second rule is create a class that inherits from the

Page object (this is why the

System.Web.UI namespace is needed). Within this class, you should declare public instances of ASP.NET server controls that are on the Web page, using the same name for the variables that the Web Control has. This provides a link between the code-behind class and the actual server controls (there are other ways to do this, but this method is simplest). Within this class, create event procedures, methods, and properties, just as with any class. The events can be event procedures named on server controls in the web page.

For example, consider the simple select list with Shipping Methods shown earlier in the chapter. The following code samples show the code-behind class. With the exception of the additions required for the code-behind model, the code is exactly the same as the code inline samples.

VB .NET

Imports System 

Imports System.Web.UI 

Imports System.Web.UI.WebControls 

Imports System.Data 

Imports System.Data.SqlClient 

 

Public Class ShipMethodClass 

Inherits Page 

' public variables to match the server controls 

Public ShipMethod As DropDownList 

Public YouSelected As Label 

Public PlaceOrder As Button 

 

Sub Page_Load(Source As Object, E As EventArgs) 

If Not Page.IsPostBack Then 

Dim myConnection As SqlConnection 

Dim myCommand    As SqlCommand 

Dim myReader     As SqlDataReader 

Dim SQL          As String 

Dim ConnStr      As String 

 

SQL = "SELECT * FROM Shippers" 

ConnStr = "server=localhost;uid=sa;pwd=;database=Northwind" 

 

myConnection = New SqlConnection(ConnStr) 

myConnection.Open() 

 

myCommand = New SqlCommand(SQL, myConnection) 

 

myReader = myCommand.ExecuteReader() 

ShipMethod.DataTextField = "CompanyName" 

ShipMethod.DataSource = myReader 

ShipMethod.DataBind() 

End If 

 

End Sub 

 

Sub PlaceOrder_click(Source As Object, E As EventArgs) 

 

YouSelected.Text = "Your order will be delivered via " & _ 

ShipMethod.SelectedItem.Text 

 

End Sub 

End Class 

C#

using System; 

using System.Data; 

using System.Data.SqlClient; 

using System.Web.UI; 

using System.Web.UI.WebControls; 

public class ShipMethodClass : Page 

{ 

// public variables to match the server controls 

public DropDownList    ShipMethod; 

public Label      YouSelected; 

public Button      PlaceOrder; 

 

public void Page_Load(Object Source, EventArgs E) 

{ 

if (!Page.IsPostBack) 

{ 

SqlConnection    myConnection; 

SqlCommand       myCommand; 

SqlDataReader    myReader; 

String       SQL; 

String       ConnStr; 

 

SQL = "select * from Shippers"; 

ConnStr = "server=localhost;uid=sa;pwd=;database=Northwind"; 

 

myConnection = new SqlConnection(ConnStr); 

myConnection.Open(); 

 

myCommand = new SqlCommand(SQL, myConnection); 

 

myReader = myCommand.ExecuteReader(); 

ShipMethod.DataTextField = "CompanyName"; 

ShipMethod.DataSource = myReader; 

ShipMethod.DataBind(); 

} 

} 

public void PlaceOrder_Click(Object Source, EventArgs E) 

{ 

YouSelected.Text = "Your order will be delivered via " + 

ShipMethod.SelectedItem.Text; 

} 

} 

Inheriting the Code-Behind Class File in an ASP.NET Page

To connect the class file containing the code implementation to your ASP.NET page, add an

Inherits attribute to the

<%@Page ...

%> directive, and specify the location of the 'Code-Behind' file:

<%@Page Inherits=" class="emphasis">class_name
" Src=" class="emphasis">path_to_class_file" %> 

For example, to inherit from a Visual Basic .NET class named

ShipMethodClass that is implemented in a file named

in the same directory as the page, you would use:

<%@Page Inherits="ShipMethodClass" Src=" %> 

An alternative form of this directive allows the

Src attribute to be omitted:

<%@ Page Inherits="ShipMethodClass" %> 

In this case ASP.NET will assume that the class is pre-compiled, and in the

bin directory of the application.