05 asp.net session07

of 33Ver. 1.0

Developing Web Applications Using ASP.NET

In this session, you will learn to:Describe the ViewState and ControlState data models for Web pages

Describe the Application and Session objects and explain how state data is stored and retrieved in these objects

Describe various session-state data-storage strategies

Describe the Cache object and explain how you can use it to store and manage state data

Objectives

of 33Ver. 1.0


A new instance of the Web page class is created each time the page is posted to the server.

In traditional Web programming, all information that is associated with the page, along with the controls on the page, would be lost with each roundtrip.

Microsoft ASP.NET framework includes several options to help you preserve data on both a per-page basis and an application-wide basis. These options can be broadly divided into two categories:

Client-Based State Management Options

Server-Based State Management Options

ASP.NET State Management Overview

of 33Ver. 1.0


Client-based options involve storing information either in the page or on the client computer.

Some client-based state management options are:View state

Control state

Hidden form fields

Cookies

Query strings

Client-Based State Management Options

of 33Ver. 1.0


View State:The ViewState property provides a dictionary object for retaining values between multiple requests for the same page.

When the page is processed, the current state of the page and controls is hashed into a string and saved in the page as a hidden field.

When the page is posted back to the server, the page parses the view-state string at page initialization and restores property information in the page.

To specify the maximum size allowed in a single view-state field, you can use the property, System.Web.UI.Page.MaxPageStateFieldLength.

In addition to the contents of controls, the ViewState property can also contain some additional information: ViewState[“color”] = “Yellow” ;

Client-Based State Management Options (Contd.)

of 33Ver. 1.0


Control State:The ControlState property allows you to persist property information that is specific to a control.

This property cannot be turned off at a page level as can the ViewState property.

Hidden Form Fields:ASP.NET provides the HtmlInputHidden control, which offers hidden-field functionality.

A hidden field does not render visibly in the browser.

The content of a hidden field is sent in the HTTP form collection along with the values of other controls.


of 33Ver. 1.0


Cookies:Cookies are stored either in a text file on the client file system or in memory in the client browser session.

They contain site-specific information that a server sends to the client along with the page output.

When the browser requests a page, the client sends the information in the cookie along with the request information.

The server can read the cookie and extract its value.

Query Strings:Query string is a piece of information that is appended to the end of a page URL.

You must submit the page by using an HTTP GET command to ensure availability of these values.


of 33Ver. 1.0


Server-based options maintain state information on the server.

Some server-based state management options are:Application state

Session state

Server-Based State Management Options

of 33Ver. 1.0


Application State:Application state is an instance of the System.Web.HttpApplicationState class.

It allows you to save values for each active Web application.

Application state is stored in a key/value dictionary that is created during each request to a specific URL.

It is a global storage mechanism that is accessible from all pages in the Web application.

It supports the following events:Application.Start

Application.End

Application.Error

The handlers for the preceding events can be defined in the Global.asax file.

Server-Based State Management Options (Contd.)

of 33Ver. 1.0


Values can be saved in the Application state as:Application[“Message”]=“Hello,world.”;

Values can be retrieved from the Application state as:if (Application[“AppStartTime”] != null)

{

DateTime myAppStartTime = (DateTime)

Application[“AppStartTime”];

}


of 33Ver. 1.0


Session State:Session state is an instance of the System.Web.SessionState.HttpSessionState class.

It allows you to save values for each active Web application session.

It is similar to application state, except that it is scoped to the current browser session.

It supports the following events:Session.Start

Session.End

The handlers for the preceding events can be defined in the Global.asax file.


of 33Ver. 1.0


Values can be saved in the Session state as: string name = “Jeff”;

Session[“Name”] = name;

Values can be retrieved from the Session state as:

if(Session[“Name”]!=null)

{

string name=(string)Session[“Name”];

}


of 33Ver. 1.0


Session state information can be stored in several locations.

Location can be configured by setting the mode attribute of the SessionState element in Web.config file.

Three possible storage modes can be used:InProc Mode

State Server Mode

SQL Server Mode

Strategies for Managing Session State Data

of 33Ver. 1.0


InProc Mode:This is the default mode.

Session state data is stored in memory on the Web server within the process that is running the Web application.

This is the only mode that supports the Session.End event.

Session state information will be lost if application is restarted.

Session state cannot be shared between multiple servers in a Web farm.

To enable InProc mode, the following markup can be added within the <system.web> tags in the Web.config file:

<sessionState mode=“InProc”></sessionState>

Strategies for Managing Session State Data

of 33Ver. 1.0


Following Diagram shows how Session state information is managed in InProc mode, when Cookies are enabled.

Strategies for Managing Session State Data (Contd.)

Client Server

Request received

Create session object and store data in it

Fetch session object identified by cookie

Fetch data from session object

Receives first page

Request first page

Store cookie on client, send along with first page

Second request (with cookie)

Send second page based on data in Session object

Receives second page

Session ID Cookies

of 33Ver. 1.0


State Server Mode:Session state data is managed by a separate process called the ASP.NET State Service.

Session state information will not be lost if application is restarted.

A single session state can be shared between multiple servers in a Web farm.

ASP.NET State Service does not start automatically.

To use ASP.NET State Service, make sure it is running on the desired server.


of 33Ver. 1.0


You need to configure each Web server in the Web farm to connect to the ASP.NET state service by modifying the Web.config file as:<configuration>

<system.web>

<sessionState mode="StateServer“

stateConnectionString=

"tcpip=MyStateServer:42424"

cookieless="AutoDetect"

timeout="20"/>

</system.web>

</configuration>


of 33Ver. 1.0



Status of ASP.NET State Service can be checked from the Services window on the server on which the service is running.

of 33Ver. 1.0


SQL Server Mode:Session state data is stored in Microsoft SQL Server database.

Session state information will not be lost, in case application is restarted.

Session state can be shared between multiple servers in a Web farm.

To use SQLServer mode, session state database must be installed on an existing SQL Server.


of 33Ver. 1.0


After database has been installed, you need to specify SQLServer mode in Web.config file as:<configuration>

<system.web>

<sessionState mode="SQLServer"

sqlConnectionString="

Integrated Security=SSPI;data

source=MySqlServer;" />

</system.web>

</configuration>


of 33Ver. 1.0


An object can be stored in cache if it consumes a lot of server resources during creation and is being used frequently.

This caching system can be used to improve the response time of an application.

This caching system automatically removes items when system memory becomes scarce, in a process called scavenging.

The Cache Object

of 33Ver. 1.0


To cache an item, you can use any of the following methods:

Key name/Value pair method:Add a value to the cache object by using the key name as indexer.

The following code caches the value in the Text property of a TextBox control called txtExample:

Cache[“key"] = value;

Insert method:Specify the key name as the first argument and the value being cached as the second argument.

The following code performs the same task as the previous example by using the Insert method of the Cache object:

Cache.Insert(“key", value);

How to: Store and Retrieve State Data in the Cache Object

of 33Ver. 1.0


To retrieve values from the cache, Cache object can be referenced using the key name as the indexer:if (Cache[“key"] != null)

{

txtExample.Text = (string)Cache[“key"];

}

If you try to access an object from the cache that has been removed because of scarcity of memory, the cache will return a Null reference.

How to: Store and Retrieve State Data in the Cache Object (Contd.)

of 33Ver. 1.0


Expiration time of a cached object can be specified during the object addition into the cache.

Expiration time can be:Absolute

Sliding

Absolute Expiration:This method specifies a date and time when the object will be removed.

To add an item to the cache with an absolute expiration of two minutes, the following code snippet can be used:

Cache.Insert("CacheItem", "Cached Item Value", null, DateTime.Now.AddMinutes(2), System.Web.Caching.Cache.NoSlidingExpiration);

Controlling Expiration

of 33Ver. 1.0


Sliding Expiration:This method specifies a duration for which an item can lie unused in the cache.

The caching system can scavenge the item if it has not been used for a duration that exceeds this value.

To add an item to the cache with a sliding expiration of 10 minutes, the following code snippet can be used:Cache.Insert("CacheItem", "Cached Item Value", null, System.Web.Caching.Cache.NoAbsoluteExpiration,

new TimeSpan(0, 10, 0));

Controlling Expiration

of 33Ver. 1.0


Policy for removing objects from the cache can be influenced by specifying CacheItemPriority value.

The caching system will scavenge low-priority items before high-priority items when system memory becomes scarce.

To set the priority of ac cached object to high at the time of creation, the following code snippet can be used:

Cache.Insert("CacheItem", "Cached Item Value", null, System.Web.Caching.Cache.NoAbsoluteExpiration, System.Web.Caching.Cache.NoSlidingExpiration, System.Web.Caching.CacheItemPriority.High, null);

Cache Item Priority

of 33Ver. 1.0


Cached items can become invalid because the source of the data has changed.

Cached items may be dependent on files, directories, and other cached items.

At the time of adding an item to the cache, you can specify the object on which the cached item depends.

If any object (on which a cached item depends) changes, the cached item is automatically removed from the cache.

Cache Dependencies

of 33Ver. 1.0


You can add an item with a dependency to the cache by using the dependencies parameter in the Cache.Insert method, as:Cache.Insert(“Key", value, new CacheDependency Server.MapPath("~\myConfig.xml")));

You can also add an item that depends on another cached item to the cache, as:string[] sDependencies = new string[1];

sDependencies[0] = “key_original";

CacheDependency dependency = new CacheDependency(null, sDependencies);

Cache.Insert(“key_dependent", "This item depends on OriginalItem", dependency);

How to: Define Dependencies Between Cached Items

of 33Ver. 1.0


Cached data can be deleted by:Setting expiration policies that determine the total amount of time the item remains in the cache.

Setting expiration policies that are based on the amount of time that must pass following the previous time the item was accessed.

Specifying files, directories, or keys that the item is dependent on. The item is removed from the cache when those dependencies change.

Removing items from the cache by using the Cache.Remove method as:

Cache.Remove("MyData1");

How to: Delete Cached Data

of 33Ver. 1.0


How to: Implement Deletion Notifications in Cached Data

CacheItemRemovedCallback delegate defines the signature to use while writing the event handlers to respond when an item is deleted from the cache.

CacheItemRemovedReason enumeration can be used to make event handlers dependent upon the reason the item is deleted.

of 33Ver. 1.0


How to: Implement Deletion Notifications in Cached Data (Contd.)

To notify an application when an item is deleted from the cache:

Create a local variable that raises the event for the CacheItemRemovedCallback delegate as:private static CacheItemRemovedCallback onRemove = null;

Create an event handler to respond when the item is removed from the cache as:static bool itemRemoved = false;

static CacheItemRemovedReason reason;

public void RemovedCallback(string key, object value, CacheItemRemovedReason

callbackreason)

{ itemRemoved = true;

reason = callbackreason;

}

of 33Ver. 1.0


How to: Implement Deletion Notifications in Cached Data (Contd.)

Create an instance of the CacheItemRemovedCallback delegate that calls the event handler as:onRemove = new CacheItemRemovedCallback(this.RemovedCallback);

Add the item to the cache by using the Cache.Insert method as:Cache.Insert("MyData1", Source, null,

DateTime.Now.AddMinutes(2),

NoSlidingExpiration,

CacheItemPriority.High, onRemove);

of 33Ver. 1.0


In this session, you learned that:ViewState is the mechanism for preserving the contents and state of the controls on a Web page during a round trip.

ASP.NET enables controls to preserve their ControlState even when ViewState is disabled.

The Application and Session objects enable you to cache information for use by any page in your ASP.NET application.

ASP.NET maintains a single Application object for each application on your Web server.

An ASP.NET Session object is an object that represents a user’s visit to your application.

Summary

of 33Ver. 1.0


The possible storage modes for storing session state information are:

InProc

StateServer

SQLServer

ASP.NET has a powerful caching system that you can use to improve the response time of your application.

The ASP.NET caching system automatically removes items from the cache when system memory becomes scarce.

Summary (Contd.)

05 asp.net session07

Documents

Transcript of 05 asp.net session07