SessionStateUtility Класс

Определение

Предоставляет вспомогательные методы, которые используются модулями и поставщиками хранилища состояния сеанса для управления данными сеанса для приложения ASP.NET. Этот класс не наследуется.

public static class SessionStateUtility
Наследование
SessionStateUtility

Примеры

В следующем примере кода показана реализация пользовательского модуля состояния сеанса, который хранит сведения о сеансе в памяти с помощью Hashtable. Модуль использует SessionStateUtility класс для ссылки на текущий HttpContext и SessionIDManager, извлекает текущий HttpStaticObjectsCollectionи вызывает событие Session_OnEnd , определенное в файле Global.asax для приложения ASP.NET. Это приложение не запрещает одновременным веб-запросам использовать один и тот же идентификатор сеанса.

using System;
using System.Web;
using System.Web.SessionState;
using System.Collections;
using System.Threading;
using System.Web.Configuration;
using System.Configuration;

namespace Samples.AspNet.SessionState
{

    public sealed class MySessionStateModule : IHttpModule, IDisposable
    {
        private Hashtable pSessionItems = new Hashtable();
        private Timer pTimer;
        private int pTimerSeconds = 10;
        private bool pInitialized = false;
        private int pTimeout;
        private HttpCookieMode pCookieMode = HttpCookieMode.UseCookies;
        private ReaderWriterLock pHashtableLock = new ReaderWriterLock();
        private ISessionIDManager pSessionIDManager;
        private SessionStateSection pConfig;

        // The SessionItem class is used to store data for a particular session along with
        // an expiration date and time. SessionItem objects are added to the local Hashtable
        // in the OnReleaseRequestState event handler and retrieved from the local Hashtable
        // in the OnAcquireRequestState event handler. The ExpireCallback method is called
        // periodically by the local Timer to check for all expired SessionItem objects in the
        // local Hashtable and remove them.

        private class SessionItem
        {
            internal SessionStateItemCollection Items;
            internal HttpStaticObjectsCollection StaticObjects;
            internal DateTime Expires;
        }

        //
        // IHttpModule.Init
        //

        public void Init(HttpApplication app)
        {
            // Add event handlers.
            app.AcquireRequestState += new EventHandler(this.OnAcquireRequestState);
            app.ReleaseRequestState += new EventHandler(this.OnReleaseRequestState);

            // Create a SessionIDManager.
            pSessionIDManager = new SessionIDManager();
            pSessionIDManager.Initialize();

            // If not already initialized, initialize timer and configuration.
            if (!pInitialized)
            {
                lock (typeof(MySessionStateModule))
                {
                    if (!pInitialized)
                    {
                        // Create a Timer to invoke the ExpireCallback method based on
                        // the pTimerSeconds value (e.g. every 10 seconds).

                        pTimer = new Timer(new TimerCallback(this.ExpireCallback),
                                           null,
                                           0,
                                           pTimerSeconds * 1000);

                        // Get the configuration section and set timeout and CookieMode values.
                        Configuration cfg =
                          WebConfigurationManager.OpenWebConfiguration(System.Web.Hosting.HostingEnvironment.ApplicationVirtualPath);
                        pConfig = (SessionStateSection)cfg.GetSection("system.web/sessionState");

                        pTimeout = (int)pConfig.Timeout.TotalMinutes;
                        pCookieMode = pConfig.Cookieless;

                        pInitialized = true;
                    }
                }
            }
        }

        //
        // IHttpModule.Dispose
        //

        public void Dispose()
        {
            if (pTimer != null)
            {
                this.pTimer.Dispose();
               ((IDisposable)pTimer).Dispose();
            }
        }

        //
        // Called periodically by the Timer created in the Init method to check for 
        // expired sessions and remove expired data.
        //

        void ExpireCallback(object state)
        {
            try
            {
                pHashtableLock.AcquireWriterLock(Int32.MaxValue);

                this.RemoveExpiredSessionData();
            }
            finally
            {
                pHashtableLock.ReleaseWriterLock();
            }
        }

        //
        // Recursivly remove expired session data from session collection.
        //
        private void RemoveExpiredSessionData()
        {
            string sessionID;

            foreach (DictionaryEntry entry in pSessionItems)
            {
                SessionItem item = (SessionItem)entry.Value;

                if ( DateTime.Compare(item.Expires, DateTime.Now)<=0 )
                {
                    sessionID = entry.Key.ToString();
                    pSessionItems.Remove(entry.Key);

                    HttpSessionStateContainer stateProvider =
                      new HttpSessionStateContainer(sessionID,
                                                   item.Items,
                                                   item.StaticObjects,
                                                   pTimeout,
                                                   false,
                                                   pCookieMode,
                                                   SessionStateMode.Custom,
                                                   false);

                    SessionStateUtility.RaiseSessionEnd(stateProvider, this, EventArgs.Empty);
                    this.RemoveExpiredSessionData();
                    break;
                }
            }
        }

        //
        // Event handler for HttpApplication.AcquireRequestState
        //

        private void OnAcquireRequestState(object source, EventArgs args)
        {
            HttpApplication app = (HttpApplication)source;
            HttpContext context = app.Context;
            bool isNew = false;
            string sessionID;
            SessionItem sessionData = null;
            bool supportSessionIDReissue = true;

            pSessionIDManager.InitializeRequest(context, false, out supportSessionIDReissue);
            sessionID = pSessionIDManager.GetSessionID(context);

            if (sessionID != null)
            {
                try
                {
                    pHashtableLock.AcquireReaderLock(Int32.MaxValue);
                    sessionData = (SessionItem)pSessionItems[sessionID];

                    if (sessionData != null)
                       sessionData.Expires = DateTime.Now.AddMinutes(pTimeout);
                }
                finally
                {
                    pHashtableLock.ReleaseReaderLock();
                }
            }
            else
            {
                bool redirected, cookieAdded;

                sessionID = pSessionIDManager.CreateSessionID(context);
                pSessionIDManager.SaveSessionID(context, sessionID, out redirected, out cookieAdded);

                if (redirected)
                    return;
            }

            if (sessionData == null)
            {
                // Identify the session as a new session state instance. Create a new SessionItem
                // and add it to the local Hashtable.

                isNew = true;

                sessionData = new SessionItem();

                sessionData.Items = new SessionStateItemCollection();
                sessionData.StaticObjects = SessionStateUtility.GetSessionStaticObjects(context);
                sessionData.Expires = DateTime.Now.AddMinutes(pTimeout);

                try
                {
                    pHashtableLock.AcquireWriterLock(Int32.MaxValue);
                    pSessionItems[sessionID] = sessionData;
                }
                finally
                {
                    pHashtableLock.ReleaseWriterLock();
                }
            }

            // Add the session data to the current HttpContext.
            SessionStateUtility.AddHttpSessionStateToContext(context,
                             new HttpSessionStateContainer(sessionID,
                                                          sessionData.Items,
                                                          sessionData.StaticObjects,
                                                          pTimeout,
                                                          isNew,
                                                          pCookieMode,
                                                          SessionStateMode.Custom,
                                                          false));

            // Execute the Session_OnStart event for a new session.
            if (isNew && Start != null)
            {
                Start(this, EventArgs.Empty);
            }
        }

        //
        // Event for Session_OnStart event in the Global.asax file.
        //

        public event EventHandler Start;

        //
        // Event handler for HttpApplication.ReleaseRequestState
        //

        private void OnReleaseRequestState(object source, EventArgs args)
        {
            HttpApplication app = (HttpApplication)source;
            HttpContext context = app.Context;
            string sessionID;

            // Read the session state from the context
            HttpSessionStateContainer stateProvider =
              (HttpSessionStateContainer)(SessionStateUtility.GetHttpSessionStateFromContext(context));

            // If Session.Abandon() was called, remove the session data from the local Hashtable
            // and execute the Session_OnEnd event from the Global.asax file.
            if (stateProvider.IsAbandoned)
            {
                try
                {
                    pHashtableLock.AcquireWriterLock(Int32.MaxValue);

                    sessionID = pSessionIDManager.GetSessionID(context);
                    pSessionItems.Remove(sessionID);
                }
                finally
                {
                    pHashtableLock.ReleaseWriterLock();
                }

                SessionStateUtility.RaiseSessionEnd(stateProvider, this, EventArgs.Empty);
            }

            SessionStateUtility.RemoveHttpSessionStateFromContext(context);
        }
    }
}

Чтобы использовать этот пользовательский модуль состояния сеанса в приложении ASP.NET, можно заменить существующую SessionStateModule ссылку в файле Web.config, как показано в следующем примере.

<configuration>
  <system.web>
    <httpModules>
      <remove name="Session" />
      <add name="Session"
      type="Samples.AspNet.SessionState.MySessionStateModule" />
    </httpModules>
  </system.web>
</configuration>

Комментарии

Класс предоставляет статические SessionStateUtility вспомогательные методы, используемые модулем состояния сеанса или поставщиком хранилища состояний сеанса. Разработчикам приложений не нужно будет вызывать эти методы из кода.

В следующей таблице описано, как модуль состояния сеанса и поставщик хранилища состояний сеансов используют методы.

Метод Использовать
Метод GetHttpSessionStateFromContext Может использоваться пользовательскими модулями состояния сеанса для получения сведений о сеансе для существующего сеанса или создания сведений о сеансе для нового сеанса.
Метод AddHttpSessionStateToContext Вызывается модулем состояния сеанса, чтобы добавить данные сеанса в текущий HttpContext и сделать их доступными для кода приложения с помощью Session свойства .
Метод RemoveHttpSessionStateFromContext Вызывается модулем состояния сеанса ReleaseRequestState во время событий или EndRequest в конце запроса для очистки данных сеанса из текущего HttpContext.
Метод GetSessionStaticObjects Вызывается модулем состояния сеанса для получения ссылки на коллекцию StaticObjects на основе объектов, определенных в файле Global.asax. Возвращаемая HttpStaticObjectsCollection коллекция включается в данные сеанса, добавленные в текущий HttpContextобъект .

Данные сеанса передаются и извлекаются из текущего HttpContext объекта в виде HttpSessionStateContainer объекта или любой допустимой IHttpSessionState реализации интерфейса.

Сведения о реализации поставщика хранилища состояний сеансов см. в разделе Реализация поставщика хранилища Session-State.

Свойства

SerializationSurrogateSelector

Получает или задает селектор суррогата сериализации, который используется для настройки сериализации сеанса.

Методы

AddHttpSessionStateToContext(HttpContext, IHttpSessionState)

Применяет данные о сеансе к контексту для текущего запроса.

GetHttpSessionStateFromContext(HttpContext)

Возвращает данные о сеансе из контекста для текущего запроса.

GetSessionStaticObjects(HttpContext)

Возвращает ссылку на коллекцию статичных объектов для указанного контекста.

IsSessionStateReadOnly(HttpContext)

Возвращает значение, которое указывает, является ли состояние сеанса доступным только для чтения для заданного HttpContext.

IsSessionStateRequired(HttpContext)

Возвращает значение, показывающее, требуется ли состояние сеанса для указанного контекста HttpContext.

RaiseSessionEnd(IHttpSessionState, Object, EventArgs)

Выполняет событие Session_OnEnd, заданное в файле Global.asax для приложения ASP.NET.

RemoveHttpSessionStateFromContext(HttpContext)

Удаляет данные о сеансе из указанного контекста.

Применяется к

Продукт Версии
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1

См. также раздел