抽象共同的一般处理程序+动软代码生成器快速开发项目 一

        在做上一个项目中，大量的使用了一般处理程序，由于一般处理程序的优点是非常大的，但是在善良公社的项目中，基本上每一个页面都对应一个一般处理程序，更呕吐的是，这些一般处理程序的核心内容几句话之外都差不多，当时项目紧，没有继续抽象，现在我们有五个人在研究通用型网站开发平台这块，先解决这个大问题，抽象出公共的一般处理程序类，结合东软生成的代码，可以实现网站的简单快速的开发（这是我们刚开始的一个小需求）。

针对以前的一般程序程序大家可以参考文章

接下来是经过抽象后的：

前台灵活传递需要的数据

 //查询并把数据传递给后台，数组,把前台的查询的条件传递过去
        function getQueryParams(queryParams) {
            var StartTime = $("#StartTime").datebox("getValue");
            var EndTime = $("#EndTime").datebox("getValue");
            var KeyWord = document.getElementById("KeyWord").value;
            
            //获取的值灵活的传递给后台处理，这个只需要灵活的想传什么参数，直接在这个写入就行了
            //传值的入口，后台不需要传值了，根据页面灵活的写入就行
            
            queryParams.bt_ss_PublishDate = StartTime;
            queryParams.bt_es_PublishDate = EndTime;
            queryParams.lkd_a_ScoreStyleName = KeyWord;
            queryParams.lkd_a_o_ScoreStyleState = KeyWord;
            return queryParams;
        }

把数据传递给后台属于自己的一般处理程序

//增加查询参数，重新加载表格
        function reloadgrid() {

            //查询参数直接添加在queryParams中    

            var queryParams = $('#tt').datagrid('options').queryParams;
            getQueryParams(queryParams);
            $('#tt').datagrid('options').queryParams = queryParams;//传递值

            $("#tt").datagrid('reload');//重新加载table

        }

公共的一般处理程序类（PublicClass.ashx）

 /// <summary>
    /// Public 的摘要说明
    /// </summary>
    public class PublicClass : IHttpHandler
    {

       private Type type;
        private object obj = null;                                         //实例
        //构造函数
        public PublicClass(){
        }

        public PublicClass(object obj)
        {
            this.obj = obj;
        }

        public void SetObj(object obj)
        {
            this.obj = obj;
        }

        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/plain";
            context.Response.Write("Hello World");
        }


        /// <summary>
        /// 执行任意对象Query方法
        /// </summary>
        /// <param name="context">上下文</param>
        /// <param name="methodName">方法名称</param>
        /// <param name="paras">参数</param>
        /// <param name="types">参数类型</param>
        /// <returns></returns>
        public void Query(HttpContext context, string methodName, object[] paras, Type[] types)
        {


            context.Response.ContentType = "text/plain";
            //===============================================================
            //通过循环，获取表单中的数据
            StringBuilder conditions = new StringBuilder();


            
            //获取QueryString中的参数
            NameValueCollection collection = context.Request.QueryString;
            conditions = SetParams(collection, conditions);

            //获取Form中的参数
            collection = context.Request.Form;
            conditions = SetParams(collection, conditions);

            
            //================================================================
            //获取分页和排序信息：页大小，页码，排序方式，排序字段
            int pageRows, page;
            pageRows = 10;
            page = 1;
            string order, sort, oderby; order = sort = oderby = "";
            if (null != context.Request.QueryString["rows"])
            {
                pageRows = int.Parse(context.Request.QueryString["rows"].ToString().Trim());
            }
            if (null != context.Request.QueryString["page"])
            {

                page = int.Parse(context.Request.QueryString["page"].ToString().Trim());

            }
            if (null != context.Request.QueryString["sort"])
            {

                order = context.Request.QueryString["sort"].ToString().Trim();

            }
            if (null != context.Request.QueryString["order"])
            {

                sort = context.Request.QueryString["order"].ToString().Trim();

            }

            //===================================================================
            
            if (sort != "" && order != "")
            {
                //strWhere.AppendFormat(" order by {0} {1}", sort, order);//添加排序
                oderby = order + " " + sort;
            }


            //设置参数和参数类型
            paras =new Object[] {conditions.ToString(),oderby,(page - 1) * pageRows + 1, page * pageRows};
            types =new Type[] {typeof (string), typeof (string), typeof (int),typeof(int)};


            //调用类型中的某个方法:
            //MethodInfo method = obj.GetType().GetMethod(methodName, types); //通过方法名称获得方法
            MethodInfo method = obj.GetType().GetMethod("GetListByPage", types); //通过方法名称获得方法，B下的唯一的方法

            //调用分页的GetList方法
            DataSet ds = (DataSet) method.Invoke(obj, paras);


            //调用类型中的某个方法:
            types = new Type[]{typeof (string)};
            paras = new object[] { conditions.ToString() };
            MethodInfo method2 = obj.GetType().GetMethod("GetRecordCount", types); //通过方法名称获得方法

            int count = (int) method2.Invoke(obj, paras);

            string strJson = ToJson.Dataset2Json(ds, count);
            context.Response.Write(strJson);
            context.Response.End();

        }
        /// <summary>
        /// 执行任意对象update方法
        /// </summary>
        /// <param name="entity">类型</param>
        /// <param name="paras">实体参数</param>
        /// <param name="types">实体类型</param>
        /// <returns></returns>
        public bool Update(Object entity, object[] paras, Type[] types)
        {

            //调用类型中的某个方法:
            types = new Type[] { entity.GetType() };
            paras = new object[] { entity };
            MethodInfo method = obj.GetType().GetMethod("Update", types); //通过方法名称获得方法
            //调用B层下的添加的add方法

            bool IsBool = (bool)method.Invoke(obj, paras);

            return IsBool;


        }
        /// <summary>
        /// 执行任意对象Delete方法
        /// </summary>
        /// <param name="entity">类型</param>
        /// <param name="paras">实体参数</param>
        /// <param name="types">实体类型</param>
        /// <returns></returns>
        public bool Delete(Object entity, object[] paras, Type[] types)
        {
            if (entity != null)
            {
                types = new Type[] { entity.GetType() };//数据类型
                paras = new object[] { entity };
            }
            else
            {
                types = new Type[] { typeof(string) };
               

            }

            MethodInfo method = obj.GetType().GetMethod("Delete", types); //通过方法名称获得方法
            //调用B层下的添加的add方法
            bool IsBool = (bool)method.Invoke(obj, paras);

            return IsBool;

            
          


        }
    /// <summary>
        /// 执行任意对象Add方法
    /// </summary>
    /// <param name="entity">类型</param>
    /// <param name="paras">实体参数</param>
    /// <param name="types">实体类型</param>
    /// <returns></returns>
        public bool Add( Object entity, object[] paras, Type[] types)
        {

            //调用类型中的某个方法:
            types = new Type[] { entity.GetType() };
            paras = new object[] { entity };
            MethodInfo method = obj.GetType().GetMethod("Add", types); //通过方法名称获得方法
            //调用B层下的添加的add方法
           
            bool IsBool = (bool)method.Invoke(obj, paras);

            return IsBool;
          

        }
        /// <summary>
        /// 设置查询条件
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="conditions"></param>
        /// <returns></returns>
        private StringBuilder SetParams(NameValueCollection collection, StringBuilder conditions)
        {
            //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|
            //规定参数类型
            //bt_ss_xxx，bt_es_xxx 表示s:string,i:int，between and的开始参数和结束参数
            //ob_a_xxx,ob_d_xxx 表示order by asc升序和order by desc降序
            //lkd_a_xxx,lkd_l_xxx,lkd_r_xxx ,lkd_ao_xxx,lkd_lo_xxx,lkd_ro_xxx 表示like %keyword%,like %keyword,like keyword%
            //lt_s_xxx,gt_s_xxx,eq_s_xxx,lt_i_xxx,gt_i_xxx,eq_i_xxx, 表示s:string,i:int ;lt:less than,gt:greater than,eq:equals
            //_o_  表示条件不能使用and来连接，改用or关键字
            //
            //
            //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX|

            string key="", value="";
            for (int i = 0; i < collection.Count; i++)
            {
                //获取列名和值
                key = collection.Keys[i]; //或者用collection.GetKey(i);
                value = collection.Get(i);

                //如果是这4个参数，则在分页中处理，这里不做处理
                if ("rows page sort order".IndexOf(key) >= 0) continue;
              
                //如果值为空，跳过该参数
                if (value == "") continue;

                //如果使用_o_则改and为or
                if (key.IndexOf("_o_") >= 0)
                {
                    //替换and关键字成or
                    int startindex = conditions.ToString().LastIndexOf("and");//获取最后一个and的位置
                    if (startindex >= 0)
                    {
                        conditions.Replace("and", "or", startindex, 3);//and关键字替换成or
                        key = key.Replace("o_", "");
                    }
                }



                //如果是 between and,直接读取2个值
                if (key.IndexOf("bt_si_") >= 0)
                {
                    if (i+1< collection.Count && collection.Keys[i + 1].IndexOf("bt_ei_") >= 0)
                    {
                        conditions.AppendFormat("{0} between {1} and {2} and ", key.Replace("bt_si_", ""), value, collection.Get(i + 1));
                        i++;
                        continue;
                    }
                }
                else if (key.IndexOf("bt_ss_") >= 0)
                    {
                        if (i + 1 < collection.Count && collection.Keys[i + 1].IndexOf("bt_es_") >= 0)
                        {
                            conditions.AppendFormat("{0} between '{1}' and '{2}' and ", key.Replace("bt_ss_", ""), value, collection.Get(i + 1));
                            i++;
                            continue;
                        }
                    }

                //暂时只支持一个order by的判断
                if (key.IndexOf("ob_a_") >= 0)
                {
                    if (conditions.ToString().IndexOf("order by") == -1)
                    {
                        conditions.Append(" order by ");
                    }
                    conditions.AppendFormat(" {0} asc ", key.Replace("ob_a_", ""), value);
                }
                else if (key.IndexOf("ob_d_") >= 0)
                {
                    if (conditions.ToString().IndexOf("order by") == -1)
                    {
                        conditions.Append(" order by ");
                    }
                    conditions.AppendFormat(" {0} desc ", key.Replace("ob_d_", ""), value);
                }

                //like 或者是比较 >,<,=
                if (key.IndexOf("lkd_a_") >= 0)
                {
                    conditions.AppendFormat(" {0} like '%{1}%' and ", key.Replace("lkd_a_", ""), value);
                }
                else if (key.IndexOf("lkd_l_") >= 0)
                {
                    conditions.AppendFormat(" {0} like '%{1}' and ", key.Replace("lkd_a_", ""), value);
                }
                else if (key.IndexOf("lkd_r_") >= 0)
                {
                    conditions.AppendFormat(" {0} like '{1}%' and ", key.Replace("lkd_r_", ""), value);
                }
                
                else if (key.IndexOf("lt_s_") >= 0)
                {
                    conditions.AppendFormat(" {0} < '{1}' and ", key.Replace("lt_s_", ""), value);
                }
                else if (key.IndexOf("gt_s_") >= 0)
                {
                    conditions.AppendFormat(" {0} > '{1}' and ", key.Replace("gt_s_", ""), value);
                }
                else if (key.IndexOf("eq_s_") >= 0)
                {
                    conditions.AppendFormat(" {0} = '{1}' and ", key.Replace("eq_s_", ""), value);
                }
                else if (key.IndexOf("lt_i_") >= 0)
                {
                    conditions.AppendFormat(" {0} < {1} and ", key.Replace("lt_i_", ""), value);
                }
                else if (key.IndexOf("gt_i_") >= 0)
                {
                    conditions.AppendFormat(" {0} > {1} and ", key.Replace("gt_i_", ""), value);
                }
                else if (key.IndexOf("eq_i_") >= 0)
                {
                    conditions.AppendFormat(" {0} = {1} and ", key.Replace("eq_i_", ""), value);
                }else{
                    conditions.AppendFormat(" {0} = '{1}' and ", key, value);
                }
			}

            //如果有条件，则删除最后一个and
            if (collection.Count > 0)
            {
                //删除多余的and
                int startindex = conditions.ToString().LastIndexOf("and");//获取最后一个and的位置
                if (startindex >= 0)
                {
                    conditions.Remove(startindex, 3);//删除多余的and关键字
                }
            }

            return conditions;
        }



        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }

这样公共的一般处理程序抽象完之后，再写每个页面对于的一般处理程序的只需写一点点内容，即可实例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data;
using  BLL;
using  Entity;
using System.Text;


namespace CommonModel
{
    /// <summary>
    /// JsonData 的摘要说明
    /// </summary>
    public class JsonData : IHttpHandler
    {
        //实例化对于的B层类
            scoreRuleBLL scorebll = new scoreRuleBLL();

          /// </summary>
        /// 条件查询公告
        /// </summary>
        /// <param name="context"></param>
        
        public void ProcessRequest(HttpContext context)//context中包含前台与后台来回传递的值
        {//判断前台请求的是增删改查的哪一个
            
            string command = context.Request.QueryString["test"];//前台传的标示值
            if (command == null)
            {
                Query(context);
            }
            if (command == "add")
            {//调用添加方法
                Add(context);
            }
            else if (command == "delete")
            {//调用删除方法
                Delete(context);
            }
            else if (command == "modify")
            {//调用修改方法
                Modify(context);
            }
            
        }

        public void Query(HttpContext context)
        {

            //调用Test.ashx的方法
            PublicClass test = new PublicClass();
            test.SetObj(scorebll);//调用相应界面下B层中的类
            //调用公共一版处理程序的查询的方法
            test.Query(context, "", null, null);

            return;



        }
        public bool IsReusable
        {
            get
            {
                return false;
            }
        }

        /// <summary>
        /// 删除记录
        /// </summary>
        /// <param name="context"></param>
        public void Delete(HttpContext context)
        { //实例化实体
            scoreRuleEntity scoreRuleEntity = new scoreRuleEntity();
            scoreRuleEntity.ScoreStyleID = context.Server.UrlDecode(context.Request.QueryString["ID"]);

            object[] paras;
            paras = new object[] { scoreRuleEntity.ScoreStyleID };
            PublicClass test = new PublicClass();//实例化一般处理程序类
            test.SetObj(scorebll);//调用相应界面下B层中的类


          

            //调用共同一版处理程序中的删掉方法
            if (test.Delete(scoreRuleEntity.ScoreStyleID,null,null))
            {
                context.Response.Write("T");
            }
            else
            {
                context.Response.Write("F");
            }




            context.Response.ContentType = "text/plain";
        }
        /// <summary>
        /// 添加记录
        /// </summary>
        /// <param name="context"></param>
        public void Add(HttpContext context)
        {

            //实例化实体
            scoreRuleEntity scoreRuleEntity = new scoreRuleEntity();
            scoreRuleEntity.Score = context.Server.UrlDecode(context.Request.QueryString["lastname"]);
            scoreRuleEntity.ScoreStyleName = context.Server.UrlDecode(context.Request.QueryString["firstname"]);
            scoreRuleEntity.ScoreStyleState = context.Server.UrlDecode(context.Request.QueryString["message"]);
            scoreRuleEntity.ScoreItem = context.Server.UrlDecode(context.Request.QueryString["unit"]);
            PublicClass test = new PublicClass();
            test.SetObj(scorebll);//调用相应界面下B层中的类
            //调用共同一版处理程序中的添加方法
            try
            {
                if (test.Add(scoreRuleEntity,null,null))
                {
                    context.Response.Write("T");
                }
                else
                {
                    context.Response.Write("F");
                }
            }

            catch (System.Exception ex)
            {
                throw ex;
            }
           
        }
        /// <summary>
        /// 修改记录
        /// </summary>
        /// <param name="context"></param>
        public void Modify(HttpContext context)
        {

            //实例化实体
            scoreRuleEntity scoreRuleEntity = new scoreRuleEntity();

            scoreRuleEntity.Score = context.Server.UrlDecode(context.Request.QueryString["lastname"]);
            scoreRuleEntity.ScoreStyleName = context.Server.UrlDecode(context.Request.QueryString["firstname"]);
            scoreRuleEntity.ScoreStyleState = context.Server.UrlDecode(context.Request.QueryString["message"]);
            scoreRuleEntity.ScoreItem = context.Server.UrlDecode(context.Request.QueryString["unit"]);
            scoreRuleEntity.ScoreStyleID = context.Server.UrlDecode(context.Request.QueryString["ID"]);
            PublicClass test = new PublicClass();
            test.SetObj(scorebll);//调用相应界面下B层中的类
            //调用共同一版处理程序中的修改方法
            try
            {
                if (test.Update(scoreRuleEntity, null, null))
                {
                    context.Response.Write("T");
                }
                else
                {
                    context.Response.Write("F");
                }
            }

            catch (System.Exception ex)
            {
                throw ex;
            }
           
        }
    }
}

       这样解决了公共方法传递参数与界面的B层类，大大简化了一般处理程序的的使用，从Web到B层类之间起到了很好的解耦的作用，这只是我们刚刚完善的一部分功能，基于EasyUI+动软逐步实现快速开发，接下来是我们小组的核心内容是灵活配置页面（页面菜单的灵活配置、工具栏的灵活添加、页面数据的灵活配置显隐等这是我们的二期任务），这个过程我们会遇到很多问题，但是这是我们进步的时候到啦，大家有关于这方面的自考可以共同给我们啊，大家共同学习进步。

以下是demo地址，供大家学习使用

大力点击我

参考图示：