_linkdatabase.cs

是一个合格证打印系统

using System;
using System.Data;
using System.Data.SqlClient;

using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data.OleDb;



namespace PrintSystem  
{
	
	
	#region 普通OleDb 数据库连接类
	/// <summary>
	/// 普通OleDb 数据库连接类
	/// </summary>
	#endregion
	public class DataBase
	{
		public DataBase()
		{
			this.oleConnection = new OleDbConnection();
			this.nCommandTimeout = 30;
			this.oleCommand = null;

		}
		public DataBase(string strConnectionString)
		{
			this.oleConnection = new OleDbConnection();
			this.nCommandTimeout = 30;
			this.oleCommand = null;
			this.Open(strConnectionString);
		}

			
			
		#region 重新设置数据库
		/// <summary>
		/// 重新设置数据库
		/// </summary>
		/// <param name="strDatabase">数据库连接串</param>
		#endregion
		public void Use(string strDatabase)
		{
			this.oleConnection.ChangeDatabase(strDatabase);
		}
		#region 打开数据库连接
		/// <summary>
		/// 打开数据库连接
		/// </summary>
		/// <param name="strConnectionString"></param>
		#endregion
		public void Open(string strConnectionString)
		{
			this.oleConnection.ConnectionString = strConnectionString;
			this.oleConnection.Open();
		}

		#region 关闭数据库连接
		/// <summary>
		/// 关闭数据库连接
		/// </summary>
		#endregion
		public void Close()
		{
			this.oleConnection.Close();
		}


		public virtual void Prepare(string strSQLCommand, params OleDbParameter[] oleParams)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			foreach (OleDbParameter parameter1 in oleParams)
			{
				this.oleCommand.Parameters.Add(parameter1);
			}
		}

		#region 执行SQL 返回影响的行数
		/// <summary>
		/// 执行SQL 返回影响的行数
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual int ExecSQLNonQuery(params object[] objData)
		{
			for (int num1 = 0; num1 < objData.Length; num1++)
			{
				this.oleCommand.Parameters[num1].Value = objData[num1];
			}
			return this.oleCommand.ExecuteNonQuery();
		}

		#region 执行SQL 返回影响的行数
		/// <summary>
		/// 执行SQL 返回影响的行数
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual int ExecSQLNonQueryDirect(string strSQLCommand)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			return this.oleCommand.ExecuteNonQuery();
		}

		#region 返回一个对象
		/// <summary>
		/// 返回一个对象
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual object ExecSQLScalar(params object[] objData)
		{
			for (int num1 = 0; num1 < objData.Length; num1++)
			{
				this.oleCommand.Parameters[num1].Value = objData[num1];
			}
			return this.oleCommand.ExecuteScalar();
		}

		#region 返回一个对象
		/// <summary>
		/// 返回一个对象
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual object ExecSQLScalarDirect(string strSQLCommand)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			return this.oleCommand.ExecuteScalar();
		}


		#region 通过匹配SQL 来得到一个数据集
		/// <summary>
		/// 通过匹配SQL 来得到一个数据集
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual DataSet ExecSQLSet(params object[] objData)
		{
			for (int num1 = 0; num1 < objData.Length; num1++)
			{
				this.oleCommand.Parameters[num1].Value = objData[num1];
			}
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(this.oleCommand).Fill(set1);
			return set1;
		}
 
		#region 通过直接查询返回一个数据集 
		/// <summary>
		/// 通过直接查询返回一个数据集
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual DataSet ExecSQLSetDirect(string strSQLCommand)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(this.oleCommand).Fill(set1);
			return set1;
		}
		public virtual DataSet ExecSQLSetDirect(string strSQLCommand,string strTableName)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(this.oleCommand).Fill(set1,strTableName);
			return set1;
		}

		#region 通过匹配SQL 来得到一个表
		/// <summary>
		/// 通过匹配SQL 来得到一个表
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual DataTable ExecSQLTable(params object[] objData)
		{
			for (int num1 = 0; num1 < objData.Length; num1++)
			{
				this.oleCommand.Parameters[num1].Value = objData[num1];
			}
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(this.oleCommand).Fill(set1);
			return set1.Tables[0];
		}

		#region 通过直接查询返回一个表
		/// <summary>
		/// 通过直接查询返回一个表
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual DataTable ExecSQLTableDirect(string strSQLCommand)
		{
			this.oleCommand = this.oleConnection.CreateCommand();
			this.oleCommand.CommandTimeout = this.nCommandTimeout;
			this.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(this.oleCommand).Fill(set1);
			return set1.Tables[0];
		}


		#region 数据库的抄时时间
		/// <summary>
		/// 数据库的抄时时间
		/// </summary>
		#endregion
		public int CommandTimeout
		{
			get
			{
				return this.nCommandTimeout;
			}
			set
			{
				this.nCommandTimeout = value;
			}
		}
		#region 数据库的连接串
		/// <summary>
		/// 数据库的连接串
		/// </summary>
		#endregion
		public string ConnectionString
		{
			get
			{
				return this.oleConnection.ConnectionString;
			}
		} 
		#region 返回数据库的连接状态
		/// <summary>
		/// 返回数据库的连接状态
		/// </summary>
		#endregion
		public bool Opened
		{
			get
			{
				return (this.oleConnection.State == ConnectionState.Open);
			}
		}
 


		#region 超时时间
		/// <summary>
		/// 超时时间
		/// </summary>
		#endregion
		protected int nCommandTimeout;
		#region 连接串
		/// <summary>
		/// 连接串
		/// </summary>
		#endregion
		protected OleDbCommand oleCommand;
		#region 数据库连接
		/// <summary>
		/// 数据库连接
		/// </summary>
		#endregion
		protected OleDbConnection oleConnection;

	}

	#region 可以带事务的数据库连接类
	/// <summary>
	/// 可以带事务的数据库连接类
	/// </summary>
	#endregion
	public class TDataBaseWithTransaction : DataBase
	{
		
		public TDataBaseWithTransaction()
		{
			this.oleTransaction = null;
		}
 
		public TDataBaseWithTransaction(string strConnectionString) : base(strConnectionString)
		{
			this.oleTransaction = null;
		}

			
		#region 事务
		/// <summary>
		/// 事务
		/// </summary>
		#endregion
		protected OleDbTransaction oleTransaction;

		#region 打开事务
		/// <summary>
		/// 打开事务
		/// </summary>
		#endregion
		public void Begin()
		{
			this.oleTransaction = base.oleConnection.BeginTransaction(IsolationLevel.RepeatableRead);
		}

		#region 以特定的事务级别打开事务
		/// <summary>
		/// 以特定的事务级别打开事务
		/// </summary>
		/// <param name="isolationLevel"></param>
		#endregion
		public void Begin(IsolationLevel isolationLevel)
		{
			this.oleTransaction = base.oleConnection.BeginTransaction(isolationLevel);
		}
		#region 提交事务
		/// <summary>
		/// 提交事务
		/// </summary>
		#endregion
		public void Commit()
		{
			this.oleTransaction.Commit();
		}
		#region 回滚事务
		/// <summary>
		/// 回滚事务
		/// </summary>
		#endregion 
		public void Rollback()
		{
			this.oleTransaction.Rollback();
		}

		#region 执行SQL 返回影响的行数
		/// <summary>
		/// 执行SQL 返回影响的行数
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual int TExecSQLNonQuery(params object[] objData)
		{
			return this.ExecSQLNonQuery(objData);
		}

		#region 执行SQL 返回影响的行数
		/// <summary>
		/// 执行SQL 返回影响的行数
		/// </summary>			
		/// <returns></returns>
		#endregion
		public virtual int TExecSQLNonQueryDirect(string strSQLCommand)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			return base.oleCommand.ExecuteNonQuery();
		}

		#region 返回一个对象
		/// <summary>
		/// 返回一个对象
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual object TExecSQLScalar(params object[] objData)
		{
			return this.ExecSQLScalar(objData);
		}
		#region 返回一个对象
		/// <summary>
		/// 返回一个对象
		/// </summary>			
		/// <returns></returns>
		#endregion 
		public virtual object TExecSQLScalarDirect(string strSQLCommand)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			return base.oleCommand.ExecuteScalar();
		}

		#region 通过匹配SQL 来得到一个数据集
		/// <summary>
		/// 通过匹配SQL 来得到一个数据集
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual DataSet TExecSQLSet(params object[] objData)
		{
			return this.ExecSQLSet(objData);
		}

		#region 通过直接查询返回一个数据集 
		/// <summary>
		/// 通过直接查询返回一个数据集
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual DataSet TExecSQLSetDirect(string strSQLCommand)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(base.oleCommand).Fill(set1);
			return set1;
		}
		public virtual DataSet TExecSQLSetDirect(string strSQLCommand,string strTableName)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(base.oleCommand).Fill(set1,strTableName);
			return set1;
		}
		#region 通过匹配SQL 来得到一个表
		/// <summary>
		/// 通过匹配SQL 来得到一个表
		/// </summary>
		/// <param name="objData"></param>
		/// <returns></returns>
		#endregion
		public virtual DataTable TExecSQLTable(params object[] objData)
		{
			return this.ExecSQLTable(objData);
		}

		#region 通过直接查询返回一个表
		/// <summary>
		/// 通过直接查询返回一个表
		/// </summary>
		/// <param name="strSQLCommand"></param>
		/// <returns></returns>
		#endregion
		public virtual DataTable TExecSQLTableDirect(string strSQLCommand)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			DataSet set1 = new DataSet();
			new OleDbDataAdapter(base.oleCommand).Fill(set1);
			return set1.Tables[0];
		}

 
		public virtual void TPrepare(string strSQLCommand, params OleDbParameter[] oleParams)
		{
			base.oleCommand = base.oleConnection.CreateCommand();
			base.oleCommand.CommandTimeout = base.nCommandTimeout;
			base.oleCommand.Transaction = this.oleTransaction;
			base.oleCommand.CommandText = strSQLCommand;
			foreach (OleDbParameter parameter1 in oleParams)
			{
				base.oleCommand.Parameters.Add(parameter1);
			}
		}


	}
//	public class SmsManager :ShouYan_SmsGate61.SmsgateClass
//	{
//		public SmsManager(){}
// 
//	
//	}
}