IStateManager Interface
TOC
Collapse the table of content
Expand the table of content

IStateManager Interface

Defines the properties and methods any class must implement to support view state management for a server control.

For a list of all members of this type, see IStateManager Members.

[Visual Basic]
Public Interface IStateManager
[C#]
public interface IStateManager
[C++]
public __gc __interface IStateManager
[JScript]
public interface IStateManager

Classes that Implement IStateManager

Class Description
DataGridColumn Serves as the base class for the different column types of the DataGrid control.
DataGridColumnCollection A collection of DataGridColumn derived column objects that represent the columns in a DataGrid control. This class cannot be inherited.
ListItem Represents a data item in a data-bound list control. This class cannot be inherited.
ListItemCollection A collection of ListItem objects in a list control. This class cannot be inherited.
StateBag Manages the view state of ASP.NET server controls, including pages. This class cannot be inherited.
Style Represents the style of a Web server control.

Remarks

A server control's view state comprises the cumulative values of the control's properties. This interface includes methods that save and load a server control's view state values, as well as a method that instructs the control to track any changes to its view state.

To customize the way your ASP.NET application manages server control view state, you must create a class that implements this interface since you cannot inherit from the StateBag class.

Example

[Visual Basic, C#, C++] The following example shows a class that implements the IStateManager interface. It includes implementations of the IsTrackingViewState property and the LoadViewState, SaveViewState, and TrackViewState methods.

[Visual Basic] 
' Create a class that implements IStateManager so that
' it can manage its own view state.   

Public Class MyItem
   Implements IStateManager 'ToDo: Add Implements Clauses for implementation methods of these interface(s)
   Private _message As String
   
   ' The StateBag object that allows you to save
   ' and restore view-state information.
   Private _viewstate As StateBag
   
   
   ' The constructor for the MyItem class.
   Public Sub New(mesg As String)
      _message = mesg
      _viewstate = New StateBag()
      _viewstate.Add("message", _message)
   End Sub 'New
   
   ' 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 Property Message() As String
      Get
         Return CStr(_viewstate("message"))
      End Get
      Set
         _message = value
         _viewstate.SetItemDirty("message", True)
      End Set
   End Property
   
   ' Implement the LoadViewState method. If the saved view state
   ' exists, the view-state value is loaded to the MyItem 
   ' control. 
   Sub LoadViewState(savedState As Object) Implements IStateManager.LoadViewState
      _message = CStr(_viewstate("message"))
      If Not (savedState Is Nothing) Then
         CType(_viewstate, IStateManager).LoadViewState(savedState)
      End If
   End Sub 'LoadViewState
   ' 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.
   Function SaveViewState() As Object Implements 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 Not CType(_viewstate, IDictionary).Contains("message") OrElse _viewstate.IsItemDirty("message") Then
         If (True) Then
            _viewstate.Clear()
            ' Add the _message property to the StateBag.
            _viewstate.Add("message", _message)
         End If
      End If
      Return CType(_viewstate, IStateManager).SaveViewState()
   End Function 'IStateManager.SaveViewState
   
   
   ' Implement the TrackViewState method for this class by
   ' calling the TrackViewState method of the class's private
   ' _viewstate property.
   Sub TrackViewState() Implements IStateManager.TrackViewState
      CType(_viewstate, IStateManager).TrackViewState()
   End Sub 'IStateManager.TrackViewState
   ' Implement the IsTrackingViewState method for this class 
   ' by calling the IsTrackingViewState method of the class's
   ' private _viewstate property. 
   
   ReadOnly Property IsTrackingViewState() As Boolean Implements IStateManager.IsTrackingViewState
      Get
         Return CType(_viewstate, IStateManager).IsTrackingViewState
      End Get
   End Property
   
   ' Create a function that iterates through the view-state
   ' values stored for this class and returns the
   ' results as a string.
   Public Function EnumerateViewState() As String
      Dim keyName, keyValue As String
      Dim result As String = [String].Empty
      Dim myStateItem As StateItem
      Dim myDictionaryEnumerator As IDictionaryEnumerator = _viewstate.GetEnumerator()
      While myDictionaryEnumerator.MoveNext()
         keyName = CStr(myDictionaryEnumerator.Key)
         myStateItem = CType(myDictionaryEnumerator.Value, StateItem)
         keyValue = CStr(myStateItem.Value)
         result = result + "<br>ViewState[" + keyName + "] = " + keyValue
      End While
      Return result
   End Function 'EnumerateViewState
End Class 'MyItem 

[C#] 
// Create a class that implements IStateManager so that
// it can manage its own view state.   
public 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
   {
      get
      {
         return (string)_viewstate["message"];
      }
      set
      {
         _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)
         ((IStateManager)_viewstate).LoadViewState(savedState);
   }

   // 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")))
      {
         {
            _viewstate.Clear();
            // 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()
   {
      ((IStateManager)_viewstate).TrackViewState();
   }

   // Implement the IsTrackingViewState method for this class 
   // by calling the IsTrackingViewState method of the class's
   // private _viewstate property. 
   bool IStateManager.IsTrackingViewState
   {
      get
      {
         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;
   }
}

[C++] 
// Create a class that implements IStateManager so that
// it can manage its own view state.
public __gc class MyItem : public 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(S"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:
   __property String* get_Message() {
      return dynamic_cast<String*>(_viewstate->Item[S"message"]);
   }
   __property void set_Message(String* value) {
      _message = value;
      _viewstate->SetItemDirty(S"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 = dynamic_cast<String*>(_viewstate->Item[S"message"]);
      if (savedState != 0)
         (dynamic_cast<IStateManager*>(_viewstate))->LoadViewState(savedState);
   }

   // 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 ((!(dynamic_cast<IDictionary*>(_viewstate))->Contains(S"message")) || (_viewstate->IsItemDirty(S"message"))) { {
         _viewstate->Clear();
         // Add the _message property to the StateBag.
         _viewstate->Add(S"message", _message);
      }
      }
      return (dynamic_cast<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() {
      (dynamic_cast<IStateManager*>(_viewstate))->TrackViewState();
   }

   // Implement the IsTrackingViewState method for this class
   // by calling the IsTrackingViewState method of the class's
   // private _viewstate property.
   __property bool IStateManager::get_IsTrackingViewState() {
      return (dynamic_cast<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 = dynamic_cast<String*>(myDictionaryEnumerator->Key);
         myStateItem = 
            dynamic_cast<StateItem*>(myDictionaryEnumerator->Value);
         keyValue = dynamic_cast<String*>(myStateItem->Value);
         result = 
            String::Concat(result, S"<br>ViewState->Item[ ", keyName, S"] = ", keyValue);
      }
      return result;
   }
};

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.Web.UI

Platforms: Windows 2000, Windows XP Professional, Windows Server 2003 family

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

See Also

IStateManager Members | System.Web.UI Namespace | Introduction to Web Forms State Management | StateBag | StateItem

Show:
© 2016 Microsoft