Last Updated - Sun Oct 29 2017

At the Richmond Code Camp I went over some of my tips and tricks to get ASP.NET to perform as fast as possible. One of the biggest things you have to do is reduce the size of your ViewState and also move it to the bottom of the page. It was brought to my attention that the View State can be stripped entirely from the page as it is being sent to the client (well sort of) and stored or persisted as a local file. I found Dino Esposito's Cutting Edge article on working with the ViewState where he demonstrates this principle.

I tried this with some code to see what happened and I was pleasently surprised that this was pretty quick and did not produce any ViewState related exceptions for me. Let's take a look, first at the original ViewState for a page:

<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="/wEPDwUJMTE2MTg3NTYyDs2QWAmYPZBYCAgEPZBYCAg4PZBYCAgEP

ZBYEZg9kFgQCAw8QZGQWAQIdBZAIfDxQrAAJkZGQCAQ9kFgQCAQ8WAh4HVmlza

WJsZWgWAgIBD2QWAgIBD2QWAgIFsDw8WAh4ISW1hZ2VVcmwFKmh0dHA6Ly9sb2

NhbGhvc3QvbWFjL2ltYWdlcy9jb250YWdN0XzMyLmdpZmRkAgUPZBYEAgEPFgIfAGcW

BAICD2QWAgIBDxYCHgRUZXh0BQ9MdaW5kYSBEZW1lcml0dGVkAgQPZBYEAgMPF

gIfAGcWAgICD2QWAgIBDxYCHwIFCfUFsYW4gSHVudGQCBQ8PFgIfAGhkZAICD2QW

AmYPZBYCAgEPFgIfAGhkGAEFJGNf0bDAwJENvbnRlbnRQbGFjZUhvbGRlcjEkTXVsdG

lWaWV3MQ8PZAIBZBLDmk8f72Yt1WKBfAWhD8KS0hJhM" />

Now this is the ViewState Input tag using the PageState Persistance:

As you can see this is quite an improvement. What happens is a file is created on the web server that contains the Page's ViewState. The file contains the following text and is named after the session state.

/wEPGAEFJGN0bDAwJENvbnRlbnRQbGFjZUhvbGRlcjfEkTXVsdGlWaWV3MQ8PZAIBZA8FCTExNjE4Nz

U2Mg9kFgJmD2QWAgIBD2QWAgIOD2QWAgIBD2QWBGfYPZBYEAgMPEGRkFgECAWQCHw8UKwAC

ZGRkAgEPZBYEAgEPFgIeB1Zpc2libGVoFgICAQ9kFgICAQf9kFgICBQ8PFgIeCEltYWdlVXJsBSpodHRw

Oi8vbG9jYWxob3N0L21hYy9pbWFnZXMvY29udGFjdF8zMi5naWZkZAIFD2QWBAIBDxYCHwBnFgQCAg

9kFgICAQ8WAh4EVGV4dAUPTGluZGEgRGVtZfXJpdHRlZAIED2QWBAIDDxYCHwBnFgICAg9kFgICAQ8

WAh8CBQlBbGFuIEh1bnRkAgUPDxYCHwBofZGQCAg9kFgJmD2QWAgIBDxYCHwBoZA==

Now this leaves a problem because the ViewState files are bound to build up. So you will have to build a purging mechanism into the web application to keep the directory as clean as possible. For security purposes you also may not be allowed to store media either created on the fly or uploaded by users from the web. I decided a good way to counter this problem would be to store the ViewState in cache with a dependancy. This of course causes considerations for memory usage, so you will have to decide what is the most important in your situation.

I like to use the Enterprise Library to handle my Caching needs, so you will need to investigate this on your on, or wait will I get a chance to Blog about using the Caching block. But until then, trust me this works. The methodology relies on two special methods being created. I created these methods to abstract the methodology out of the two Page class methods that need to be overriden. I also created a utility method to return the sessionid as a name for the Cache variable, again just to abstract this out.

 
    
Protected
Function
 LoadPageStateFromCache() As
Object
 
        
Dim
 m_viewState As
String
        
Dim
 m_formatter As
 LosFormatter
        
Dim
 viewStateBag As
Object
 
        
Dim
 pc As
 CacheManager = CacheFactory.GetCacheManager()
 
        
Dim
 sRequestContent As
String
 = DirectCast
(pc.GetData(GetCacheName), String
)
 
        
If
String
.IsNullOrEmpty(sRequestContent) = False
Then
 
            
Dim
 sr As
New
 StringReader(sRequestContent)
            m_viewState = sr.ReadToEnd()
            sr.Close()
 
            m_formatter = 
New
 LosFormatter()
 
            viewStateBag = m_formatter.Deserialize(m_viewState)
 
        
End
If
 
        
Return
String
.Empty
 
    
End
Function
 
    
Protected
Sub
 SavePageStateToCache(ByVal
 viewStateBag As
Object
)
 
        
Dim
 m_formatter As
 LosFormatter = New
 LosFormatter()
        
Dim
 stw As
 StringWriter = New
 StringWriter
        m_formatter.Serialize(stw, viewStateBag)
        
Dim
 primitivesCache As
 CacheManager = CacheFactory.GetCacheManager()
        primitivesCache.Add(GetCacheName, stw.ToString(), CacheItemPriority.Normal, 
New
 ExCacheRefreshAction, _
            
New
 AbsoluteTime(DateAdd(DateInterval.Minute, Session.Timeout + 30, Now())))
 
    
End
Sub
 
    
Protected
Overloads
Overrides
Function
 LoadPageStateFromPersistenceMedium() As
Object
 
        
Return
 LoadPageStateFromCache()
        
'Return LoadPageStateFromFile()
        
'Return MyBase.LoadPageStateFromPersistenceMedium()
 
    
End
Function
 
    
Protected
Overloads
Overrides
Sub
 SavePageStateToPersistenceMedium(ByVal
 viewStateBag As
Object
)
 
        SavePageStateToCache(viewStateBag)
        
'SavePageStateToFile(viewStateBag)
        
'MyBase.SavePageStateToPersistenceMedium(viewStateBag)
 
    
End
Sub
 
    
Private
Function
 GetCacheName() As
String
        
Return
 Session.SessionID.ToString
    
End
Function

One trick I do, just to be a little safe is to tell the Cache dependancy to keep the value in memory for 30 minutes past the session timeout. What this will lead us to is creating a handler to let the user know their session has timed out. I know I am real bad about always having my computer on and on about 20 pages all the time. That means that many of these stateless pages will eventually cause a post back to the server when I get back to it. My online banking application does this if I leave it running without a postback in say 10 minutes, so it is a common scenario to handle. That will lead to another Blog entry. I hope to have that ready by the NJ Code Camp this weekend.

Persist the ViewState and Increase ASP.NET Performance