The Code Behind feature in .NET Framework allows developers to separate server-side code from the presentation layer. This concept makes the server-side code store in one file and the presentation code, that is HTML code, in another file. When you compile the ASP.NET page, both these files get compiled as a single entity.
In the traditional ASP model, this couldn't be achieved, which often led to intermingling of code and design. The biggest advantage in ASP.NET is that the presentation code will be in an ASPX file and the server-side code will be in any .NET-compatible language such as Visual Basic.NET, C#, or J#.
You can delegate the presentation layer to web designers, which saves time and lets you concentrate only on the coding part of the application. You can create a class for your code and inherit this class from the ASP.NET Page object. By doing this, the class can access page intrinsics and also interact with the postback architecture.
After creating your Code Behind class, you can create the ASP.NET page and apply a page directive to inherit from this new class. This creates a clean separation between design and logic.
Before you create a Code Behind class, you need to reference it to a namespace. The namespace could be System.Web.UI or System.Web.UI.WebControls. Next, you need to inherit the class from the Page object. You must declare some public instances of server controls using names for the variables that are similar to the web controls. This procedure creates a link between the Code Behind class and the server controls.
using System;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace MyWebApp
{
public partial class Default : System.Web.UI.Page
{
// Declare controls that match ASPX page
protected Label lblMessage;
protected TextBox txtName;
protected Button btnSubmit;
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
lblMessage.Text = "Welcome!";
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
lblMessage.Text = "Hello, " + txtName.Text + "!";
}
}
}<%@ Page Language="C#" CodeBehind="Default.aspx.cs"
Inherits="MyWebApp.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
<title>Code Behind Example</title>
</head>
<body>
<form id="form1" runat="server">
<div>
<asp:Label ID="lblMessage" runat="server" />
<br /><br />
<asp:TextBox ID="txtName" runat="server" />
<asp:Button ID="btnSubmit" runat="server"
Text="Submit" OnClick="btnSubmit_Click" />
</div>
</form>
</body>
</html>The Page directive at the top of your ASPX file connects the presentation layer to the Code Behind file. The CodeBehind attribute specifies the filename, and the Inherits attribute specifies the class name including namespace.
<%@ Page Language="C#"
CodeBehind="ProductList.aspx.cs"
Inherits="OnlineStore.ProductList"
AutoEventWireup="true" %>
<!-- Language: Programming language used in Code Behind -->
<!-- CodeBehind: Path to code file -->
<!-- Inherits: Full class name with namespace -->
<!-- AutoEventWireup: Automatic event handler binding -->Code Behind works with any .NET language. Here's an example using Visual Basic.NET, showing the same separation of concerns with VB syntax:
Imports System
Imports System.Web
Imports System.Web.UI
Imports System.Web.UI.WebControls
Namespace MyWebApp
Partial Public Class DefaultPage
Inherits System.Web.UI.Page
Protected lblMessage As Label
Protected txtName As TextBox
Protected btnSubmit As Button
Protected Sub Page_Load(sender As Object, e As EventArgs)
If Not IsPostBack Then
lblMessage.Text = "Welcome!"
End If
End Sub
Protected Sub btnSubmit_Click(sender As Object, e As EventArgs)
lblMessage.Text = "Hello, " & txtName.Text & "!"
End Sub
End Class
End NamespaceYou can use the Code Behind feature in various web application development tools such as Visual Studio.NET and ASP.NET Web Matrix. They provide very easy ways to use Code Behind. After dragging and dropping the server control from the Toolbox to the web page, you can just right-click on it to view the Code Behind page.
Visual Studio automatically creates the Code Behind file structure, generates the Page directive, and sets up the class with proper inheritance. This makes working with Code Behind straightforward and reduces the chance of configuration errors.
// Visual Studio generates event handler stubs
public partial class ContactForm : System.Web.UI.Page
{
// Double-click button in designer to create handler
protected void btnSend_Click(object sender, EventArgs e)
{
// Your event handling code here
string name = txtName.Text;
string email = txtEmail.Text;
string message = txtMessage.Text;
// Process form data
SendEmail(name, email, message);
lblConfirmation.Text = "Message sent successfully!";
}
private void SendEmail(string name, string email, string message)
{
// Email sending logic
}
}Keep your Code Behind files focused on page-specific logic. Move business logic to separate classes or components. Use meaningful names for controls that match between ASPX and Code Behind files. Declare controls as protected to allow access from the Code Behind class.
Organize your namespaces logically and use consistent naming conventions. Handle page events like Page_Load, Page_Init, and Page_PreRender in your Code Behind for initialization and cleanup tasks. This separation of concerns makes your application easier to maintain and test.
Code Behind separates presentation from logic, allowing designers to work on HTML while developers focus on code. This separation makes maintenance easier, enables better code organization, and prevents mixing of design and logic which was common in classic ASP.
Yes, you need to add a Page directive at the top of your ASPX file that specifies the CodeBehind file and Inherits attribute pointing to your class. This tells ASP.NET which code file contains the logic for the page.
Yes, you can use any .NET-compatible language like Visual Basic.NET, C#, or J# for your Code Behind files. Each page can use a different language as long as you specify the correct language in the Page directive.