Posso acessar o estado da sessão de um HttpModule?

Question

Eu poderia realmente fazer com atualizar as variáveis ??de sessão de um usuário de dentro do meu HTTPModule, mas pelo que posso ver, não é possível.

UPDATE:. Meu código está sendo executado dentro do manipulador de eventos OnBeginRequest ()

UPDATE: Seguindo o conselho recebido até agora, eu tentei adicionar isso para a rotina Init () na minha HTTPModule:

AddHandler context.PreRequestHandlerExecute, AddressOf OnPreRequestHandlerExecute

Mas na minha rotina OnPreRequestHandlerExecute, o estado da sessão ainda não está disponível!

Obrigado, e desculpas se eu estou faltando alguma coisa!

Answer 1

Encontrado sobre isso nos fóruns ASP.NET :

using System;
using System.Web;
using System.Web.Security;
using System.Web.SessionState;
using System.Diagnostics;

// This code demonstrates how to make session state available in HttpModule,
// regradless of requested resource.
// author: Tomasz Jastrzebski

public class MyHttpModule : IHttpModule
{
   public void Init(HttpApplication application)
   {
      application.PostAcquireRequestState += new EventHandler(Application_PostAcquireRequestState);
      application.PostMapRequestHandler += new EventHandler(Application_PostMapRequestHandler);
   }

   void Application_PostMapRequestHandler(object source, EventArgs e)
   {
      HttpApplication app = (HttpApplication)source;

      if (app.Context.Handler is IReadOnlySessionState || app.Context.Handler is IRequiresSessionState) {
         // no need to replace the current handler
         return;
      }

      // swap the current handler
      app.Context.Handler = new MyHttpHandler(app.Context.Handler);
   }

   void Application_PostAcquireRequestState(object source, EventArgs e)
   {
      HttpApplication app = (HttpApplication)source;

      MyHttpHandler resourceHttpHandler = HttpContext.Current.Handler as MyHttpHandler;

      if (resourceHttpHandler != null) {
         // set the original handler back
         HttpContext.Current.Handler = resourceHttpHandler.OriginalHandler;
      }

      // -> at this point session state should be available

      Debug.Assert(app.Session != null, "it did not work :(");
   }

   public void Dispose()
   {

   }

   // a temp handler used to force the SessionStateModule to load session state
   public class MyHttpHandler : IHttpHandler, IRequiresSessionState
   {
      internal readonly IHttpHandler OriginalHandler;

      public MyHttpHandler(IHttpHandler originalHandler)
      {
         OriginalHandler = originalHandler;
      }

      public void ProcessRequest(HttpContext context)
      {
         // do not worry, ProcessRequest() will not be called, but let's be safe
         throw new InvalidOperationException("MyHttpHandler cannot process requests.");
      }

      public bool IsReusable
      {
         // IsReusable must be set to false since class has a member!
         get { return false; }
      }
   }
}

Answer 2

HttpContext.Current.Session deve Basta trabalhar, assumindo que o seu HTTP Module não está a lidar com qualquer eventos gasoduto que ocorrer antes o ser o estado da sessão inicializado ...

EDIT, depois de esclarecimentos nos comentários: ao manusear a BeginRequest evento , o objeto de sessão, na verdade ainda vai ser nulo / Nada, como ele não foi inicializado pelo ASP.NET ainda tempo de execução. Para contornar esse problema, mover o código de manipulação de um evento que ocorre depois de PostAcquireRequestState - Eu gosto PreRequestHandlerExecute para que eu, como todo o trabalho de baixo nível é muito bem feito nesta fase, mas você ainda antecipar-se qualquer processamento normal.

Answer 3

Acessando o HttpContext.Current.Session em um IHttpModule pode ser feito no manipulador PreRequestHandlerExecute.

PreRequestHandlerExecute : "Ocorre pouco antes ASP.NET começa a executar um manipulador de eventos (por exemplo, uma página ou um XML Web Services)" Isso significa que antes de uma página 'aspx' é servido este evento é executado. O 'estado de sessão' está disponível para que você possa bater-se.

Exemplo:

public class SessionModule : IHttpModule 
    {
        public void Init(HttpApplication context)
        {
            context.BeginRequest += BeginTransaction;
            context.EndRequest += CommitAndCloseSession;
            context.PreRequestHandlerExecute += PreRequestHandlerExecute;
        }



        public void Dispose() { }

        public void PreRequestHandlerExecute(object sender, EventArgs e)
        {
            var context = ((HttpApplication)sender).Context;
            context.Session["some_sesion"] = new SomeObject();
        }
...
}

Answer 4

Se você estiver escrevendo um normal, básica HttpModule em um aplicativo gerenciado que você deseja aplicar aos pedidos ASP.NET através de páginas ou manipuladores, você apenas tem que ter certeza que você está usando um evento no ciclo de vida após a criação da sessão . PreRequestHandlerExecute vez de Begin_Request geralmente é onde eu vou. mdb tem direito em sua edição.

O código mais snippet originalmente listadas como responder a pergunta obras, mas é complicado e mais amplo do que a questão inicial. Ele vai lidar com o caso quando o conteúdo é proveniente de algo que não tem um manipulador ASP.net disponíveis onde você pode implementar a interface IRequiresSessionState, desencadeando assim o mecanismo de sessão para torná-lo disponível. (Como um arquivo GIF estático no disco). É basicamente definir um manipulador fictício que, em seguida, apenas implementa essa interface para fazer a sessão disponível.

Se você quiser apenas a sessão para o seu código, basta escolher o evento certo para lidar em seu módulo.

Answer 5

Experimente: na declarar classe MyHttpModule:

private HttpApplication contextapp;

Depois:

public void Init(HttpApplication application)
{
     //Must be after AcquireRequestState - the session exist after RequestState
     application.PostAcquireRequestState += new EventHandler(MyNewEvent);
     this.contextapp=application;
}  

E assim, em um outro método (o evento) na mesma classe:

public void MyNewEvent(object sender, EventArgs e)
{
    //A example...
    if(contextoapp.Context.Session != null)
    {
       this.contextapp.Context.Session.Timeout=30;
       System.Diagnostics.Debug.WriteLine("Timeout changed");
    }
}