Implementing a Session-State Store Provider

我的学习自定义SessionState存储的总结与大家分享，有很多足,在学习中。
关于自定义SessionState存储之SessionStateStoreProviderBase类
Custom Session-State Module
SessionStateItemCollection
自定义SessionIDManager

原文http://msdn2.microsoft.com/en-us/library/ms178587.aspx

---

描述一个自定义session-state store provider的实现和一个
范例来实现简单的provider.

---

ASP.NET session state 被设计授权你存储User session数据在不同的数据源.默认session state值和信息是保存在ASP.NET进程内的内存中的.但还可以选的就是存储session 数据在一个state server端,保存session 数据在一个单独进程并如果APS.NET应用程序关闭和重新启动都能保留它.另一个是保存session 数据在一个SQL Server数据库中,这里它能被多个Web server端所共享.

你能在ASP.NET中使用session-state存储,并且你能实现你自己的session-state store provider.您也可以创建一个自定义的session-state存储提供者,有下面的理由:

   (1)你需要保存session-state信息保存在SQL Server之外的数据源,如果FoxPro数据库或Oracle 数据库.

   (2)你需要使用数据库模式管理session-state信息,在.NET Framework之上不同的数据库使用不同的provader.如Shopping cart数据被存储在预先定义好的SQL Server数据库中.

你能创建一个类继承SessionStateStoreProviderBase实现一个自定义 session-state提供者.

---

 The Session State Module

---

Session state 被SessionStateModule类管理,调用session-state存储提供者在不同时期的请求来读和写session data到数据存储中.在请求开始时,SessionStateModule实例调用GetItemExclusive方法从数据源中找回数据,或如果EnableSessionState页面属性已经被设置为ReadOnly,就只能调用GetItem方法.在一个请求结束时,如果session-state值已经被修改,SessionStateModule实例调用SessionStateStoreProviderBase.SetAndReleaseItemExclusive 方法写入更新session-state存储值.SessionStateModule调用另外的SessionStateStoreProviderBase实现来初始一个新的session,也是调用HttpSessionState.Abandon删除session 数据.每一个SessionStateStoreProviderBase 成员详细讨论会在之后的部分.

这个SessionStateModule类决定SessionID自己的值,比依赖Session-state 存储提供者等更好.如果你需要你能创建一个类继承ISessionIDManager interface实现一个自定义的SessionIDManager.更多可以看ISessionIDManager.

SessionStateModule将还原为ASP.NET进程一致这样能访问任何安全资源,如一个数据库服务端.你能指定SessionStateModule 实例模仿支持IIS识别,设置<sessionState>配置文件元素的属性useHostingIdentity为false.例如,如果你已经为你的IIS应用程序配置使用Windows Integrated security和你要ASP.NET去模仿由IIS for session management提供识别,那就指定在<system.web>中<identity impersonate="true" />,并且设置useHostingIdentity属性为false.如果useHostingIdentity属性为true,ASP.NET将默认进程识别,或当连接数据源时使用配置文件中的<identity>支持用户提供证书.更信息看Configuring ASP.NET Process Identity and ASP.NET Impersonation.

---

Locking Session-Store Data

---

因为ASP.NET应用程序是多线程支持响应并发请求,它能并发请求尝试访问同一个Session信息.考虑一个场景有一个在同一个应用程序中所有ASP.NET pages都有中一个frameset，frameset中有多个 frame.这里在服务端并发不同的线程独立请求在ASP.NET pages中的frameset中每一个frame.如果ASP.NET页面为每一个 frame都去想数据存储中访问session-state变量,你用就会使用多线程并发访问session 存储.

在session储存和异常的session-state行为中避免数据冲突.SessionStateModule和 SessionStateStoreProviderBase类中包括了lock功能,就是在ASP.NET页面在执行的整个期间使用排它琐琐住session 存储的item.注意如果EnableSessionState属性设置为ReadOnly,没有琐住这个session-store item,另外同一个应用程序ASP.NET页面能写一个 session 存储,所以一个请求read-only session数据仍然需要等待被锁数据释放.

在SessionStateModule 对象调用GetItemExclusive方法请求一个锁住的session-store数据开始时,当请求完成时,这个锁回在调用SetAndReleaseItemExclusive 方法期间被调用.

如果SessionStateModule实例在调用GetItemExclusive方法时也在调用GetItem方法期间遇到session 数据被琐住,它将既每隔half-second(2.5秒)重新请求session数据直到lock被释放或指定的ExecutionTimeout属性指定的时间已经过期.如果请求超时,SessionStateModule调用ReleaseItemExclusive方法释放session-store数据和在那时在请求的session-store数据.

被锁住的session-store数据可能已经被独立的线程调用ReleaseItemExclusive方法释放,那之前可能已经为当前响应调用SetAndReleaseItemExclusive 方法.这个可能的原因是SessionStateModule实例去设置和释放已经其他session被释放和修改的session-state存储数据.为避免这中情况,SessionStateModule 包含一个关于每一个请求更改被琐的session-store数据锁标识(lock identifer). 如果在数据存储中匹配SessionStateModule提供的锁标识Session-store数据就能修改.

---

Deleting Expired Session-Store Data

---

但为一个session调用Abandon方法时,这个数据要从数据存储中删除就要调用RemoverItem方法.另一方面这个数据将保留在 Session数据存储中直到Sever端在未来再次请求Session时.它是使用SessionStateStoreProviderBase实现删除过期session数据.

---

ApplicationName

---

主要session的范围,session-state提供者为每一个应用程序提供唯一的存储信息.这允许多个ASP.NET应用程序使用同一个数据源在完全相同的session标识相遇时也不会运行冲突.

因为session-state提供者为每一个应用程序提供唯一的存储信息,所以你必须确保你的数据模式,查询,和更新都包括应用程序名.如,下面命令使用从数据库中找回session数据.

SELECT * FROM Sessions
  WHERE SessionID = 'ABC123' AND ApplicationName = 'MyApplication'

你能存储结合session标识和应用程序名两者都需要为一个存储在数据存储中session创建唯一的标识.

---

Required Classes

---

去实现一个session-state 存储提供者,创建一个类继承SessionStateStoreProviderBase抽像类.这个SessionStateStoreProviderBase继承ProviderBase abstract class,所以你必须实现ProviderBase 的所需成员.下面表格是你必须实现的ProviderBase and SessionStateStoreProviderBase抽像类的方法和属性并且提供每一个描述.

---

Required ProviderBase Members

---

---

Initialize方法 

---

获得输入的提供者的名和一个配置设置的NameValueCollection实例.这个方法被使用来为提供者实例设置属性值,包括指定实现的值和指定可选的.

---

Required SessionStateStoreProvider Members

---

---

InitializeRequest method

---

传入为当前请求的HttpContext实例和为你session-state存储提供者执行任何所需的初始化.

---

EndRequest方法

---

传入为当前请求的HttpContext实例并且执行所有的session-state store provider所需的清出工作.

Dispose放

释放所有session-state store provider不再使用的资源.

---

GetItemExclusive方法

---

获得为当前请求传入HttpContext实例和当前请求的SessionID值.从session数据存储中找session值和信息并且在请求期间锁住session-item数据.GetItemExclusive方法设置提供给几个参数值来告诉正在调用的SessionStateModule关于当前存储在数据存储中session-state item的状态.
更多在

---

GetItem 方法

---

这个方法执行工作就像GetItemExclusive 方法样,只是除没有追加lock到session item上.这个GetItem方法是在EnableSessionState attribute 设置为 ReadOnly时调用.

---

SetAndReleaseItemExclusive 方法

---

在这里有

---

ReleaseItemExclusive方法

---

传入当前去请求的HttpContext实例和当前请求的这个sessionID值,并且当前请求的lock标识,还有释放在数据存储中item的的lock.这个方法是当GetItem或GetItemExclusive方法被调用时调用并且在数据存储中指定的被请求item被锁,但锁已经超过ExcutioinTimeout属性的值.这个方法会清楚琐,为其他请求释放item.

---

RemoveItem 方法

---

传入 当前请求的HttpContext instance,和SessionID值和锁的标识,并且当前支持琐标识的应用程序中删除在数据存储中与提供的SessionID值相匹配的session信息.这个方法在调用Abandon 方法时被调用.

---

CreateUninitializedItem方法

---

传入当前去请求的HttpContext实例和当前请求的这个sessionID值,并且当前请求的lock标识,和使用InitializeItem的actionFlags值添加一个非初始化的item进入session数据存储.

CreateUninitializedItem 方法使用当regenerateExpiredSessionId 属性设置为true时的cookieless sessions,原因是当sessionID遭遇过期时,SessinStateModule产生一个新的SessionID值.
在产生一个新的SessionID值的过程需要浏览器被重定向URL中包括新产生的session ID.CreateUninitializedItem方法被调用期间一个初始化请求包括一个过期的sessionID.之后SessionStateModule获得一个新的SessionID值替换过期的SessionID,它调用CreateUninitializedItem方法添加一个没初始化的session item进入session数据存储中.这时浏览器仍然要重定向URL包括新的SessionID值.这时的没有初始化session item已经进入session数据存储中并已经存在是为确保用已经产生新的SessionID值来重定向的请求没有一个请求过期session的错误,并且是已经经过处理的session.

这里的没初始化的session item进入session数据存储结合新产生的SessionID值并且包括现有的默认值,包含过期时间和具体时间,和一个符合GetItem和GetItemExclusive 方法sactionFlags参数的值.这个没初始化的session item进入session数据存储应该包括一个与InitializeItem 枚举值相等的actionFlags值.这个值被GetItem 和 GetItemExclusive传给SessionStateModule,并为SessionStateModule指定当前session是为一个新的session.SessionStateModule将初始化新的session并调用Session_OnStart 事件.

---

CreateNewStoreData 方法

---

传入当前去请求的HttpContext实例和当前请求的这个session的Timeout值,并且返回一个新的SessionStateStoreData对象,实现一个空的ISessionStateItemCollection 对象,一个HttpStaticObjectsCollection集合,和指定Timeout值.这里的HttpStaticObjectsCollection实例可以使用在ASP.NET应用程序中使用GetSessionStaticObjce方法找回.

---

SetItemExpireCallback方法

---

传入一个定义在Global.asax文件中的Session_OnEnd 委托.如果session-state 存储提供者支持Session_OnEnd事件,那就设置一个本地引用SessionStateItemExpireCallback 参数.这个方法会返回true,另外的方法返回false.

---

一个Session-State Store Provider的事例

---

Sample Session-State Store Provider

描述一个自定义的 sessioin-state存储提供者实现使用ODBC.使用.NET Framework data 提供者访问数据库管理session信息.

下面包括一个session-state store-provide的实现的事例.数据提供者是使用System.Data.Odbc 类去存储并且找会session信息.

---

一 数据库设计:

---

使用一个表名为Session 去管理session信息.并去创建这个表通过提供者访问它并,发给其他使用者.你可以在你的现在有的Access数据库中创建这个表:

CREATE TABLE Sessions
(
  SessionId       Text(80)  NOT NULL,
  ApplicationName Text(255) NOT NULL,
  Created         DateTime  NOT NULL,
  Expires         DateTime  NOT NULL,
  LockDate        DateTime  NOT NULL,
  LockId          Integer   NOT NULL,
  Timeout         Integer   NOT NULL,
  Locked          YesNo     NOT NULL,
  SessionItems    Memo,
  Flags           Integer   NOT NULL,
    CONSTRAINT PKSessions PRIMARY KEY (SessionId, ApplicationName)
)

---

二:事件日志的访问

---

如果当正在工作的数据源,简单的提供者遇到异常,它将这个异常的详细内容写如应用程序事件日志中,替代拉ASP.NET应用程序的异常.这样做是为来确保安全性避免数据源的有私有信息暴露在ASP.NET应用程序上.

这个sample提供者在你的ASP.NET应用程序将异常成功写入Application Event Log之前,你需要指定一个OdbcSessionStateStore事件源的属性值.

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application\OdbcSessionStateStore

如果不要这个sample提供写异常到Event Log里面你可以在你的Web.config文件中将writeExceptionsToEventLog属性设置为false;

---

三:支持Session_OnEnd 事件

---

这个sample session-state存储提供者不支持在Global.asax文件中的Session_OnEnd事件,主要在访问数据库时没有办法为session-state存储提供者通报一个session已经已经过期,超级时.这里的session-state存储提供者必须查询相关的信息.你不能预见当session-state store provider将在什么时候使用,并且因此它不像Session_OnEnd事件能准确的时间单出session的time-out.所以设置SetItemExpireCallback方法实现在sample中session-state store provider中返回一个false.相关SessionStateModule 对Session_OnEnd事件不只的信息.

---

四:Cleaning Up Expired Session Data

---

因为sample session-state store provider不提供支持Session_OnEnd事件,它不能自动清除过期的session-item 数据.我们推荐的方法是你定期性从你的数据存储中的删除过期的session 信息.

string commandString = "DELETE FROM Sessions WHERE Expires < ?";
OdbcConnection conn = new OdbcConnection(connectionString);
OdbcCommand cmd = new OdbcCommand(commandString, conn);
cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value = DateTime.Now;
conn.Open();
cmd.ExecuteNonQuery();
conn.Close();

---

五:Building the Sample Provider

---

为使用这个sample的provider,你将你的源代码放入App_Code中.注意如果你已经有源代码放入这个文件夹中,你必须添加这个sample的provider的版本.这个provider将被ASP.NET按照需编译.

你还能编译sample的提供者为库并切放它在Bin文件中,或trongly name它并放如GAC中.下面命令Show的是怎样使用Command-line编译器编译这个sample的provider.
在编译后,在sample中的文件名OdbcSessionStateStore.cs .

csc /out:OdbcSessionStateStore.dll /t:library OdbcSessionStateStore.cs /r:System.Web.dll /r:System.Configuration.dll

---

六 Using the Sample Provider in an ASP.NET Application

---

下面事例Show的是在Web.Config文件中配置使用sample的provider.使用ODBC DSN名为"SessionState",用这个来获得连接Access数据库的信息.使用这个Sample的provider,您将需要既要创建"SessionState" System DSN也要应用有效的ODBC连接字符串.

下面是你的Web site 的配置文件,使用forms authentication和包括ASP.NET页面调用login.aspx来让你的用户登陆.

<configuration>
  <connectionStrings>
    <add name="OdbcSessionServices" connectionString="DSN=SessionState;" />
  </connectionStrings>

  <system.web>
    <sessionState
      cookieless="true"
      regenerateExpiredSessionId="true"
      mode="Custom"
      customProvider="OdbcSessionProvider">
      <providers>
        <add name="OdbcSessionProvider"
          type="Samples.AspNet.Session.OdbcSessionStateStore"
          connectionStringName="OdbcSessionServices"
          writeExceptionsToEventLog="false" />
      </providers>
    </sessionState>
  </system.web>
</configuration>

 

---

a session-state store provider implementation

---

下面代码事例Show的是怎样实现a session-state store provider.

Code
using System;
using System.Web;
using System.Web.Configuration;
using System.Configuration;
using System.Configuration.Provider;
using System.Collections.Specialized;
using System.Web.SessionState;
using System.Data;
using System.Data.Odbc;
using System.Diagnostics;
using System.IO;


/**//*
This session state store provider supports the following schema:

  CREATE TABLE Sessions
  (
    SessionId       Text(80)  NOT NULL,
    ApplicationName Text(255) NOT NULL,
    Created         DateTime  NOT NULL,
    Expires         DateTime  NOT NULL,
    LockDate        DateTime  NOT NULL,
    LockId          Integer   NOT NULL,
    Timeout         Integer   NOT NULL,
    Locked          YesNo     NOT NULL,
    SessionItems    Memo,
    Flags           Integer   NOT NULL,
      CONSTRAINT PKSessions PRIMARY KEY (SessionId, ApplicationName)
  )

This session state store provider does not automatically clean up 
expired session item data. It is recommended
that you periodically delete expired session information from the
data store with the following code (where 'conn' is the OdbcConnection
for the session state store provider):

  string commandString = "DELETE FROM Sessions WHERE Expires < ?";
  OdbcConnection conn = new OdbcConnection(connectionString);
  OdbcCommand cmd = new OdbcCommand(commandString, conn);
  cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value = DateTime.Now;
  conn.Open();
  cmd.ExecuteNonQuery();
  conn.Close();

*/

namespace Samples.AspNet.Session
{

  public sealed class OdbcSessionStateStore : SessionStateStoreProviderBase
  {
    private SessionStateSection pConfig = null;
    private string connectionString;
    private ConnectionStringSettings pConnectionStringSettings;
    private string eventSource = "OdbcSessionStateStore";
    private string eventLog = "Application";
    private string exceptionMessage = 
      "An exception occurred. Please contact your administrator.";
    private string pApplicationName;


    //
    // If false, exceptions are thrown to the caller. If true,
    // exceptions are written to the event log.
    //

    private bool pWriteExceptionsToEventLog = false;

    public bool WriteExceptionsToEventLog
    {
      get { return pWriteExceptionsToEventLog; }
      set { pWriteExceptionsToEventLog = value; }
    }


    //
    // The ApplicationName property is used to differentiate sessions
    // in the data source by application.
    //

    public string ApplicationName
    {
      get { return pApplicationName; }
    }


    public override void Initialize(string name, NameValueCollection config)
    {
      //
      // Initialize values from web.config.
      //

      if (config == null)
        throw new ArgumentNullException("config");

      if (name == null || name.Length == 0)
        name = "OdbcSessionStateStore";

      if (String.IsNullOrEmpty(config["description"]))
      {
        config.Remove("description");
        config.Add("description", "Sample ODBC Session State Store provider");
      }

      // Initialize the abstract base class.
      base.Initialize(name, config);


      //
      // Initialize the ApplicationName property.
      //

      pApplicationName = 
        System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath;


      //
      // Get <sessionState> configuration element.
      //

      Configuration cfg =
        WebConfigurationManager.OpenWebConfiguration(ApplicationName);
      pConfig = 
        (SessionStateSection)cfg.GetSection("system.web/sessionState");


      //
      // Initialize connection string.
      //

      pConnectionStringSettings = 
        ConfigurationManager.ConnectionStrings[config["connectionStringName"]];

      if (pConnectionStringSettings == null || 
        pConnectionStringSettings.ConnectionString.Trim() == "")
      {
        throw new ProviderException("Connection string cannot be blank.");
      }

      connectionString = pConnectionStringSettings.ConnectionString;


      //
      // Initialize WriteExceptionsToEventLog
      //

      pWriteExceptionsToEventLog = false;

      if (config["writeExceptionsToEventLog"] != null)
      {
        if (config["writeExceptionsToEventLog"].ToUpper() == "TRUE") 
          pWriteExceptionsToEventLog = true;
      }
    }


    //
    // SessionStateStoreProviderBase members
    //

    public override void Dispose()
    {
    }


    //
    // SessionStateProviderBase.SetItemExpireCallback
    //

    public override bool SetItemExpireCallback(SessionStateItemExpireCallback expireCallback)
    {
      return false;
    }


    //
    // SessionStateProviderBase.SetAndReleaseItemExclusive
    //

    public override void SetAndReleaseItemExclusive(HttpContext context,
      string id,
      SessionStateStoreData item,
      object lockId,
      bool newItem)                                           
    {
      // Serialize the SessionStateItemCollection as a string.
      string sessItems = Serialize((SessionStateItemCollection)item.Items);

      OdbcConnection conn = new OdbcConnection(connectionString);
      OdbcCommand cmd;
      OdbcCommand deleteCmd = null;

      if (newItem)
      {
        // OdbcCommand to clear an existing expired session if it exists.
        deleteCmd = new OdbcCommand("DELETE FROM Sessions " +
            "WHERE SessionId = ? AND ApplicationName = ? AND Expires < ?", conn);
        deleteCmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
        deleteCmd.Parameters.Add
          ("@ApplicationName", OdbcType.VarChar, 255).Value = ApplicationName;
        deleteCmd.Parameters.Add
          ("@Expires", OdbcType.DateTime).Value = DateTime.Now;

        // OdbcCommand to insert the new session item.
        cmd = new OdbcCommand("INSERT INTO Sessions " +
          " (SessionId, ApplicationName, Created, Expires, " +
          "  LockDate, LockId, Timeout, Locked, SessionItems, Flags) " +
          " Values(?, ?, ?, ?, ?, ? , ?, ?, ?, ?)", conn);
        cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
        cmd.Parameters.Add
          ("@ApplicationName", OdbcType.VarChar, 255).Value = ApplicationName;
        cmd.Parameters.Add
          ("@Created", OdbcType.DateTime).Value = DateTime.Now;
        cmd.Parameters.Add
          ("@Expires", OdbcType.DateTime).Value = DateTime.Now.AddMinutes((Double)item.Timeout);
        cmd.Parameters.Add
          ("@LockDate", OdbcType.DateTime).Value = DateTime.Now;
        cmd.Parameters.Add("@LockId", OdbcType.Int).Value = 0;
        cmd.Parameters.Add
          ("@Timeout", OdbcType.Int).Value = item.Timeout;
        cmd.Parameters.Add("@Locked", OdbcType.Bit).Value = false;
        cmd.Parameters.Add
          ("@SessionItems", OdbcType.VarChar, sessItems.Length).Value = sessItems;
        cmd.Parameters.Add("@Flags", OdbcType.Int).Value = 0;
      }
      else
      {
        // OdbcCommand to update the existing session item.
        cmd = new OdbcCommand(
          "UPDATE Sessions SET Expires = ?, SessionItems = ?, Locked = ? " +
          " WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
        cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value = 
          DateTime.Now.AddMinutes((Double)item.Timeout);
        cmd.Parameters.Add("@SessionItems", 
          OdbcType.VarChar, sessItems.Length).Value = sessItems;
        cmd.Parameters.Add("@Locked", OdbcType.Bit).Value = false;
        cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
        cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
          255).Value = ApplicationName;
        cmd.Parameters.Add("@LockId", OdbcType.Int).Value = lockId;
      }

      try
      {
        conn.Open();

        if (deleteCmd != null)
          deleteCmd.ExecuteNonQuery();

        cmd.ExecuteNonQuery();
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "SetAndReleaseItemExclusive");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        conn.Close();
      }
    }


    //
    // SessionStateProviderBase.GetItem
    //

    public override SessionStateStoreData GetItem(HttpContext context,
      string id,
      out bool locked,
      out TimeSpan lockAge,
      out object lockId,
      out SessionStateActions actionFlags)
    {
      return GetSessionStoreItem(false, context, id, out locked,
        out lockAge, out lockId, out actionFlags);
    }


    //
    // SessionStateProviderBase.GetItemExclusive
    //

    public override SessionStateStoreData GetItemExclusive(HttpContext context, 
      string id,
      out bool locked,
      out TimeSpan lockAge,
      out object lockId,
      out SessionStateActions actionFlags)
    {
      return GetSessionStoreItem(true, context, id, out locked, 
        out lockAge, out lockId, out actionFlags);
    }


    //
    // GetSessionStoreItem is called by both the GetItem and 
    // GetItemExclusive methods. GetSessionStoreItem retrieves the 
    // session data from the data source. If the lockRecord parameter
    // is true (in the case of GetItemExclusive), then GetSessionStoreItem
    // locks the record and sets a new LockId and LockDate.
    //

    private SessionStateStoreData GetSessionStoreItem(bool lockRecord,
      HttpContext context, 
      string id,
      out bool locked,
      out TimeSpan lockAge,
      out object lockId,
      out SessionStateActions actionFlags)
    {
      // Initial values for return value and out parameters.
      SessionStateStoreData item = null;
      lockAge = TimeSpan.Zero;
      lockId = null;
      locked = false;
      actionFlags = 0;

      // ODBC database connection.
      OdbcConnection conn = new OdbcConnection(connectionString);
      // OdbcCommand for database commands.
      OdbcCommand cmd = null;              
      // DataReader to read database record.
      OdbcDataReader reader = null;  
      // DateTime to check if current session item is expired.
      DateTime expires;              
      // String to hold serialized SessionStateItemCollection.
      string serializedItems = "";
      // True if a record is found in the database.
       bool foundRecord = false;    
      // True if the returned session item is expired and needs to be deleted.
       bool deleteData = false;             
      // Timeout value from the data store.
      int timeout = 0;               

      try
      {
        conn.Open();

        // lockRecord is true when called from GetItemExclusive and
        // false when called from GetItem.
        // Obtain a lock if possible. Ignore the record if it is expired.
        if (lockRecord)
        {
          cmd = new OdbcCommand(
            "UPDATE Sessions SET" +
            " Locked = ?, LockDate = ? " +
            " WHERE SessionId = ? AND ApplicationName = ? AND Locked = ? AND Expires > ?", conn);
          cmd.Parameters.Add("@Locked", OdbcType.Bit).Value = true;
          cmd.Parameters.Add("@LockDate", OdbcType.DateTime).Value 
            = DateTime.Now;
          cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
          cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
            255).Value = ApplicationName;
          cmd.Parameters.Add("@Locked", OdbcType.Int).Value = false;
          cmd.Parameters.Add
            ("@Expires", OdbcType.DateTime).Value = DateTime.Now;

          if (cmd.ExecuteNonQuery() == 0)
            // No record was updated because the record was locked or not found.
            locked = true;             
          else
            // The record was updated.

            locked = false;
          }

        // Retrieve the current session item information.
        cmd = new OdbcCommand(
          "SELECT Expires, SessionItems, LockId, LockDate, Flags, Timeout " +
          "  FROM Sessions " +
          "  WHERE SessionId = ? AND ApplicationName = ?", conn);
        cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
        cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
          255).Value = ApplicationName;

        // Retrieve session item data from the data source.
        reader = cmd.ExecuteReader(CommandBehavior.SingleRow);
        while (reader.Read())
        {
          expires = reader.GetDateTime(0);

          if (expires < DateTime.Now)
          {
            // The record was expired. Mark it as not locked.
            locked = false;     
            // The session was expired. Mark the data for deletion.
            deleteData = true;
            }
          else
            foundRecord = true;

          serializedItems = reader.GetString(1);
          lockId = reader.GetInt32(2);
          lockAge = DateTime.Now.Subtract(reader.GetDateTime(3));
          actionFlags = (SessionStateActions)reader.GetInt32(4);
          timeout = reader.GetInt32(5);
        }
        reader.Close();


        // If the returned session item is expired, 
        // delete the record from the data source.
        if (deleteData)   
        {
          cmd = new OdbcCommand("DELETE FROM Sessions " +
            "WHERE SessionId = ? AND ApplicationName = ?", conn);
          cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
          cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
            255).Value = ApplicationName;

          cmd.ExecuteNonQuery();
        }

        // The record was not found. Ensure that locked is false.
        if (!foundRecord)
          locked = false;

        // If the record was found and you obtained a lock, then set 
        // the lockId, clear the actionFlags,
        // and create the SessionStateStoreItem to return.
        if (foundRecord && !locked)
        {
          lockId = (int)lockId + 1;

          cmd = new OdbcCommand("UPDATE Sessions SET" +
            " LockId = ?, Flags = 0 " +
            " WHERE SessionId = ? AND ApplicationName = ?", conn);
          cmd.Parameters.Add("@LockId", OdbcType.Int).Value = lockId;
          cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
          cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 255).Value = ApplicationName;

          cmd.ExecuteNonQuery();

          // If the actionFlags parameter is not InitializeItem, 
          // deserialize the stored SessionStateItemCollection.
          if (actionFlags == SessionStateActions.InitializeItem)
            item = CreateNewStoreData(context, pConfig.Timeout.Minutes);
          else
            item = Deserialize(context, serializedItems, timeout);
        }
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "GetSessionStoreItem");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        if (reader != null) { reader.Close(); }
        conn.Close();
      } 

      return item;
    }




    //
    // Serialize is called by the SetAndReleaseItemExclusive method to 
    // convert the SessionStateItemCollection into a Base64 string to    
    // be stored in an Access Memo field.
    //

    private string Serialize(SessionStateItemCollection items)
    {
      MemoryStream ms = new MemoryStream();
      BinaryWriter writer = new BinaryWriter(ms);

      if (items != null)
        items.Serialize(writer);

      writer.Close();

      return Convert.ToBase64String(ms.ToArray());
    }

    //
    // DeSerialize is called by the GetSessionStoreItem method to 
    // convert the Base64 string stored in the Access Memo field to a 
    // SessionStateItemCollection.
    //

    private SessionStateStoreData Deserialize(HttpContext context, 
      string serializedItems, int timeout)
    {
      MemoryStream ms = 
        new MemoryStream(Convert.FromBase64String(serializedItems));

      SessionStateItemCollection sessionItems =
        new SessionStateItemCollection();

      if (ms.Length > 0)
      {
          BinaryReader reader = new BinaryReader(ms);
          sessionItems = SessionStateItemCollection.Deserialize(reader);
      }

      return new SessionStateStoreData(sessionItems,
        SessionStateUtility.GetSessionStaticObjects(context),
        timeout);
    }

    //
    // SessionStateProviderBase.ReleaseItemExclusive
    //

    public override void ReleaseItemExclusive(HttpContext context,
      string id,
      object lockId)
    {
      OdbcConnection conn = new OdbcConnection(connectionString);
      OdbcCommand cmd = 
        new OdbcCommand("UPDATE Sessions SET Locked = 0, Expires = ? " +
        "WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
      cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value = 
        DateTime.Now.AddMinutes(pConfig.Timeout.Minutes);
      cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
      cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
        255).Value = ApplicationName;
      cmd.Parameters.Add("@LockId", OdbcType.Int).Value = lockId;

      try
      {
        conn.Open();

        cmd.ExecuteNonQuery();
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "ReleaseItemExclusive");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        conn.Close();
      }      
    }


    //
    // SessionStateProviderBase.RemoveItem
    //

    public override void RemoveItem(HttpContext context,
      string id,
      object lockId,
      SessionStateStoreData item)
    {
      OdbcConnection conn = new OdbcConnection(connectionString);
      OdbcCommand cmd = new OdbcCommand("DELETE * FROM Sessions " +
        "WHERE SessionId = ? AND ApplicationName = ? AND LockId = ?", conn);
      cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
      cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
        255).Value = ApplicationName;
      cmd.Parameters.Add("@LockId", OdbcType.Int).Value = lockId;

      try
      {
        conn.Open();

        cmd.ExecuteNonQuery();
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "RemoveItem");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        conn.Close();
      } 
    }



    //
    // SessionStateProviderBase.CreateUninitializedItem
    //

    public override void CreateUninitializedItem(HttpContext context,
      string id,
      int timeout)
    {
       OdbcConnection conn = new OdbcConnection(connectionString);
       OdbcCommand cmd = new OdbcCommand("INSERT INTO Sessions " +
         " (SessionId, ApplicationName, Created, Expires, " +
         "  LockDate, LockId, Timeout, Locked, SessionItems, Flags) " +
         " Values(?, ?, ?, ?, ?, ? , ?, ?, ?, ?)", conn);
      cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
      cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
        255).Value = ApplicationName;
      cmd.Parameters.Add("@Created", OdbcType.DateTime).Value 
        = DateTime.Now;
      cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value 
        = DateTime.Now.AddMinutes((Double)timeout);
      cmd.Parameters.Add("@LockDate", OdbcType.DateTime).Value 
        = DateTime.Now;
      cmd.Parameters.Add("@LockId", OdbcType.Int).Value = 0;
      cmd.Parameters.Add("@Timeout", OdbcType.Int).Value = timeout;
      cmd.Parameters.Add("@Locked", OdbcType.Bit).Value = false;
      cmd.Parameters.Add("@SessionItems", OdbcType.VarChar, 0).Value = "";
      cmd.Parameters.Add("@Flags", OdbcType.Int).Value = 1;

      try
      {
        conn.Open();

        cmd.ExecuteNonQuery();
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "CreateUninitializedItem");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        conn.Close();
      }
    }


    //
    // SessionStateProviderBase.CreateNewStoreData
    //

    public override SessionStateStoreData CreateNewStoreData(
      HttpContext context,
      int timeout)
    {
      return new SessionStateStoreData(new SessionStateItemCollection(),
        SessionStateUtility.GetSessionStaticObjects(context),
        timeout);
    }



    //
    // SessionStateProviderBase.ResetItemTimeout
    //

    public override void ResetItemTimeout(HttpContext context,
                                          string id)
    {
      OdbcConnection conn = new OdbcConnection(connectionString);
      OdbcCommand cmd = 
        new OdbcCommand("UPDATE Sessions SET Expires = ? " +
        "WHERE SessionId = ? AND ApplicationName = ?", conn);
      cmd.Parameters.Add("@Expires", OdbcType.DateTime).Value 
        = DateTime.Now.AddMinutes(pConfig.Timeout.Minutes);
      cmd.Parameters.Add("@SessionId", OdbcType.VarChar, 80).Value = id;
      cmd.Parameters.Add("@ApplicationName", OdbcType.VarChar, 
        255).Value = ApplicationName;

      try
      {
        conn.Open();

        cmd.ExecuteNonQuery();
      }
      catch (OdbcException e)
      {
        if (WriteExceptionsToEventLog)
        {
          WriteToEventLog(e, "ResetItemTimeout");
          throw new ProviderException(exceptionMessage);
        }
        else
          throw e;
      }
      finally
      {
        conn.Close();
      }
    }


    //
    // SessionStateProviderBase.InitializeRequest
    //

    public override void InitializeRequest(HttpContext context)
    {
    }


    //
    // SessionStateProviderBase.EndRequest
    //

    public override void EndRequest(HttpContext context)
    {
    }


    //
    // WriteToEventLog
    // This is a helper function that writes exception detail to the 
    // event log. Exceptions are written to the event log as a security
    // measure to ensure private database details are not returned to 
    // browser. If a method does not return a status or Boolean
    // indicating the action succeeded or failed, the caller also 
    // throws a generic exception.
    //

    private void WriteToEventLog(Exception e, string action)
    {
      EventLog log = new EventLog();
      log.Source = eventSource;
      log.Log = eventLog;

      string message = 
        "An exception occurred communicating with the data source.\n\n";
      message += "Action: " + action + "\n\n";
      message += "Exception: " + e.ToString();

      log.WriteEntry(message);
    }
  }
}

这里还有相关问题的讨论
http://www.cnblogs.com/Pierce/archive/2005/08/05/208048.html
worksguo