我的天
你干脆让他们传进来sql字符串就行了,搞这么多参数
要么也用个params object[]做参数,不过真不推荐这样的写法

而且现在主流都是把sql或者Expression执行结果映射到实体类了
这样的orm框架满大街都是
何必用这种原始的sqlhelper呢,实现还很另类

引用 2 楼 stherix 的回复:

而且现在主流都是把sql或者Expression执行结果映射到实体类了
这样的orm框架满大街都是
何必用这种原始的sqlhelper呢,实现还很另类

说的只是思路 解决办法千万条，   公司项目已经开始写了。    SQL拼装 会被注入的。
映射的话，  更麻烦。   创建一个表 都要对应 一个映射类，     这个方式只是 可以.出来了，  更直观。  但是开发量也上去了
最主要的是 表之间联合查询，  又要创建对应类，  或者修改主表类映射。    orm看起来直观，  维护起来我可不觉得简单。   而且如果2个人需要的数据可能就差几个字段， 你说他俩是维护一个类 然后往里添加， 还是各起各的类。

我看来 最好的是扔SQL 或者存储过程 。   但是直接SQL 会被注入。    防注入就得用参数化，无论SQL语句 还是存储过程。
上面封装只是个例子，  一旦封装OK了，  程序猿 其实也是拼装SQL 然后调用 类，  麻烦都在ABC公共类里。 他们又不用管

引用 3 楼 好奇都是要学的 的回复:

Quote: 引用 2 楼 stherix 的回复:

而且现在主流都是把sql或者Expression执行结果映射到实体类了
这样的orm框架满大街都是
何必用这种原始的sqlhelper呢,实现还很另类

说的只是思路 解决办法千万条，   公司项目已经开始写了。    SQL拼装 会被注入的。
映射的话，  更麻烦。   创建一个表 都要对应 一个映射类，     这个方式只是 可以.出来了，  更直观。  但是开发量也上去了
最主要的是 表之间联合查询，  又要创建对应类，  或者修改主表类映射。    orm看起来直观，  维护起来我可不觉得简单。   而且如果2个人需要的数据可能就差几个字段， 你说他俩是维护一个类 然后往里添加， 还是各起各的类。

我看来 最好的是扔SQL 或者存储过程 。   但是直接SQL 会被注入。    防注入就得用参数化，无论SQL语句 还是存储过程。
上面封装只是个例子，  一旦封装OK了，  程序猿 其实也是拼装SQL 然后调用 类，  麻烦都在ABC公共类里。 他们又不用管

写几个实体类还会比去DataSet里取数据还麻烦吗?
至于sql注入,都是业务层去处理这个,因为只有字符串格式的输入数据才有可能被注入
而业务层是知道自己所需要的数据的格式,比如人的姓名,所以含有各种引号分号的可以被检查出来

public class BasicDAL<T> where T : class,new()

    {

        AutomobileInsuranceEntities db = new AutomobileInsuranceEntities();



        /// <summary>

        /// 按条件查询返回对应的实体集，并且排序输出对应页码数据

        /// </summary>

        /// <typeparam name="f"></typeparam>

        /// <param name="where"></param>

        /// <param name="orderby"></param>

        /// <param name="page"></param>

        /// <param name="size"></param>

        /// <returns></returns>

        public IQueryable<T> GetEntities<f>(Expression<Func<T, bool>> where, Expression<Func<T, f>> orderby, int page, int size)

        {

            try

            {

                return db.Set<T>().Where<T>(where).OrderBy<T, f>(orderby).Skip((page - 1) * size).Take(size);

            }

            catch (Exception)

            {



                throw;

            }

        }



        /// <summary>

        /// 按条件查询并排序返回对应的实体集，并且排序输出对应页码数据

        /// </summary>

        /// <typeparam name="f"></typeparam>

        /// <param name="where"></param>

        /// <param name="orderby"></param>

        /// <param name="page"></param>

        /// <param name="size"></param>

        /// <param name="flog"></param>

        /// <returns></returns>

        public IQueryable<T> GetEntities<f>(Expression<Func<T, bool>> where, Expression<Func<T, f>> orderby, int page, int size, string flog)

        {

            try

            {

                if (flog == "asc")

                {

                    return db.Set<T>().Where<T>(where).OrderBy<T, f>(orderby).Skip((page - 1) * size).Take(size);

                }

                else

                {

                    return db.Set<T>().Where<T>(where).OrderByDescending<T, f>(orderby).Skip((page - 1) * size).Take(size);

                }

            }

            catch (Exception)

            {



                throw;

            }

        }



        /// <summary>

        /// 返回指定条件的实体集

        /// </summary>

        /// <typeparam name="f"></typeparam>

        /// <param name="where"></param>

        /// <param name="orderby"></param>

        /// <returns></returns>

        public IQueryable<T> GetEntities<f>(Expression<Func<T, bool>> where, Expression<Func<T, f>> orderby)

        {

            try

            {

                return db.Set<T>().Where<T>(where).OrderBy<T, f>(orderby);

            }

            catch (Exception)

            {



                throw;

            }

        }



        /// <summary>

        /// 按指定条件返回一个实体

        /// </summary>

        /// <param name="where"></param>

        /// <returns></returns>

        public T GetEntity(Expression<Func<T, bool>> where)

        {

            try

            {

                return db.Set<T>().Where<T>(where).FirstOrDefault();

            }

            catch (Exception)

            {



                throw;

            }

        }

        /// <summary>

        /// 新增实体

        /// </summary>

        /// <param name="entity"></param>

        /// <returns></returns>

        public T AddEntity(T entity)

        {

            try

            {

                db.Set<T>().Add(entity);

                db.SaveChanges();

                return entity;

            }

            catch (Exception)

            {



                throw;

            }

        }



        /// <summary>

        /// 删除实体

        /// </summary>

        /// <param name="entity"></param>

        /// <returns></returns>

        public bool DeleteEntity(T entity)

        {

            try

            {

                db.Entry<T>(entity).State = System.Data.EntityState.Deleted;

                db.SaveChanges();

                return true;

            }

            catch (Exception)

            {



                throw;

            }

        }

        /// <summary>

        /// 更新实体

        /// </summary>

        /// <param name="id"></param>

        /// <param name="entity"></param>

        /// <returns></returns>

        public bool UpdateEntity(int id, T entity)

        {

            try

            {

                var entry = db.Entry(entity);

                if (entry.State == EntityState.Detached)

                {

                    var set = db.Set<T>();

                    T obj = set.Local.SingleOrDefault(p => ((dynamic)p).ID == id);

                    if (obj != null)

                    {

                        var attacheEntry = db.Entry(obj);

                        attacheEntry.CurrentValues.SetValues(entity);

                    }

                    else

                    {

                        entry.State = EntityState.Modified;

                    }

                }

                if (db.SaveChanges()>0)

                {

                    return true;

                }

                else

                {

                    return true;

                }

                

            }

            catch (Exception)

            {



                throw;

            }

        }



        /// <summary>

        /// 用指定SQL语句及参数进行（增，删，改）

        /// </summary>

        /// <param name="sql"></param>

        /// <param name="pars"></param>

        /// <returns></returns>

        public int ExecuteSql(string sql, params ObjectParameter[] pars)

        {

            try

            {

                return db.Database.ExecuteSqlCommand(sql, pars);

            }

            catch (Exception)

            {

                

                throw;

            }

        }



        /// <summary>

        /// 用指定SQL语句进行操作（查询）

        /// </summary>

        /// <param name="sql"></param>

        /// <param name="obj"></param>

        /// <returns></returns>

        public dynamic ExecuteSelect(string sql, params ObjectParameter[] obj)

        {

            try

            {

                return db.Database.SqlQuery<string>(sql, obj).ToList();

            }

            catch (Exception)

            {

                

                throw;

            }

        }



        /// <summary>

        /// 

        /// </summary>

        public void Dispose()

        {

            db.Dispose();

        }



    }

这是我学三层架构的时候  我们老师给我的，方法很少，你可以看看

而且可以对字符串里的单引号,双引号进行转义
自己再手动两边加上引号,这样怎么都不可能被注入

引用 4 楼 stherix 的回复:

Quote: 引用 3 楼 好奇都是要学的 的回复:

Quote: 引用 2 楼 stherix 的回复:

而且现在主流都是把sql或者Expression执行结果映射到实体类了
这样的orm框架满大街都是
何必用这种原始的sqlhelper呢,实现还很另类

说的只是思路 解决办法千万条，   公司项目已经开始写了。    SQL拼装 会被注入的。
映射的话，  更麻烦。   创建一个表 都要对应 一个映射类，     这个方式只是 可以.出来了，  更直观。  但是开发量也上去了
最主要的是 表之间联合查询，  又要创建对应类，  或者修改主表类映射。    orm看起来直观，  维护起来我可不觉得简单。   而且如果2个人需要的数据可能就差几个字段， 你说他俩是维护一个类 然后往里添加， 还是各起各的类。

我看来 最好的是扔SQL 或者存储过程 。   但是直接SQL 会被注入。    防注入就得用参数化，无论SQL语句 还是存储过程。
上面封装只是个例子，  一旦封装OK了，  程序猿 其实也是拼装SQL 然后调用 类，  麻烦都在ABC公共类里。 他们又不用管

写几个实体类还会比去DataSet里取数据还麻烦吗?
至于sql注入,都是业务层去处理这个,因为只有字符串格式的输入数据才有可能被注入
而业务层是知道自己所需要的数据的格式,比如人的姓名,所以含有各种引号分号的可以被检查出来

参数化的意思 就是想让程序猿专心写程序， 根本不用考虑注入

真不知道你干什么。这么简单，被还搞复杂化了。一个LIST就搞定了。

引用 6 楼 stherix 的回复:

而且可以对字符串里的单引号,双引号进行转义
自己再手动两边加上引号,这样怎么都不可能被注入

你说的 是我上个项目用的，  所有单引号 都替换成 2个 单引号，    觉得防注入，   但是有的时候  程序猿会忘记套用
比如  select * from a where a='"+rep(txt)+"' ;        忘记后就是 select * from a where a='"+txt+"' ;        rep写到哪里 带到哪里  

引用 8 楼 Fucking888 的回复:

真不知道你干什么。这么简单，被还搞复杂化了。一个LIST就搞定了。

哥们 list 怎么搞定啊。  反序列吗？   list<T> 吗？