StateItem Class


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Represents an item that is saved in the StateBag class when view state information is persisted between Web requests. This class cannot be inherited.

Namespace:   System.Web.UI
Assembly:  System.Web (in System.Web.dll)


public sealed class StateItem


Gets or sets a value indicating whether the StateItem object has been modified.


Gets or sets the value of the StateItem object that is stored in the StateBag object.


Determines whether the specified object is equal to the current object.(Inherited from Object.)


Serves as the default hash function. (Inherited from Object.)


Gets the Type of the current instance.(Inherited from Object.)


Returns a string that represents the current object.(Inherited from Object.)

View state is the accumulation of a page's or an ASP.NET server control's property values and is sent to the requesting browser in a hidden field.

You can explicitly add StateItem objects to an ASP.NET server control's StateBag object using either the Item property or the Add method. The StateBag then tracks changes to all the items that it stores. Any changes to a StateItem object are reflected in its IsDirty property. These changes are saved by a call to the SaveViewState method during the save view state phase of server control processing, just before the control is rendered to the page. For more information, see NIB: ASP.NET Web Server Controls.

The following code example uses the Value and IsDirty properties of the StateItem class to save the state of a simple custom ASP.NET server control class, StateBagSample. When the page has posted to the server, the IsDirty property checks whether the item has been modified. The state values are displayed by accessing the Value property.

// Create a namespace that contains a class, MyItem,
// that implements the IStateManager interface and 
// another, MyControl, that overrides its own view-state
// management methods to use those of MyItem.
using System;
using System.Web;
using System.Web.UI;
using System.Collections;
using System.Security.Permissions;

namespace StateBagSample
    // Create a class that implements IStateManager so that
    // it can manage its own view state.   
       Level = AspNetHostingPermissionLevel.Minimal)]
    public sealed class MyItem : IStateManager
        private string _message;

        // The StateBag object that allows you to save
        // and restore view-state information.
        private StateBag _viewstate;

        // The constructor for the MyItem class.
        public MyItem(string mesg)
            _message = mesg;
            _viewstate = new StateBag();
            _viewstate.Add("message", _message);

        // Create a Message property that reads from and writes
        // to view state. If the set accessor writes the message
        // value to view state, the StateBag.SetItemDirty method
        // is called, telling view state that the item has changed. 
        public string Message
                return (string)_viewstate["message"];
                _message = value;
                _viewstate.SetItemDirty("message", true);

        // Implement the LoadViewState method. If the saved view state
        // exists, the view-state value is loaded to the MyItem control. 
        void IStateManager.LoadViewState(object savedState)
            _message = (string)_viewstate["message"];
            if (savedState != null)

        // Implement the SaveViewState method. If the StateBag
        // that stores the MyItem class's view state contains
        // a value for the message property and if the value
        // has changed since the TrackViewState method was last 
        // called, all view state for this class is deleted, 
        // using the StateBag.Clear method,and the new value is added.
        object IStateManager.SaveViewState()
            // Check whether the message property exists in 
            // the ViewState property, and if it does, check
            // whether it has changed since the most recent
            // TrackViewState method call.
            if (!((IDictionary)_viewstate).Contains("message") || _viewstate.IsItemDirty("message"))
                // Add the _message property to the StateBag.
                _viewstate.Add("message", _message);
            return ((IStateManager)_viewstate).SaveViewState();

        // Implement the TrackViewState method for this class by
        // calling the TrackViewState method of the class's private
        // _viewstate property.
        void IStateManager.TrackViewState()

        // Implement the IsTrackingViewState method for this class 
        // by calling the IsTrackingViewState method of the class's
        // private _viewstate property. 
        bool IStateManager.IsTrackingViewState
                return ((IStateManager)_viewstate).IsTrackingViewState;

        // Create a function that iterates through the view-state
        // values stored for this class and returns the
        // results as a string.
        public string EnumerateViewState()
            string keyName, keyValue;
            string result = String.Empty;
            StateItem myStateItem;
            IDictionaryEnumerator myDictionaryEnumerator = _viewstate.GetEnumerator();
            while (myDictionaryEnumerator.MoveNext())
                keyName = (string)myDictionaryEnumerator.Key;
                myStateItem = (StateItem)myDictionaryEnumerator.Value;
                keyValue = (string)myStateItem.Value;
                result = result + "<br>ViewState[" + keyName + "] = " + keyValue;
            return result;
    // This class contains an instance of the MyItem class as 
    // private member. It overrides the state management methods 
    // of the Control class, since it has to invoke state 
    // management methods of MyItem whenever its own
    // view state is being saved, loaded, or tracked.
       Level = AspNetHostingPermissionLevel.Minimal)]
    public sealed class MyControl : Control
        private MyItem myItem;
        public MyControl()
            : base()
            myItem = new MyItem("Hello World!");
        // Override the LoadViewState method of the Control class.
        protected override void LoadViewState(object savedState)
            if (savedState != null)
                object[] myState = (object[])savedState;
                if (myState[0] != null)
                if (myState[1] != null)
        // Override the TrackViewState method of the Control class
        // to call the version of this method that was 
        // implemented in the MyItem class.
        protected override void TrackViewState()
            if (myItem != null)

        // Override the SaveViewState method of the Control class to
        // call the version of this method that was implemented by
        // the MyItem class.
        protected override object SaveViewState()
            object baseState = base.SaveViewState();
            object itemState = (myItem != null) ? ((IStateManager)myItem).SaveViewState() : null;
            object[] myState = new object[2];
            myState[0] = baseState;
            myState[1] = itemState;
            return myState;

        public void SetMessage(string mesg)
            myItem.Message = mesg;

        public string GetMessage()
            return myItem.Message;

        // Display the contents of Message and ViewState properties. 
        protected override void Render(HtmlTextWriter output)
            // Track changes to  view state before rendering.
            output.Write("Message: " + myItem.Message);
            output.Write("<br>Enumerating the view state of the custom control<br>");

.NET Framework
Available since 1.1

Any public static ( Shared in Visual Basic) members of this type are thread safe. Any instance members are not guaranteed to be thread safe.

Return to top