dot net 下的数据处理类
eidolon 2006-03-09
using System;
using RLDMS.Data;
using System.Text;
using System.Data;
using System.Data.SqlClient;
/// <summary>
/// 异常处理
/// </summary>
public class RLDMSException:System.Exception{
public RLDMSException(string ExceptionName): base(ExceptionName){}
}
/// <summary>
/// 参数类公共接口
/// </summary>
public interface IEntityPublic{}
/// <summary>
/// 具体参数类 实现了System.Collections.IList 接口
/// 每一个参数类都来源于数据库的表
/// Entity_Customers:参数类名
/// Customers:数据表名
/// </summary>
public class CEntity_Customers:System.Collections.IList,IEntityPublic
{
private System.Collections.ArrayList _List;
public CEntity_Customers()
{
this._List = new System.Collections.ArrayList();
}
public bool IsReadOnly
{
get{return false;}
}
public object this[int index]
{
get{return this._List[index];}
set{this._List[index] = value;}
}
public void RemoveAt(int index)
{
this._List.Remove(index);
}
public void Insert(int index,object value)
{
this._List.Insert(index,value);
}
public void Remove(object value)
{
this._List.Remove(value);
}
public bool Contains(object value)
{
return this._List.Contains(value);
}
public void Clear()
{
this._List.Clear();
}
public bool IsFixedSize
{
get{ return false;}
}
public bool IsSynchronized
{
get
{
return this._List.IsSynchronized;
}
}
public int Count
{
get{
return this._List.Count;
}
}
public void CopyTo(Array array,int index)
{
this._List.CopyTo(array,index);
}
public object SyncRoot
{
get
{
return this._List.SyncRoot;
}
}
public System.Collections.IEnumerator GetEnumerator()
{
return this._List.GetEnumerator();
}
/// <summary>
/// Collection的add方法的实现
/// </summary>
/// <param name="_entity">Entity_customers类型变量</param>
public int Add( object value)
{
return this._List.Add(value);
}
public int IndexOf(object value)
{
return this._List.IndexOf(value);
}
/*System.Collections.CollectionBase 的实现
public void Add( CEntity_Customers _entity)
{
List.Add(_entity);
}
public CEntity_Customers this[int index]
{
get
{
return (CEntity_Customers) List[index];
}
}
*/
#region 根据数据库字段产生的私有变量和类的属性
private string _CustomerID = string.Empty;
private string _CompanyName = string.Empty;
private string _ContactName = string.Empty;
private string _ContactTitle = string.Empty;
private string _Address = string.Empty;
private string _City = string.Empty;
private string _Region = string.Empty;
private string _PostalCode = string.Empty;
private string _Country = string.Empty;
private string _Phone = string.Empty;
private string _Fax = string.Empty;
public string CustomerID {
get {
// if (( _CustomerID == null) || ( _CustomerID == string.Empty ))
// {
// CustomerID = string.Empty;
// }
return _CustomerID;
}
set{
_CustomerID = value;
}
}
public string CompanyName
{
get
{
if (( _CompanyName == null) || ( _CompanyName == string.Empty ))
{
CompanyName = string.Empty;
}
return _CompanyName;
}
set
{
_CompanyName = value;
}
}
public string ContactName
{
get
{
if (( _ContactName == null) || ( _ContactName == string.Empty ))
{
ContactName = string.Empty;
}
return _ContactName;
}
set
{
_CompanyName = value;
}
}
public string ContactTitle
{
get
{
if (( _ContactTitle == null) || ( _ContactTitle == string.Empty ))
{
ContactTitle = string.Empty;
}
return _ContactTitle;
}
set
{
_ContactTitle = value;
}
}
public string Address
{
get
{
if (( _Address == null) || ( _Address == string.Empty ))
{
Address = string.Empty;
}
return _Address;
}
set
{
_Address = value;
}
}
public string City
{
get
{
if (( _City == null) || ( _City == string.Empty ))
{
City = string.Empty;
}
return _City;
}
set
{
_City = value;
}
}
public string Region
{
get
{
if (( _Region == null) || ( _Region == string.Empty ))
{
Region = string.Empty;
}
return _Region;
}
set
{
_Region = value;
}
}
public string PostalCode
{
get
{
if (( _PostalCode == null) || ( _PostalCode == string.Empty ))
{
_PostalCode = string.Empty;
}
return _PostalCode;
}
set
{
_PostalCode = value;
}
}
public string Country
{
get
{
if (( _Country == null) || ( _Country == string.Empty ))
{
Country = string.Empty;
}
return _Country;
}
set
{
_Country = value;
}
}
public string Phone
{
get
{
if (( _Phone == null) || ( _Phone == string.Empty ))
{
Phone = string.Empty;
}
return _Phone;
}
set
{
_Phone = value;
}
}
public string Fax
{
get
{
if (( _Fax == null) || ( _Fax == string.Empty ))
{
Fax = string.Empty;
}
return _Fax;
}
set
{
_Fax = value;
}
}
#endregion
}
/// <summary>
/// 数据业务类接口
/// </summary>
public interface IDataBusiness
{
/// <summary>
/// 判断是否有事务
/// </summary>
bool IsTranscation{ get; }
/// <summary>
/// 公共属性 父类型 实现时用子类代替
/// </summary>
IEntityPublic CEntity{get;set;}
/// <summary>
/// 排序语句
/// </summary>
string strOrderBy{get;set;}
/// <summary>
/// 有事务的增加
/// </summary>
/// <param name="DataAccess">数据访问类</param>
/// <param name="_Transaction">已经存在的事务</param>
void AddDataWithTranscation( CAccessDataClass DataAccess ,System.Data.SqlClient.SqlTransaction _Transaction);
/// <summary>
/// 没有事务的增加方法
/// </summary>
/// <param name="DataAccess">数据访问类</param>
void AddDataWithOutTranscation( CAccessDataClass DataAccess);
/// <summary>
/// 有事务的修改方法
/// </summary>
/// <param name="DataAccess">数据访问类</param>
/// <param name="_Transaction">已经存在的事务</param>
void UpdateDataWithTranscation( CAccessDataClass DataAccess ,System.Data.SqlClient.SqlTransaction _Transaction);
/// <summary>
/// 没有事务的修改方法
/// </summary>
/// <param name="DataAccess">数据访问类</param>
void UpdateDataWithOutTranscation( CAccessDataClass DataAccess );
/// <summary>
/// 有事务的删除方法
/// </summary>
/// <param name="DataAccess"></param>
/// <param name="_Transaction"></param>
void DeleteDataWithTranscation( CAccessDataClass DataAccess ,System.Data.SqlClient.SqlTransaction _Transaction);
/// <summary>
/// 没有事务的删除方法
/// </summary>
/// <param name="DataAccess"></param>
void DeleteDataWithOutTranscation( CAccessDataClass DataAccess );
/// <summary>
/// 查询方法
/// </summary>
/// <param name="DS">DataSet</param>
void QueryData( CAccessDataClass DataAccess ,out DataSet DS);
/// <summary>
/// 查询方法
/// </summary>
/// <param name="cOutEntity"></param>
void QueryData( CAccessDataClass DataAccess ,out IEntityPublic cOutEntity);
/// <summary>
/// 返回查询结果,查询语句不带where条件
/// </summary>
/// <param name="DataAccess">数据访问类</param>
/// <param name="strSql">不带条件的查询语句</param>
/// <returns>字符串</returns>
string QueryResultWithoutWhere( CAccessDataClass DataAccess ,string strSql);
/// <summary>
/// 返回查询结果,查询语句带有where条件
/// </summary>
/// <param name="DataAccess">数据访问类</param>
/// <param name="strSql">带有查询条件的查询语句 </param>
/// <returns>字符串</returns>
string QueryResultWithWhere( CAccessDataClass DataAccess ,string strSql);
/// <summary>
/// 查询方法
/// </summary>
/// <param name="cEntity"></param>
/// <returns></returns>
bool IsEntityExsite( CAccessDataClass _DataAccess );
/// <summary>
/// 得到查询条件 Where语句
///
/// 或者应用在其它地方
/// </summary>
/// <returns>字符串</returns>
string GetSearchCondition();
/// <summary>
/// 根据排序属性得到排序条件
///
/// </summary>
/// <returns>字符串</returns>
string GetOrderCondition();
}
//业务类制造工厂
public class VehicleFactory
{
public static IDataBusiness CreateBusinessVehicle(Type vehicleType)
{
//自己写构造参数!
System.Reflection.ConstructorInfo construct
= vehicleType.GetConstructor(Type.EmptyTypes);
IDataBusiness v = (IDataBusiness)construct.Invoke(null);
return v;
}
public static IEntityPublic CreataEntityVerchicle(Type vehicleType)
{
//自己写构造参数!
System.Reflection.ConstructorInfo construct
= vehicleType.GetConstructor(Type.EmptyTypes);
IEntityPublic v = (IEntityPublic)construct.Invoke(null);
return v;
}
}
/// <summary>
/// DataCustomers数据类
/// </summary>
public class DataCustomers :IDataBusiness
{
private RLDMS.Other.COther Other;
/// <summary>
/// SqlCommand参数类
/// </summary>
private SqlParameter[] sqlPara ;
/// <summary>
/// 事务标志
/// </summary>
private bool _IsTranscation;
/// <summary>
/// 事务标志
/// </summary>
public bool IsTranscation
{
get{return _IsTranscation;}
set{_IsTranscation = value;}
}
/// <summary>
/// 排序条件
/// </summary>
private string _strOrderBy = string.Empty;
/// <summary>
/// 排序条件
/// </summary>
public string strOrderBy
{
get{return _strOrderBy;}
set{_strOrderBy = value;}
}
/// <summary>
/// 实体类Customer
/// </summary>
private CEntity_Customers _Entity ;
/// <summary>
/// 实体类的公共接口实现
/// </summary>
public IEntityPublic CEntity
{
get
{
if (_Entity == null )
_Entity = new CEntity_Customers();
return (IEntityPublic)_Entity;
}
set
{
_Entity = ( CEntity_Customers)value;
}
}
/// <summary>
/// 构造函数
/// </summary>
public DataCustomers()
{
this.Other = new RLDMS.Other.COther();
this._Entity = new CEntity_Customers();
}
/// <summary>
/// 带有事务的录入接口的实现
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="_Transaction">定义好的事务</param>
/// <exception cref="SqlException">Sql异常</exception>
public void AddDataWithTranscation( CAccessDataClass _DataAccess , System.Data.SqlClient.SqlTransaction _Transaction)
{
try
{
StringBuilder sSql = new StringBuilder();
sSql = GetInsertSql();
this.SetParam();
_DataAccess.Open();
_DataAccess.ExecuteSQL(_Transaction,CommandType.Text,sSql.ToString(),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 不带事务的录入接口的实现
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <exception cref="SqlException">Sql异常</exception>
public void AddDataWithOutTranscation( CAccessDataClass _DataAccess )
{
try
{
StringBuilder sSql = new StringBuilder();
sSql = GetInsertSql();
this.SetParam();
_DataAccess.Open();
_DataAccess.ExecuteSQL(CommandType.Text,sSql.ToString(),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 不带事务的修改
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <exception cref="SqlException">Sql异常</exception>
public void UpdateDataWithOutTranscation( CAccessDataClass _DataAccess )
{
try
{
StringBuilder sSql = new StringBuilder();
this.SetParam();
sSql = this.GetUpdateSql();
_DataAccess.Open();
_DataAccess.ExecuteSQL(CommandType.Text,sSql.ToString (),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 带事务的修改
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="_Transaction">定义好的事务</param>
/// <exception cref="SqlException">Sql异常</exception>
public void UpdateDataWithTranscation( CAccessDataClass _DataAccess ,System.Data.SqlClient.SqlTransaction _Transaction)
{
try
{
StringBuilder sSql = new StringBuilder();
this.SetParam();
sSql = this.GetUpdateSql();
_DataAccess.Open();
_DataAccess.ExecuteSQL(_Transaction,CommandType.Text,sSql.ToString (),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 带事务的删除
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="_Transaction">定义好的事务</param>
/// <exception cref="SqlException">Sql异常</exception>
public void DeleteDataWithTranscation( CAccessDataClass _DataAccess ,System.Data.SqlClient.SqlTransaction _Transaction)
{
try
{
StringBuilder sSql = new StringBuilder();
this.SetParam();
sSql = this.GetDeleteSql();
_DataAccess.Open();
_DataAccess.ExecuteSQL(_Transaction,CommandType.Text,sSql.ToString (),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 带有事务的删除
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <exception cref="SqlException">Sql异常</exception>
public void DeleteDataWithOutTranscation( CAccessDataClass _DataAccess )
{
try
{
StringBuilder sSql = new StringBuilder();
this.SetParam();
sSql = this.GetDeleteSql();
_DataAccess.Open();
_DataAccess.ExecuteSQL(CommandType.Text,sSql.ToString (),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 查询方法 返回dataset
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="DS">DataSet</param>
public void QueryData( CAccessDataClass _DataAccess , out DataSet DS)
{
try
{
StringBuilder sSql = new StringBuilder();
sSql = GetWhereCondition( GetSelectSql() );
sSql = GetOrderBy( sSql );
_DataAccess.Open();
DS = _DataAccess.GetDataSet(System.Data.CommandType.Text,sSql.ToString(),sqlPara);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 查询方法 返回实体类
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="cOutEntity">实体类</param>
public void QueryData( CAccessDataClass _DataAccess ,out IEntityPublic cOutEntity)
{
try
{
StringBuilder sSql = new StringBuilder();
sSql = GetWhereCondition( GetSelectSql() );
sSql = GetOrderBy( sSql );
_DataAccess.Open();
cOutEntity = this.GetEntity(sSql,_DataAccess);
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 查询方法 判断数据表中是否存在指定的数据
/// </summary>
/// <param name="_DataAccess">数据反问类</param>
/// <returns>Boolean</returns>
public bool IsEntityExsite( CAccessDataClass _DataAccess ){
try
{
StringBuilder sSql = new StringBuilder();
sSql = this.GetCountSql();
this.SetParam();
sSql.Append( this.GetWhereCondition() );
_DataAccess.Open();
int iCount = Convert.ToInt32(_DataAccess.GetScalar(System.Data.CommandType.Text,sSql.ToString(),this.sqlPara)) ;
if (iCount>0)
return true;
else
return false;
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 没有Where条件的查询
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="strSql">查询语句</param>
/// <returns>结果字符串</returns>
public string QueryResultWithoutWhere(CAccessDataClass _DataAccess ,string strSql)
{
try
{
StringBuilder sSql = new StringBuilder();
this.SetParam();
sSql.Append( strSql );
sSql.Append( this.GetWhereCondition() );
_DataAccess.Open();
return _DataAccess.GetScalar(System.Data.CommandType.Text,sSql.ToString(),this.sqlPara) ;
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 有Where条件的查询
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <param name="strSql">查询语句</param>
/// <returns>结果字符串</returns>
public string QueryResultWithWhere(CAccessDataClass _DataAccess ,string strSql)
{
try
{
StringBuilder sSql = new StringBuilder();
_DataAccess.Open();
return _DataAccess.GetScalar(System.Data.CommandType.Text,strSql,this.sqlPara) ;
}
catch(SqlException ex)
{
throw(ex);
}
catch(ApplicationException ex)
{
throw(new RLDMSException(ex.Message));
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally{ _DataAccess.Close();}
}
/// <summary>
/// 根据参数类的赋值
/// 返回拼接完好的查询条件
/// </summary>
/// <returns></returns>
public string GetSearchCondition()
{
return this.GetWhereCondition().ToString();
}
/// <summary>
/// 根据排序属性的赋值
/// 返回拼接完好的排序条件
/// </summary>
/// <returns></returns>
public string GetOrderCondition()
{
return this.GetOrderBy().ToString();
}
#region 附属函数
/// <summary>
/// 得到插入语句
/// </summary>
/// <returns>返回插入语句</returns>
private StringBuilder GetInsertSql()
{
StringBuilder sSql = new StringBuilder();
sSql.Append(" INSERT INTO [Customers]");
sSql.Append(" ( [CustomerID], [CompanyName], [ContactName], [ContactTitle], ");
sSql.Append(" [Address], [City], [Region], [PostalCode], ");
sSql.Append(" [Country], [Phone], [Fax])");
sSql.Append(" VALUES ");
sSql.Append(" ( @CustomerID , @CompanyName, @ContactName, @ContactTitle ");
sSql.Append(" @Address, @City, @Region, @PostalCode");
sSql.Append(" @Country, @Phone, @Fax");
sSql.Append(" )");
return sSql;
}
/// <summary>
/// 得到查询语句
/// </summary>
/// <returns>返回查询语句</returns>
private StringBuilder GetSelectSql()
{
StringBuilder sSql = new StringBuilder();
sSql.Append(" SELECT ");
sSql.Append(" [CustomerID], [CompanyName], [ContactName], [ContactTitle], ");
sSql.Append(" [Address], [City], [Region], [PostalCode], ");
sSql.Append(" [Country], [Phone], [Fax] ");
sSql.Append(" FROM [Customers]");
return sSql;
}
/// <summary>
/// 得到查询结果数量语句
/// </summary>
/// <returns>返回结果集数量语句</returns>
private StringBuilder GetCountSql()
{
StringBuilder sSql = new StringBuilder();
sSql.Append(" SELECT count(*) FROM [Customers] ");
return sSql;
}
/// <summary>
/// 得到删除语句
/// </summary>
/// <returns>返回删除语句</returns>
public StringBuilder GetDeleteSql()
{
StringBuilder sSql = new StringBuilder();
sSql.Append("DELETE FROM [Customers]");
return sSql;
}
/// <summary>
/// 得到更新语句
/// </summary>
/// <returns>返回更新语句</returns>
private StringBuilder GetUpdateSql()
{
StringBuilder sSql = new StringBuilder(),sWhere = new StringBuilder(),sUpdate = new StringBuilder();
Other.SQLAddUpdate("[Customers]",sUpdate,out sSql);
sqlPara = this.SetParam();
//Other.SQLAddWhere(" ID ",cEntity.ID," @ID ","=",ref sWhere);
Other.SQLAddUpdate(" CustomerID ",_Entity.CustomerID," @CustomerID ",ref sUpdate);
Other.SQLAddUpdate(" CompanyName ",_Entity.CompanyName," @CompanyName ",ref sUpdate);
Other.SQLAddUpdate(" ContactName ",_Entity.ContactName," @ContactName ",ref sUpdate);
Other.SQLAddUpdate(" ContactTitle ",_Entity.ContactTitle," @ContactTitle ",ref sUpdate);
Other.SQLAddUpdate(" Address ",_Entity.Address," @Address ",ref sUpdate);
Other.SQLAddUpdate(" City ",_Entity.City," @City ",ref sUpdate);
Other.SQLAddUpdate(" Region ",_Entity.Region," @Region ",ref sUpdate);
Other.SQLAddUpdate(" PostalCode ",_Entity.PostalCode," @PostalCode ",ref sUpdate);
Other.SQLAddUpdate(" Country ",_Entity.Country," @Country ",ref sUpdate);
Other.SQLAddUpdate(" Phone ",_Entity.Phone," @Phone ",ref sUpdate);
Other.SQLAddUpdate(" Fax ",_Entity.Fax," @Fax ",ref sUpdate);
sSql.Append(sUpdate.ToString());
Other.SQLAddWhere(ref sSql,sWhere);
return sSql;
}
/// <summary>
/// 得到where语句
/// </summary>
/// <returns>返回where语句</returns>
private StringBuilder GetWhereCondition()
{
StringBuilder sWhere = new StringBuilder();
sqlPara = this.SetParam();
Other.SQLAddWhere(" CustomerID ",_Entity.CustomerID," @CustomerID "," = ",ref sWhere);
Other.SQLAddWhere(" CompanyName ",_Entity.CompanyName," @CompanyName "," = ",ref sWhere);
Other.SQLAddWhere(" ContactName ",_Entity.ContactName," @ContactName "," = ",ref sWhere);
Other.SQLAddWhere(" ContactTitle ",_Entity.ContactTitle," @ContactTitle "," = ",ref sWhere);
Other.SQLAddWhere(" Address ",_Entity.Address," @Address "," = ",ref sWhere);
Other.SQLAddWhere(" City ",_Entity.City," @City "," = ",ref sWhere);
Other.SQLAddWhere(" Region ",_Entity.Region," @Region "," = ",ref sWhere);
Other.SQLAddWhere(" PostalCode ",_Entity.PostalCode," @PostalCode "," = ",ref sWhere);
Other.SQLAddWhere(" Country ",_Entity.Country," @Country "," = ",ref sWhere);
Other.SQLAddWhere(" Phone ",_Entity.Phone," @Phone "," = ",ref sWhere);
Other.SQLAddWhere(" Fax ",_Entity.Fax," @Fax "," = ",ref sWhere);
return sWhere;
}
/// <summary>
/// 得到where语句
/// </summary>
/// <param name="sSql">查询语句</param>
/// <returns>返回Select + where语句</returns>
private StringBuilder GetWhereCondition(StringBuilder sSql)
{
Other.SQLAddWhere(ref sSql,GetWhereCondition());
return sSql;
}
/// <summary>
/// 得到排序语句
/// </summary>
/// <returns></returns>
private StringBuilder GetOrderBy()
{
StringBuilder sSql = new StringBuilder();
if (this._strOrderBy == string.Empty)
{
return sSql;
}
else
{
return sSql.Append( " ORDER BY " + this._strOrderBy );
}
}
/// <summary>
/// 得到排序语句
/// </summary>
/// <returns></returns>
private StringBuilder GetOrderBy(StringBuilder sSql)
{
if (this._strOrderBy == string.Empty)
{
return sSql;
}
else
{
return sSql.Append(" ORDER BY " + this._strOrderBy );
}
}
/// <summary>
/// 得到实体对象
/// </summary>
/// <param name="sSql">查询语句</param>
/// <param name="_DataAccess">数据访问类</param>
/// <returns>实体对象集合</returns>
private CEntity_Customers GetEntity( StringBuilder sSql,RLDMS.Data.CAccessDataClass _DataAccess )
{
try
{
_DataAccess.Open();
//cOutEntity = new CEntity_Customers();
SqlDataReader SDR = _DataAccess.GetReader(CommandType.Text, sSql.ToString(),sqlPara );
#region READ DATA
while (SDR.Read())
{
CEntity_Customers cOutEntity = new CEntity_Customers();
if (SDR.IsDBNull(0))
{ cOutEntity.CustomerID = ""; }
else
{ cOutEntity.CustomerID = SDR.GetString(0).ToString(); }
if (SDR.IsDBNull(1))
{ cOutEntity.CompanyName = ""; }
else
{ cOutEntity.CompanyName = SDR.GetString(1).ToString(); }
if (SDR.IsDBNull(2))
{ cOutEntity.ContactName = ""; }
else
{ cOutEntity.ContactName = SDR.GetString(2).ToString(); }
if (SDR.IsDBNull(3))
{ cOutEntity.ContactTitle = ""; }
else
{ cOutEntity.ContactTitle = SDR.GetString(3).ToString(); }
if (SDR.IsDBNull(4))
{ cOutEntity.Address = ""; }
else
{ cOutEntity.Address = SDR.GetString(4).ToString(); }
if (SDR.IsDBNull(5))
{ cOutEntity.City = ""; }
else
{ cOutEntity.City = SDR.GetString(5).ToString(); }
if (SDR.IsDBNull(6))
{ cOutEntity.Region = ""; }
else
{ cOutEntity.Region = SDR.GetString(6).ToString(); }
if (SDR.IsDBNull(7))
{ cOutEntity.PostalCode = ""; }
else
{ cOutEntity.PostalCode = SDR.GetString(7).ToString(); }
if (SDR.IsDBNull(8))
{ cOutEntity.Country = ""; }
else
{ cOutEntity.Country = SDR.GetString(8).ToString(); }
if (SDR.IsDBNull(9))
{ cOutEntity.Phone = ""; }
else
{ cOutEntity.Phone = SDR.GetString(9).ToString(); }
if (SDR.IsDBNull(10))
{ cOutEntity.Fax = ""; }
else
{ cOutEntity.Fax = SDR.GetString(10).ToString(); }
_Entity.Add(cOutEntity);
}
#endregion
return _Entity;
}
catch(SqlException ex)
{
throw(new Exception(Other.ErrorReplace(ex)));
}
finally
{
_DataAccess.Close();
}
}
/// <summary>
///数据参数设置
/// </summary>
/// <param name="sqlPara">参数对象</param>
private SqlParameter[] SetParam()
{
sqlPara = new SqlParameter[]
{
new SqlParameter("@CustomerID",SqlDbType.VarChar),
new SqlParameter("@CompanyName",SqlDbType.VarChar),
new SqlParameter("@ContactName",SqlDbType.VarChar),
new SqlParameter("@ContactTitle",SqlDbType.VarChar),
new SqlParameter("@Address",SqlDbType.VarChar),
new SqlParameter("@City",SqlDbType.VarChar),
new SqlParameter("@Region",SqlDbType.VarChar),
new SqlParameter("@PostalCode",SqlDbType.VarChar),
new SqlParameter("@Country",SqlDbType.VarChar),
new SqlParameter("@Phone",SqlDbType.VarChar),
new SqlParameter("@Fax",SqlDbType.VarChar)
};
Other.SetParm(sqlPara[0],_Entity.CustomerID);
Other.SetParm(sqlPara[1],_Entity.CompanyName);
Other.SetParm(sqlPara[2],_Entity.ContactName);
Other.SetParm(sqlPara[3],_Entity.ContactTitle);
Other.SetParm(sqlPara[4],_Entity.Address);
Other.SetParm(sqlPara[5],_Entity.City);
Other.SetParm(sqlPara[6],_Entity.Region);
Other.SetParm(sqlPara[7],_Entity.PostalCode);
Other.SetParm(sqlPara[8],_Entity.Country);
Other.SetParm(sqlPara[9],_Entity.Phone);
Other.SetParm(sqlPara[10],_Entity.Fax);
return sqlPara;
}
#endregion
}
/// <summary>
/// 数据代理类
/// </summary>
public class DataDelegate
{
/// <summary>
/// 数据业务类
/// </summary>
private IDataBusiness iDataBusiness;
/// <summary>
/// 工厂方法构造函数
/// 创造IDataBusiness
/// 调用方法,例:DataContral(typeof(DataCustomers) )
/// </summary>
/// <param name="vehicleType"></param>
public DataDelegate(Type vehicleType )
{
//通过反射建立一个数据操作类
this.iDataBusiness = VehicleFactory.CreateBusinessVehicle( vehicleType );
}
#region 设置、得到查询条件
/// <summary>
/// 设置查询条件
/// </summary>
/// <param name="_Entity">参数类</param>
/// <returns>返回拼接好的查询条件</returns>
public string SetEntity( IEntityPublic _Entity)
{
this.iDataBusiness.CEntity = _Entity;
return iDataBusiness.GetSearchCondition();
}
#endregion
#region 设置、得到排序条件
/// <summary>
/// 设置排序条件
/// </summary>
/// <param name="strOrderBy">参数类</param>
/// <returns>返回拼接好的排序条件</returns>
public string SetOrderBy(string strOrderBy)
{
this.iDataBusiness.strOrderBy = strOrderBy;
return iDataBusiness.GetOrderCondition();
}
#endregion
#region 数据增加
/// <summary>
/// 数据增加
/// 如果对于复杂业务在一个事务下要执行多个步骤
/// 需要仿照此方法重写
/// </summary>
/// <returns></returns>
public bool AddData()
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
System.Data.SqlClient.SqlTransaction _SqlTranscation = DataAccess.BeginTransaction("Transcation1");
if ( iDataBusiness.IsTranscation )
{
try
{
DataAccess.Open();
iDataBusiness.AddDataWithTranscation(DataAccess, _SqlTranscation);
_SqlTranscation.Commit();
return true;
}
catch(SqlException ex)
{
_SqlTranscation.Rollback("Transcation1");
return false;
}
catch(RLDMSException ex)
{
throw(ex);
}
finally
{
DataAccess.Close();
}
}
else
{
try
{
DataAccess.Open();
iDataBusiness.AddDataWithOutTranscation(DataAccess);
return true;
}
catch(SqlException ex)
{
throw( new RLDMSException( ex.Message ));
return false;
}
finally{ DataAccess.Close();}
}
}
#endregion
#region 数据删除
/// <summary>
/// 数据删除
/// 如果对于复杂业务在一个事务下要执行多个步骤
/// 需要仿照此方法重写
/// </summary>
/// <returns>Boolean</returns>
public bool DeleteData()
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
System.Data.SqlClient.SqlTransaction _SqlTranscation = DataAccess.BeginTransaction("Transcation1");
if ( iDataBusiness.IsTranscation )
{
try
{
DataAccess.Open();
iDataBusiness.DeleteDataWithTranscation(DataAccess, _SqlTranscation);
_SqlTranscation.Commit();
return true;
}
catch(SqlException ex)
{
_SqlTranscation.Rollback("Transcation1");
return false;
}
catch(RLDMSException ex)
{
throw(ex);
}
finally
{
DataAccess.Close();
}
}
else
{
try
{
DataAccess.Open();
iDataBusiness.DeleteDataWithOutTranscation(DataAccess);
return true;
}
catch(SqlException ex)
{
throw( new RLDMSException( ex.Message ));
return false;
}
finally{ DataAccess.Close();}
}
}
#endregion
#region 数据修改
/// <summary>
/// 数据修改
/// 如果对于复杂业务在一个事务下要执行多个步骤
/// 需要仿照此方法重写
/// </summary>
/// <returns>Boolean</returns>
public bool UpdateData()
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
System.Data.SqlClient.SqlTransaction _SqlTranscation = DataAccess.BeginTransaction("Transcation1");
if ( iDataBusiness.IsTranscation )
{
try
{
DataAccess.Open();
iDataBusiness.UpdateDataWithTranscation(DataAccess, _SqlTranscation);
_SqlTranscation.Commit();
return true;
}
catch(SqlException ex)
{
_SqlTranscation.Rollback("Transcation1");
return false;
}
catch(RLDMSException ex)
{
throw(ex);
}
finally
{
DataAccess.Close();
}
}
else
{
try
{
DataAccess.Open();
iDataBusiness.UpdateDataWithOutTranscation(DataAccess);
return true;
}
catch(SqlException ex)
{
throw( new RLDMSException( ex.Message ));
return false;
}
finally{ DataAccess.Close();}
}
}
#endregion
#region 数据查询
/// <summary>
/// 数据查询
/// </summary>
/// <param name="DS">DataSet</param>
public DataSet QueryDataSet()
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
try
{
DataAccess.Open();
DataSet DS;
iDataBusiness.QueryData( DataAccess, out DS);
return DS;
}
catch(SqlException ex)
{
throw( new RLDMSException(ex.Message));
}
catch(RLDMSException ex)
{
throw(ex);
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally
{
DataAccess.Close();
}
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="cOutEntity"></param>
public IEntityPublic QueryDataCollections( )
{
IEntityPublic cOutEntity ;
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
try
{
DataAccess.Open();
iDataBusiness.QueryData( DataAccess, out cOutEntity);
}
catch(SqlException ex)
{
throw( new RLDMSException(ex.Message));
}
catch(RLDMSException ex)
{
throw(ex);
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally
{
DataAccess.Close();
}
return cOutEntity;
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="_DataAccess">数据访问类</param>
/// <returns>Boolean</returns>
public bool IsEntityExsite( CAccessDataClass _DataAccess )
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
try
{
DataAccess.Open();
return iDataBusiness.IsEntityExsite( _DataAccess);
}
catch(SqlException ex)
{
throw( new RLDMSException(ex.Message));
}
catch(RLDMSException ex)
{
throw(ex);
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally
{
DataAccess.Close();
}
}
/// <summary>
/// 返回查询结果
/// </summary>
/// <param name="strSql"></param>
/// <returns></returns>
public string QueryResultWhithWhere( string strSql)
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
try
{
DataAccess.Open();
return iDataBusiness.QueryResultWithWhere( DataAccess, strSql );
}
catch(SqlException ex)
{
throw( new RLDMSException(ex.Message));
}
catch(RLDMSException ex)
{
throw(ex);
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally
{
DataAccess.Close();
}
}
/// <summary>
/// 返回查询结果
/// </summary>
/// <param name="strSql"></param>
/// <returns></returns>
public string QueryResultWhithOutWhere( string strSql)
{
//定义数据访问类
CAccessDataClass DataAccess= new CAccessDataClass ();
try
{
DataAccess.Open();
return iDataBusiness.QueryResultWithoutWhere( DataAccess,strSql );
}
catch(SqlException ex)
{
throw( new RLDMSException(ex.Message));
}
catch(RLDMSException ex)
{
throw(ex);
}
catch(Exception ex)
{
throw(new RLDMSException(ex.Message));
}
finally
{
DataAccess.Close();
}
}
#endregion
}