在其中的实体层，一般是根据数据库进行映射外加入注释等，技术含量不大，在此一笔带过；数据库访问层和业务逻辑层，是关键之所在，因为这里好的设计，会利用很多基类的操作，减少很多代码和重复劳动；界面层，不管是WebForm还是WinForm，都是尽可能少的逻辑代码或者SQL语句在其中，好的项目可能会利用一些优秀的控件进去，提高体验，减少代码。另外，由于一些创建操作费时费资源，一般还需要把可重复利用的资源缓存起来，提高性能。
先给大家预览下项目的框架，再一层层分析讨论：
1、 实体层（定义一个空的基类，其他实体类继承之，主要是为了利用泛型操作，用途下面细说）
public class BaseEntity
{
}
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
}
2、 数据库访问层，数据访问层的关键是数据访问基类的设计，基类实现大多数数据库的日常操作，如下：
/**//// <summary>
/// 数据访问层的基类
/// </summary>
public abstract class BaseDAL<T> : IBaseDAL<T> where T : BaseEntity, new()
{
}
BaseEntity就是实体类的基类，IBaseDAL是定义的数据访问基类接口，包含各种常用的操作定义；因此BaseDAL就是要对各种操作的进行实现，实现接口越多，将来继承类的重用程度就越高。
以上通过泛型<T> ，我们就可以知道实例化那个具体访问类的信息了，可以实现强类型的函数定义。
/**//// <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
}
细看上面代码，会发现由一个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
}
3、具体的数据访问类
基类完成所有的操作了，对于具体的类将是一大福音，说明它的工作减少很多了，下面看看具体的实现过程。定义一个数据访问类接口，然后实现接口和继承基类即可。
public interface IEquipment : IBaseDAL<EquipmentInfo>
{
} public class Equipment : BaseDAL<EquipmentInfo>, IEquipment
{
对象实例及构造函数#region 对象实例及构造函数
public static Equipment Instance
{
get
{
return new Equipment();
}
}
public Equipment() : base("Equipment","ID")
{
}
#endregion
}
其实这样就完成了，我们为了提高效率，重载两个函数的实现，避免基类的属性反射带来的性能损失，这两个函数看似很复杂，其实通过代码生成工具，生成起来也是毫不费功夫的。。
protected override EquipmentInfo DataReaderToEntity(IDataReader dataReader)
protected override Hashtable GetHashByEntity(EquipmentInfo obj)
因此最后的代码就变为下面
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;
}
}