Manage ViewState using ASP.NET 2.0 Provider Architecture

• Download ViewStateProvider_Net2_0_demo.zip - 203.0 KB
• Download ViewStateProvider_Net2_0_src.zip - 83.3 KB

Introduction

This article shows an implementation of a couple of custom viewstate providers using ASP.NET 2.0 Provider architecture and the Provider Model design pattern. To get more information regarding the ASP.NET 2.0 Provider Model please read Introduction to the Provider Model

Background

About half a year ago I was working on a project that required moderately large datasets fetched from the database and displayed in a datagrid. Going to the database on every postback seemed like a waste of resources, therefore, I decided to store the data in viewstate. And thats when the page load times started taking longer and longer. I started researching alternative solutions for optimizing viewstate and found a moderate amount of information and examples online. Nevertheless, I have not been able to find a complete solution that would let me easily manage and extend the functionality of viewstate without having to make significant changes to the website.

I have looked at a number of interesting and useful articles that provided different takes on the implementation of the viewstate management, but none had a complete and easily integrable solution.

The code presented below was inspired by or partially taken from the following articles:

• Custom Provider-Based Services - ASP.NET 2.0 provider architecture and pattern design.
• ViewState Provider - an implementation using Provider Model Design Pattern - ASP.NET 1.1 implementation
• Analysis of Keeping ViewState out of the Page - SessionViewState provider idea, performance stats and useful discussion
• Keep ASP.NET ViewState out of ASPX Page for Performance Improvement - SessionViewState provider idea
• SqlViewState - The Path To Better ViewState Storage

Using the code

I will concentrate on describing just the viewstate provider code without going into details on the provider pattern design. For detailed explanation of pattern design and architecture please see references listed above.

Writing the providers

First, we need an abstract class representing the viewstate and exposing functions actual providers will implement. ViewStateProvider is derived from ProviderBase and will be the base class for all concrete viewstate provider classes. It will have two functions that must be implemented by derived classes: LoadPageState and SavePageState.

    ''' <summary>

    ''' Defines the contract that ASP.NET implements to provide viewstate

    ''' services using custom viewstate providers.

    ''' </summary>

    Public MustInherit Class ViewStateProvider
        Inherits System.Configuration.Provider.ProviderBase


        Public MustOverride Property ApplicationName() As String

    ''' <summary>

    ''' The hidden field variable name where our viewstate reference key is stored on a page.

    ''' </summary>

    Public MustOverride Property ViewStateKeyName() As String

        ''' -----------------------------------------------------------------------------

        ''' <summary>

        ''' Loads any saved view-state of the current page from virtually any

        ''' storage medium other than a hidden field

        ''' </summary>

        ''' <param name="pControl">System.Web.UI.Page</param>

        ''' <returns>The saved view state</returns>

        ''' -----------------------------------------------------------------------------

        Public MustOverride Function LoadPageState(ByVal pControl As Control) As Object

        ''' -----------------------------------------------------------------------------

        ''' <summary>

        ''' Saves any view-state information of the page to virtually any

        ''' storage medium other than a hidden field

        ''' </summary>

        ''' <param name="pControl">System.Web.UI.Page</param>

        ''' <param name="viewState">A System.Object in which to store the view-state information</param>

        ''' -----------------------------------------------------------------------------

        Public MustOverride Sub SavePageState(ByVal pControl As Control, ByVal viewState As Object)

    End Class

Next, we need an actual provider class. I have three concrete provider classes in the example:

SessionViewStateProvider

- viewstate is being maintained as a session variable.

CompressionViewStateProvider

- viewstate is being compressed using ICSharpCode.SharpZipLib and written to a page.

SqlViewStateProvider

- viewstate is maintained using a modified ASPState database. The ViewState is written to the database similar to an OutOfProc Session.

Lets look at one of them - SessionViewStateProvider.

NOTE: This provider requires sql script attached with the code to be executed on the database where the viewstate will be stored. Proper sql connection and impersonation must be set up in Web.config. All of the sql script code is taken from Adam Weigert's SqlViewState - The Path To Better ViewState Storage.
Other providers in the example do not require any additional setup except registration in a Web.config(explained here).

    ''' <summary>

    ''' Manages storage of viewstate object for an ASP.NET application in a SQL Server database.

    ''' </summary>

    ''' <remarks><para><pre>

    ''' RevisionHistory:

    ''' --------------------------------------------------------------------------------

    ''' Date        Name            Description

    ''' --------------------------------------------------------------------------------

    ''' 10/11/2006    Oleg Sobol        Initial Creation

    ''' inspiration taken from

    ''' http://weblogs.asp.net/adweigert/archive/2004/03/09/sqlviewstate-the-path-to-better-viewstate-storage.aspx

    ''' 5/11/2007    Oleg Sobol      Added ViewStateKeyName and DEFAULT_TIMEOUT

    ''' </pre></para></remarks>

    Public Class SqlViewStateProvider
        Inherits System.Web.UI.ViewStateProvider

    Public Const DEFAULT_TIMEOUT As Integer = 25

        Private _applicationName As String
        Private _connectionString As String
        Private _connectionStringName As String
        Private _timeout As TimeSpan
        Private _enableViewStateMac As Boolean
        Private _lockLoad As New Object
        Private _lockSave As New Object
    Private _viewStateKeyName As String = "__VIEWSTATE_KEY"


        Public Overloads Overrides Property ApplicationName() As String
            Get
                Return _applicationName
            End Get
            Set(ByVal value As String)
                _applicationName = value
            End Set
        End Property

        Public Property ConnectionStringName() As String
            Get
                Return _connectionStringName
            End Get
            Set(ByVal value As String)
                _connectionStringName = value
            End Set
        End Property

        Public Property Timeout() As TimeSpan
            Get
                Return _timeout
            End Get
            Set(ByVal value As TimeSpan)
                _timeout = value
            End Set
        End Property

        Public Property EnableViewStateMac() As Boolean
            Get
                Return _enableViewStateMac
            End Get
            Set(ByVal value As Boolean)
                _enableViewStateMac = value
            End Set
        End Property

    Public Overrides Property ViewStateKeyName() As String
        Get
        Return _viewStateKeyName
        End Get
        Set(ByVal value As String)
        _viewStateKeyName = value
        End Set
    End Property


        Public Overloads Overrides Sub "init">Initialize(ByVal name As String, ByVal config As NameValueCollection)
            ' Verify that config isn't null

            If config Is Nothing Then Throw New ArgumentNullException("config")
            ' Assign the provider a default name if it doesn't have one

            If String.IsNullOrEmpty(name) Then name = "SqlViewStateProvider"
            ' Add a default "description" attribute to config if the attribute doesn't exist or is empty

            If String.IsNullOrEmpty(config("description")) Then
                config.Remove("description")
                config.Add("description", "SQL viewstate provider")
            End If
            ' Call the base class's Initialize method

            MyBase.Initialize(name, config)

            ' Initialize _applicationName

            _applicationName = config("applicationName")
            If String.IsNullOrEmpty(_applicationName) Then _applicationName = "/"
            config.Remove("applicationName")


            Dim connect As String = config("connectionStringName")
            If String.IsNullOrEmpty(connect) Then
                Throw New ViewStateProviderException("Empty or missing connectionStringName")
            End If
            config.Remove("connectionStringName")
            If WebConfigurationManager.ConnectionStrings(connect) Is Nothing Then
                Throw New ViewStateProviderException("Missing connection string")
            End If
            _connectionString = WebConfigurationManager.ConnectionStrings(connect).ConnectionString
            If String.IsNullOrEmpty(_connectionString) Then
                Throw New ViewStateProviderException("Empty connection string")
            End If


            Dim timeout As String = config("timeout")
            If String.IsNullOrEmpty(timeout) OrElse Not IsNumeric(timeout) Then
                _timeout = TimeSpan.FromMinutes(ViewStateProvidersConfig.DefaultViewStateTimeout)
            Else
                _timeout = TimeSpan.FromMinutes(CInt(timeout))
            End If
            config.Remove("timeout")


            Dim enableViewStateMac As String = config("enableViewStateMac")
            Try
                _enableViewStateMac = CBool(enableViewStateMac)
            Catch ex As Exception
                _enableViewStateMac = False
            End Try
            config.Remove("enableViewStateMac")


            ' Throw an exception if unrecognized attributes remain

            If config.Count > 0 Then
                Dim attr As String = config.GetKey(0)
                If Not String.IsNullOrEmpty(attr) Then _
Throw New ViewStateProviderException("Unrecognized attribute: " + attr)
            End If
        End Sub


        Public Overrides Function LoadPageState(ByVal pControl As System.Web.UI.Control) As Object
            Dim connection As SqlConnection = Nothing
            Dim rawData As Byte() = Nothing
            Dim stream As MemoryStream = Nothing

            Try
                Dim viewStateGuid As Guid = GetViewStateGuid(pControl)
                connection = New SqlConnection(_connectionString)
                Dim command As SqlCommand = New SqlCommand("GetViewState", connection)


                Try
                    command.CommandType = CommandType.StoredProcedure
                    command.Parameters.Add("@returnValue", SqlDbType.Int).Direction = ParameterDirection.ReturnValue
                    command.Parameters.Add("@viewStateId", SqlDbType.UniqueIdentifier).Value = viewStateGuid
                    connection.Open()


                    Dim reader As SqlDataReader = command.ExecuteReader
                    Try
                        If reader.Read Then
                            rawData = CType(Array.CreateInstance(GetType(Byte), reader.GetInt32(0)), Byte())
                        End If
                        If reader.NextResult AndAlso reader.Read Then
                            reader.GetBytes(0, 0, rawData, 0, rawData.Length)
                        End If
                    Catch e As Exception
                        Throw New ViewStateProviderException("Problem reading data returned from SqlServer", e)
                    Finally
                        CType(reader, IDisposable).Dispose()
                    End Try


                Catch e As Exception
                    Throw New ViewStateProviderException("Problem executing SqlCommand", e)
                Finally
                    If Not command Is Nothing Then command.Dispose()
                End Try


            Catch e As Exception
                Throw New ViewStateProviderException("Problem with SqlConnection", e)
            Finally
                If Not connection Is Nothing Then connection.Dispose()
            End Try



            Try
                stream = New MemoryStream(rawData)
                Return Me.GetLosFormatter(pControl, False).Deserialize(stream)
            Catch e As Exception
                Throw New ViewStateProviderException("Problem with data deserialization", e)
            Finally
                If Not stream Is Nothing Then CType(stream, IDisposable).Dispose()
            End Try

            Return Nothing
        End Function


        Public Overrides Sub SavePageState(ByVal pControl As System.Web.UI.Control, ByVal viewState As Object)
            Dim p As Page = Nothing
            Dim viewStateGuid As Guid
            Dim stream As MemoryStream = Nothing


            Try
                p = CType(pControl, Page)
                viewStateGuid = GetViewStateGuid(p)
                stream = New MemoryStream
                GetLosFormatter(p, _enableViewStateMac).Serialize(stream, viewState)

                Dim connection As SqlConnection = New SqlConnection(_connectionString)
                Try


                    Dim command As SqlCommand = New SqlCommand("SetViewState", connection)
                    Try
                        command.CommandType = CommandType.StoredProcedure
                        command.Parameters.Add("@returnValue", SqlDbType.Int).Direction _
= ParameterDirection.ReturnValue
                        command.Parameters.Add("@viewStateId", SqlDbType.UniqueIdentifier).Value = viewStateGuid
                        command.Parameters.Add("@value", SqlDbType.Image).Value = stream.ToArray
                        command.Parameters.Add("@timeout", SqlDbType.Int).Value = _timeout.TotalMinutes
                        connection.Open()
                        command.ExecuteNonQuery()
                    Catch e As Exception
                        System.Diagnostics.Trace.Write(e.Message)
                    Finally
                        If Not command Is Nothing Then command.Dispose()
                    End Try

                Catch e As Exception
                    System.Diagnostics.Trace.Write(e.Message)
                Finally
                    If Not connection Is Nothing Then connection.Dispose()
                End Try


            Catch e As Exception
                System.Diagnostics.Trace.Write(e.Message)
            Finally
                If Not stream Is Nothing Then CType(stream, IDisposable).Dispose()
            End Try


            Dim control As Html.HtmlInputHidden _
= CType(p.FindControl(ViewStateProvidersConfig.ViewStateKeyFieldName), Html.HtmlInputHidden)
            If control Is Nothing Then
                p.ClientScript.RegisterHiddenField(ViewStateProvidersConfig.ViewStateKeyFieldName, _
viewStateGuid.ToString)
            Else
                control.Value = viewStateGuid.ToString
            End If

        End Sub


#Region " Private Helper Functions "

        Private Function GetViewStateGuid(ByVal pControl As Control) As Guid
            Dim p As Page = CType(pControl, Page)
            Dim viewStateKey As String = p.Request.Form(ViewStateProvidersConfig.ViewStateKeyFieldName)

            If viewStateKey Is Nothing OrElse viewStateKey.Length < 1 Then
                viewStateKey = p.Request.QueryString(ViewStateProvidersConfig.ViewStateKeyFieldName)
                If viewStateKey Is Nothing OrElse viewStateKey.Length < 1 Then
                    Return Guid.NewGuid
                End If
            End If
            Try
                Return New Guid(viewStateKey)
            Catch e As FormatException
                Return Guid.NewGuid
            End Try
        End Function


        Private Function GetMacKeyModifier(ByVal pControl As Control) As String
            Dim p As Page = CType(pControl, Page)
            Dim value As Integer = p.TemplateSourceDirectory.GetHashCode + Me.GetType.Name.GetHashCode

            If Not (p.ViewStateUserKey Is Nothing) Then
                Return String.Concat(value.ToString(NumberFormatInfo.InvariantInfo), p.ViewStateUserKey)
            End If
            Return value.ToString(NumberFormatInfo.InvariantInfo)
        End Function


        Private Function GetLosFormatter(ByVal pControl As Control, ByVal enableViewStateMac As Boolean) _
As LosFormatter
            If enableViewStateMac Then Return New LosFormatter(True, GetMacKeyModifier(CType(pControl, Page)))
            Return New LosFormatter
        End Function

#End Region

    End Class

SessionViewStateProvider's Initialize method expects to find a configuration attribute named ConnectionStringName identifying a connection string in the <connectionStrings> configuration section. The connection string is used by LoadPageState and SavePageState methods to load/save the viewstate string from/to the database.

Other properties include:
ApplicationName which gets populated from applicationName attribute.
ViewStateKeyName property will contain the name of the hidden field where the reference to the viewstate will be kept on the page. This reference cannot be kept in default __VIEWSTATE field, because it gets overwritten by Asp.Net rendering engine.
Timeout property which sets the time in minutes for how long the database should keep the current viewstate record. A SqlServer job runs every so often and deletes all expired viewstate records from the table.

SavePageState serializes the viewState object passed into it using System.Web.UI.LosFormatter. Creates a GUID to serve as a unique identifier, and saves the record in a database. The newly generated GUID is then saved in a hidden field variable of a page.
LoadPageState retrieves the GUID from the hidden variable and gets viewState from the database.

Web Application Configuration

Viewstate provider requires the following be added to the Web.config of the Web Application:

    <configuration>
        <configSections>
            <sectionGroup name="system.web">
                <section name="viewstate" type="System.Web.UI.ViewStateSection, CustomProviders"
restartOnExternalChanges="true" allowDefinition="MachineToApplication" />
            </sectionGroup>
        </configSections>
        <connectionStrings>
            <add name="ViewStateConnectionString" 
connectionString="Server=(local);Database=ASPState;Integrated Security=True;" />
        </connectionStrings>
        <system.web>
            <viewstate defaultProvider="CompressionViewStateProvider" enabled="true">
                <providers>
                    <add name="SqlViewStateProvider" type="System.Web.Configuration.Providers.SqlViewStateProvider,
CustomViewStateProviders" connectionStringName="ViewStateConnectionString" timeout="35" />
                    <add name="SessionViewStateProvider" 
type="System.Web.Configuration.Providers.SessionViewStateProvider, 
CustomViewStateProviders" numberOfPagesInMemory="10" />
                    <add name="CompressionViewStateProvider" 
type="System.Web.Configuration.Providers.CompressionViewStateProvider, CustomViewStateProviders" />
                </providers>
            </viewstate>
        <system.web>
    </configuration>

Explanation of infrastructure for configuration

Since viewstate is not a stock configuration section, a custom configuration section must be written that derives from System.Configuration.ConfigurationSection. The following is a System.Web.UI.ViewStateSection class that exposes two properties: Providers and DefaultProvider. The <ConfigurationProperty> attributes map ViewStateSection properties to <viewstate> attributes in a configuration file. As a result, the DefaultProvider property will get its value from <viewstate> element's defaultProvider attribute, if present, and so on.

    ''' <summary>

    ''' Maps to a <viewstate> section in a configuration file

    ''' </summary>

    Public Class ViewStateSection
        Inherits ConfigurationSection


        <ConfigurationProperty("providers")> Public ReadOnly Property Providers() As ProviderSettingsCollection
            Get
                Return CType(MyBase.Item("providers"), ProviderSettingsCollection)
            End Get
        End Property

        <ConfigurationProperty("defaultProvider"), DefaultSettingValue("")> _
        Public Property DefaultProvider() As String
            Get
                Return CStr(MyBase.Item("defaultProvider"))
            End Get
            Set(ByVal value As String)
                MyBase.Item("defaultProvider") = value
            End Set
        End Property

    End Class

Below is the way our custom section is registered with ASP.NET to be inside system.web section of a configuration file. NOTE: type="System.Web.UI.ViewStateSection, CustomProviders" has the namespace.class and assembly name in which the class is located.

    <configSections>
        <sectionGroup name="system.web">
            <section name="viewstate" type="System.Web.UI.ViewStateSection, CustomProviders"
restartOnExternalChanges="true" allowDefinition="MachineToApplication" />
        </sectionGroup>
    </configSections>

Loading and initializing viewstate providers

At last we need a class that will load and manage all viewstate providers registered in Web.config. ViewStateManager class will be used in actual aspx pages to load/save the viewstate. It will contain a collection of all providers registered in Web.config, with one of them set as default provider.

    ''' <summary>

    ''' Manages all viewstate manipulations.

    ''' </summary>

    Public Class ViewStateManager

        Private Shared _provider As ViewStateProvider = Nothing
        Private Shared _providers As ViewStateProviderCollection = Nothing
        Private Shared _lock As New Object
        Private Shared _enabled As Boolean
        Private Shared _enabledSet As Boolean

        ''' <summary>

        ''' Default provider set in web.config

        ''' </summary>

        Public Shared ReadOnly Property Provider() As ViewStateProvider
            Get
                Return _provider
            End Get
        End Property


        Public Shared ReadOnly Property Providers() As ViewStateProviderCollection
            Get
               Return _providers
            End Get
        End Property

        Public Shared ReadOnly Property Enabled() As Boolean
            Get
                If Not _enabledSet Then
                    _enabled = GetViewStateSection().Enabled
                    _enabledSet = True
                End If
                Return _enabled
           End Get
        End Property

        Shared Sub New()
            Call LoadProviders()
        End Sub


        Public Shared Function LoadPageState(ByVal pControl As Control) As Object
            ' Make sure a provider is loaded

            Call LoadProviders()
            ' Delegate to the provider

            Return _provider.LoadPageState(pControl)
        End Function


        Public Shared Sub SavePageState(ByVal pControl As Control, ByVal viewState As Object)
            ' Make sure a provider is loaded

             Call LoadProviders()
            ' Delegate to the provider

             _provider.SavePageState(pControl, viewState)
        End Sub


        Private Shared Sub LoadProviders()
            ' Avoid claiming lock if providers are already loaded

            If _provider Is Nothing Then
                SyncLock _lock
                    ' Do this again to make sure _provider is still null

                    If _provider Is Nothing Then
                        ' Get a reference to the <viewstate> section

                        Dim section As ViewStateSection = GetViewStateSection()
                        ' Is custom viewstate management enabled

                        If section IsNot Nothing Then _enabled = section.Enabled
                        _enabledSet = True

                        If _enabled Then
                            ' Load registered providers and point _provider to the default provider

                            _providers = New ViewStateProviderCollection
                            ProvidersHelper.InstantiateProviders(section.Providers, _providers, _
    GetType(ViewStateProvider))
                            _provider = _providers(section.DefaultProvider)
                            If _provider Is Nothing Then
                                Throw New ViewStateProviderException("Unable to load default ViewStateProvider")
                            End If
                        End If
                    End If
                End SyncLock
            End If
        End Sub


        Private Shared Function GetViewStateSection() As ViewStateSection
            Return CType(WebConfigurationManager.GetSection("system.web/viewstate"), ViewStateSection)
        End Function

    End Class
</viewstate>

Inside LoadProviders, ProvidersHelper.InstantiateProviders subroutine loops through the viewstate/providers section under system.web in Web.Config and loads registered providers. It looks at the following to load a provider:

    <add name="SqlViewStateProvider" type="System.Web.Configuration.Providers.SqlViewStateProvider,
CustomViewStateProviders" connectionStringName="ViewStateConnectionString" timeout="35" />

Using ViewStateManager

Now we need to overload the functions exposed by the Page class to use our viewstate manager to save/load the viewstate. In the example this is done by deriving a PageTemplate class that inherits from System.Web.UI.Page, and making all aspx pages inherit from the PageTemplate.

PageTemplate has the following exposed besides the overriden viewstate functions:

• ServerSideViewState - set to false to use regular page viewstate. This property can be set in a Web.config or in page's Init method.
• SetServerSideViewStateProvider - sets provider to be used on a page. This is a hack I used to enable using different provider on per page basis.

NOTE: Common practice is to use the defaultProvider property in Web.config to set the provider for the whole application. Using SetServerSideViewStateProvider could get messy fast and is not a best practice in my opinion.

Below is the proper code for the overloaded page. The code in the example will differ slightly to show different implementations on per page basis.

    Protected Overloads Overrides Function LoadPageStateFromPersistenceMedium() As Object
        If _serverSideViewState AndAlso ViewStateManager.Enabled Then
            Return ViewStateManager.LoadPageState(Me)
        Else
            Return MyBase.LoadPageStateFromPersistenceMedium             ' regular client viewState

        End If
    End Function

    Protected Overloads Overrides Sub SavePageStateToPersistenceMedium(ByVal viewState As Object)
        If _serverSideViewState AndAlso ViewStateManager.Enabled Then
            ViewStateManager.SavePageState(Me, viewState)
        Else
            MyBase.SavePageStateToPersistenceMedium(viewState)            ' regular client viewState

        End If
    End Sub

Anthem.Net integration

Anthem.Net is, in my opinion, the best AJAX library out to date. And it would be a shame if it couldn't be used in conjunction with CustomViewState implementation. To read more on Anthem.Net please see Introduction to Anthem.NET.

NOTE: This solution will always use the default viewstate provider set in web.config. Setting provider on per page basis using SetServerSideViewStateProvider property will be ignored.

Because Anthem is managing outputting ViewState to the page separately from Asp.Net, we need to make Anthem write our hidden variable with the ViewStateKeyName to the page if it exists. Retrieval and loading of viewstate will be handled by Asp.Net as the normal page lifecycle is started by Anthem during a callback.

To integrate ViewStateManager we need to make the following modifications in Anthem project:

• Add CustomProviders.dll as a reference to the Anthem project in order to get access to ViewStateManager.
• Add the following function in Manager.cs to retrieve viewstate key from the page's markup after the callback
  

  private string GetServerSideViewState(string html)
  {
      if (ViewStateManager.Enabled) {
          return GetHiddenInputValue(html, "<input type=\"hidden\" name=\"" +
          ViewStateManager.Provider.ViewStateKeyName + "\" id=\"" +
          ViewStateManager.Provider.ViewStateKeyName + "\" value=\"");
      }
      else {
          return null;
      }
  }
  

• Create an overloaded WriteValueAndError function in Manager.cs, which will add values including updated serverSideViewState variable to the response string to be written back to the page

  /// <summary>
  
  /// Adds ServerSideViewState support
  
  /// </summary>
  
  private static void WriteValueAndError(
  StringBuilder sb,
  object val,
  string error,
  string viewState,
  string viewStateEncrypted,
  string serverSideViewState,
  string serverSideViewStateKey,
  string eventValidation,
  Hashtable controls,
  string[] scripts)
  {
      sb.Append("{\"value\":");
      WriteValue(sb, val);
      sb.Append(",\"error\":");
      WriteValue(sb, error);
      if (viewState != null)
      {
          sb.Append(",\"viewState\":");
          WriteValue(sb, viewState);
      }
      if (viewStateEncrypted != null)
      {
          sb.Append(",\"viewStateEncrypted\":");
          WriteValue(sb, viewStateEncrypted);
      }
      if (serverSideViewState != null)
      {
          sb.Append(",\"serverSideViewState\":");
          WriteValue(sb, serverSideViewState);
      }
      if (serverSideViewStateKey != null)
      {
          sb.Append(",\"serverSideViewStateKey\":");
          WriteValue(sb, serverSideViewStateKey);
      }
      if (eventValidation != null)
      {
          sb.Append(",\"eventValidation\":");
          WriteValue(sb, eventValidation);
      }
      if (controls != null && controls.Count > 0)
      {
          sb.Append(",\"controls\":{");
          foreach (DictionaryEntry control in controls)
          {
              sb.Append("\"" + control.Key + "\":");
              WriteValue(sb, control.Value);
              sb.Append(",");
          }
          --sb.Length;
          sb.Append("}");
      }
      if (scripts != null && scripts.Length > 0)
      {
          sb.Append(",\"pagescript\":[");
          foreach (string script in scripts)
          {
              WriteValue(sb, script);
              sb.Append(",");
          }
          --sb.Length;
          sb.Append("]");
      }
      if (GetManager()._clientSideEvalScripts.Count > 0)
      {
          sb.Append(",\"script\":[");
          foreach (string script in GetManager()._clientSideEvalScripts)
          {
              WriteValue(sb, script);
              sb.Append(",");
          }
          --sb.Length;
          sb.Append("]");
      }
      sb.Append("}");
  }
  

• Next we need to modify the WriteResult(Stream stream, MemoryStream htmlBuffer) function in Manager.cs to integrate CustomViewState. This function sends the result string back to the page. Modifications are shown in bold.

  internal void WriteResult(Stream stream, MemoryStream htmlBuffer)
  {
      string viewState = null;
      string serverSideViewState = null;
      string viewStateEncrypted = null;
      string eventValidation = null;
      Hashtable controls = null;
      string[] scripts = null;
      if (_updatePage)
      {
          string html = HttpContext.Current.Response.ContentEncoding.GetString(htmlBuffer.GetBuffer());
          viewState = GetViewState(html);
          serverSideViewState = GetServerSideViewState(html);
  #if V2
          viewStateEncrypted = GetViewStateEncrypted(html);
          eventValidation = GetEventValidation(html);
  #endif
          controls = GetControls(html);
          foreach (object o in _targets.Values)
          {
              Control c = o as Control;
              if (c != null && !c.Visible)
              {
                  if (c.ID != null && controls.ContainsKey(c.ID))
                      controls[c.ID] = "";
              }
          }
  
          scripts = GetScripts(html);
      }
      StringBuilder sb = new StringBuilder();
      try
      {
          // If the serverSideViewState is null, that means CustomViewState is turned off on the page,
  
          // and thus will be ignored inside WriteValueAndError.
  
          // But we will double check for it here anyways.
  
          if (ViewStateManager.Enabled && serverSideViewState != null) {
              WriteValueAndError(sb, _value, _error, viewState, viewStateEncrypted,
                  serverSideViewState, ViewStateManager.Provider.ViewStateKeyName, eventValidation, controls, scripts);
          }
          else {
              WriteValueAndError(sb, _value, _error, viewState, viewStateEncrypted, eventValidation, controls, scripts);
          }
      }
      catch (Exception ex)
      {
          // If an exception was thrown while formatting the
  
          // result value, we need to discard whatever was
  
          // written and start over with nothing but the error
  
          // message.
  
          sb.Length = 0;
          WriteValueAndError(sb, null, ex.Message, null, null, null, null, null);
      }
  
      // If an IOFrame was used to make this callback, then wrap the response in a <textarea> element
  
      // so the iframe will not mess with the text of the JSON object.
  
      string response = sb.ToString();
      if (string.Compare(HttpContext.Current.Request["Anthem_IOFrame"], "true", true) == 0)
      {
          response = "<textarea id=\"response\">" + response + "</textarea>";
      }
  
      byte[] buffer = HttpContext.Current.Response.ContentEncoding.GetBytes(response);
      stream.Write(buffer, 0, buffer.Length);
  }
  

• Finally, we need to modify Anthem.js to update the serverSideViewState hidden input value on a page. Modifications are shown in bold.

  function Anthem_UpdatePage(result) {
      var form = Anthem_GetForm();
      if (result.viewState) {
          Anthem_SetHiddenInputValue(form, "__VIEWSTATE", result.viewState);
      }
      
      if (result.serverSideViewState && result.serverSideViewStateKey) {
          Anthem_SetHiddenInputValue(form, result.serverSideViewStateKey, result.serverSideViewState);
      }
      if (result.viewStateEncrypted) {
          Anthem_SetHiddenInputValue(form, "__VIEWSTATEENCRYPTED", result.viewStateEncrypted);
      }
      if (result.eventValidation) {
          Anthem_SetHiddenInputValue(form, "__EVENTVALIDATION", result.eventValidation);
      }
      if (result.controls) {
          for (var controlID in result.controls) {
              var containerID = "Anthem_" + controlID.split("$").join("_") + "__";
              var control = document.getElementById(containerID);
              if (control) {
                  control.innerHTML = result.controls[controlID];
                  if (result.controls[controlID] == "") {
                      control.style.display = "none";
                  } else {
                      control.style.display = "";
                  }
              }
          }
      }
      if (result.pagescript) {
          Anthem_LoadPageScript(result, 0);
      }
  }
  

That's it. ServerSide viewstate makes Anthem noticeably more responsive. Check it out for yourself!

Points of Interest

This code has been written but unfortunately never been tested in a real life application. Very interested to see SqlViewStateProvider and other providers get used in a large scale application with a high usage. Any ideas or other provider(better) implementations? All feedback is most welcome.

History

• June 5, 2007
  - Removed ViewStateProvidersConfig class.
  - Added enabled property to the Viewstate config section.
  - Added Anthem integration, and a sample page using Anthem datagrid.
  

You must Sign In to use this message board.

FAQ    Noise Tolerance Very HighHighMediumLowVery Low   Layout Expand Posts & RepliesThread ViewNo JavascriptNo JS + Preview   Per page 102550

Msgs 1 to 7 of 7 (Total in Forum: 7) (Refresh) FirstPrevNext

Another approach Pro Dev 10:05 7 Sep '07   A practical way of implementing such a solution would be to create a new object, which inherits from the PageStatePersister class. In your page, or base page, you would override the PageStatePersister property returning your new object. public class BasePage : Page {       public BasePage(){}       protected override PageStatePersister PageStatePersister       {             get             {                   return new MySQLServerPageStatePersister(this);             }       } } Additional information can be found here: http://msdn2.microsoft.com/en-us/library/aa479403.aspx Hope this helps! ~Joshua Sign In·View Thread·PermaLink Great Job.. s_ruchit 21:03 5 Jun '07   great job buddy.. thanks for the article.. Sign In·View Thread·PermaLink Good stuff but I'm going to play devils advocate bri189b 15:40 15 May '07   Allan Cooper wrote a great book (a few actually), but my favorite is 'The Inmates are Running the Asylum'.   It's great that you came up with this whole provider model and I'm sure it fits the bill, and there are the right places for this and by no means do I want you to think that I'm belittling your work; it's actually pretty cool and it's very gracious of you to share your code and time - but as someone who wants to play devils advocate and tell the otherside of the tale for young developers who may read your work and are too quick to jump on the latest solutions for problems they don't have; I have to share my advice; unwarnted as it is; so please take it with a grain of salt and not directed towards you; but towards our community. One of the frustrating things after doing this all these years is seeing people re-invent the wheel or fix a problem that doesn't exist.   I've fell victim to it myself for years. So you make multiple trips to the database.   That is what a database is for.   It is designed to have multiple transactions occuring constantly.   A server with four processors that is idling, and network cable with no data on it are wasted money. Should you bomb the server with 20 million hits per minute?   No.   But do you build a complex architecture to keep from hitting the database 2000 times per minute...no.   Martin Fowler speaks of this in his Refactoring book. Most view state problems can be solved by better design.   A human being cannot comprehend more than 20 records at a time; and they're reaching at that - open excel and add 20 columns and 20 rows of random data...can you comprehend that all at once?   Even if it's sorted and categorized - well you know that L is somewhere in the middle of a list for A-Z; but what does that do for you?   So   ask yourself, why I am looking at all this data?   Am I trying to find something.   Do I really need to show all this, or just part of the whole list to find what I need?   Maybe the design is flawed. You'll find after several years of experiance, sometimes it not the lack of memory, or the amount of data that is the problem - it's the answer to the problem that is wrong. Sign In·View Thread·PermaLink 3.00/5 (1 vote) Re: Good stuff but I'm going to play devils advocate Oleg Sobol 18:25 15 May '07   All your arguments are good and valid. I agree that this solution is not for all situations. The db, if managed properly, should be able to sustain a high volume of calls, even though it can be avoided. And, of course, you can write sprocs that use paging. But think about a user with a 56K connection waiting for the viewstate to be needlessly passed back and forth. And think about the bandwidth being wasted by a company which has hundreds of thousands hits a day. Then count the money saved on the bandwidth and user satisfaction caused by faster page loads. I can come up with a number of pros and you probably can come up with just as many cons. At the end of the day a company must make a decision that saves it money. Just something to think about! Sign In·View Thread·PermaLink Re: Good stuff but I'm going to play devils advocate merlin981 12:51 5 Jun '07   Agreed. I always hated that the datagrids appear both in viewstate AND html, thus doubling the size of the html passed to the user. For my grids, I use sprocs that page the data, and anything that needs to be cached is saved either in cache or session state. Calling the database each time the user pages the grid is not too much activity for the database (unless you have a poorly written long running sproc). Your idea is good and well written, but I think it's uses are severly limited. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ I get my developer tools from Merlin A.I. Soft I get my news and jokes from Daily Roundup ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sign In·View Thread·PermaLink Wow!!! Ricardo Casquete 0:31 15 May '07   Wow mate, the idea of creating ViewState Providers is good, I had read some time ago some of the articles you mentioned in the top of yours. I will try them, and maybe I'll adapt the Sql one to work with Oracle and to integrate it with the Enterpise Library and we'll use in the current project I am working at. Regards Ricardo Casquete Sign In·View Thread·PermaLink 2.00/5 (1 vote) Re: Wow!!! Oleg Sobol 6:53 15 May '07   Sounds great Ricardo! Please post whatever u come up with here. I am very interested in seeing the EntLib integration. I am going to be making an update to the code, and will post another short paragraph soon on integration with Anthem.Net controls. Oleg Sign In·View Thread·PermaLink 2.00/5 (1 vote)

Last Visit: 2:18 9 Nov '09     Last Update: 2:18 9 Nov '09 1