This documentation is archived and is not being maintained.

StateManagedCollection Class

Provides a base class for all strongly typed collections that manage IStateManager objects.

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

[AspNetHostingPermissionAttribute(SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermissionAttribute(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
public abstract class StateManagedCollection : IList, 
	ICollection, IEnumerable, IStateManager

The StateManagedCollection class is the base class for all strongly typed collections that store IStateManager elements, including DataControlFieldCollection, ParameterCollection, StyleCollection, TreeNodeBindingCollection, and others. The StateManagedCollection collection manages its own state as well as the state of the elements it contains. Therefore, a call to SaveViewState saves the state of the collection and the state of all the elements currently contained by the collection.

The most important methods to consider when deriving from the StateManagedCollection class are CreateKnownType, GetKnownTypes, OnValidate, SetDirty, and SetDirtyObject. The CreateKnownType and GetKnownTypes methods are used to store an index in view state for the type of a contained element. Storing an index rather than a fully qualified type name improves performance. The OnValidate method is called whenever elements of the collection are manipulated, and validates the elements according to business rules. Currently, the implementation of the OnValidate method prohibits null objects from being stored in the collection; however, you can override this method to define your own validation behavior in a derived type. The SetDirty method forces the entire collection to be serialized to view state, rather than just serializing changes made to state since the last time it was loaded. The SetDirtyObject method is an abstract method you can implement to perform this same behavior at the element level.

Security noteSecurity Note:

StateManagedCollection stores assembly-qualified type names of the collection items in view state. A site visitor could decode the view state and retrieve the type name. If this scenario creates a security concern in your Web site, you can manually encrypt the type name before placing it in the view state.

The following code example demonstrates how to derive a strongly typed collection class from StateManagedCollection to contain IStateManager objects. In this example, the CycleCollection is derived to contain instances of the abstract Cycle class, which can be either Bicycle or Tricycle objects. The Cycle class implements the IStateManager interface because it stores the value of the CycleColor property in view state.

namespace Samples.AspNet.CS.Controls {

    using System;
    using System.Security.Permissions;
    using System.Collections;
    using System.ComponentModel;
    using System.Drawing;           
    using System.Web;
    using System.Web.UI;            
    // The strongly typed CycleCollection class is a collection 
    // that contains Cycle class instances, which implement the 
    // IStateManager interface. 
    public sealed class CycleCollection : StateManagedCollection {

        private static readonly Type[] _typesOfCycles 
            = new Type[] { typeof(Bicycle), typeof(Tricycle) };

        protected override object CreateKnownType(int index) {
            switch(index) {
                case 0:
                    return new Bicycle();
                case 1:
                    return new Tricycle();                    
                    throw new ArgumentOutOfRangeException("Unknown Type");

        protected override Type[] GetKnownTypes() {
            return _typesOfCycles;

        protected override void SetDirtyObject(object o) {

    // The abstract Cycle class represents bicycles and tricycles. 
    public abstract class Cycle : IStateManager {

        protected internal Cycle(int numWheels) : this(numWheels, "Red"){ }

        protected internal Cycle(int numWheels, String color) {    
            numberOfWheels = numWheels;
            CycleColor = color;

        private int numberOfWheels = 0;
        public int NumberOfWheels {
            get { return numberOfWheels; }

        public string CycleColor {
            get { 
                object o = ViewState["Color"];
                return (null == o) ? String.Empty : o.ToString() ;
            set {
                ViewState["Color"] = value;            

        internal void SetDirty() {

        // Because Cycle does not derive from Control, it does not  
        // have access to an inherited view state StateBag object. 
        private StateBag viewState;
        private StateBag ViewState {
            get {
                if (viewState == null) {
                    viewState = new StateBag(false);
                    if (isTrackingViewState) {
                return viewState;

        // The IStateManager implementation. 
        private bool isTrackingViewState;
        bool IStateManager.IsTrackingViewState {
            get {
                return isTrackingViewState;

        void IStateManager.LoadViewState(object savedState) {
            object[] cycleState = (object[]) savedState;

            // In SaveViewState, an array of one element is created. 
            // Therefore, if the array passed to LoadViewState has  
            // more than one element, it is invalid. 
            if (cycleState.Length != 1) {
                throw new ArgumentException("Invalid Cycle View State");

            // Call LoadViewState on the StateBag object.

        // Save the view state by calling the StateBag's SaveViewState 
        // method.
        object IStateManager.SaveViewState() {
            object[] cycleState = new object[1];

            if (viewState != null) {
                cycleState[0] = ((IStateManager)viewState).SaveViewState();
            return cycleState;

        // Begin tracking view state. Check the private variable, because  
        // if the view state has not been accessed or set, then it is not   
        // being used and there is no reason to store any view state. 
        void IStateManager.TrackViewState() {
            isTrackingViewState = true;
            if (viewState != null) {

    public sealed class Bicycle : Cycle {

        // Create a red Cycle with two wheels. 
        public Bicycle() : base(2) {}    

    public sealed class Tricycle : Cycle {

        // Create a red Cycle with three wheels. 
        public Tricycle() : base(3) {}


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

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0