一个比较高级的问题，请高手救命啊！！！有关Session反射的问题

处理DLLusing System;
using System.Web.SessionState;
namespace TestClass
{
/// <summary>
/// Class1 的摘要说明。
/// </summary>
public class TestClass
{
public TestClass()
{
//
// TODO: 在此处添加构造函数逻辑
//
} public string Test(System.Web.SessionState.HttpSessionState session)
{

return (session["test"].ToString()); }
}
}

解决方案 »

  1.   

    搞定了，用的是Session.GetType(),不能从System.Web.SessionState.HttpSessionState派生，那就意味着不要用Assembly调用,直接GetType就可以了
      

  2.   

    为什么不使用HttpHandler，反而要用这种曲折的办法呢？
      

  3.   

    ASP.NET 将 HTTP 请求映射到 HttpHandler。每个 HttpHandler 都能够处理应用程序中的单个 HTTP URL 或 URL 扩展组。HttpHandler 具有与 ISAPI 扩展相同的功能，但编程模型更简单。下表显示 ASP.NET 所提供的 HttpHandler 的示例。处理程序 说明 
    ASP.NET 页处理程序 (*.aspx) 用于所有 ASP.NET 页的默认 HttpHandler。 
    ASP.NET 服务处理程序 (*.asmx) 用于所有 ASP.NET 服务页的默认 HttpHandler。 HttpHandler 可以是同步或异步的。同步处理程序在完成对为其调用该处理程序的 HTTP 请求的处理后才会返回。异步处理程序通常启动可能很耗时的进程，并且在该进程完成前返回。在编写和编译实现 HttpHandler 的代码以后，必须使用应用程序的 Web.config 文件注册该处理程序。
    同步 HttpHandler 实现 System.Web.IHttpHandler 接口。异步 HttpHandler 实现 System.Web.IHttpAsyncHandler 接口。System.Web.IHttpAsyncHandler 接口从 System.Web.IHttpHandler 继承。这两个接口都需要实现 ProcessRequest 方法和 IsReusable 属性。ProcessRequest 处理单个 HTTP 请求。IsReusable 指定是否支持池。另外，System.Web.IHttpAsyncHandler 接口需要实现 BeginProcessRequest 和 EndProcessRequest 方法。BeginProcessRequest 启动异步调用以处理单个的 HTTP 请求，而 EndProcessRequest 则在该进程结束时执行清理代码。也可以通过实现 IHttpHandlerFactory 接口的类创建 HttpHandler 的实例。这可以更好地控制对 HTTP 请求的处理，因为这样可将 URL 映射到基于一组复杂条件创建不同处理程序的 HttpHandler 工厂。例如，通过 HttpHandler 工厂，可以在 HTTP 请求方法为 PUT 时为文件类型创建一个 HttpHandler，而在该方法为 GET 时创建另一个 HttpHandler。
     
    注册 HttpHandler在创建了自定义 HttpHandler 后，必须配置 ASP.NET 以便将传入的对特定 URL 的 HTTP 请求映射到处理程序。以下过程描述所需步骤。注册 HttpHandler 在应用程序的虚拟根目录下的 \bin 目录中编译和部署 HttpHandler 的 .NET 类。 
    在应用程序的 Web.config 配置文件中注册同步或异步的 HttpHandler。以下示例将所有 HTTP 请求映射到 Myhandler.dll 文件中 MyHandler 程序集的 MyHandler.New 类和 MyHandler.Fin 类。 
    <configuration>
        <system.web>
            <httpHandlers>
                <add verb="*" path="MyHandler.New" 
                   type="MyHandler.New, MyHandlerAssembly" />
                <add verb="*" path="*.myNewFileNameExtension" 
                   type="MyHandler.Fin, MyHandlerAssembly" />
            </httpHandlers>
        <system.web>
    </configuration><httpHandlers> 配置节中的项具有三个属性，如下表中所示。 属性 说明 
    路径 路径属性可以包含单个 URL 路径或简单的通配符字符串（例如 *.aspx）。 
    类型 指定逗号分隔的类/程序集组合。ASP.NET 首先在应用程序的专用 \bin 目录中搜索程序集 DLL，然后在系统程序集缓存中搜索程序集 DLL。 
    谓词 谓词列表可以是逗号分隔的 HTTP 方法列表（例如“GET, PUT, POST”），也可以是开始脚本映射（例如通配符 * [星号]）。 确保将 HttpHandler 文件扩展名注册到 Internet 信息服务 (IIS) 中。 
    HttpHandler 示例
    本节提供下列代码示例： 同步 HttpHandler 
    异步 HttpHandler 
    HttpHandler 工厂 
    同步 HttpHandler
    以下代码说明如何在 ASP.NET 应用程序中处理对特定的 MyApp.MyHello URL 的请求。接下来，将显示注册 HttpHandler 所需的配置文件更改。[C#]
    using System.Web;
    public class HelloWorldHandler : IHttpHandler {
        public void ProcessRequest(HttpContext context) {
            HttpRequest Request = context.Request;
            HttpResponse Response = context.Response;
            // A file ending in .MyHello need not exist. This handler executes
            // whenever a file ending in .MyHello is requested.
            Response.Write("<html>");
            Response.Write("<body>");
            Response.Write("<h1> Hello from Synchronous custom handler. </h1>");
            Response.Write("</body>");
            Response.Write("</html>");
        }
        public bool IsReusable {
            // To enable pooling, return true here.
            // This keeps the handler in memory.
            get { return false; }  
        }
    }[Visual Basic]
    Imports System.WebPublic Class HelloWorldHandler
        Implements IHttpHandler    Public Sub ProcessRequest(ByVal context As System.Web.HttpContext) Implements System.Web.IHttpHandler.ProcessRequest
            Dim request As HttpRequest = context.Request
            Dim response As HttpResponse = context.Response
            ' A file named ending in .MyHello need not exist. This handler 
            ' executes whenever a file ending in .MyHello is requested.
            response.Write("<html>")
            response.Write("<body>")
            response.Write("<h1> Hello from Synchronous custom handler. </h1>")
            response.Write("</body>")
            response.Write("</html>")
        End Sub    Public ReadOnly Property IsReusable() As Boolean Implements System.Web.IHttpHandler.IsReusable
            Get
                Return False
            End Get
        End Property
    End Class通过在 Web.config 中创建项来注册自定义 HttpHandler，如下所示：<configuration>
        <system.web>
            <httpHandlers>
               <add verb="*" path="*.MyHello" 
                    type="HelloWorldHandler,httpruntime" /> 
            </httpHandlers>
        </system.web>
    </configuration>
      

  4.   

    异步 HttpHandler
    以下代码说明如何在 ASP.NET 应用程序中注册和处理对特定的 *.MyAsynch URL 的请求。在这种情况下，处理程序启动一个很耗时的进程，在若干时刻向用户发送响应以指示进程。接下来，将显示注册 HttpHandler 所需的配置文件更改。[C#]
    using System;
    using System.Web;
    using System.Threading;namespace Handlers
    {
        class AsynchHandler : IHttpAsyncHandler
        {
            private HttpContext _context;
            public bool IsReusable
            {
                get
                {
                     // To enable pooling, return true here.
                     // This keeps the handler in memory.
                     return false;
                }
            }        public IAsyncResult BeginProcessRequest(HttpContext context,            AsyncCallback cb, Object extraData)
            {
                // Now do something that might take a while.
                MyAsynchOperation asynch = new MyAsynchOperation(cb, context);
                asynch.KickOffThread();            context.Response.Write("BeginProcessRequest. Just kicked off a Thread.<br>");
                context.Response.Flush();            // Signal the application that asynchronous 
                // processing is being performed. 
                SomeResult asynchForBegin = new SomeResult();            // Processing is not synchronous.
                asynchForBegin.SetSynch(false);            // Processing is not complete.
                asynchForBegin.SetCompleted(false);            _context = context;
                return new SomeResult();
            }        public void EndProcessRequest(IAsyncResult result)
            {
                _context.Response.Write("EndProcessRequest called.<br>");
            }        // This method is required but is not called.
            public void ProcessRequest(HttpContext context)
            {
            }    }//end class    public class SomeResult : IAsyncResult
        {    /*
        An instance of this class is returned to the application.
        This class lets the application know how the BeginEventHandler method     
        has been handled. The application checks the CompletedSynchronously     
        method.
        */        private bool _blnIsCompleted = false;
            private Mutex myMutex = null;
            private Object myAsynchStateObject = null;
            private bool _blnCompletedSynchronously = false;        public void SetCompleted(bool blnTrueOrFalse)
            {
                _blnIsCompleted = blnTrueOrFalse;
            }        public void SetSynch(bool blnTrueOrFalse)
            {
                _blnCompletedSynchronously = blnTrueOrFalse;
            }        public bool IsCompleted
            {
                // This is not called by the application. 
                // However, set it to true. 
                get { return _blnIsCompleted; }
            }        public WaitHandle AsyncWaitHandle
            {
                // The application does not call this method.         
                get { return myMutex; }
            }        public Object AsyncState
            {  
                // The application does not call this method because
                // null is passed in as the last parameter to 
                // BeginEventHandler.
                get { return myAsynchStateObject; }
           }        public bool CompletedSynchronously
            {
                // The application wants to know if this is synchronous.
                // Return true if the Begin method was called synchronously.
                get { return _blnCompletedSynchronously; }
            }
        }
    }[Visual Basic]
    Imports System
    Imports System.Web
    Imports System.ThreadingNamespace handler    Public Class AsynchHandler
            Implements IHttpAsyncHandler        Private _context As HttpContext
            Public ReadOnly Property IsReusable() As Boolean Implements System.Web.IHttpAsyncHandler.IsReusable
                Get
                    Return False
                End Get
            End Property        Public Function BeginProcessRequest(ByVal context As System.Web.HttpContext, ByVal cb As System.AsyncCallback, ByVal extraData As Object) As System.IAsyncResult Implements System.Web.IHttpAsyncHandler.BeginProcessRequest
                Dim asynch As New MyAsynchOperation(cb, context)
                asynch.KickOffThread()            context.Response.Write("BeginProcessRequest. Just kicked off a Thread.<br>")
                context.Response.Flush()
                ' Signal the application that asynchronous 
                ' processing is being performed. 
                Dim asynchForBegin As New SomeResult()           ' Processing is not synchronous.
                asynchForBegin.SetSynch(False)           ' Processing is not complete.
                asynchForBegin.SetCompleted(False)            _context = context            Return New SomeResult()
            End Function
            Public Sub EndProcessRequest(ByVal result As System.IAsyncResult) Implements System.Web.IHttpAsyncHandler.EndProcessRequest
                _context.Response.Write("EndProcessRequest called.<br>")
            End Sub        Public Sub ProcessRequest(ByVal context As System.Web.HttpContext) Implements System.Web.IHttpAsyncHandler.ProcessRequest
                ' Ths is required but is not called.
            End Sub
        End Class    Class SomeResult
            Implements IAsyncResult        Private _blnIsCompleted As Boolean = False
            Private myMutex As Mutex = Nothing
            Private myAsynchStateObject As Object = Nothing
            Private _blnCompletedSynchronously As Boolean = False        Public Sub SetCompleted(ByVal blnTrueOrFalse As Boolean)
                _blnIsCompleted = blnTrueOrFalse
            End Sub        Public Sub SetSynch(ByVal blnTrueOrFalse As Boolean)
                _blnCompletedSynchronously = blnTrueOrFalse
            End Sub        Public ReadOnly Property AsyncState() As Object Implements System.IAsyncResult.AsyncState
                Get
                    Return myAsynchStateObject
                End Get
            End Property        Public ReadOnly Property AsyncWaitHandle() As System.Threading.WaitHandle Implements System.IAsyncResult.AsyncWaitHandle
                Get
                    Return myMutex
                End Get
            End Property        Public ReadOnly Property CompletedSynchronously() As Boolean Implements System.IAsyncResult.CompletedSynchronously
                Get
                    Return _blnCompletedSynchronously
                End Get
            End Property        Public ReadOnly Property IsCompleted() As Boolean Implements System.IAsyncResult.IsCompleted
                Get
                    Return _blnIsCompleted
                End Get
            End Property
        End Class
    End Namespace通过在 Web.config 中创建项来注册自定义异步 HttpHandler，如下所示：<configuration>
        <system.web>
            <httpHandlers>
                <add verb="GET,POST" path="*.MyAsynch"
                     type="Handlers.AsynchHandler, Handlers" />
            </httpHandlers>
        </system.web>
    </configuration>
      

  5.   

    没加分辨就从MDSN贴了一大堆，反而不好弄了。自己去看MSDN吧。