What is control state in ASP.NET Web Forms?

Control state in ASP.NET Web Forms is a mechanism that allows individual controls to maintain their state across postbacks, even if view state is disabled for the page or if the control is dynamically created. It is used to persist control-specific data that is critical for the control's functionality.

Control state is different from view state in that it is not affected by view state being turned off at the page level. It is specifically designed to store information that is essential for the control's operation, such as data entered by the user, and cannot be turned off or modified by developers.

Here are some key points about control state:

Enabling Control State: Control state is enabled for a control by setting the 'EnableViewState' property of the control to 'true' and by overriding the 'SaveControlState' and 'LoadControlState' methods.
ControlState Property: Each control has a 'ControlState' property that represents its control-specific state. This property is used to save and load the control state. The control state is automatically serialized and persisted during postbacks, ensuring that the control's data is preserved.
Control State Persistence: Control state is persisted as a part of the page's hidden form field and is sent back to the server during postbacks. This allows the control to retrieve its state and restore its data, even if the page's view state is disabled.
Control State vs. View State: Control state is separate from view state. While view state stores the state of controls at the page level, control state is used to store the state of individual controls. Control state is not affected by the 'EnableViewState' property of the page or other controls.
Control State Usage: Control state is typically used when a control needs to maintain critical data that is required for its functionality, even if view state is disabled. Examples include maintaining user-entered values in textboxes, maintaining custom control properties, or tracking the state of dynamically created controls.

Here's an example to illustrate the usage of control state in ASP.NET:

Let's say we have a custom control called "CounterControl" that displays a counter and allows the user to increment or decrement the counter value. We want the counter value to be maintained even if view state is disabled or if the control is dynamically created.

1. Create the CounterControl:
First, create a new class that inherits from 'System.Web.UI.Control' to define the CounterControl. This control will have a counter value that can be incremented or decremented. Here's a basic example:



using System.Web.UI;

public class CounterControl : Control
{
    private int counter = 0;

    protected override void OnInit(System.EventArgs e)
    {
        Page.RegisterRequiresControlState(this);
        base.OnInit(e);
    }

    protected override object SaveControlState()
    {
        return counter;
    }

    protected override void LoadControlState(object savedState)
    {
        if (savedState != null)
        {
            counter = (int)savedState;
        }
    }

    public int Counter
    {
        get { return counter; }
        set { counter = value; }
    }

    protected override void Render(HtmlTextWriter writer)
    {
        writer.Write($"Counter: {counter}");
    }
}

In this example, the CounterControl class overrides the 'OnInit', 'SaveControlState', and 'LoadControlState' methods. The 'OnInit' method registers the control to participate in control state. The 'SaveControlState' method saves the counter value, and the 'LoadControlState' method loads the saved counter value during postbacks.

2. Using the CounterControl:
Next, add the CounterControl to a web form. In the web form's code-behind file, you can access and manipulate the counter value of the control. Here's an example of using the CounterControl in a web form:



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

<!DOCTYPE html>
<html>
<head>
    <title>Control State Example</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <custom:CounterControl ID="counterControl1" runat="server" />
        </div>
        <asp:Button ID="incrementButton" runat="server" Text="Increment" OnClick="incrementButton_Click" />
        <asp:Button ID="decrementButton" runat="server" Text="Decrement" OnClick="decrementButton_Click" />
    </form>
</body>
</html>

In the code-behind file (Default.aspx.cs), you can handle the button clicks and manipulate the counter value of the CounterControl:



using System;

public partial class Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            // Set an initial value for the counter
            counterControl1.Counter = 0;
        }
    }

    protected void incrementButton_Click(object sender, EventArgs e)
    {
        // Increment the counter value
        counterControl1.Counter++;
    }

    protected void decrementButton_Click(object sender, EventArgs e)
    {
        // Decrement the counter value
        counterControl1.Counter--;
    }
}

In this example, the page has two buttons (incrementButton and decrementButton) that handle the increment and decrement operations respectively. The CounterControl is placed on the page, and its counter value is accessed and manipulated in the button click event handlers.

When the page is rendered and the buttons are clicked, the counter value in the CounterControl will be maintained across postbacks using control state, even if view state is disabled.

This example demonstrates how control state allows the CounterControl to maintain its specific data (the counter value) across postbacks, ensuring that the counter value persists and is not affected by view state settings or dynamic control creation.

It's important to note that control state is not as widely used as view state because it is meant for control-specific data and has a smaller storage capacity compared to view state. It is recommended to use control state sparingly and only for essential control data that cannot be stored in view state or other persistence mechanisms.

What is control state in ASP.NET Web Forms?

Subscribe to Newsletter