发布.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 : class , new ()
{
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 == null ) throw new ArgumentNullException( " objEntity " );
if (dataRow == null ) throw 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 == null ) throw new ArgumentNullException( " objEntity " );
if (dataRow == null ) throw 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 == null ) throw 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实体生成器
作者： Leo_wl
出处： http://www.cnblogs.com/Leo_wl/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
版权信息查看更多关于发布.NET 开发工具 DevNet4.0 开发框架 Maper 映射的详细内容...