軽量の Ajax コンポーネントを作成する 3 番目の実装

この記事では、主に軽量の Ajax コンポーネントを作成する 3 番目の実装を詳細に紹介します。これには特定の参考値があります。興味のある方は参照してください。

前の紹介を通じて、中核となるのはリフレクションです。リクエストからパラメータを取得し、指定されたメソッドを実行するプロセスです。実際、これは ASP.NET MVC フレームワークの中心的な考え方に非常に似ており、URL を解析し、そこからコントローラーとアクション名を取得し、コントローラー オブジェクトをアクティブ化し、リクエストからアクション パラメーターを取得します。アクションを実行します。 Web フォーム プラットフォームでは、.aspx.cs にメソッドを記述します。目的は、ページ オブジェクトが生成される前に指定されたメソッドを実行し、結果を返すことです。

まず、実装後のいくつかの呼び出し例を見てみましょう。これらの関数は組み合わせて使用​​することもできます:

 [AjaxMethod]
    public void Test1(int index)
    {
      //简单调用
    }

    [AjaxMethod]
    public string Test2(Test test)
    {
      return "参数为一个Test实例";
    }

    [AjaxMethod(OutputCache = 20)]
    public string Test3(int index)
    {
      return "输出结果缓存20秒";
    }

    [AjaxMethod(ServerCache = 20)]
    public string Test4()
    {
      return "在服务端缓存20秒";
    }

    [AjaxMethod(SessionState=SessionState.None)]
    public void Test5()
    {
      //Session未被加载
    }

    [AjaxMethod(SessionState = SessionState.ReadOnly)]
    public void Test6()
    {
      //Session只能读不能写
    }

    [AjaxMethod(SessionState = SessionState.ReadWrite)]
    public void Test7()
    {
      //Session可以读写
    }

    [AjaxMethod(IsAsync = true)]
    public void Test8()
    {
      //异步调用
    }

基本的な実行プロセスについてはすでに理解しているので、ここからは直接トピックに進みます。

Ajax 規約

通常、主流ブラウザが ajax を使用して非同期リクエストを送信する場合、リクエスト ヘッダーには X-Requested-With:XMLHttpRequest というマークが付けられます。このタグを直接使用して Ajax リクエストであるかどうかを判断することもできますが、相互に影響を与えないように、プロジェクト内で他のコンポーネントが役立つ場合があります。これは次のとおりです:

internal static class AjaxConfig
 {
  /// <summary>
  /// 请求头Ajax标记键
  /// </summary>
  public const string Key = "AjaxFlag";

  /// <summary>
  /// 请求头Ajax标记值
  /// </summary>
  public const string Value = "XHR";

  /// <summary>
  /// 请求头Ajax方法标记
  /// </summary>
  public const string MethodName = "";
 }

httpリクエストヘッダーにAjaxFlag:XHRが含まれている場合、それに対処する必要があることを意味します。さらに、http ヘッダーの MethodName は、実行するメソッドの名前を示します。

AjaxMethodAttribute mark属性

Mark属性はリフレクションに使用されます。ここで必要な関数をいくつか定義します。期待したいのは:

1.セッションステータスを設定できる

2.非同期ハンドラーをサポート

3.キャッシュの取得をサポート

4.サーバーサイドキャッシュをサポート

定義は以下の通りで、AttributeUsagでマークされたタグメソッドでのみ使用できます。

  /// <summary>
  /// ajax方法标记属性
  /// </summary>
  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
  public class AjaxMethodAttribute : Attribute
  {
    public AjaxMethodAttribute()
    {      
    }

    private SessionState _sessionState = SessionState.None;
    private int _outputCache = 0;
    private int _serverCache = 0;
    private ContentType _contentType = ContentType.Plain;
    private bool _isUseAsync = false;

    /// <summary>
    /// session状态
    /// </summary>
    public SessionState SessionState 
    {
      get { return _sessionState; }
      set { _sessionState = value; }
    }

    /// <summary>
    /// 客户端缓存时间，以秒为单位。该标记只对get请求有效
    /// </summary>
    public int OutputCache 
    {
      get { return _outputCache; }
      set { _outputCache = value; }
    }

    /// <summary>
    /// 服务端缓存时间，以秒为单位
    /// </summary>
    public int ServerCache 
    {
      get { return _serverCache; }
      set { _serverCache = value; }
    }    

    /// <summary>
    /// 输出类型（默认为text/plain）
    /// </summary>
    public ContentType ContentType 
    {
      get { return _contentType; }
      set { _contentType = value; }
    }

    /// <summary>
    /// 使用启用异步处理
    /// </summary>
    public bool IsAsync 
    {
      get { return _isUseAsync; }
      set { _isUseAsync = value; }
    }
  }

  /// <summary>
  /// Session状态
  /// </summary>
  public enum SessionState
  {
    None,
    ReadOnly,
    ReadWrite    
  }

  /// <summary>
  /// 输出内容类型
  /// </summary>
  public enum ContentType
  {
    Plain,
    Html,
    XML,
    Javascript,
    JSON
  }

各種ハンドラーとAjaxHandlerFactory

前の記事によると、特定のハンドラーは主に非同期と非同期の 2 つのカテゴリに分けられ、セッションのステータスは 3 です。サポートされていない、読み取りのみサポート (IReadOnlySessionState インターフェイスの実装)、読み取りと書き込みのサポート (IRequiresSessionState インターフェイスの実装) の 3 つのタイプです。 IReadOnlySessionState と IRequiresSessionState は単なるマーク インターフェイスです (メソッドを使用しない場合は、マーク属性を使用して実装する方が合理的です)。非同期ハンドラーは IHttpAsyncHandler インターフェイスを実装する必要があり、このインターフェイスが IHttpHandler を実装します。 Handler の ProcessRequest メソッド (または BeginProcessRequest) でメソッドを実行します。定義は次のとおりです。

非同期状態のハンドラー:

 //不支持Session
  internal class SyncAjaxHandler : IHttpHandler
  {
    private Page _page;
    private CacheMethodInfo _cacheMethodInfo;

    internal SyncAjaxHandler(Page page, CacheMethodInfo cacheMethodInfo)
    {
      _page = page;
      _cacheMethodInfo = cacheMethodInfo;
    }

    public void ProcessRequest(HttpContext context)
    {
      //执行方法（下面详细介绍）
      Executor.Execute(_page, context, _cacheMethodInfo);
    }

    public bool IsReusable
    {
      get { return false; }
    }

    public static SyncAjaxHandler CreateHandler(Page page, CacheMethodInfo cacheMethodInfo, SessionState state)
    {
      switch (state)
      {
        case SessionState.ReadOnly:
          return new SyncAjaxSessionReadOnlyHandler(page, cacheMethodInfo);
        case SessionState.ReadWrite:
          return new SyncAjaxSessionHandler(page, cacheMethodInfo);
        default:
          return new SyncAjaxHandler(page, cacheMethodInfo);
      }
    }
  }

  //支持只读Session
  internal class SyncAjaxSessionReadOnlyHandler : SyncAjaxHandler, IReadOnlySessionState
  {
    internal SyncAjaxSessionReadOnlyHandler(Page page, CacheMethodInfo cacheMethodInfo)
      : base(page, cacheMethodInfo)
    {
    }
  }

  //支持读写Session
  internal class SyncAjaxSessionHandler : SyncAjaxHandler, IRequiresSessionState
  {
    internal SyncAjaxSessionHandler(Page page, CacheMethodInfo cacheMethodInfo)
      : base(page, cacheMethodInfo)
    {
    }
  }

非同期状態のハンドラー:

 //不支持Session
  internal class ASyncAjaxHandler : IHttpAsyncHandler, IHttpHandler
  {
    private Page _page;
    private CacheMethodInfo _cacheMethodInfo;

    internal ASyncAjaxHandler(Page page, CacheMethodInfo cacheMethodInfo)
    {
      _page = page;
      _cacheMethodInfo = cacheMethodInfo;
    }

    public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
    {
      //执行方法(下面详细介绍)
      Action<Page, HttpContext, CacheMethodInfo> action = new Action<Page, HttpContext, CacheMethodInfo>(Executor.Execute);
      IAsyncResult result = action.BeginInvoke(_page, context, _cacheMethodInfo, cb, action);
      return result;
    }

    public void EndProcessRequest(IAsyncResult result)
    {
      Action<Page, HttpContext, CacheMethodInfo> action = result.AsyncState as Action<Page, HttpContext, CacheMethodInfo>;
      action.EndInvoke(result);
    }

    public void ProcessRequest(HttpContext context)
    {
      throw new NotImplementedException();
    }

    public bool IsReusable
    {
      get { return false; }
    }

    public static ASyncAjaxHandler CreateHandler(Page page, CacheMethodInfo cacheMethodInfo, SessionState state)
    {
      switch (state)
      {
        case SessionState.ReadOnly:
          return new ASyncAjaxSessionReadOnlyHandler(page, cacheMethodInfo);
        case SessionState.ReadWrite:
          return new ASyncAjaxSessionHandler(page, cacheMethodInfo);
        default:
          return new ASyncAjaxHandler(page, cacheMethodInfo);
      }
    }
  }

  //支持只读Session
  internal class ASyncAjaxSessionReadOnlyHandler : ASyncAjaxHandler, IReadOnlySessionState
  {
    internal ASyncAjaxSessionReadOnlyHandler(Page page, CacheMethodInfo cacheMethodInfo)
      : base(page, cacheMethodInfo)
    {
    }
  }

  //支持读写Session
  internal class ASyncAjaxSessionHandler : ASyncAjaxHandler, IRequiresSessionState
  {
    internal ASyncAjaxSessionHandler(Page page, CacheMethodInfo cacheMethodInfo)
      : base(page, cacheMethodInfo)
    {
    }
  }

AjaxHandlerFactory は IHand を実装しますlerF 特定のハンドラーを生成するために、actory インターフェースが使用されます。リクエストに基づいて web.config に登録する必要があります。 AjaxHandlerFactory の GetHandler は、リクエストをインターセプトするための最初のステップです。リクエスト ヘッダーの AjaxFlag:XHR を使用して、処理する必要があるかどうかを判断し、必要な場合はハンドラーを作成します。それ以外の場合は、通常の方法で処理します。このメソッドは .aspx.cs で記述されているため、リクエストはページ (Page、IHttpHandler を実装する) タイプである .aspx サフィックスを持ちます。ページは PageHandlerFactory を通じて作成されます。これは、IHandlerFactory インターフェイスも実装します。つまり、次の目的で使用されます。ハンドラーを作成します。したがって、PageHandlerFactory を使用して IHttpHandler を作成する必要があります。ただし、PageHandlerFactory のコンストラクターは保護された内部型であるため、新しいコンストラクターを直接作成することはできないため、CommonPageHandlerFactory を通じて継承する必要があります。

PageHandlerFactoryでPageを取得した後、メソッド名と組み合わせてリフレクションによりAjaxMethodAttributeのマーク属性を取得できます。次に、関連するプロパティに基づいて特定のハンドラーを生成します。具体的なコードは次のとおりです。

 internal class CommonPageHandlerFactory : PageHandlerFactory { }

  internal class AjaxHandlerFactory : IHttpHandlerFactory
  {
    public void ReleaseHandler(IHttpHandler handler)
    {
    }

    public IHttpHandler GetHandler(HttpContext context, string requestType, string url, string pathTranslated)
    {
      HttpRequest request = context.Request;
      if (string.Compare(request.Headers[AjaxConfig.Key], AjaxConfig.Value, true) == 0)
      {
        //检查函数标记
        string methodName = request.Headers[AjaxConfig.MethodName];
        if (methodName.IsNullOrEmpty())
        {
          Executor.EndCurrentRequest(context, "方法名称未正确指定！");
          return null;
        }
        try
        {          
          CommonPageHandlerFactory ajaxPageHandler = new CommonPageHandlerFactory();
          IHttpHandler handler = ajaxPageHandler.GetHandler(context, requestType, url, pathTranslated);
          Page page = handler as Page;
          if (page == null)
          {
            Executor.EndCurrentRequest(context, "处理程序类型必须是aspx页面！");
            return null;
          }
          return GetHandler(page, methodName, context);
        }
        catch
        {
          Executor.EndCurrentRequest(context, url + " 不存在！");
          return null;
        }
      }
      if (url.EndsWith(".aspx", StringComparison.CurrentCultureIgnoreCase))
      {
        CommonPageHandlerFactory orgPageHandler = new CommonPageHandlerFactory();
        return orgPageHandler.GetHandler(context, requestType, url, pathTranslated);
      }
      return null;
    }

    /// <summary>
    /// 获取自定义处理程序
    /// </summary>
    /// <param name="page">处理页面</param>
    /// <param name="methodName">处理方法</param>
    /// <param name="context">当前请求</param>
    private IHttpHandler GetHandler(Page page, string methodName, HttpContext context)
    {
      //根据Page和MethodName进行反射，获取标记属性（下面详细介绍）
      CacheMethodInfo methodInfo = Executor.GetDelegateInfo(page, methodName);
      if (methodInfo == null)
      {
        Executor.EndCurrentRequest(context, "找不到指定的Ajax方法！");
        return null;
      }
      AjaxMethodAttribute attribute = methodInfo.AjaxMethodAttribute;
      if (attribute.ServerCache > 0)
      {
        //先查找缓存
        object data = CacheHelper.TryGetCache(context);
        if (data != null)
        {
          Executor.EndCurrentRequest(context, data);
          return null;
        }
      }
      if (attribute.IsAsync)
      {
        //异步处理程序
        return ASyncAjaxHandler.CreateHandler(page, methodInfo, attribute.SessionState);
      }
      return SyncAjaxHandler.CreateHandler(page, methodInfo, attribute.SessionState);
    }
  }

上記の CacheMethodInfo は、呼び出しメソッドの関連情報をキャッシュするために使用されます。 最初の記事では、キャッシュ + 委任など、キャッシュを最適化するためのいくつかの方法について説明しました。ただし、ここではメソッドの MethodInfo を直接キャッシュしません。これは、MethodInfo をキャッシュすると、Invoke を介して実行する必要があり、比較的効率が悪いためです。ここでキャッシュするのはメソッドのデリゲートです。デリゲートのシグネチャは Func です。デリゲートの戻り値はオブジェクト型です。つまり、任意の型を返すことができます。コンポーネント内で処理できます。たとえば、参照型 (非文字列) の場合、json にシリアル化されますが、ここでは実装されていません)。デリゲートは 2 つのパラメーターを受け取ります。最初のパラメーターはメソッドが属するオブジェクトであり、2 番目のパラメーターは object[] として定義されます。あらゆる種類のパラメータを受け取ることができます。実行メソッドを委託することで、メソッドを直接呼び出す場合との効率の差はそれほど大きくありません (委任に慣れていない友人は、「委任」を参照してください)。 CacheMethodInfo は次のように定義されます:

 /// <summary>
  /// 缓存方法信息  
  /// </summary>
  sealed class CacheMethodInfo
  {
    /// <summary>
    /// 方法名称
    /// </summary>
    public string MethodName { get; set; }

    /// <summary>
    /// 方法委托
    /// </summary>
    public Func<object, object[], object> Func { get; set; }

    /// <summary>
    /// 方法参数
    /// </summary>
    public ParameterInfo[] Parameters { get; set; }

    /// <summary>
    /// Ajax标记属性
    /// </summary>
    public AjaxMethodAttribute AjaxMethodAttribute { get; set; }
  }

核心方法

1. Eexcutor.GetDelegateInfo 获取方法相关信息

　　该方法用于遍历页面类，获取所有AjaxMethodAttribute标记的方法信息，生成一个CacheMethodInfo对象，包括标记信息、方法名称、参数信息，以及最重要的方法委托。该对象会缓存在一个哈希表中，下次获取时，直接从内存获得。

 /// <summary>
    /// 获取页面标记方法信息
    /// </summary>
    /// <param name="page">页面对象</param>
    /// <param name="methodName">方法名称</param>
    internal static CacheMethodInfo GetDelegateInfo(Page page, string methodName)
    {
      if (page == null)
      {
        throw new ArgumentNullException("page");
      }
      Type type = page.GetType();
      //ajaxDelegateTable是一个Hashtable
      Dictionary<string, CacheMethodInfo> dic = ajaxDelegateTable[type.AssemblyQualifiedName] as Dictionary<string, CacheMethodInfo>;
      if (dic == null)
      {
        dic = new Dictionary<string, CacheMethodInfo>();
        //遍历页面的所有MethodInfo
        IEnumerable<CacheMethodInfo> infos = (from m in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)
                           let ca = m.GetCustomAttributes(typeof(AjaxMethodAttribute), false).FirstOrDefault()
                           where ca != null
                           select new CacheMethodInfo
                           {
                             //方法标记属性
                             AjaxMethodAttribute = ca as AjaxMethodAttribute,
                             //方法名称
                             MethodName = m.Name,
                             //方法参数信息
                             Parameters = m.GetParameters()
                           });

        if (infos.IsNullOrEmpty())
        {
          return null;
        }          
        for (int i = 0, length = infos.Count(); i < length; i++)
        {          
          CacheMethodInfo cacheMethodInfo = infos.ElementAt(i);          
          string name = cacheMethodInfo.MethodName;
          MethodInfo methodInfo = type.GetMethod(name);
          if (!dic.ContainsKey(name))
          {            
            //根据MethodInfo获取方法委托
            cacheMethodInfo.Func = ReflectionUtil.GetMethodDelegate(methodInfo);
            dic.Add(name, cacheMethodInfo);
          }
        }
        ajaxDelegateTable[type.AssemblyQualifiedName] = dic;
      }
      CacheMethodInfo currentMethodInfo = null;
      dic.TryGetValue(methodName, out currentMethodInfo);
      return currentMethodInfo;      
    }

　　获取方法的委托的是通过一个ReflectionUtil获得的，该类主要用来优化反射，它通过Expression，可以将MethodInfo编译成Func委托，为Type编译一个Func