05 asp.net session07

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

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

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

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.)

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.

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.

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

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.)

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”];
}

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.

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”];
}

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

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

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

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.

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>

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

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.

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>

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

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

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.)

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

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

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

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

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

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

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.

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;
}

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);

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

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

More Related Content

What's hot (18)

Viewers also liked (13)

Similar to 05 asp.net session07 (20)

More from Vivek Singh Chandel (20)

Recently uploaded (20)

05 asp.net session07