05 ASP - Net Session07

Developing Web Applications Using ASP.
NET
Objectives
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
Ver. 1.0 Slide 1 of 33

Developing Web Applications Using ASP.NET
ASP.NET State Management Overview
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

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

(Contd.)
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” ;

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

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

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

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

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

(Contd.)
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”];
}

Strategies for Managing Session State Data
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

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>

(Contd.)
Following Diagram shows how Session state information is

managed in InProc mode, when Cookies are enabled.
Client Server
Request first page
Request received
Receives first page Store cookie on client,

send along with first page Create session object and
Session ID Cookies store data in it
Second request (with cookie)

Fetch session object identified
by cookie
Send second page based
on data in Session object
Receives second page
Fetch data from session object

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

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

(Contd.)
Status of ASP.NET State Service can be checked from the

Services window on the server on which the service is
running.

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

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

The Cache Object
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.

How to: Store and Retrieve State Data in 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
(Contd.)
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.

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

Cache Item Priority
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 Dependencies
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.

How to: Define Dependencies Between Cached
Items
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: Delete Cached Data
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: 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);

Summary
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 (Contd.)
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.

05 ASP - Net Session07

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

05 ASP - Net Session07

Загружено:

Авторское право:

Доступные форматы

Developing Web Applications Using ASP.

In this session, you will learn to:

Ver. 1.0 Slide 1 of 33

A new instance of the Web page class is created each time

Ver. 1.0 Slide 2 of 33

Client-based options involve storing information either in the

Ver. 1.0 Slide 3 of 33

Ver. 1.0 Slide 4 of 33

Ver. 1.0 Slide 5 of 33

Ver. 1.0 Slide 6 of 33

Server-based options maintain state information on the

Ver. 1.0 Slide 7 of 33

Ver. 1.0 Slide 8 of 33

Values can be saved in the Application state as:

Ver. 1.0 Slide 9 of 33

Ver. 1.0 Slide 10 of 33

Values can be saved in the Session state as:

Ver. 1.0 Slide 11 of 33

Session state information can be stored in several locations.

Ver. 1.0 Slide 12 of 33

Ver. 1.0 Slide 13 of 33

Following Diagram shows how Session state information is

Receives first page Store cookie on client,

Second request (with cookie)

Ver. 1.0 Slide 14 of 33

State Server Mode:

Ver. 1.0 Slide 15 of 33

You need to configure each Web server in the Web farm to

Ver. 1.0 Slide 16 of 33

Status of ASP.NET State Service can be checked from the

Ver. 1.0 Slide 17 of 33

SQL Server Mode:

Ver. 1.0 Slide 18 of 33

After database has been installed, you need to specify

Ver. 1.0 Slide 19 of 33

An object can be stored in cache if it consumes a lot of

Ver. 1.0 Slide 20 of 33

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

Ver. 1.0 Slide 21 of 33

To retrieve values from the cache, Cache object can be

Ver. 1.0 Slide 22 of 33

Expiration time of a cached object can be specified during

Ver. 1.0 Slide 23 of 33

Ver. 1.0 Slide 24 of 33

Policy for removing objects from the cache can be

Ver. 1.0 Slide 25 of 33

Cached items can become invalid because the source of

Ver. 1.0 Slide 26 of 33

You can add an item with a dependency to the cache by

Ver. 1.0 Slide 27 of 33

Cached data can be deleted by:

Ver. 1.0 Slide 28 of 33

CacheItemRemovedCallback delegate defines the

Ver. 1.0 Slide 29 of 33

To notify an application when an item is deleted from the

Ver. 1.0 Slide 30 of 33

Create an instance of the CacheItemRemovedCallback

Add the item to the cache by using the Cache.Insert

Ver. 1.0 Slide 31 of 33

In this session, you learned that:

Ver. 1.0 Slide 32 of 33

The possible storage modes for storing session state