zoukankan      html  css  js  c++  java
  • 发布.NET 开发工具 DevNet4.0 开发框架 Maper 映射

    现发布.net开发工具及开发框架,已用于很多项目,能提高开发效率和开发速度,大大提高维护性,扩展性,及适应快速的需求变化;如有兴趣可以联系我;QQ:69983534  Emal:sjfe_cn@foxmail.com

    一、代码生成器:

     该代码生成器是配合DevNet框架而开发,涵盖了普通常用的实体等代码生成,先上几张截图:

    使用起来比较简单,熟悉一下即可;

    二 DevNet4.0演示项目

      演示下载包包括代码生成器、DevNet框架htm帮助文档(index.htm),Mapper映射文件操作和实体操作演示,大家下载后看一下即可明白,让开发人员彻底摆脱枯燥的重复代码编写,把更多的时间和精力关注到业务逻辑上去,可提高30%的开发效率;

    DevNet4.0演示下载

    演示项目使用VS2008 sp1开发

    有任何疑问可以联系我QQ:69983534  Email:sjfe_cn@foxmail.com

    本篇我描述DevNet中实体层的实现,.net的数据集很强大,原来做cs项目时都用的DataTable,不管从性能,灵活性,可操作性以及写代码的方便性都很实用,唯一感觉不舒服的是在获取某字段值是需要使用DataRow[fieldName]或者DataRow[index]方式,在项目需求变化数据字段有变化时,需要修改大量的字段名称,在编译时并不会报错,项目很容易出错。再到后来做bs项目时使用了实体模式,虽然在灵活性及List数据集的计算等方面不如DataTable方便,但感觉在维护及开发调试中方便了许多。

      实体如果都要手写的话就受不了了,网上很多生成实体的工具,我也根据DevNet类库弄了个实体生成器,有需要的朋友可以到第一篇下载。

          在转换成实体时原先都是用反射方法,网上绝大部分都使用该方法,虽然用起来没啥大问题,但我感觉对性能多少有点影响。下面的反射转换实体的代码,DevNet类库中仍保留着。

      

    代码
    /// <summary>
    /// 获取实体集合[使用反射]
    /// </summary>
    /// <typeparam name="T">实体(请确保存在无参数构造函数)</typeparam>
    /// <param name="table">内存表</param>
    /// <returns></returns>
    public static List<T> GetEntityCollection<T>(DataTable table) where T : classnew()
    {
    if (table == null)
    throw new ArgumentNullException("table""参数table不能为null");
    List
    <T> ts = new List<T>();
    foreach (DataRow dr in table.Rows)
    {
    T t 
    = new T();
    SetObjByRow(t, dr);
    ts.Add(t);
    }
    return ts;
    }

    /// <summary>
    /// 从DataRow中获取数据设置Object对象[实体类]的值[使用反射]
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="objEntity">Object对象[实体类](属性名称请与数据表字段名称保持一致)</param>
    /// <param name="dataRow"></param>
    /// <returns></returns>
    public static void SetObjByRow<T>(T objEntity, DataRow dataRow) where T : class
    {
    if (objEntity == nullthrow new ArgumentNullException("objEntity");
    if (dataRow == nullthrow new ArgumentNullException("dataRow");

    System.Reflection.PropertyInfo[] objs 
    = objEntity.GetType().GetProperties();

    foreach (System.Reflection.PropertyInfo pobj in objs)
    {
    int i = dataRow.Table.Columns.IndexOf(pobj.Name);
    if (i >= 0)
    {
    if (dataRow[pobj.Name] is DBNull)
    continue;

    try
    {
    pobj.SetValue(objEntity, dataRow[pobj.Name], 
    null);
    }
    catch (Exception ex)
    {
    throw new Exception("设置实体属性 " + pobj.Name + " 值时出错,请检查数据表字段 " + pobj.Name + " 和该实体属性类型是否一致。" + ex.Message, ex);

    }
    }

    }

      这些方法都在DevNet的DBHelper.cs类中 ,该类中也保留了从DbDataReader转换成实体集合的方法。你可以从(一)篇文档中下载的DevNet.chm文件中查找。

      本来一直使用也相安无事,本着精益求精的精神,一直想把反射的方法改掉,所幸从网上找到了方法,有位似乎叫深蓝博士(很抱歉,记得不太清了,如果您看到此篇还请见谅)的博客中实体的思路,方法相当不错,根据他的实体模式,我修改了我的实体结构,从我的实体生成器中选择EntityBase项生成的实体如下:

    代码
    using System;
    using System.Collections.Generic;
    using System.Text;
    using DevNet.Common; //请添加引用
    using DevNet.Common.Entity;

    namespace CodeDemo.Entity
    {
    #region====PermissionEntity====
    /// <summary>
    /// 表 Permission 的实体类
    /// </summary>
    [Serializable]
    public class Permission: EntityBase
    {
    public Permission()
    {
    AddProperty(PermissionID_FieldName, 
    0);
    AddProperty(PermissionName_FieldName, 
    string.Empty);
    AddProperty(PermissionMemo_FieldName, 
    string.Empty);
    AddProperty(PerParentID_FieldName, 
    0);
    AddProperty(ImageURL_FieldName, 
    string.Empty);
    AddProperty(LinkURL_FieldName, 
    string.Empty);
    AddProperty(DisplayIndex_FieldName, 
    0);
    AddProperty(IsShow_FieldName, 
    false);
    AddProperty(Owner_FieldName, 
    0);
    base.TableName = Permission_TableName;
    base.AutoIncrements = AutoIncrement;
    base.PrimaryKeyFields = PrimaryKeyField;
    }


    #region====表名称、字段名称、主键字段、自动增长型字段名称====
    /// <summary>
    /// 表 Permission 数据表名称
    /// </summary>
    public const string Permission_TableName = "PERMISSION";

    /// <summary>
    /// 表 Permission 主键字段集合
    /// </summary>
    public readonly static string[] PrimaryKeyField = new string[] {"PermissionID"};

    /// <summary>
    /// 表 Permission 自动增长型字段名称
    /// </summary>
    public const string AutoIncrement = "";

    /// <summary>
    /// PermissionID 字段名称
    /// </summary>
    public const string PermissionID_FieldName = "PermissionID";
    /// <summary>
    /// 权限名称 字段名称
    /// </summary>
    public const string PermissionName_FieldName = "PermissionName";
    /// <summary>
    /// 权限说明 字段名称
    /// </summary>
    public const string PermissionMemo_FieldName = "PermissionMemo";
    /// <summary>
    /// 父权限ID 字段名称
    /// </summary>
    public const string PerParentID_FieldName = "PerParentID";
    /// <summary>
    /// 图片URL 字段名称
    /// </summary>
    public const string ImageURL_FieldName = "ImageURL";
    /// <summary>
    /// 连接URL 字段名称
    /// </summary>
    public const string LinkURL_FieldName = "LinkURL";
    /// <summary>
    /// 显示索引 字段名称
    /// </summary>
    public const string DisplayIndex_FieldName = "DisplayIndex";
    /// <summary>
    /// 是否在管理显示 字段名称
    /// </summary>
    public const string IsShow_FieldName = "IsShow";
    /// <summary>
    /// 权限所属后台系统(多后台系统,譬如:1系统后台权限 2用户后台权限 3园区后台权限 4 政府后台权限......) 字段名称
    /// </summary>
    public const string Owner_FieldName = "Owner";
    #endregion


    #region====字段属性====
    /// <summary>
    /// PermissionID 列
    /// </summary>
    public int PermissionID
    {
    get
    {
    return Convert.ToInt32(GetProperty(PermissionID_FieldName));
    }
    set
    {
    SetProperty(PermissionID_FieldName, value);
    }
    }
    /// <summary>
    /// 权限名称 列
    /// </summary>
    public string PermissionName
    {
    get
    {
    return Convert.ToString(GetProperty(PermissionName_FieldName));
    }
    set
    {
    SetProperty(PermissionName_FieldName, value);
    }
    }
    /// <summary>
    /// 权限说明 列
    /// </summary>
    public string PermissionMemo
    {
    get
    {
    return Convert.ToString(GetProperty(PermissionMemo_FieldName));
    }
    set
    {
    SetProperty(PermissionMemo_FieldName, value);
    }
    }
    /// <summary>
    /// 父权限ID 列
    /// </summary>
    public int PerParentID
    {
    get
    {
    return Convert.ToInt32(GetProperty(PerParentID_FieldName));
    }
    set
    {
    SetProperty(PerParentID_FieldName, value);
    }
    }
    /// <summary>
    /// 图片URL 列
    /// </summary>
    public string ImageURL
    {
    get
    {
    return Convert.ToString(GetProperty(ImageURL_FieldName));
    }
    set
    {
    SetProperty(ImageURL_FieldName, value);
    }
    }
    /// <summary>
    /// 连接URL 列
    /// </summary>
    public string LinkURL
    {
    get
    {
    return Convert.ToString(GetProperty(LinkURL_FieldName));
    }
    set
    {
    SetProperty(LinkURL_FieldName, value);
    }
    }
    /// <summary>
    /// 显示索引 列
    /// </summary>
    public int DisplayIndex
    {
    get
    {
    return Convert.ToInt32(GetProperty(DisplayIndex_FieldName));
    }
    set
    {
    SetProperty(DisplayIndex_FieldName, value);
    }
    }
    /// <summary>
    /// 是否在管理显示 列
    /// </summary>
    public bool IsShow
    {
    get
    {
    return Convert.ToBoolean(GetProperty(IsShow_FieldName));
    }
    set
    {
    SetProperty(IsShow_FieldName, value);
    }
    }
    /// <summary>
    /// 权限所属后台系统(多后台系统,譬如:1系统后台权限 2用户后台权限 3园区后台权限 4 政府后台权限......) 列
    /// </summary>
    public int Owner
    {
    get
    {
    return Convert.ToInt32(GetProperty(Owner_FieldName));
    }
    set
    {
    SetProperty(Owner_FieldName, value);
    }
    }
    #endregion


    #region====表关系属性====


    #endregion
    }
    #endregion
    }

      实体中的常量是数据表的字段名称,我配合使用我的ScriptQuery.cs类(下面会讲一点)操作,完全不需要把字段名称写在项目中,有了这个实体,那么实体转换就不再需要用反射了。

    代码
    /// <summary>
    /// 设置实体属性值[使用EntityBase中的方法]
    /// </summary>
    /// <typeparam name="T">实体泛型[请继承自EntityBase]</typeparam>
    /// <param name="objEntity">泛型对象[请继承自EntityBase](属性名称请与数据表字段名称保持一致)</param>
    /// <param name="dataRow">DataRow数据行</param>
    public static void SetEntityByRow<T>(T objEntity, DataRow dataRow) where T : EntityBase
    {
    if (objEntity == nullthrow new ArgumentNullException("objEntity");
    if (dataRow == nullthrow new ArgumentNullException("dataRow");

    foreach(DataColumn col in dataRow.Table.Columns)
    {
    if (dataRow[col] is DBNull)
    continue;

    objEntity.SetPropertyValue(col.ColumnName, dataRow[col]);
    }
    }

    在DBHelper.cs类中你可以找到该方法。使用实体的SetPropertyValue方法设置实体属性值,不再依赖反射。另外在该类中有这样一个方法

    代码
    /// <summary>
    /// 根据Object对象[实体类]设置DbParameter参数值[使用反射]
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="objEntity">Object对象[实体类](属性名称请与参数名称保持一致)</param>
    /// <param name="parameter"></param>
    public static void SetParamsValue<T>(T objEntity, params DbParameter[] parameter) where T : class
    {
    if (parameter == nullthrow new ArgumentNullException("parameter");
    if (objEntity != null)
    {
    System.Reflection.PropertyInfo[] properties 
    = objEntity.GetType().GetProperties();
    foreach (DbParameter p in parameter)
    {
    if (p.Direction == ParameterDirection.ReturnValue)// ParameterName == flag + "RETURN_VALUE")
    {
    continue;
    }
    foreach (System.Reflection.PropertyInfo property in properties)
    {
    if (property.Name.Equals(p.ParameterName.Substring(1),StringComparison.OrdinalIgnoreCase))
    {
    try
    {
    p.Value 
    = property.GetValue(objEntity, null);
    }
    catch (Exception ex)
    {
    throw new Exception("设置参数 " + p.ParameterName + " 值时出错,请检查实体属性名 " + property.Name + " 和该参数类型是否一致。" + ex.Message, ex);
    }
    if (p.Value == null)
    {
    throw new ArgumentException("实体属性名: " + property.Name + " 值为 null,请提供该属性值",
    property.Name);
    }
    break;
    }
    }
    }
    }

    }

    该方法的实体类是指参数查询实体类,不知道各位在多条件查询时如何做的,本人使用查询实体类来作为查询条件传递的。该方法是使用反射方法,根据查询实体属性名称来设置DbParameter的参数值。我想各位都看过微软的SqlHelper类,该类中有方法可以从存储过程中直接创建参数并放入缓存,在DevNet类库中DBStoredParams.cs类中包含了此类方法并且修改成使用Dbparameter抽象类,不再局限于Sql存储过程参数(虽然很多都用的sql存储过程)。

      实体的结构就是以上这些,下面描述一下ScriptQuery.cs。

      该类基于第一篇DBConnect数据库连接对象,使用参数模式简单的封装了一些sql语句以及提供了简单的操作帮助,代码在此就不贴了,贴些部分使用代码

    代码
    ScriptQuery _query = new ScriptQuery("tb_user");
    _query.Select().ALL().From().Where(Tb_user.Userid_FieldName, 
    5, ScriptQuery.CompareEnum.MoreThan).AddOrderBy()
    .OrderBy(Tb_user.Userid_FieldName, ScriptQuery.SortEnum.DESC);

    _query.PageIndex 
    =1;
    _query.PageSize 
    = 10;

    List
    <Tb_user> users = _query.GetList<Tb_user>();
    MessageBox.Show(
    "RecordCount:" + _query.RecordCount.ToString() + "PageCount:" + _query.PageCount.ToString());

    该方法获取分页信息列表,默认使用sql2005分页语句(ROW_NUMBER() OVER (ORDER BY {0}),配置文件appSettings节中

     <add key="IsSql2000" value="true"/>

    将使用top语句查询分页,在使用top语句分页查询时请设置PrimaryKey查询主键的属性值(默认名称为“id”),否则将出错。

    再看一下该类如何使用存储过程

    代码
    //存储过程
             Tb_user user = _query.GetSingle<Tb_user>(Tb_user.Userid_FieldName, id, ScriptQuery.CompareEnum.Equal);
    DbParameter[] ps = DBStoredParams.GetSpParameter("sp_tb_user_insertupdate");
    DBHelper.SetParamsInfo(user, ps); 
    //这里设置不使用反射,提高效率 user为数据表对应的实体
    _query.Value = "sp_tb_user_insertupdate";
    _query.SetCmdParameters(ps);
    _query.CmdType 
    = CommandType.StoredProcedure;
    _query.ExecuteNonQuery();

    下面是查询实体参数的使用: 

    代码
    //基类抽象方法的实现
    public override List<NewBooks> GetPageList(SearchNewBooks condition, Pagination pagination, string sortFieldName,
    ScriptQuery.SortEnum sortEnum)
    {
    Script.Select().ALL().From().Where();
    if (!string.IsNullOrEmpty(condition.F_Sm))
    {
    Script.Like(NewBooks.F_SM_FieldName, condition.F_Sm);
    }
    if (!string.IsNullOrEmpty(condition.F_BBMC))
    {
    Script.Like(NewBooks.F_BBMC_FieldName, condition.F_BBMC);
    }

    if (condition.IsShow != 2)
    {
    Script.Where(NewBooks.IsShow_FieldName, condition.IsShow);
    }
    Script.Between(NewBooks.F_DJ_FieldName, condition.MinPrice, condition.MaxPrice);
    Script.Between(NewBooks.AddDate_FieldName, condition.StartDate, condition.EndDate);
    Script.AddOrderBy().OrderBy(sortFieldName, sortEnum);

    Script.PageIndex 
    = pagination.PageIndex;
    Script.PageSize 
    = pagination.PageSize;

    List
    <NewBooks> lists = Script.GetList<NewBooks>();
    pagination.RecordCount 
    = Script.RecordCount;

    return lists;
    }

     实体层与ScriptQuery就到此,下一篇描述DevNet的DAL数据层。

    做开发也有不少年月了,刚入行时,只知道不断重复着写SqlConnection啊,SqlCommand啊等等方法啊,写多了实在感到很枯燥,那么为何不把它们封装起来,做成通用的呢?于是琢磨着开始把常用的方法封装成类库,目的只有一个:实现基本的数据层通用,不用为移植数据库而修改太多的数据层代码,不用在项目中重复写那些简单的数据操作方法,提高项目的开发速度。于是DevNet类库形成。

      自DevNet类库形成后,一直在项目中使用,最近在思索如何再次增强其功能,让她适用的范围更广,苦于经验、思路有限,一直没有找到更好的方法,故将DevNet在此详细描述,还请高手们多提宝贵建议。

      发现文字表达能力非常的差,悲哀啊!还是闲话少说,直接说该类库。

      首先声明:该类库中的方法借鉴了网络上很多好的思路,在此表示非常感谢!因为借鉴的地方很多,现在也无法一一罗列,如发现该类库中使用了您的思路,还请多多包涵!

      要想做成通用的开发类库,适用多数据库,类似于DBHelper的类也是必不可少,只不过我做成了抽象类,DBAccessBase.cs,以下是部分代码

        /// <summary>
        /// 通用数据库访问基类
        /// </summary>

        //[LicenseProvider(typeof(DevNetLicenseProvider))]  //License,类库中已注释
         public class DBAccessBase
        {
            /// <summary>
            /// 静态的 DataTable ExtendedProperties 属性
            /// </summary>
            internal static string C_PROP_SQL = "SourceSQL";
            /// <summary>
            /// 连接对象
            /// </summary>
            protected DbConnection con;
            /// <summary>
            /// 事务对象
            /// </summary>
            protected DbTransaction trans;

            /// <summary>
            /// 构造函数
            /// </summary>
            public DBAccessBase()
            {
               // DevNetLicenseProvider.ValidateLicense(typeof (DBConnect), this);
            }

            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="dbConnection">DbConnection</param>
            public DBAccessBase(DbConnection dbConnection):this()
            {
                this.con = dbConnection;
            }

            /// <summary>
            /// 析构函数
            /// </summary>
            ~DBAccessBase()
            {
                con = null;
                trans = null;
            }

            /// <summary>
            /// 打开连接
            /// </summary>
            public virtual void Open()
            {
                if (con != null)
                {
                    if (con.State == ConnectionState.Broken)
                        this.con.Close();
                    if(con.State == ConnectionState.Closed)
                        this.con.Open();
                }
            }

            /// <summary>
            /// 关闭连接
            /// </summary>
            public virtual void Close()
            {
                if (con != null && con.State != ConnectionState.Closed)
                    this.con.Close();
            }

            /// <summary>
            /// 开始事务
            /// </summary>
            public virtual void BeginTransaction()
            {
                if (con == null || con.State == ConnectionState.Closed)
                    throw new Exception("Connection is Null or Not Open");

                this.trans = this.con.BeginTransaction();
            }

            /// <summary>
            /// 开始事务
            /// </summary>
            /// <param name="isoLationLevel">事务锁定行为</param>
            public virtual void BeginTransaction(IsolationLevel isoLationLevel)
            {
                if (con == null || con.State == ConnectionState.Closed)
                    throw new Exception("Connection is Null or Not Open");
               this.trans = this.con.BeginTransaction(isoLationLevel);
            }

            /// <summary>
            /// 回滚事务
            /// </summary>
            public virtual void RollBackTransaction()
            {
                if (this.trans == null)
                    throw new Exception("Transaction Not Begin");

                this.trans.Rollback();
                this.trans.Dispose();
                this.trans = null;
            }

            /// <summary>
            /// 提交事务
            /// </summary>
            public virtual void CommitTransaction()
            {
                if (this.trans == null)
                    throw new Exception("Transaction Not Begin");

                this.trans.Commit();
                this.trans.Dispose();
                this.trans = null;
            }

             /// <summary>
            /// 创建参数
            /// </summary>
            /// <param name="cmd"></param>
            /// <param name="parameterName"></param>
            /// <param name="direction"></param>
            /// <param name="paraType"></param>
            /// <param name="size"></param>
            /// <returns></returns>
            public DbParameter CreateCmdParameter(DbCommand cmd, string parameterName, ParameterDirection direction, DbType paraType, int size)
            {
                DbParameter parameter = cmd.CreateParameter();
                parameter.ParameterName = parameterName; 
                parameter.Direction = direction;
                if (this.con is OleDbConnection && (paraType == DbType.DateTime))
                {
                    ((OleDbParameter)parameter).OleDbType = OleDbType.Date;
                }
                else
                    parameter.DbType = paraType;
                parameter.Size = size;
                return parameter;
            }

             /// <summary>
            /// 创建参数
            /// </summary>
            /// <param name="cmd"></param>
            /// <param name="parameterName"></param>
            /// <param name="direction"></param>
            /// <param name="paraType"></param>
            /// <param name="size"></param>
            /// <param name="Value"></param>
            /// <returns></returns>
            public DbParameter CreateCmdParameter(DbCommand cmd, string parameterName, ParameterDirection direction, DbType paraType, int size, object Value)
            {
                DbParameter parameter = this.CreateCmdParameter(cmd, parameterName, direction, paraType, size);
                parameter.Value = Value;
                return parameter;
            }

            /// <summary>
            /// 增加一个参数
            /// </summary>
            /// <param name="cmd"></param>
            /// <param name="paramName"></param>
            /// <param name="paramValue"></param>
            public virtual void AddCmdParamWithValue(DbCommand cmd, string paramName, object paramValue)
            {
                if (cmd is SqlCommand)
                    ((SqlCommand)cmd).Parameters.AddWithValue(paramName, paramValue);
                else if (cmd is OleDbCommand)
                    ((OleDbCommand)cmd).Parameters.AddWithValue(paramName, paramValue);
                else if (cmd is System.Data.OracleClient.OracleCommand)
                    ((System.Data.OracleClient.OracleCommand)cmd).Parameters.AddWithValue(paramName, paramValue);
              else if (cmd is MySqlDBAccess.MySqlCommand)
                    ((MySqlDBAccess.MySqlCommand)cmd).Parameters.AddWithValue(paramName, paramValue);
              else
                    throw new Exception("DbCommand Error!");
            }

             /// <summary>
            /// 创建 DbCommandBuilder
            /// </summary>
            /// <param name="da"></param>
            /// <returns></returns>
            public virtual DbCommandBuilder CreateCommandBuilder(DbDataAdapter da)
            {
                if (da is SqlDataAdapter)
                    return new SqlCommandBuilder((SqlDataAdapter)da);
                else if (da is OleDbDataAdapter)
                    return new OleDbCommandBuilder((OleDbDataAdapter)da);
                else if (da is System.Data.OracleClient.OracleDataAdapter)
                    return new System.Data.OracleClient.OracleCommandBuilder((System.Data.OracleClient.OracleDataAdapter)da);
                else if (da is MySqlDBAccess.MySqlDataAdapter)
                    return new MySqlDBAccess.MySqlCommandBuilder((MySqlDBAccess.MySqlDataAdapter)da);
                return null;
            }
               /// <summary>
            /// 创建 DbDataAdapter
            /// </summary>
            /// <param name="selectCmd">DbCommand</param>
            /// <returns></returns>
            public virtual DbDataAdapter CreateDbAdapter(DbCommand selectCmd)
            {
                if (selectCmd is SqlCommand)
                    return new SqlDataAdapter((SqlCommand)selectCmd);
                else if (selectCmd is OleDbCommand)
                    return new OleDbDataAdapter((OleDbCommand)selectCmd);
                else if (selectCmd is System.Data.OracleClient.OracleCommand)
                    return new System.Data.OracleClient.OracleDataAdapter((System.Data.OracleClient.OracleCommand)selectCmd);
                else if (selectCmd is MySqlDBAccess.MySqlCommand)
                    return new MySqlDBAccess.MySqlDataAdapter((MySqlDBAccess.MySqlCommand)selectCmd);
                 return null; 
            }

             /// <summary>
            /// 创建DbDataAdapter 
            /// </summary>
            /// <param name="selectCmd"></param>
            /// <returns></returns>
            public DbDataAdapter CreateDbAdapter(string selectCmd)
            {
                DbCommand dbCmd = this.PrepareCommand(CommandType.Text, selectCmd, null);
                
                return this.CreateDbAdapter(dbCmd);
                
            }
             /// <summary>
            /// 执行DbCommand
            /// </summary>
            /// <param name="selectCommand"></param>
            /// <returns></returns>
            public DataTable ExecuteDataTable(DbCommand selectCommand)
            {
                return this.ExecuteDataTable(selectCommand, null);
            }

            /// <summary>
            /// 获取一个DataTable
            /// </summary>
            /// <param name="commandText"></param>
            /// <returns></returns>
            public DataTable ExecuteDataTable(string commandText)
            {
                return this.ExecuteDataTable(CommandType.Text, commandText, null);
            }

            /// <summary>
            /// 获取一个DataTable
            /// </summary>
            /// <param name="selectCommand"></param>
            /// <param name="srcTable"></param>
            /// <returns></returns>
            public virtual DataTable ExecuteDataTable(DbCommand selectCommand, string srcTable)
            {
                DataTable dataTable = new DataTable();
                using (DbDataAdapter adapter = this.CreateDbAdapter(selectCommand))
                {
                    adapter.Fill(dataTable);
                    dataTable.ExtendedProperties[C_PROP_SQL] = selectCommand.CommandText;
                    if (!String.IsNullOrEmpty(srcTable))
                    {
                        dataTable.TableName = srcTable;
                    }
                }
                return dataTable;
            }

            /// <summary>
            /// 获取一个DataTable
            /// </summary>
            /// <param name="commandText"></param>
            /// <param name="srcTable"></param>
            /// <returns></returns>
            public DataTable ExecuteDataTable(string commandText, string srcTable)
            {
                DataTable table = this.ExecuteDataTable(CommandType.Text, commandText, null);
                if(!String.IsNullOrEmpty(srcTable))
                    table.TableName = srcTable;
                return table;
            }

            /// <summary>
            /// 获取指定记录数集合的表
            /// </summary>
            /// <param name="commandText"></param>
            /// <param name="startIndex"></param>
            /// <param name="maxRecords"></param>
            /// <returns></returns>
            public DataTable ExecuteDataTable(string commandText, int startIndex, int maxRecords)
            {
                DataTable dt;// = new DataTable();
                using (DbCommand cmd = this.PrepareCommand(CommandType.Text, commandText, null))
                {
                    dt = ExecuteDataTable(cmd, startIndex, maxRecords);
                }
                return dt;
            }

            /// <summary>
            /// 获取指定记录数集合的表
            /// </summary>
            /// <param name="selectCmd"></param>
            /// <param name="startIndex"></param>
            /// <param name="maxRecords"></param>
            /// <returns></returns>
            public virtual DataTable ExecuteDataTable(DbCommand selectCmd, int startIndex, int maxRecords)
            {
                DataTable dt = new DataTable();
                using (DbDataAdapter da = this.CreateDbAdapter(selectCmd))
                {
                    da.Fill(startIndex, maxRecords, dt);
                    dt.ExtendedProperties[C_PROP_SQL] = selectCmd.CommandText;
                }
                return dt;
            }

            /// <summary>
            /// 获取一个DataTable 
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="commandParameters"></param>
            /// <returns></returns>
            public virtual DataTable ExecuteDataTable(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
            {
                DataTable dataTable = new DataTable();
                using(DbCommand selectCommand = this.PrepareCommand(cmdType, cmdText, commandParameters))
                {
                    using (DbDataAdapter adapter = this.CreateDbAdapter(selectCommand))
                    {
                        adapter.Fill(dataTable);
                        dataTable.ExtendedProperties[C_PROP_SQL] = cmdText;
                    }
                    selectCommand.Parameters.Clear();
                }
                return dataTable;
            }

            /// <summary>
            /// 执行ExecuteNonQuery
            /// </summary>
            /// <param name="cmdText"></param>
            /// <returns></returns>
            public int ExecuteNonQuery(string cmdText)
            {
                return this.ExecuteNonQuery(CommandType.Text, cmdText, null);
            }

            /// <summary>
            /// 执行ExecuteNonQuery
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="commandParameters"></param>
            /// <returns></returns>
            public int ExecuteNonQuery(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
            {
                using (DbCommand dbCmd = this.PrepareCommand(cmdType, cmdText, commandParameters))
                {
                    int i = dbCmd.ExecuteNonQuery();
                    dbCmd.Parameters.Clear();
                    return i;
                }
            }

            /// <summary>
            /// 获取DbDataReader
            /// </summary>
            /// <param name="cmdText"></param>
            /// <returns></returns>
            public DbDataReader ExecuteReader(string cmdText)
            {
                return this.ExecuteReader(CommandType.Text, cmdText, null);
            }

            /// <summary>
            /// 获取DbDataReader
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="commandParameters"></param>
            /// <returns></returns>
            public DbDataReader ExecuteReader(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
            {
                return this.ExecuteReader(cmdType, cmdText, CommandBehavior.CloseConnection, commandParameters);
            }

            /// <summary>
            /// 获取DbDataReader
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="cmdBehavior"></param>
            /// <param name="commandParameters"></param>
            /// <returns></returns>
            public DbDataReader ExecuteReader(CommandType cmdType, string cmdText,CommandBehavior cmdBehavior, params DbParameter[] commandParameters)
            {
                DbCommand dbCmd = this.PrepareCommand(cmdType, cmdText, commandParameters);

                DbDataReader read = dbCmd.ExecuteReader(cmdBehavior);
                dbCmd.Parameters.Clear();
                return read;
            }

            /// <summary>
            /// 获取ExecuteScalar
            /// </summary>
            /// <param name="cmdText"></param>
            /// <returns></returns>
            public object ExecuteScalar(string cmdText)
            {
                return this.ExecuteScalar(CommandType.Text, cmdText, null);
            }

            /// <summary>
            /// 获取ExecuteScalar
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="commandParameters"></param>
            /// <returns></returns>
            public object ExecuteScalar(CommandType cmdType, string cmdText, params DbParameter[] commandParameters)
            {
                using (DbCommand dbCmd = this.PrepareCommand(cmdType, cmdText, commandParameters))
                {
                    object obj = dbCmd.ExecuteScalar();
                    dbCmd.Parameters.Clear();
                    return obj;
                }
            }

            /// <summary>
            /// 创建DbCommand
            /// </summary>
            /// <returns></returns>
            public virtual DbCommand CreateCommand()
            {
                DbCommand cmd = this.con.CreateCommand();
                if (this.trans != null)
                    cmd.Transaction = this.trans;
                return cmd;
            }

            /// <summary>
            /// 创建DbCommand
            /// </summary>
            /// <returns></returns>
            public virtual DbCommand CreateCommand(string commandText)
            {
                DbCommand command = this.CreateCommand();
                command.CommandText = commandText;
                return command;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="cmdType"></param>
            /// <param name="cmdText"></param>
            /// <param name="cmdParms"></param>
            /// <returns></returns>
            protected virtual DbCommand PrepareCommand(CommandType cmdType, string cmdText, params DbParameter[] cmdParms)
            {
                DbCommand command = this.CreateCommand(cmdText);
                 command.CommandType = cmdType;

                if (cmdParms != null)
                {
                    foreach (DbParameter parameter in cmdParms)
                    {
                        command.Parameters.Add(parameter);
                    }
                }
                return command;
            }

            /// <summary>
            /// 更新DataTable
            /// </summary>
            /// <param name="dataTable"></param>
            /// <returns></returns>
            public int UpdateDataTable(DataTable dataTable)
            {
                return this.UpdateDataTable(dataTable, dataTable.TableName);
            }

            /// <summary>
            /// 更新DataTable
            /// </summary>
            /// <param name="dataTable"></param>
            /// <param name="srcTable"></param>
            /// <returns></returns>
            public virtual int UpdateDataTable(DataTable dataTable, string srcTable)
            {
                string cmdText = null;
                if (dataTable.ExtendedProperties.Contains(C_PROP_SQL))
                {
                    cmdText = dataTable.ExtendedProperties[C_PROP_SQL].ToString();
                    if (cmdText.IndexOf("select", StringComparison.OrdinalIgnoreCase) >= 0 && cmdText.IndexOf("from", StringComparison.OrdinalIgnoreCase) >= 0)
                    {
                        int index = cmdText.IndexOf(" where ", StringComparison.OrdinalIgnoreCase);
                        if (index > 0)
                        {
                            cmdText = cmdText.Substring(0, index);
                        }
                        goto Flag;
                    }
                }

                if (String.IsNullOrEmpty(srcTable) && String.IsNullOrEmpty(dataTable.TableName))
                {
                    throw new Exception("没有设置TableName,或DataTable不是由DBConnect创建");
                }
                if (String.IsNullOrEmpty(srcTable))
                    srcTable = dataTable.TableName;

                System.Text.StringBuilder builder = new System.Text.StringBuilder();
                foreach (DataColumn column in dataTable.Columns)
                {
                    builder.Append(",[");
                    builder.Append(column.ColumnName);
                    builder.Append("]");
                }
                builder.Append(" From ");
                builder.Append(srcTable);
                cmdText = "Select " + builder.ToString(1, builder.Length - 1);

                Flag:
                
                using (DbDataAdapter da = this.CreateDbAdapter(this.PrepareCommand(CommandType.Text, cmdText, null)))
                {
                    if (da != null)
                    {
                        this.CreateCommandBuilder(da);
                        return da.Update(dataTable);
                    }
                }
                return -1;
            }

             /// <summary>
            /// Return ConnectionState
            /// </summary>
            public virtual ConnectionState State
            {
                get{ return this.con.State; }
            }

            /// <summary>
            /// Return or Set Connection's Trans
            /// </summary>
            public virtual DbTransaction Transaction
            {
                get { return this.trans; }
                set { this.trans = value; }
            }

            /// <summary>
            /// Return or Set DbConnection
            /// </summary>
            public virtual DbConnection DbConnection
            {
                get { return this.con; }
                set { this.con = value; }
            }

            /// <summary>
            /// 返回或设置连接的字符串
            /// </summary>
            public virtual string ConnectionString
            {
                get
                {
                    if (con == null)
                        return string.Empty;
                    return this.con.ConnectionString;
                }
                set
                {
                    if (this.con != null)
                        this.con.ConnectionString = value;
                }
            }

      }

    这个是该类库最底层的数据操作类了, 我想大家看了就明白了!

    我把该类作为基类派生出SqlDbDirect.cs、OleDbDirect.cs、OracleDbDirect.cs和MySqlDbDirect.cs目前支持这几种数据库,数据库类型枚举:

        /// <summary>
        /// 数据库类型枚举
        /// </summary>
        public enum DBTypeEnum
        {
            /// <summary>
            /// Sql DataBase  1
            /// </summary>
            SQL = 1,
            /// <summary>
            /// OleDb Access DataBase  2
            /// </summary>
            OleDb = 2,
            /// <summary>
            /// Oracle DataBase  3
            /// </summary>
            Oracle = 3,
            /// <summary>
            /// ADO Access DataBase 4
            /// </summary>
            ADO = 4,
            /// <summary>
            /// MySql DataBase  5
            /// </summary>
            MySql = 5
        }  

    在以上基础上我封装了DBConnect.cs类,有兴趣的朋友可以查看帮助文档,该类进一步封装数据操作方法,增加编写代码的实用性和易操作性。贴上构造函数代码:

       static readonly string Provider = ConfigurationManager.AppSettings["Provider"];

            private DBAccessBase con = null;

           /// <summary>
            ///  构造函数  
            ///  配置文件     
            ///  (appSettings)
            ///  add key="Provider" value="sql"  (Sql,OleDb,Oracle,mysql )    
            ///  add key="sql" value="Data Source=.;Initial Catalog=test;Persist Security Info=True;User ID=sa;Password=sa"    
            ///  add key="oledb" value="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=D:\sqldatabase\test.mdb"     
            ///  (appSettings)
            ///  无参数构造函数将自动创建连接
            /// </summary>
            public DBConnect()
            {
                if (String.IsNullOrEmpty(Provider))
                {
                       return;
                }

                string conStr = GetConStr();  //根据配置文件获取连接字符串
                if (!string.IsNullOrEmpty(conStr))
                {
                    this.dbEnum = getDBEnum();  //获取数据库类型枚举
                    setConnect(conStr);
                }
          }

       /// <summary>
            /// 构造函数
             /// </summary>
            /// <param name="dataBaseEnum">数据库类型枚举</param>
            /// <param name="connString">数据库的连接字符串</param>
            public DBConnect(DBTypeEnum dataBaseEnum, string connString)
            {
                this.dbEnum = dataBaseEnum;
                setConnect(connString);
            }

            void setConnect(string connString)
            {
                con = DBFactory.GetDBConnection(this.dbEnum, connString);  //使用工厂统一获取数据库连接对象
                ConnectString = connString;
            }

    配置文件如下设置 :

      <appSettings>
            <add key="Provider" value="sql" />
            <add key="sql" value="Data Source=.;Initial Catalog=userinfo;Persist Security Info=True;User ID=sa;Password=sql" />
        </appSettings>

     至此,数据底层通用的代码编写完毕,还请大家多提建议,下一篇描述ScriptQuery.cs和实体层!

    附件下载:DevNet类库及帮助文档

                  DevNet实体生成器

  • 相关阅读:
    LeetCode 189. Rotate Array
    LeetCode 965. Univalued Binary Tree
    LeetCode 111. Minimum Depth of Binary Tree
    LeetCode 104. Maximum Depth of Binary Tree
    Windows下MySQL的安装与配置
    LeetCode 58. Length of Last Word
    LeetCode 41. First Missing Positive
    LeetCode 283. Move Zeroes
    《蚂蚁金服11.11:支付宝和蚂蚁花呗的技术架构及实践》读后感
    删除docker下的镜像
  • 原文地址:https://www.cnblogs.com/Leo_wl/p/2330256.html
Copyright © 2011-2022 走看看