winform中利用反射实现泛型数据访问对象基类

考虑到软件使用在客户端,同时想简化代码的实现,就写了一个泛型的数据访问对象基类,并不是特别健全,按道理应该参数化的方式实现insert和update,暂未使用参数化,抽时间改进。

 /// <summary>
    /// DAO基类 实体名必须要与数据表字段名一致
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class BaseDao<T> where T : new()
    {
        protected DataModule dataModule = new DataModule();

        /// <summary>
        /// 表名
        /// </summary>
        public virtual string TableName { get; set; }

        /// <summary>
        /// 主键ID
        /// </summary>
        public virtual string PrimaryKey { get; set; }

        /// <summary>
        /// 实体属性
        /// </summary>
        private PropertyInfo[] properties = null;

        /// <summary>
        /// 实体类型
        /// </summary>
        private readonly Type t = typeof(T);

        public BaseDao()
        {
            t = typeof(T);
            properties = t.GetProperties();
        }

        public BaseDao(string tableName, string primaryKey)
            : this()
        {
            this.TableName = tableName;
            this.PrimaryKey = primaryKey;
        }

        public string GetMaxID()
        {
            string sql = "select max(cast(" + PrimaryKey + " as int)) as MaxId from " + TableName;
            DataTable dt = dataModule.GetDataTable(sql);
            if (dt.Rows[0][0] == DBNull.Value)
            {
                return "1";
            }
            else
            {
                return (Convert.ToInt64(dt.Rows[0][0]) + 1).ToString();
            }
        }

        /// <summary>
        /// 清除实体字段
        /// </summary>
        /// <param name="entity"></param>
        public void ClearT(ref T entity)
        {
            entity = default(T);
            entity = new T();
        }

        /// <summary>
        /// 获取实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetT(string id)
        {
            string sql = "select * from " + TableName + " where " + PrimaryKey + "=‘" + id + "‘";
            DataTable dt = dataModule.GetDataTable(sql);
            T entity = new T();
            return SetEntityValue(dt, entity);
        }

        /// <summary>
        /// 根据多个条件获取实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public T GetT(T entity)
        {
            StringBuilder sql = new StringBuilder("select * from " + TableName + " where ");
            string where = GetWhereConditionSQL(entity);
            sql.Append(where);
            DataTable dt = dataModule.GetDataTable(sql.ToString());
            return SetEntityValue(dt, entity);
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="e"></param>
        /// <returns></returns>
        public bool InsertT(T entity)
        {
            StringBuilder sql = new StringBuilder("");

            if (string.IsNullOrEmpty(TableName))
            {
                TableName = t.FullName.TrimStart((t.Namespace + ".").ToArray());
            }
            t.GetProperty(PrimaryKey).SetValue(entity, GetMaxID(), null);
            sql.Append(" Insert into " + TableName + " ( ");
            StringBuilder insertFields = new StringBuilder("");
            StringBuilder insertValues = new StringBuilder("");
            foreach (PropertyInfo property in properties)
            {
                if (property.GetValue(entity, null) != null)
                {
                    insertFields.Append("" + property.Name + ",");
                    if (property.PropertyType == typeof(string))
                    {
                        insertValues.Append("‘" + property.GetValue(entity, null).ToString() + "‘,");
                    }
                    else if (property.PropertyType == typeof(DateTime?))
                    {
                        insertValues.Append("‘" + Convert.ToDateTime(property.GetValue(entity, null)).ToString("yyyy-MM-dd HH:mm:ss") + "‘,");
                    }
                    else if (property.PropertyType == typeof(int?) || property.PropertyType == typeof(long?) || property.PropertyType == typeof(double?) || property.PropertyType == typeof(float?) || property.PropertyType == typeof(decimal?))
                    {
                        insertValues.Append("" + property.GetValue(entity, null).ToString() + ",");
                    }
                    else
                    {
                        insertValues.Append("‘" + property.GetValue(entity, null).ToString() + "‘,");
                    }
                }

            }
            sql.Append(insertFields.ToString().TrimEnd(‘,‘));
            sql.Append(" ) VALUES ( ");
            sql.Append(insertValues.ToString().TrimEnd(‘,‘));
            sql.Append(")");

            return dataModule.ExcuteSql(sql.ToString());
        }

        public bool UpdateT(T entity)
        {
            StringBuilder sql = new StringBuilder("");
            //获取主键ID的值
            string id = string.Empty;
            if (t.GetProperty(PrimaryKey).GetValue(entity, null) != null)
            {
                id = t.GetProperty(PrimaryKey).GetValue(entity, null).ToString();
            }
            if (string.IsNullOrEmpty(TableName))
            {
                TableName = t.FullName.TrimStart((t.Namespace + ".").ToArray());
            }

            sql.Append(" update " + TableName + " set ");
            StringBuilder updateValues = new StringBuilder("");
            foreach (PropertyInfo property in properties)
            {
                if (property.GetValue(entity, null) != null)
                {
                    if (property.PropertyType == typeof(string))
                    {
                        updateValues.Append(property.Name + "=‘" + property.GetValue(entity, null) + "‘,");
                    }
                    else if (property.PropertyType == typeof(DateTime?))
                    {
                        updateValues.Append(property.Name + "=‘" + Convert.ToDateTime(property.GetValue(entity, null)).ToString("yyyy-MM-dd HH:mm:ss") + "‘,");
                    }
                    else if (property.PropertyType == typeof(int?) || property.PropertyType == typeof(long?) || property.PropertyType == typeof(double?) || property.PropertyType == typeof(float?) || property.PropertyType == typeof(decimal?))
                    {
                        updateValues.Append(property.Name + "=" + property.GetValue(entity, null) + ",");
                    }
                    else
                    {
                        updateValues.Append(property.Name + "=‘" + property.GetValue(entity, null) + "‘,");
                    }

                }

            }
            sql.Append(updateValues.ToString().TrimEnd(‘,‘));
            sql.Append(" where " + PrimaryKey + "=" + id);

            return dataModule.ExcuteSql(sql.ToString());
        }

        /// <summary>
        /// 根据多个字段删除实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public bool DeleteT(T entity)
        {
            StringBuilder sql = new StringBuilder("delete from " + TableName + " where ");
            string where = GetWhereConditionSQL(entity);
            sql.Append(where);
            return dataModule.ExcuteSql(sql.ToString());
        }

        /// <summary>
        /// 根据主键删除实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool DeleteT(string id)
        {
            StringBuilder sql = new StringBuilder("delete from " + TableName + " where " + PrimaryKey + "=‘" + id + "‘");
            return dataModule.ExcuteSql(sql.ToString());
        }

        /// <summary>
        /// 获取where 条件sql
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private string GetWhereConditionSQL(T entity)
        {
            StringBuilder whereCondition = new StringBuilder("");
            foreach (PropertyInfo property in properties)
            {
                if (property.GetValue(entity, null) != null)
                {
                    if (property.PropertyType == typeof(string))
                    {
                        whereCondition.Append(" " + property.Name + "=‘" + property.GetValue(entity, null) + "‘ and");
                    }
                    else if (property.PropertyType == typeof(DateTime?))
                    {
                        whereCondition.Append(" " + property.Name + "=‘" + Convert.ToDateTime(property.GetValue(entity, null)).ToString("yyyy-MM-dd HH:mm:ss") + "‘ and");
                    }
                    else if (property.PropertyType == typeof(int?) || property.PropertyType == typeof(long?) || property.PropertyType == typeof(double?) || property.PropertyType == typeof(float?) || property.PropertyType == typeof(decimal?))
                    {
                        whereCondition.Append(" " + property.Name + "=" + property.GetValue(entity, null) + " and");
                    }
                    else
                    {
                        whereCondition.Append(" " + property.Name + "=‘" + property.GetValue(entity, null) + "‘ and");
                    }
                    if (property.Name == PrimaryKey)
                    {
                        break;
                    }
                }

            }
            return whereCondition.ToString().TrimEnd("and".ToArray());
        }

        /// <summary>
        /// 设置实体属性值
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        private T SetEntityValue(DataTable dt, T entity)
        {
            if (dt != null && dt.Rows.Count > 0)
            {
                foreach (PropertyInfo property in properties)
                {
                    if (dt.Rows[0][property.Name] != DBNull.Value)
                    {
                        if (property.PropertyType == typeof(string))
                        {
                            t.GetProperty(property.Name).SetValue(entity, dt.Rows[0][property.Name], null);
                        }
                        else if (property.PropertyType == typeof(int?))
                        {
                            t.GetProperty(property.Name).SetValue(entity, Convert.ToInt32(dt.Rows[0][property.Name]), null);
                        }
                        else if (property.PropertyType == typeof(DateTime?))
                        {
                            t.GetProperty(property.Name).SetValue(entity, Convert.ToDateTime(dt.Rows[0][property.Name]), null);
                        }
                        else if (property.PropertyType == typeof(long?))
                        {
                            t.GetProperty(property.Name).SetValue(entity, Convert.ToInt64(dt.Rows[0][property.Name]), null);
                        }
                        else if (property.PropertyType == typeof(double?))
                        {
                            t.GetProperty(property.Name).SetValue(entity, Convert.ToDouble(dt.Rows[0][property.Name]), null);
                        }
                        else
                        {
                            t.GetProperty(property.Name).SetValue(entity, dt.Rows[0][property.Name], null);
                        }

                    }
                }
                return entity;
            }
            else
            {
                return default(T);
            }
        }

    }

如何使用,通过将表名和主键字段名传入进去,如果多个字段是主键的情况下,可以建一个主键列,然后将多个主键的列改为索引,因为任何一个表都可以创建出一个主键列,所以暂时不影响我使用

   public BaseDao<TrafficEvent> EventDao = new BaseDao<TrafficEvent>("Sj_Event", "EventId");

UI层可以同过这种方式直接调用,目前可以暂时满足我的开发

eventBiz.EventDao.InsertT(trafficEvent)
eventBiz.EventDao.UpdateT(trafficEvent)
时间: 2024-10-16 04:51:11

winform中利用反射实现泛型数据访问对象基类的相关文章

利用反射和泛型把Model对象按行储存进数据库以及按行取出然后转换成Model 类实例 MVC网站通用配置项管理

利用反射和泛型把Model对象按行储存进数据库以及按行取出然后转换成Model 类实例 MVC网站通用配置项管理 2018-3-10 15:18 | 发布:Admin | 分类:代码库 | 评论:0 | 浏览:45 | 该类在MVC中可以方便管理配置信息,可以直接把Model储存进数据库或者从数据库去除数据转为Model. 1 何为配置项目? 比如网站的名称,页脚信息,meta中的KeyWord信息等,如果不想硬编码到网页里,就需要使用配置文件进行储存,通常都是储存到数据库中.使用的时候读取出来

【设计模式】数据访问对象模式

数据访问对象模式(Data Access Object Pattern)或 DAO 模式用于把低级的数据访问 API 或操作从高级的业务服务中分离出来.以下是数据访问对象模式的参与者. 数据访问对象接口(Data Access Object Interface) - 该接口定义了在一个模型对象上要执行的标准操作. 数据访问对象实体类(Data Access Object concrete class) - 该类实现了上述的接口.该类负责从数据源获取数据,数据源可以是数据库,也可以是 xml,或者

Java数据访问对象模式

数据访问对象模式或DAO模式用于将低级数据访问API或操作与高级业务服务分离. 以下是数据访问对象模式的参与者. 数据访问对象接口 - 此接口定义要对模型对象执行的标准操作. 数据访问对象具体类 - 此类实现上述接口. 这个类负责从数据源获取数据,数据源可以是数据库/xml或任何其他存储机制. 模型对象或值对象 - 此对象是简单的POJO,包含用于存储使用DAO类检索的数据的get/set方法. 实现实例 在这个将创建一个作为Model或Value对象的Student对象. StudentDao

java中利用反射机制绕开编译器对泛型的类型限制

首先看下面这个例子 public static void main(String[] args) { ArrayList<Integer> al1 = new ArrayList<Integer>(); al1.add(1); ArrayList<String> al2 = new ArrayList<String>(); al2.add("hello"); //int型链表和string型链表,结果为true System.out.pr

DataTable转任意类型对象List数组-----工具通用类(利用反射和泛型)

public class ConvertHelper<T> where T : new() { /// <summary> /// 利用反射和泛型 /// </summary> /// <param name="dt"></param> /// <returns></returns> public static List<T> ConvertToList(DataTable dt) { //

Hadoop 中利用 mapreduce 读写 mysql 数据

Hadoop 中利用 mapreduce 读写 mysql 数据 有时候我们在项目中会遇到输入结果集很大,但是输出结果很小,比如一些 pv.uv 数据,然后为了实时查询的需求,或者一些 OLAP 的需求,我们需要 mapreduce 与 mysql 进行数据的交互,而这些特性正是 hbase 或者 hive 目前亟待改进的地方. 好了言归正传,简单的说说背景.原理以及需要注意的地方: 1.为了方便 MapReduce 直接访问关系型数据库(Mysql,Oracle),Hadoop提供了DBInp

谈一谈:抽象工厂+反射+配置文件 实现数据访问程序

<大话设计模式>中第15章中<就不能不换DB吗?>引出了我今天要谈论的主题:抽象工厂+反射+配置文件 实现数据访问程序.当时也不甚理解啊!到了机房收费的亲身实践中,终于体会到了这对组合的奥秘. 抽象工厂模式(Abstract Factory) 提供一个创建一系列相关或相互依赖对象的接口,而无需制定它们具体的类.知道它是用来创建工厂的就OK了. 反射 提供了封装程序集.模块和类型的对象.这里仅仅用到反射的一部分功能.且记住它的格式: Assembly.Load("程序集名称

一个通用的数据访问层实现类

在java商城开发中以及人事系统开发中我们知道会涉及到很多的数据表,如果每一个数据库都按照我们开发人员所定义的那样一个表,一个实现类,然后是一个数据访问层接口,数据访问层实现类,业务逻辑层接口,业务逻辑层实现类...这样写下去,代码量无疑是很大的. 下面我们就介绍一个基本的数据访问层实现类,至于接口的定义,我想只要明白实现类,接口的定义应该很简单. ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

解析大型.NET ERP系统数据访问 对象关系映射框架LLBL Gen Pro

LLBL Gen Pro是一个为.NET开发人员设计的的对象关系映射(ORM)框架,与NHibernate,Entity Framework等框架一样,通过实体与数据表的映射,实现关系数据库持久化. 1  LLBL Gen Pro 入门  LLBL Gen Pro Basic 打开LLBL Gen Pro程序,在右边的数据库浏览器(Catelog Explorer)中根结点右键选择从关系数据库创建关系模型( Add Relational Model Data from a Database),然