自动增长的主键字段是只好东西。会使用很多基类的操作。

电动增长的主键字段是只好东西,提供了一个较起含义以及而阅览之字段内容(相对GUID来说),插入的时节,不用管它的价值,数据库自动追加;但它也是一个不好的东西,如果管理不好,可能会见招冲突。本文暂且不讨论其优劣,因为在就是是坚强道理,很多上,我们且是利用自增长字段的,特别是对SqlServer数据开发来说。

相似的话,对网的分段,一般还需下面几乎个层:实体层(Entity)、数据访问层(DAL)、业务逻辑层(BLL)、界面层(UI);而数据访问层,一般也会见参加一个接口层(IDAL)。
在里头的实体层,一般是基于数据库进行映射外加入注释等,技术含量不怪,在是如出一辙笔带了;数据库访问层以及作业逻辑层,是重要之四海,因为此地好的规划,会采取很多基类的操作,减少过多代码和重复劳动;界面层,不管是WebForm还是WinForm,都是尽可能少的逻辑代码或者SQL语句以中,好的种或者会见以有了不起的控件进去,提高体验,减少代码。另外,由于部分创立操作费时费资源,一般还索要拿可重复用的资源缓存起来,提高性能。
优先给大家预览下路之框架,再同稀有分析议论:

 本文阐述一下以Database2Sharp(软件下充斥地址:http://www.iqidi.com/database2sharp.htm)生成的Enterprise
Library架构如何落实Oracle的起增长之支撑。同时为会见顺手说说对SqlServer、Access的兑现。

1、
实体层(定义一个缺损的基类,其他实体类继承之,主要是为着使泛型操作,用途下面细说)

 Database2Sharp生成的Enterprise
Library架构其实对Oracle内置了针对从增长序列的支撑,在数据库访问层的基类BaseDAL中,我们看出底的代码。

    public class BaseEntity
    {    
    }

     /// <summary>

    public class EquipmentInfo : BaseEntity
    {    
        Field Members#region Field Members

        private int m_ID = 0; //ID          
        private string m_PartID = “”; //备件编号           
        //

        #endregion

        Property Members#region Property Members
        
        /**//// <summary>
        /// ID
        /// </summary>
        public virtual int ID
        {
            get
            {
                return this.m_ID;
            }
            set
            {
                this.m_ID = value;
            }
        }

        /**//// <summary>
        /// 备件编号
        /// </summary>
        public virtual string PartID
        {
            get
            {
                return this.m_PartID;
            }
            set
            {
                this.m_PartID = value;
            }
        }

        //

        #endregion

    }

    /// 数据访问层的基类
    /// </summary>
    public abstract class BaseDAL<T> : IBaseDAL<T> where T : BaseEntity, new()
    {
        #region 构造函数

2、
数据库访问层,数据访问层的严重性是多少访问基类的统筹,基类实现多数数据库的通常操作,如下:

        protected string tableName;//需要初始化的靶子表名
        protected string primaryKey;//数据库的主键字段名
        protected string sortField = “ID”;//排序字段
        private bool isDescending = false;//

    /**//// <summary>
    /// 数据访问层的基类
    /// </summary>
    public abstract class BaseDAL<T> : IBaseDAL<T> where T : BaseEntity, new()
    {
}

        protected string selectedFields = ” * “;//选择的字段,默认为所有(*)
        private string seqField = “”;//指定特别字段是因此序列来控制其的价值的,一般为主键
        private string seqName = “”;//指定的行列名称,建议规则为:SEQ_表名称
        
        /// <summary>
        /// 指定特别字段是因此序列来决定它们的值的,一般为主键
        /// </summary>
        public string SeqField
        {
            get { return seqField; }
            set { seqField = value; }
        }

BaseEntity就是实体类的基类,IBaseDAL是概念的数码看基类接口,包含各种常用的操作定义;因此BaseDAL就是设对各种操作的展开落实,实现接口越多,将来继承类的用程度就越是强。
如上通过泛型<T> ,我们就可解实例化那个具体访问类的信了,可以兑现强类型的函数定义。

        /// <summary>
        /// 指定的班名称,建议规则为:SEQ_表名称
        /// </summary>
        public string SeqName
        {
            get { return seqName; }
            set { seqName = value; }
        }

    /**//// <summary>
    /// 一些核心的,作为辅助函数的接口
    /// </summary>
    public interface IBaseDAL<T> where T : BaseEntity
    {
        /**//// <summary>
        /// 查询数据库,检查是否是指定键值的对象
        /// </summary>
        /// <param name=”recordTable”>Hashtable:键[key]呢字段名;值[value]啊字段对应之值</param>
        /// <returns>存在则归<c>true</c>,否则也<c>false</c>。</returns>
        bool IsExistKey(Hashtable recordTable);

        /**//// <summary>
        /// 查询数据库,检查是否存在指定键值的对象
        /// </summary>
        /// <param name=”fieldName”>指定的特性名</param>
        /// <param name=”key”>指定的值</param>
        /// <returns>存在则归<c>true</c>,否则也<c>false</c>。</returns>
        bool IsExistKey(string fieldName, object key);

        /**//// <summary>
        /// 获取数据库中该对象的最为要命ID值
        /// </summary>
        /// <returns>最大ID值</returns>
        int GetMaxID();

        /**//// <summary>
        /// 根据指定对象的ID,从数据库被删除指定对象
        /// </summary>
        /// <param name=”key”>指定对象的ID</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        bool DeleteByKey(string key);
        
        /**//// <summary>
        /// 根据条件,从数据库被删除指定对象
        /// </summary>
        /// <param name=”condition”>删除记录之口径语句</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        bool DeleteByCondition(string condition);


        /**//// <summary>
        /// 插入指定对象到数据库被
        /// </summary>
        /// <param name=”obj”>指定的对象</param>
        /// <returns>执行成功返回True</returns>
        bool Insert(T obj);

        /**//// <summary>
        /// 更新目标属性到数据库被
        /// </summary>
        /// <param name=”obj”>指定的靶子</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        bool Update(T obj, string primaryKeyValue);

        /**//// <summary>
        /// 查询数据库,检查是否是指定ID的靶子(用于整型主键)
        /// </summary>
        /// <param name=”key”>对象的ID值</param>
        /// <returns>存在则赶回指定的对象,否则回Null</returns>
        T FindByID(int key);

        /**//// <summary>
        /// 查询数据库,检查是不是存在指定ID的目标(用于字符型主键)
        /// </summary>
        /// <param name=”key”>对象的ID值</param>
        /// <returns>存在则归指定的目标,否则回Null</returns>
        T FindByID(string key);

        返回集合的接口#region 返回集合的接口

        /**//// <summary>
        /// 根据ID字符串(逗号分隔)获取对象列表
        /// </summary>
        /// <param name=”idString”>ID字符串(逗号分隔)</param>
        /// <returns>符合条件的目标列表</returns>
        List<T> FindByIDs(string idString);

        /**//// <summary>
        /// 根据标准查询数据库,并赶回对象集合
        /// </summary>
        /// <param name=”condition”>查询的法</param>
        /// <returns>指定对象的集合</returns>
        List<T> Find(string condition);

        /**//// <summary>
        /// 根据条件查询数据库,并返对象集合(用于分页数据展示)
        /// </summary>
        /// <param name=”condition”>查询的规格</param>
        /// <param name=”info”>分页实体</param>
        /// <returns>指定对象的集合</returns>
        List<T> Find(string condition, PagerInfo info);

        /**//// <summary>
        /// 返回数据库有的靶子集合
        /// </summary>
        /// <returns>指定对象的集合</returns>
        List<T> GetAll();

        /**//// <summary>
        /// 返回数据库有的目标集合(用于分页数据展示)
        /// </summary>
        /// <param name=”info”>分页实体信息</param>
        /// <returns>指定对象的集合</returns>                
        List<T> GetAll(PagerInfo info);

        DataSet GetAllToDataSet(PagerInfo info);

        #endregion
    }

马上段代码定义了零星个属性,一个凡排字段名称(一般是主键,如ID),一个凡是我们为该字段指定的行列对象名称,我们这边建议之称是”SEQ_表名称”,当然为足以利用任意的称号,合理统一就得了。这简单只属性在基类不欲修改,只待以现实的数额访问对象(如数据看层中之Customer类)构造函数中,指定序列字段和班对象即可。

审视上面代码,会发觉由于一个PagerInfo 的类,这个近乎是故来做分页参数传递作用的,根据是参数,你得了解具体返回那些关注的笔录信息,这些记录同时变为强类型的List<T>集合。
再省数据库访问基类的切切实实落实代码吧:
    /**//// <summary>
    /// 数据访问层的基类
    /// </summary>
    public abstract class BaseDAL<T> : IBaseDAL<T> where T : BaseEntity, new()
    {
        构造函数#region 构造函数

        protected string tableName;//需要初始化的目标表名
        protected string primaryKey;//数据库的主键字段名
        protected string sortField = “LastUpdated”;//排序字段
        private bool isDescending = true;//
        
        /**//// <summary>
        /// 排序字段
        /// </summary>
        public string SortField
        {
            get 
            {
                return sortField; 
            }
            set 
            {
                sortField = value; 
            }
        }

        /**//// <summary>
        /// 是否也降序
        /// </summary>
        public bool IsDescending
        {
            get { return isDescending; }
            set { isDescending = value; }
        }       

        /**//// <summary>
        /// 数据库访问对象的表名
        /// </summary>
        public string TableName
        {
            get
            {
                return tableName;
            }
        }

        /**//// <summary>
        /// 数据库访问对象的外键约束
        /// </summary>
        public string PrimaryKey
        {
            get
            {
                return primaryKey;
            }
        }
        
        public BaseDAL()
        {}

        /**//// <summary>
        /// 指定表名以及主键,对基类进组织
        /// </summary>
        /// <param name=”tableName”>表名</param>
        /// <param name=”primaryKey”>表主键</param>
        public BaseDAL(string tableName, string primaryKey)
        {
            this.tableName = tableName;
            this.primaryKey = primaryKey;
        }

        #endregion

        通用操作方法#region 通用操作方法

        /**//// <summary>
        /// 添加记录
        /// </summary>
        /// <param name=”recordField”>Hashtable:键[key]也字段名;值[value]呢字段对应的值</param>
        /// <param name=”trans”>事务对象,如果下工作,传入事务对象,否则也Null不利用工作</param>
        public bool Insert(Hashtable recordField, DbTransaction trans)
        {
            return this.Insert(recordField, tableName, trans);
        }

        /**//// <summary>
        /// 添加记录
        /// </summary>
        /// <param name=”recordField”>Hashtable:键[key]也字段名;值[value]呢字段对应的值</param>
        /// <param name=”targetTable”>需要操作的目标表名称</param>
        /// <param name=”trans”>事务对象,如果采用工作,传入事务对象,否则也Null不使工作</param>
        public bool Insert(Hashtable recordField, string targetTable, DbTransaction trans)
        {
            bool result = false;
            string fields = “”; // 字段名
            string vals = “”; // 字段值
            if ( recordField == null || recordField.Count < 1 )
            {
                return result;
            }

            SqlParameter[] param = new SqlParameter[recordField.Count];
            IEnumerator eKeys = recordField.Keys.GetEnumerator();

            int i = 0;
            while ( eKeys.MoveNext() )
            {
                string field = eKeys.Current.ToString();
                fields += field + “,”;
                vals += string.Format(“@{0},”, field);
                object val = recordField[eKeys.Current.ToString()];
                param[i] = new SqlParameter(“@” + field, val);

                i++;
            }

            fields = fields.Trim(‘,’);//除去前后的逗号
            vals = vals.Trim(‘,’);//除去前后的逗号
            string sql = string.Format(“INSERT INTO {0} ({1}) VALUES ({2})”, targetTable, fields, vals);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);
            command.Parameters.AddRange(param);

            if ( trans != null )
            {
                result = db.ExecuteNonQuery(command, trans) > 0;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > 0;
            }

            return result;
        }
        
        /**//// <summary>
        /// 更新某个表一长达记下(只适用于用单键,用int类型作键值的表明)
        /// </summary>
        /// <param name=”id”>ID号</param>
        /// <param name=”recordField”>Hashtable:键[key]也字段名;值[value]呢字段对应之值</param>
        /// <param name=”trans”>事务对象,如果以工作,传入事务对象,否则也Null不动工作</param>
        public bool Update(int id, Hashtable recordField, DbTransaction trans)
        {
            return this.Update(id, recordField, tableName, trans);
        }

        /**//// <summary>
        /// 更新某个表一漫漫记下(只适用于用单键,用string类型作键值的表明)
        /// </summary>
        /// <param name=”id”>ID号</param>
        /// <param name=”recordField”>Hashtable:键[key]为字段名;值[value]呢字段对应之值</param>
        /// <param name=”trans”>事务对象,如果利用工作,传入事务对象,否则也Null不应用工作</param>
        public bool Update(string id, Hashtable recordField, DbTransaction trans)
        {
            return this.Update(id, recordField, tableName, trans);
        }

        /**//// <summary>
        /// 更新某个表一长长的记下(只适用于用单键,用int类型作键值的表明)
        /// </summary>
        /// <param name=”id”>ID号</param>
        /// <param name=”recordField”>Hashtable:键[key]否字段名;值[value]也字段对应之值</param>
        /// <param name=”targetTable”>需要操作的目标表名称</param>
        /// <param name=”trans”>事务对象,如果利用工作,传入事务对象,否则也Null不采取工作</param>
        public bool Update(int id, Hashtable recordField, string targetTable, DbTransaction trans)
        {
            return Update(id, recordField, targetTable, trans);
        }

        /**//// <summary>
        /// 更新某个表一长长的记下(只适用于用单键,用string类型作键值的阐明)
        /// </summary>
        /// <param name=”id”>ID号</param>
        /// <param name=”recordField”>Hashtable:键[key]呢字段名;值[value]啊字段对应之值</param>
        /// <param name=”targetTable”>需要操作的对象表名称</param>
        /// <param name=”trans”>事务对象,如果应用工作,传入事务对象,否则也Null不使工作</param>
        public bool Update(string id, Hashtable recordField, string targetTable, DbTransaction trans)
        {
            string field = “”; // 字段名
            object val = null; // 值
            string setValue = “”; // 更新Set () 中的言辞

            if ( recordField == null || recordField.Count < 1 )
            {
                return false;
            }

            SqlParameter[] param = new SqlParameter[recordField.Count];
            int i = 0;

            IEnumerator eKeys = recordField.Keys.GetEnumerator();
            while ( eKeys.MoveNext() )
            {
                field = eKeys.Current.ToString();
                val = recordField[eKeys.Current.ToString()];
                setValue += string.Format(“{0} = @{0},”, field);
                param[i] = new SqlParameter(string.Format(“@{0}”, field), val);

                i++;
            }

            string sql = string.Format(“UPDATE {0} SET {1} WHERE {2} = ‘{3}’ “, targetTable, setValue.Substring(0, setValue.Length – 1), primaryKey, id);
            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);
            command.Parameters.AddRange(param);

            bool result = false;
            if (trans != null)
            {
                result = db.ExecuteNonQuery(command, trans) > 0;
            }
            else
            {
                result = db.ExecuteNonQuery(command) > 0;
            }

            return result;
        }

        #endregion

        对象添加、修改、查询接口#region 对象添加、修改、查询接口

        /**//// <summary>
        /// 插入指定对象到数据库被
        /// </summary>
        /// <param name=”obj”>指定的目标</param>
        /// <returns>执行成功返回新增记录之于增长ID。</returns>
        public bool Insert(T obj)
        {
            ArgumentValidation.CheckForNullReference(obj, “传入的靶子obj为空”);
            
            Hashtable hash = GetHashByEntity(obj);
            return Insert(hash, null);
        }
        
        /**//// <summary>
        /// 更新目标属性到数据库被
        /// </summary>
        /// <param name=”obj”>指定的对象</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        public bool Update(T obj, string primaryKeyValue)
        {
            ArgumentValidation.CheckForNullReference(obj, “传入的目标obj为空”);
        
            Hashtable hash = GetHashByEntity(obj);
            return Update(primaryKeyValue, hash, null);
        }
        
        /**//// <summary>
        /// 查询数据库,检查是不是在指定ID的靶子(用于整型主键)
        /// </summary>
        /// <param name=”key”>对象的ID值</param>
        /// <returns>存在则赶回指定的靶子,否则回Null</returns>
        public T FindByID(int key)
        {            
            return FindByID(key.ToString());
        }        
        
        /**//// <summary>
        /// 查询数据库,检查是否是指定ID的对象(用于字符型主键)
        /// </summary>
        /// <param name=”key”>对象的ID值</param>
        /// <returns>存在则归指定的目标,否则回Null</returns>
        public T FindByID(string key)
        {
            string sql = string.Format(“Select * From dbo.{0} Where ({1} = @ID)”, tableName, primaryKey);

            SqlParameter param = new SqlParameter(“@ID”, key);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);
            command.Parameters.Add(param);

            T entity = null;
            using (IDataReader dr = db.ExecuteReader(command))
            {
                if (dr.Read())
                {
                    entity = DataReaderToEntity(dr);
                }
            }
            return entity;
        }


        #endregion

        返回集合的接口#region 返回集合的接口
        
        /**//// <summary>
        /// 根据ID字符串(逗号分隔)获取对象列表
        /// </summary>
        /// <param name=”idString”>ID字符串(逗号分隔)</param>
        /// <returns>符合条件的对象列表</returns>
        public List<T> FindByIDs(string idString)
        {
            string condition = string.Format(“{0} in({1})”, primaryKey, idString);
            return this.Find(condition);
        }        
        
        /**//// <summary>
        /// 根据条件查询数据库,并回对象集合
        /// </summary>
        /// <param name=”condition”>查询的口径</param>
        /// <returns>指定对象的集合</returns>
        public List<T> Find(string condition)
        {
            //串连口径语句也一个总体的Sql语句
            string sql = string.Format(“Select * From dbo.{0} Where “, tableName);
            sql +=  condition;
            sql += string.Format(” Order by {0} {1}”, sortField, isDescending ? “DESC” : “ASC”); 

            T entity = null;
            List<T> list = new List<T>();

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);

            using (IDataReader dr = db.ExecuteReader(command))
            {
                while (dr.Read())
                {
                    entity = DataReaderToEntity(dr);

                    list.Add(entity);
                }
            }
            return list;
        }
        
        /**//// <summary>
        /// 根据条件查询数据库,并赶回对象集合(用于分页数据展示)
        /// </summary>
        /// <param name=”condition”>查询的尺度</param>
        /// <param name=”info”>分页实体</param>
        /// <returns>指定对象的集合</returns>
        public List<T> Find(string condition, PagerInfo info)
        {
            List<T> list = new List<T>();

            Database db = DatabaseFactory.CreateDatabase();

            PagerHelper helper = new PagerHelper(tableName, condition);
            info.RecordCount = helper.GetCount();

            PagerHelper helper2 = new PagerHelper(tableName, false, ” * “, sortField,
                info.PageSize, info.CurrenetPageIndex, true, condition);

            using (IDataReader dr = helper2.GetDataReader())
            {
                while (dr.Read())
                {
                    list.Add(this.DataReaderToEntity(dr));
                }
            }
            return list;
        }

        /**//// <summary>
        /// 返回数据库有的靶子集合
        /// </summary>
        /// <returns>指定对象的集合</returns>
        public List<T> GetAll()
        {
            string sql = string.Format(“Select * From dbo.{0}”, tableName);
            sql += string.Format(” Order by {0} {1}”, sortField, isDescending ? “DESC” : “ASC”); 

            T entity = null;
            List<T> list = new List<T>();

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);

            using (IDataReader dr = db.ExecuteReader(command))
            {
                while (dr.Read())
                {
                    entity = DataReaderToEntity(dr);

                    list.Add(entity);
                }
            }
            return list;
        }
        
        /**//// <summary>
        /// 返回数据库有的对象集合(用于分页数据显示)
        /// </summary>
        /// <param name=”info”>分页实体信息</param>
        /// <returns>指定对象的集合</returns>
        public List<T> GetAll(PagerInfo info)
        {
            List<T> list = new  List<T>();
            string condition = “”;

            Database db = DatabaseFactory.CreateDatabase();

            PagerHelper helper = new PagerHelper(tableName, condition);
            info.RecordCount = helper.GetCount();

            PagerHelper helper2 = new PagerHelper(tableName, false, ” * “, sortField,
                info.PageSize, info.CurrenetPageIndex, true, condition);

            using (IDataReader dr = helper2.GetDataReader())
            {
                while (dr.Read())
                {
                    list.Add(this.DataReaderToEntity(dr));
                }
            }
            return list;
        }

        public DataSet GetAllToDataSet(PagerInfo info)
        {
            DataSet ds = new DataSet();
            string condition = “”;

            PagerHelper helper = new PagerHelper(tableName, condition);
            info.RecordCount = helper.GetCount();

            PagerHelper helper2 = new PagerHelper(tableName, false, ” * “, sortField,
                info.PageSize, info.CurrenetPageIndex, true, condition);

            return helper2.GetDataSet();
        }

        #endregion
        
        子类必须实现之函数(用于创新或者插)#region 子类必须兑现的函数(用于创新或者插)

        /**//// <summary>
        /// 将DataReader的属性值转化为实体类的属性值,返回实体类
        /// (提供了默认的照机制获取信息,为了提高性能,建议再写该函数)
        /// </summary>
        /// <param name=”dr”>有效的DataReader对象</param>
        /// <returns>实体类对象</returns>
        protected virtual T DataReaderToEntity(IDataReader dr)
        {
            T obj = new T();
            PropertyInfo[] pis = obj.GetType().GetProperties();

            foreach (PropertyInfo pi in pis)
            {
                try
                {
                    if (dr[pi.Name].ToString() != “”)
                    {
                        pi.SetValue(obj, dr[pi.Name] ?? “”, null);
                    }
                }
                catch { }
            }
            return obj;
        }

        /**//// <summary>
        /// 将实体对象的属性值转化为Hashtable对应的键值(用于插入或者更新操作)
        /// (提供了默认的反光机制获取信息,为了增进性,建议还写该函数)
        /// </summary>
        /// <param name=”obj”>有效之实业对象</param>
        /// <returns>包含键值映射的Hashtable</returns>
        protected virtual Hashtable GetHashByEntity(T obj)
        {
            Hashtable ht = new Hashtable();
            PropertyInfo[] pis = obj.GetType().GetProperties();
            for (int i = 0; i < pis.Length; i++)
            {
                //if (pis[i].Name != PrimaryKey)
                {
                    object objValue = pis[i].GetValue(obj, null);
                    objValue = (objValue == null) ? DBNull.Value : objValue;

                    if (!ht.ContainsKey(pis[i].Name))
                    {
                        ht.Add(pis[i].Name, objValue);
                    }
                }
            }
            return ht;
        }

        #endregion
        
        IBaseDAL接口#region IBaseDAL接口

        /**//// <summary>
        /// 查询数据库,检查是不是留存指定键值的目标
        /// </summary>
        /// <param name=”recordTable”>Hashtable:键[key]啊字段名;值[value]否字段对应的值</param>
        /// <returns>存在则回<c>true</c>,否则也<c>false</c>。</returns>
        public bool IsExistKey(Hashtable recordTable)
        {
            SqlParameter[] param = new SqlParameter[recordTable.Count];
            IEnumerator eKeys = recordTable.Keys.GetEnumerator();

            string fields = “”;// 字段名
            int i = 0;

            while (eKeys.MoveNext())
            {
                string field = eKeys.Current.ToString();
                fields += string.Format(” {0} = @{1} AND”, field, field);

                string val = recordTable[eKeys.Current.ToString()].ToString();
                param[i] = new SqlParameter(string.Format(“@{0}”,field), val); 

                i++;
            }

            fields = fields.Substring(0, fields.Length – 3);//除去最后之AND
            string sql = string.Format(“SELECT COUNT(*) FROM {0} WHERE {1}”, tableName, fields);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);
            command.Parameters.AddRange(param);

            return (int)db.ExecuteScalar(command) > 0;
        }
        
        /**//// <summary>
        /// 查询数据库,检查是否留存指定键值的目标
        /// </summary>
        /// <param name=”fieldName”>指定的习性名</param>
        /// <param name=”key”>指定的值</param>
        /// <returns>存在则回<c>true</c>,否则也<c>false</c>。</returns>
        public bool IsExistKey(string fieldName, object key)
        {
            Hashtable table = new Hashtable();
            table.Add(fieldName, key);

            return IsExistKey(table);
        }                        
        
        /**//// <summary>
        /// 获取数据库中该目标的极端酷ID值
        /// </summary>
        /// <returns>最大ID值</returns>
        public int GetMaxID()
        {
            string sql = string.Format(“SELECT MAX({0}) AS MaxID FROM dbo.{1}”, primaryKey, tableName);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);

            object obj = db.ExecuteScalar(command);
            if(Convert.IsDBNull(obj))
            {
                return 0;//没有记录的时段为0
            }
            return Convert.ToInt32(obj);
        }
        
        /**//// <summary>
        /// 根据指定对象的ID,从数据库被去除指定对象(用于整型主键)
        /// </summary>
        /// <param name=”key”>指定对象的ID</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        public bool DeleteByKey(string key)
        {
            string condition = string.Format(“{0} = ‘{1}'”, primaryKey, key);
            return DeleteByCondition(condition);
        }                
        
        /**//// <summary>
        /// 根据指定条件,从数据库中除去指定对象
        /// </summary>
        /// <param name=”condition”>删除记录的准绳语句</param>
        /// <returns>执行成功返回<c>true</c>,否则也<c>false</c>。</returns>
        public bool DeleteByCondition(string condition)
        {
            string sql = string.Format(“DELETE FROM dbo.{0} WHERE {1} “, tableName, condition);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);

            return db.ExecuteNonQuery(command) > 0;
        }
                
        #endregion
    }

下我们省表盒序列的台本代码,例如我创建一个客户表,其配段ID为从添班,我之创建脚论是。

3、具体的数量访问类
基类完成具有的操作了,对于现实的类将是同样老福音,说明她的工作减少很多矣,下面看看具体的实现过程。定义一个数量访问类接口,然后实现接口及延续基类即可。

 create table ALL_CUSTOMER

    public interface IEquipment : IBaseDAL<EquipmentInfo>
    {
    }

(
  ID          NUMBER not null,
  USERNUMBER  VARCHAR2(50),
  NAME        VARCHAR2(50),
  TYPE        VARCHAR2(50),
  AREA        VARCHAR2(50),
  COMPANY     VARCHAR2(50),
  ADDRESS     VARCHAR2(50),
  TELEPHONE1  VARCHAR2(50),
  TELEPHONE2  VARCHAR2(50),
  TELEPHONE3  VARCHAR2(50),
  TELEPHONE4  VARCHAR2(50),
  TELEPHONE5  VARCHAR2(50),
  CREATEDATE  DATE,
  SHOP_ID     VARCHAR2(50),
  NOTE        VARCHAR2(255),
  LASTUPDATED DATE,
  constraint PK_ALL_CUSTOMER primary key (ID)
);

    public class Equipment : BaseDAL<EquipmentInfo>, IEquipment
    {
        对象实例及构造函数#region 对象实例及构造函数

        public static Equipment Instance
        {
            get
            {
                return new Equipment();
            }
        }
        public Equipment() : base(“Equipment”,”ID”)
        {
        }

        #endregion
}

create sequence SEQ_ALL_CUSTOMER
minvalue 1
maxvalue 999999999999999999999999999
start with 1220
increment by 1
cache 20;

实则这么即便成功了,我们为提高效率,重载两个函数的实现,避免基类的属性反射带来的属性损失,这简单独函数看似颇复杂,其实通过代码生成工具,生成起来吧是毫不费功夫的。。

commit;

protected override EquipmentInfo DataReaderToEntity(IDataReader dataReader)

protected override Hashtable GetHashByEntity(EquipmentInfo obj)

 

故而最终之代码就改为下面

注意SEQ_ALL_CUSTOMER就是行对象名称,那么我们再插入的下,应该如何勾勒副行字段的价,并且赢得新的值作为返回值的也罢?

    public class Equipment : BaseDAL<EquipmentInfo>, IEquipment
    {
        对象实例及构造函数#region 对象实例及构造函数

        public static Equipment Instance
        {
            get
            {
                return new Equipment();
            }
        }
        public Equipment() : base(“Equipment”,”ID”)
        {
        }

        #endregion

        /**//// <summary>
        /// 将DataReader的属性值转化为实体类的属于性值,返回实体类
        /// </summary>
        /// <param name=”dr”>有效的DataReader对象</param>
        /// <returns>实体类对象</returns>
        protected override EquipmentInfo DataReaderToEntity(IDataReader dataReader)
        {
            EquipmentInfo equipmentInfo = new EquipmentInfo();
            SmartDataReader reader = new SmartDataReader(dataReader);
            
            equipmentInfo.ID = reader.GetInt32(“ID”);
            equipmentInfo.PartID = reader.GetString(“PartID”);
            equipmentInfo.Name = reader.GetString(“Name”);
            equipmentInfo.EquipmentType = reader.GetString(“EquipmentType”);
            equipmentInfo.Specification = reader.GetString(“Specification”);
            equipmentInfo.Manufacturer = reader.GetString(“Manufacturer”);
            equipmentInfo.Picture = reader.GetBytes(“Picture”);
            equipmentInfo.ApplyEquipment = reader.GetString(“ApplyEquipment”);
            equipmentInfo.BuyAmount = reader.GetInt32(“BuyAmount”);
            equipmentInfo.BuyDate = reader.GetDateTime(“BuyDate”);
            equipmentInfo.Status = reader.GetString(“Status”);
            equipmentInfo.UserName = reader.GetString(“UserName”);
            equipmentInfo.SafeNumber = reader.GetInt32(“SafeNumber”);
            equipmentInfo.Note = reader.GetString(“Note”);
            
            return equipmentInfo;
        }

        /**//// <summary>
        /// 将实体对象的属性值转化为Hashtable对应的键值
        /// </summary>
        /// <param name=”obj”>有效之实业对象</param>
        /// <returns>包含键值映射的Hashtable</returns>
        protected override Hashtable GetHashByEntity(EquipmentInfo obj)
        {
            EquipmentInfo info = obj as EquipmentInfo;
            Hashtable hash = new Hashtable(); 
            
            hash.Add(“ID”, info.ID);
            hash.Add(“PartID”, info.PartID);
            hash.Add(“Name”, info.Name);
            hash.Add(“EquipmentType”, info.EquipmentType);
            hash.Add(“Specification”, info.Specification);
            hash.Add(“Manufacturer”, info.Manufacturer);
            hash.Add(“Picture”, info.Picture);
            hash.Add(“ApplyEquipment”, info.ApplyEquipment);
            hash.Add(“BuyAmount”, info.BuyAmount);
            hash.Add(“BuyDate”, info.BuyDate);
            hash.Add(“Status”, info.Status);
            hash.Add(“UserName”, info.UserName);
            hash.Add(“SafeNumber”, info.SafeNumber);
            hash.Add(“Note”, info.Note);
                
            return hash;
        }
    }

当BaseDAL中,有一个Insert2的主意,是专程处理
自增序列函数,并且返回创建记录的自增字段的价的,我们来探视该源码。

文章最丰富,下面关于逻辑层、缓存、界面部分的筹划在产一样篇稿子被介绍。

         /// <summary>

 以上所引述的代码是经过代码生成工具Database2Sharp自动生成(http://www.iqidi.com/Database2Sharp.htm),选择EnterpriseLibrary架构即可。

        /// 添加记录
        /// </summary>
        /// <param name=”recordField”>Hashtable:键[key]也字段名;值[value]啊字段对应之值</param>
        /// <param name=”targetTable”>需要操作的目标表名称</param>
        /// <param name=”trans”>事务对象,如果采取工作,传入事务对象,否则也Null不应用工作</param>
        public int Insert2(Hashtable recordField, string targetTable, DbTransaction trans)
        {
            int result = -1;
            string fields = “”; // 字段名
            string vals = “”; // 字段值
            if (recordField == null || recordField.Count < 1)
            {
                return result;
            }

 

            List<OracleParameter> paramList = new List<OracleParameter>();
            IEnumerator eKeys = recordField.Keys.GetEnumerator();

 

            while (eKeys.MoveNext())
            {
                string field = eKeys.Current.ToString();
                fields += field + “,”;
                if (!string.IsNullOrEmpty(seqField) && !string.IsNullOrEmpty(seqName)
                    && (field == seqField))
                {
                    vals += string.Format(“{0}.NextVal,”, seqName);
                }
                else
                {
                    vals += string.Format(“:{0},”, field);
                    object val = recordField[eKeys.Current.ToString()];
                    paramList.Add(new OracleParameter(“:” + field, val));
                }
            }

            fields = fields.Trim(‘,’);//除去前后的逗号
            vals = vals.Trim(‘,’);//除去前后的逗号
            string sql = string.Format(“INSERT INTO {0} ({1}) VALUES ({2})”, targetTable, fields, vals);

            Database db = DatabaseFactory.CreateDatabase();
            DbCommand command = db.GetSqlStringCommand(sql);
            command.Parameters.AddRange(paramList.ToArray());

            if (trans != null)
            {
                db.ExecuteNonQuery(command, trans);

                sql = string.Format(“SELECT {0}.Currval ID From Dual”, seqName);
                command = db.GetSqlStringCommand(sql);
                result = Convert.ToInt32(db.ExecuteScalar(command, trans).ToString());
            }
            else
            {
                db.ExecuteNonQuery(command);

                sql = string.Format(“SELECT {0}.Currval ID From Dual”, seqName);
                command = db.GetSqlStringCommand(sql);
                result = Convert.ToInt32(db.ExecuteScalar(command).ToString());
            }

            return result;
        }

 

其中我们看清是否发于增班ID和其名目(非空字符),如果产生则运用这段代码,来描写副打加班的生一个值NextVal(新增值),作为这个字段的价值。

vals += string.Format(“{0}.NextVal,”, seqName); 

 如果如回插入的自增序列值,那么我们运用序列对象的Currval 就好了。下面是回来插入的字段内容。

sql = string.Format(“SELECT {0}.Currval ID From Dual”, seqName); 

然于刻画副新的打增长值并赶回就兑现了。

针对SqlServer和Access自增长字段的支撑 

于SqlServer,实现由增长字段就更便民了,由于无Oracle序列对象那么累,所以就待以具体的数据库访问对象被,构建写副字段的Hash表中,忽小该字段就得了(代码都自动生成,不用管理的)。其归来刚刚插入的自增内容,则当插入的说话后面加一修告句就可了,语句如下。

 SELECT SCOPE_IDENTITY()

对此Access的数据库,原理和SqlServer一样,不过用回到刚刚插入的从增长值的时光,使用就段告诉句就足以了。

 SELECT @@IDENTITY

 对于SqlServer和Access,只要筹好数据库的自增字段,自动生成的代码中,数据看类是不要修改外音讯,就好健全支持从加班。