简体中文(ZH-CN) English(EN) 繁体中文(ZH-TW) 日本語(JA) 한국어(KO) Melayu(MS) Français(FR) Deutsch(DE)
Home> Web Front-end> JS Tutorial> body text

The third implementation of writing lightweight ajax components

亚连
Release： 2018-05-24 10:38:23
Original
1368 people have browsed it

This article mainly introduces the third implementation of writing lightweight ajax components in detail, which has certain reference value. Interested friends can refer to it

Through the previous introduction, we know To execute the method of the page object, the core is reflection, which is the process of obtaining parameters from the request and executing the specified method. In fact, this is very similar to the core idea of the ASP.NET MVC framework. It will parse the URL, get the controller and action names from it, then activate the controller object, get the action parameters from the request and execute the action. On the web form platform, we write the method in .aspx.cs. What we want to achieve is to execute the specified method before the page object is generated, and then return the result.

Let’s first look at a few call examples after implementation. These functions can also be used in combination:

[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() { //异步调用 }
Copy after login

We are already familiar with the basic execution process , now go directly to the topic.

Ajax Convention

Usually when mainstream browsers use ajax to send asynchronous requests, the request header will carry a mark: X-Requested-With:XMLHttpRequest. We can also directly use this tag to determine whether it is an ajax request, but other components may be useful in the project. In order not to affect each other, we add a custom request header. Here is:

internal static class AjaxConfig { ///  /// 请求头Ajax标记键 ///  public const string Key = "AjaxFlag"; ///  /// 请求头Ajax标记值 ///  public const string Value = "XHR"; ///  /// 请求头Ajax方法标记 ///  public const string MethodName = ""; }
Copy after login

It means that if the http request header contains an AjaxFlag: XHR, that is what we want to process. In addition, the MethodName of the http header indicates the name of the method we want to execute.

AjaxMethodAttribute mark attribute

Mark attribute is used for reflection. Here we define some functions we need. We hope to have:

　1. Can configure Session status

　2. Support asynchronous Handler

　3. Support Get cache

　4. Support server-side cache

The definition is as follows. The tag marked with AttributeUsag can only be used on methods.


///  /// ajax方法标记属性 ///  [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; ///  /// session状态 ///  public SessionState SessionState { get { return _sessionState; } set { _sessionState = value; } } ///  /// 客户端缓存时间，以秒为单位。该标记只对get请求有效 ///  public int OutputCache { get { return _outputCache; } set { _outputCache = value; } } ///  /// 服务端缓存时间，以秒为单位 ///  public int ServerCache { get { return _serverCache; } set { _serverCache = value; } } ///  /// 输出类型（默认为text/plain） ///  public ContentType ContentType { get { return _contentType; } set { _contentType = value; } } ///  /// 使用启用异步处理 ///  public bool IsAsync { get { return _isUseAsync; } set { _isUseAsync = value; } } } ///  /// Session状态 ///  public enum SessionState { None, ReadOnly, ReadWrite } ///  /// 输出内容类型 ///  public enum ContentType { Plain, Html, XML, Javascript, JSON }
Copy after login

Various handlers and AjaxHandlerFactory

According to the previous article, the specific Handler Mainly divided into two categories, asynchronous and non-asynchronous; under these two categories, there are three types of Session states: not supported, only supported for reading (implementing the IReadOnlySessionState interface), and supporting reading and writing (implementing the IRequiresSessionState interface). IReadOnlySessionState and IRequiresSessionState are just mark interfaces (without any methods, it is more reasonable to use mark attributes to implement them). Asynchronous Handler needs to implement the IHttpAsyncHandler interface, which in turn implements IHttpHandler. The ProcessRequest method (or BeginProcessRequest) of Handler is where we want to execute the method. The definition is as follows:

Handler in non-asynchronous state:

//不支持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) { } }
Copy after login

Handler in asynchronous state:

//不支持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 action = new Action(Executor.Execute); IAsyncResult result = action.BeginInvoke(_page, context, _cacheMethodInfo, cb, action); return result; } public void EndProcessRequest(IAsyncResult result) { Action action = result.AsyncState as Action; 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) { } }
Copy after login

AjaxHandlerFactory implements the IHandlerFactory interface and is used to generate specific Handlers based on requests. It needs to be registered in web.config. AjaxHandlerFactory's GetHandler is our first step in intercepting requests. Use the AjaxFlag:XHR in the request header to determine whether we need to process it. If so, create a Handler, otherwise proceed in the normal way. Since our method is written in .aspx.cs, our request is of .aspx suffix, which is the page (Page, implements IHttpHandler) type. Page is created through PageHandlerFactory, which also implements the IHandlerFactory interface, which means It is used to create handlers. So we need to use PageHandlerFactory to create an IHttpHandler. However, the constructor of PageHandlerFactory is of protected internal type. We cannot create a new one directly, so we need to inherit it through a CommonPageHandlerFactory.

After obtaining the Page through PageHandlerFactory, combined with the method name, we can reflect to obtain the AjaxMethodAttribute mark attribute. Then generate a specific Handler based on its related properties. The specific code is as follows:

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; } ///  /// 获取自定义处理程序 ///  /// 处理页面 /// 处理方法 /// 当前请求 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); } }
Copy after login

The above CacheMethodInfo is used to cache the relevant information of the calling method, as we mentioned in the first article Some methods of over-optimizing caching include cache delegation. But here we do not directly cache the MethodInfo of the method, because if we cache the MethodInfo, we need to execute it through Invoke, which is relatively inefficient. What I cache here is the delegate of the method. The signature of the delegate is: Func . The return value of the delegate is the object type, which means that any type can be returned (we can process it inside the component, For example, if it is a reference type (non-string), it will be serialized into json, but this is not implemented here). The delegate receives two parameters. The first parameter is the object to which the method belongs. If it is a static method, it is null. The second parameter is the parameter of the method. It is defined as object[], which means that it can receive any type of parameters. By entrusting the execution method, the efficiency difference between calling the method directly is not very big (friends who are not familiar with delegation can refer to: Delegation). CacheMethodInfo is defined as follows: 

///  /// 缓存方法信息 ///  sealed class CacheMethodInfo { ///  /// 方法名称 ///  public string MethodName { get; set; } ///  /// 方法委托 ///  public Func Func { get; set; } ///  /// 方法参数 ///  public ParameterInfo[] Parameters { get; set; } ///  /// Ajax标记属性 ///  public AjaxMethodAttribute AjaxMethodAttribute { get; set; } }
Copy after login

核心方法

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

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

///  /// 获取页面标记方法信息 ///  /// 页面对象 /// 方法名称 internal static CacheMethodInfo GetDelegateInfo(Page page, string methodName) { if (page == null) { throw new ArgumentNullException("page"); } Type type = page.GetType(); //ajaxDelegateTable是一个Hashtable Dictionary dic = ajaxDelegateTable[type.AssemblyQualifiedName] as Dictionary; if (dic == null) { dic = new Dictionary(); //遍历页面的所有MethodInfo IEnumerable 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; }
Copy after login

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

　　通过Expression优化反射

　　Expression（表达式树）允许我们将代码逻辑以表达式的形式存储在树状结构里，然后在运行时去动态解析，实现动态编辑和执行代码。熟悉ORM框架的朋友对Expression肯定很熟悉，因为大部分方法都有一个Expression 类型的参数。访问关系型数据库的本质还是sql语句，orm的工作就是为开发人员屏蔽这个过程，以面向对象的方式去读写数据库，而不是自己编写sql语句。例如，Users.Where(u => u.Age > 18) 就可查询年龄大于18的用户。这里不对应用在orm的过程进行详解，下面我们介绍如何用Expression并利用它来生成委托。

　　.net定义了许多表达式类型，这些类型都派生自Expression，Expression是一个抽象类，而且是一个工厂类，所有类型的表达式都通过它来创建。如图：

　　先看一个 1 * 2 + 2 例子，我们用表达树来描述来描述它：

/* * a * b + 2 */ /* 直接操作 int a = 1, b = 2; int result = a * 2 + 2; */ /* 通过委托调用 Func func = new Func((a, b) => { return a * b + 2; }); func(1, 2); */ /*通过Expression调用*/ //定义两个参数 ParameterExpression pe1 = Expression.Parameter(typeof(int), "a"); ParameterExpression pe2 = Expression.Parameter(typeof(int), "b"); //定义一个常量 ConstantExpression constExpression = Expression.Constant(2); //参数数组 ParameterExpression[] parametersExpression = new ParameterExpression[]{pe1,pe2}; //一个乘法运算 BinaryExpression multiplyExpression = Expression.Multiply(pe1, pe2); //一个加法运算 BinaryExpression unaryExpression = Expression.Add(multiplyExpression, constExpression); //将上面的表达式转换为一个委托表达式 LambdaExpression lambdaExpression = Expression.Lambda>(unaryExpression, parametersExpression); //将委托编译成可执行代码 Func func = lambdaExpression.Compile() as Func; Console.WriteLine(func(1, 2));
Copy after login

　　可以看到我们最终将其编译为一个具体类型的委托了。下面看我们真正用到的方法是如何实现的，代码如下：

public static Func GetMethodDelegate(MethodInfo methodInfo) { if (methodInfo == null) { throw new ArgumentNullException("methodInfo"); } //定义参数表达式，它表示委托的第一个参数 ParameterExpression instanceExp = Expression.Parameter(typeof(object), "instance"); //定义参数表达式，它表示委托的第二个参数 ParameterExpression paramExp = Expression.Parameter(typeof(object[]), "parameters"); //获取方法的参数信息数组 ParameterInfo[] paramInfos = methodInfo.GetParameters(); //参数表达式集合 List paramExpList = new List(); int length = paramInfos.Length; for (int i = 0; i < length; i++) { //获取paramExp参数数组的第i个元素 BinaryExpression valueObj = Expression.ArrayIndex(paramExp, Expression.Constant(i)); //将其转换为与参数类型一致的类型 UnaryExpression valueCast = Expression.Convert(valueObj, paramInfos[i].ParameterType); //添加到参数集合 paramExpList.Add(valueCast); } //方法所属的实例的表达式，如果为静态则为null UnaryExpression instanceCast = methodInfo.IsStatic ? null : Expression.Convert(instanceExp, methodInfo.ReflectedType); //表示调用方法的表达式 MethodCallExpression methodCall = Expression.Call(instanceCast, methodInfo, paramExpList); //将表达式目录描述的lambda编译为可执行代码（委托） if (methodCall.Type == typeof(void)) { Expression> lambda = Expression.Lambda>(methodCall, instanceExp, paramExp); Action action = lambda.Compile(); return (instance, parameters) => { action(instance, parameters); return null; }; } else { UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof(object)); Expression> lambda = Expression.Lambda>(castMethodCall, instanceExp, paramExp); return lambda.Compile(); } }
Copy after login

　　具体代码都有注释解释，最终我们获得了一个Func 类型的委托，它会作为CacheMethodInfo的属性进行缓存。有兴趣测试反射性能的朋友，也不妨去测试对比一下这几种方式执行的效率差别：1.直接执行方法 2.Emit 3. 缓存+委托 4.Delegate.DynamicInvoke。

2. Executor.Execute 执行委托

　　在执行委托前，我们需要先从请求获取参数，映射到方法。参数可以是简单的类型，如 string Test(int i,int j); 也可以是一个对象，如 string Test(User user); 如果是 string Test(User user1, User user2) 也行，提交参数时只需要加上 user1或 user2 前缀即可，例如 user1.Name，user2.Name。这里没有支持更多的匹配方式，像mvc，它还支持嵌套类型等等，这些可以自己去实现。如果参数是一个对象，我们可能需要为它的字段进行赋值，也可能为它的属性进行赋值。这里我们定义一个DataMember，用来表示字段或属性的父类。如：

internal abstract class DataMember { public abstract string Name { get; } public abstract Type MemberType { get; } public abstract void SetValue(object instance,object value); public abstract object GetValue(object instance); }
Copy after login

　　接着定义属性类型PropertyMember和字段类型FieldMember，分别继承了DataMember。

　　PropertyMember定义：


internal class PropertyMember : DataMember { private PropertyInfo property; public PropertyMember(PropertyInfo property) { if (property == null) { throw new ArgumentNullException("property"); } this.property = property; } public override void SetValue(object instance, object value) { if (instance == null) { throw new ArgumentNullException("instance"); } this.property.SetValue(instance, value, null); } public override object GetValue(object instance) { if (instance == null) { throw new ArgumentNullException("instance"); } return this.property.GetValue(instance,null); } public override string Name { get { return this.property.Name; } } public override Type MemberType { get { return this.property.PropertyType; } } }
Copy after login

　　FieldMember定义：

internal class FieldMember : DataMember { private FieldInfo field; public FieldMember(FieldInfo field) { if (field == null) { throw new ArgumentNullException("field"); } this.field = field; } public override void SetValue(object instance, object value) { if (instance == null) { throw new ArgumentNullException("instance"); } this.field.SetValue(instance, value); } public override object GetValue(object instance) { if (instance == null) { throw new ArgumentNullException("instance"); } return this.field.GetValue(instance); } public override string Name { get { return this.field.Name;} } public override Type MemberType { get { return this.field.FieldType; } } }
Copy after login

　　定义一个DataMemberManager，用来遍历Type，获取所有字段和属性的，实现如下：

internal static class DataMemberManager { ///  /// 获取实例字段/属性集合 ///  /// 类型 ///  public static List GetDataMember(Type type) { if (type == null) { throw new ArgumentNullException("type"); } IEnumerable propertyMembers = from property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public) select new PropertyMember(property); IEnumerable fieldMembers = from field in type.GetFields(BindingFlags.Instance | BindingFlags.Public) select new FieldMember(field); List members = new List(); foreach(var property in propertyMembers) { members.Add(property); } foreach (var field in fieldMembers) { members.Add(field); } return members; } }
Copy after login

　　在前面我们定义的Handler的ProcessRequest方法中，我们调用了Executor.Execute，该方法用于执行委托，实现如下：

///  /// 核心函数，执行Handler的方法 ///  /// 页面对象 /// 请求上下文 /// 缓存方法原数据 internal static void Execute(Page page, HttpContext context, CacheMethodInfo methodInfo) { if (page == null) { throw new ArgumentNullException("page"); } try { if (methodInfo != null) { HttpRequest request = context.Request; object[] parameters = GetParametersFromRequest(request, methodInfo.Parameters); object data = methodInfo.Func(page, parameters); int serverCache = methodInfo.AjaxMethodAttribute.ServerCache; if (serverCache > 0) { CacheHelper.Insert(context, methodInfo.AjaxMethodAttribute.ServerCache, data); } EndCurrentRequest(context, data, methodInfo.AjaxMethodAttribute.OutputCache); } else { EndCurrentRequest(context, "找不到合适的Ajax方法！"); } } catch (FormatException) { EndCurrentRequest(context, "调用方法匹配到无效的参数！"); } catch (InvalidCastException) { EndCurrentRequest(context, "参数转换出错！"); } catch (System.Threading.ThreadAbortException) { //do nothing } catch (Exception ex) { EndCurrentRequest(context, ex.Message); } }
Copy after login

　　CacheMethodInfo我们已经获得了，现在只要获得参数我们就可以执行方法。

　　GetParameterFromRequest用于从请求获取object[]参数数组。根据上面所说的，如果参数是一个简单类型，那么直接进行转换；如果是实例对象，那么我们先要创建new一个实例对象，然后为其字段或属性赋值。实现如下：

///  /// 从请求获取参参数 ///  /// HttpRequest ///参数信息 /// 参数数组 private static object[] GetParametersFromRequest(HttpRequest request, ParameterInfo[] parameters) { if (parameters.IsNullOrEmpty()) { return null; } int length = parameters.Length; object[] realParameters = new object[length]; for (int i = 0; i < length; i++) { ParameterInfo pi = parameters[i]; Type piType = pi.ParameterType.GetRealType(); object value = null; if (piType.IsValueType()) { //值类型 value = ModelUtil.GetValue(request, pi.Name, piType); value = value ?? Activator.CreateInstance(piType); } else if (piType.IsClass) { //引用类型 object model = ModelUtil.CreateModel(piType); ModelUtil.FillModelByRequest(request, pi.Name, piType, model); value = model; } else { throw new NotSupportedException(pi.Name + " 参数不被支持"); } realParameters[i] = value; } return realParameters; }
Copy after login

　　ModelUtil会从Http Request获取参数，并进行类型转换处理：

internal static class ModelUtil { ///  /// 缓存构造函数 ///  private static Hashtable constructorTable = Hashtable.Synchronized(new Hashtable()); ///  /// 根据名称从HttpRequest获取值 ///  /// HttpRequest /// 键名称 /// 参数类型 ///  public static object GetValue(HttpRequest request, string name, Type type) { string[] values = null; if (string.Compare(request.RequestType, "POST", true) == 0) { values = request.Form.GetValues(name); } else { values = request.QueryString.GetValues(name); } if (values.IsNullOrEmpty()) { return null; } string data = values.Length == 1 ? values[0] : string.Join(",", values); return Convert.ChangeType(data, type); } ///  /// 创建实例对象 ///  /// 实例类型 ///  public static object CreateModel(Type type) { if (type == null) { throw new ArgumentNullException("type"); } Func func = constructorTable[type.AssemblyQualifiedName] as Func; if (func == null) { func = ReflectionUtil.GetConstructorDelegate(type); constructorTable[type.AssemblyQualifiedName] = func; } if (func != null) { return func(); } return null; } ///  /// 填充模型 ///  /// HttpRequest /// 键名称 /// 参数类型 /// 实例对象 public static void FillModelByRequest(HttpRequest request, string name, Type type, object model) { if (model == null) { return; } IEnumerable members = DataMemberManager.GetDataMember(type); if (members.IsNullOrEmpty()) { return; } object value = null; foreach (DataMember member in members) { value = GetValue(request, string.Format("{0}.{1}", name, member.Name), member.MemberType); value = value ?? GetValue(request, member.Name, member.MemberType); member.SetValue(model, value); } } }
           

            Copy after login
           

          
　　如果是引用类型，需要通过构造函数创建对象，像前面用于，这里我们也用Expression来构建一个Func类型的委托来优化，它调用了ReflectionUtil.GetConstructorDelegate方法。实现如下：

            

             
///  /// 获取构造函数委托 ///  /// 实例类型 ///  public static Func GetConstructorDelegate(Type type) { if (type == null) { throw new ArgumentNullException("type"); } ConstructorInfo ci = type.GetConstructor(Type.EmptyTypes); if (ci == null) { throw new MissingMemberException("类型必须有一个无参public构造函数！"); } NewExpression newExp = Expression.New(type); Expression> lambda = Expression.Lambda>(newExp); return lambda.Compile(); }
             

              Copy after login
             

            
　　最后再输出结果时，如果是Get请求，并且需要缓存，我们还需要设置一下Response.Cache。如下：

            

             
private static void EndRequest(HttpContext context, object data, int outPutCache, ContentType contentType) { HttpResponse response = context.Response; if (outPutCache != 0) { if (string.Compare(context.Request.HttpMethod, "GET", true) == 0) { if (outPutCache > 0) { response.Cache.SetCacheability(HttpCacheability.Public); response.Cache.SetMaxAge(new TimeSpan(0, 0, outPutCache)); response.Cache.SetExpires(DateTime.Now.AddSeconds(outPutCache)); } else { response.Cache.SetCacheability(HttpCacheability.NoCache); response.Cache.SetNoStore(); } } } response.ContentType = GetContentType(contentType); response.ContentEncoding = System.Text.Encoding.UTF8; if (data != null) { response.Write(data); } response.End(); }

             

              Copy after login
             

            
上面是我整理给大家的，希望今后会对大家有帮助。
相关文章：
ajax返回object Object的快速解决方法
jQuery中ajax的4种常用请求方式介绍
使用原生ajax处理json字符串的方法
The above is the detailed content of The third implementation of writing lightweight ajax components. For more information, please follow other related articles on the PHP Chinese website!

            

             

              Related labels：
              

               ajax
               components
              

             

             

              source：php.cn
             

            

            

             Previous article：Analysis of the role of async:false/true in Ajax requests
             Next article：Detailed explanation of steps to use React-router v4
            

            

             

              Statement of this Website
             

             

              The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
             

            

            

            

             

              Latest Articles by Author
             

             
            

            

             

              Latest Issues
             

             

              

               

                Stream data from OpenAI's API using AJAX, PHP, and server-sent events
                How can I use Server Sent Events (SSE) to stream data from the above API to a browser clie...
                

                 

                  From 2023-11-11 12:03:23
                 

                 

                  

                   0
                  

                  

                   1
                  

                  

                   497
                  

                 

                

               

              

              

              

               

                " class="wdcdcTitle">Uncaught syntax error when parsing JSON on response using AJAX request: Unexpected token '<', "

                I'm using datefrom and dateto to make a dropdown menu and then display the dates between t...
                

                 

                  From 2023-11-01 10:06:57
                 

                 

                  

                   0
                  

                  

                   1
                  

                  

                   269
                  

                 

                

               

              

              

              

               

                Execute PHP without leaving the page
                I have a form - textarea (named su) and submit button. After the form is submitted I need ...
                

                 

                  From 2023-10-23 19:05:06
                 

                 

                  

                   0
                  

                  

                   1
                  

                  

                   285
                  

                 

                

               

              

              

              

               

                JavaScript allows access to CSS custom properties (also known as CSS variables)
                How to get and set CSS custom properties (properties accessed via var(…) in a stylesheet) ...
                

                 

                  From 2023-10-20 22:42:04
                 

                 

                  

                   0
                  

                  

                   2
                  

                  

                   244
                  

                 

                

               

              

              

              

               

                Vue 2 - Warning about changing props
                I started the https://laracasts.com/series/learning-vue-step-by-step series. I've stopped ...
                

                 

                  From 2023-10-13 10:49:44
                 

                 

                  

                   0
                  

                  

                   2
                  

                  

                   217
                  

                 

                

               

              

              

             

            

            

             

              

               Related Topics
              

              More>
             

             

              
             

            

            

             

              

               Popular Recommendations
              

              

               
              

             

             

              

               

                Popular Tutorials
               

               More>
              

              

               

                

                 Related Tutorials
                 

                

                

                 Popular Recommendations
                 

                

                

                 Latest courses
                 

                

               

               
               
               
              

             

             

              

               

                Latest Downloads
               

               More>
              

              

               

                

                 Web Effects
                 

                

                

                 Website Source Code
                 

                

                

                 Website Materials
                 

                

                

                 Front End Template
                 

                

               

               
               
               
               
              

             

            

            

             

              

               

                

                 

                  About us
                  Disclaimer
                  Sitemap
                  

                 

                 

                  php.cn：Public welfare online PHP training，Help PHP learners grow quickly！