In this article, I would only cover the basics of view state. If you do not know what view state is, it is the medium of containing data to persist when the user posts back to the same page. This concept is not new to classic ASP at all. In classic ASP, persisting data for reuse on the same page was a very tedious task - never mind the fact it was normally in clear text. ASP.NET simplifies that process of persisting data so it is as simple to use as the Application state. View state is used by server controls to persist its data across different requests - it is not designed to persist server controls itself, nor its sub controls.
I am not going to write a long talk about "What is view state?" Instead, you can read a very well explained article by Paul Wilson, title “View State: All You Wanted to Know”.
Just a recap of the only rule of view state - what view state is optimized for:
-
Objects (that are one of the following).
-
Integers.
-
Strings.
-
Floats.
-
Decimals.
-
Objects.
-
Pair class containing the above data types or Triplet class.
-
Triplet class containing the above data types.
-
Arrays of the data types stated above.
-
ArrayList with the values being a type of data types listed above.
-
A StateBag containing the values of the data types listed above.
You can create custom optimized classes for ViewState by implementing IStateManager interface but essentially, you will have to drill down your basic string data type. Essentially, a normal XYZ class is not optimal to be put into ViewState without the implementation of the IStateManager interface - it can be done but heavy work will be required to be completed by ASP.NET to be serialized.
Also note that if you are planning to persist a structure, you will have to add the SerializableAttribute attribute to the actual structure.
The normal suggestion of making your properties persist in view state is by making your properties follow the same type of format:
// [C#]
public string FooString {
get {
string value = (string)ViewState["FooString"];
return (value != null) ? (string)value : String.Empty;
}
set { ViewState["FooString"] = value; }
}
' [VB.NET]
Public Property FooString() As String
Get
Dim value As String = CStr(ViewState("FooString"))
If Not (value Is Nothing) Then
Return CStr(value)
Else
Return [String].Empty
End If
End Get
Set
ViewState("FooString") = value
End Set
End Property
Tiresome isn't it!? But I have a better solution because I am just as lazy like you. Here is the basic "magic" code that will needed by all controls that is going to follow our lazy route:
(Edit: Marvin Slayton gave some feedback on the original source. He managed to pick up a few bugs that the original source allowed to slip through for posting back to the server. To reproduce the error, view state keys that were set before the Init event caused the keys that were later added via the LoadViewState method to throw an exception. He was even kind enough to provide the fix and I have further modified the fix to provide consinstency.)
// [C#]
private const string BaseStateKey = "DefaultViewState";
private Hashtable StateTable = new Hashtable();
protected internal void SaveToStateTable(string key, object value) {
if (StateTable.ContainsKey(key)) StateTable[key] = value.ToString();
else StateTable.Add(key, value.ToString());
}protected internal object LoadFromStateTable(string key, object defaultValue) {
if (StateTable.ContainsKey(key))
return (string)StateTable[key];
else {
if ((defaultValue.GetType() != typeof(string)) &&
(defaultValue.GetType() != typeof(ValueType))) {
StateTable.Add(key, defaultValue);
} return defaultValue;
}
}
protected override object SaveViewState() {
string[] keys = new string[StateTable.Count];
ArrayList indices = new ArrayList();
ArrayList state = new ArrayList();
StateTable.Keys.CopyTo(keys, 0);
indices.Add(BaseStateKey);
state.Add(base.SaveViewState()); foreach (string key in keys) {
indices.Add(key);
state.Add(StateTable[key]);
} return new Pair(indices, state);
}
protected override void LoadViewState(object state) {
if (state == null) return; ArrayList indices = ((Pair)state).First as ArrayList;
ArrayList values = ((Pair)state).Second as ArrayList;
for (int i = 0; i < indices.Count; i++) {
if (indices[i].ToString() == BaseStateKey)
base.LoadViewState(values[i]);
else
SaveToStateTable(indices[i].ToString(), values[i]);
}
}' [VB.NET]
Private Const BaseStateKey As String = "DefaultViewState"
Private StateTable As New Hashtable()
Friend Protected Sub SaveToStateTable(key As String, value As Object)
If StateTable.ContainsKey(key) Then
StateTable(key) = value.ToString()
Else
StateTable.Add(key, value.ToString())
End If
End Sub
Friend Protected Function LoadFromStateTable(key As String, _
defaultValue As Object) As Object
If StateTable.ContainsKey(key) Then
Return CStr(StateTable(key))
Else
If defaultValue.GetType() <> GetType(String) And _
defaultValue.GetType() <> GetType(ValueType) Then
StateTable.Add(key, defaultValue)
End If
Return defaultValue
End If
End Function
Protected Overrides Function SaveViewState() As Object
Dim keys(StateTable.Count) As String
Dim indices As New ArrayList()
Dim state As New ArrayList()
StateTable.Keys.CopyTo(keys, 0)
indices.Add(BaseStateKey)
state.Add(MyBase.SaveViewState())
For Each key As String In keys
indices.Add(key)
state.Add(StateTable(key))
Next
Return New Pair(indices, state)
End Function
Protected Overrides Sub LoadViewState(state As Object)
If state Is Nothing Then
Return
End If
Dim indices As ArrayList = CType(CType(state, Pair).First, ArrayList)
Dim values As ArrayList = CType(CType(state, Pair).Second, ArrayList)
For i As Integer = 0 To indices.Count - 1
If indices(i).ToString() = BaseStateKey Then
MyBase.LoadViewState(values(i))
Else
SaveToStateTable(indices(i).ToString(), values(i))
End If
Next
End Sub
With this code, we will save the default view state with the custom view state. We also added the feature that advanced data types will be automatically added to the view state bin if it does not exist in the bin. If it does, any changes to the data inside itself will remain persistent. Now I am going to demonstrate the same functionality that the code before my magic hand was used with the new, improved, lazy format:
// [C#]
public string FooString {
get { return (string)LoadFromStateTable("FooString", String.Empty); }
set { SaveToStateTable("FooString", value); }
}
' [VB.NET]
Public Property FooString() As String
Get
Return CStr(LoadFromStateTable("FooString", [String].Empty))
End Get
Set
SaveToStateTable("FooString", value)
End Set
End Property
For more advanced data types such as classes, you can still use this lazy method. Instead of defining a default value such as a "0", you would create a new instance of that data type (by its constructor). Please remember, for optimal performance, ensure that the class implements IStateManager interface for the view state to deserialize the object a lot quicker.
I will discuss further into view state and handling it at a later article in the series. Depending on the feedback I receive and the topics and content of the threads at the www.asp.net/forums/, will determine the depth that it will be discussed in the future.
