Classe de acesso ao banco de dados SQL encapsulada para ASP.NET

usando o sistema;
usando System.Configuration;
usando System.Data;
usando System.Data.SqlClient;
usando System.Collections;

namespace MyCorporation.DepartMent.DataBase
{
/// <resumo>
/// 通用数据库类
/// </sumário>
classe pública banco de dados
{

string privada ConnStr = null;

banco de dados público()
{
ConnStr = ConfigurationSettings.AppSettings["ConnStr"];
}
banco de dados público (string Str)
{
tentar
{
this.ConnStr = Str;

}
catch(Exceção ex)
{
jogue ex;
}
}

/// <resumo>
/// 返回conexão对象
/// </sumário>
/// <retorna></retorna>
SqlConnection pública ReturnConn()
{
Conexão SqlConnection = new SqlConnection(ConnStr);
Conexão.Open();
retornar Conexão;
}
público void Dispose (Conexão SqlConnection)
{
if(Conn!=nulo)
{
Conexão.Fechar();
Conn.Dispose();
}
GC.Collect();
}
/// <resumo>
/// Alterar SQL
/// </sumário>
/// <param name="SQL"></param>
público vazio RunProc(string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlCommand Cmd;
Cmd = CreateCmd(SQL, Conexão);
tentar
{
Cmd.ExecuteNonQuery();
}
pegar
{
lançar nova exceção (SQL);
}
Descartar(Conn);
retornar;
}

/// <resumo>
/// 运行SQL语句返回DataReader
/// </sumário>
/// <param name="SQL"></param>
/// <returns>SqlDataReader对象.</returns>
público SqlDataReader RunProcGetReader(string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlCommand Cmd;
Cmd = CreateCmd(SQL, Conexão);
SqlDataReader Dr;
tentar
{
Dr = Cmd.ExecuteReader(CommandBehavior.Default);
}
pegar
{
lançar nova exceção (SQL);
}
//Dispor(Conn);
retornar Dr.;
}

/// <resumo>
/// 生成Command对象
/// </sumário>
/// <param name="SQL"></param>
/// <param name="Conn"></param>
/// <retorna></retorna>
public SqlCommand CreateCmd(string SQL, SqlConnection Conn)
{
SqlCommand Cmd;
Cmd = novo SqlCommand(SQL, Conn);
retornar Cmd;
}

/// <resumo>
/// 生成Command对象
/// </sumário>
/// <param name="SQL"></param>
/// <retorna></retorna>
SqlCommand público CreateCmd(string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlCommand Cmd;
Cmd = novo SqlCommand(SQL, Conn);
retornar Cmd;
}

/// <resumo>
/// 返回adaptador对象
/// </sumário>
/// <param name="SQL"></param>
/// <param name="Conn"></param>
/// <retorna></retorna>
SqlDataAdapter público CreateDa(string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlDataAdapter Da;
Da = novo SqlDataAdapter(SQL, Conn);
retornar Da;
}

/// <resumo>
/// Definindo SQL, 返回DataSet对象
/// </sumário>
/// <param name="procName">SQL语句</param>
/// <param name="prams">DataSet对象</param>
DataSet público RunProc (string SQL, DataSet Ds)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlDataAdapter Da;
//Da = CreateDa(SQL, Conn);
Da = novo SqlDataAdapter(SQL,Conn);
tentar
{
Da.Preenchimento(Ds);
}
catch (erro de exceção)
{
lançar Errar;
}
Descartar(Conn);
retornar D;
}

/// <resumo>
/// Definindo SQL, 返回DataSet对象
/// </sumário>
/// <param name="procName">SQL语句</param>
/// <param name="prams">DataSet对象</param>
/// <param name="dataReader">表名</param>
público DataSet RunProc (string SQL, DataSet Ds, string nome da tabela)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlDataAdapter Da;
Da = CriarDa(SQL);
tentar
{
Da.Fill(Ds,nomedatabela);
}
catch(Exceção Ex)
{
lançar Ex;
}
Descartar(Conn);
retornar D;
}

/// <resumo>
/// Definindo SQL, 返回DataSet对象
/// </sumário>
/// <param name="procName">SQL语句</param>
/// <param name="prams">DataSet对象</param>
/// <param name="dataReader">表名</param>
público DataSet RunProc (string SQL, DataSet Ds, int StartIndex, int PageSize, string nomedatabela)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlDataAdapter Da;
Da = CriarDa(SQL);
tentar
{
Da.Fill(Ds, StartIndex, PageSize, nomedatabela);
}
catch(Exceção Ex)
{
lançar Ex;
}
Descartar(Conn);
retornar D;
}

/// <resumo>
/// 检验是否存在数据
/// </sumário>
/// <retorna></retorna>
bool público ExistDate(string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlDataReader Dr.;
Dr = CreateCmd(SQL,Conn).ExecuteReader();
se (Dr.Leitura())
{
Descartar(Conn);
retornar verdadeiro;
}
outro
{
Descartar(Conn);
retornar falso;
}
}

/// <resumo>
/// 返回SQL语句执行结果的第一行第一列
/// </sumário>
/// <returns>字符串</returns>
string pública ReturnValue (string SQL)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
resultado de sequência;
SqlDataReader Dr.;
tentar
{
Dr = CreateCmd(SQL,Conn).ExecuteReader();
se (Dr.Leitura())
{
resultado = Dr[0].ToString();
Dr.Fechar();
}
outro
{
resultado = "";
Dr.Fechar();
}
}
pegar
{
lançar nova exceção (SQL);
}
Descartar(Conn);
resultado de retorno;
}

/// <resumo>
/// 返回SQL语句第一列,第ColumnI列,
/// </sumário>
/// <returns>字符串</returns>
string pública ReturnValue (string SQL, int ColumnI)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
resultado de sequência;
SqlDataReader Dr.;
tentar
{
Dr = CreateCmd(SQL,Conn).ExecuteReader();
}
pegar
{
lançar nova exceção (SQL);
}
se (Dr.Leitura())
{
resultado = Dr[ColunaI].ToString();
}
outro
{
resultado = "";
}
Dr.Fechar();
Descartar(Conn);
resultado de retorno;
}

/// <resumo>
/// 生成一个存储过程使用的sqlcommand.
/// </sumário>
/// <param name="procName">存储过程名.</param>
/// <param name="prams">存储过程入参数组.</param>
/// <returns>sqlcommand对象.</returns>
public SqlCommand CreateCmd(string procName, SqlParameter[] prams)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlCommand Cmd = novo SqlCommand(procName, Conn);
Cmd.CommandType = CommandType.StoredProcedure;
if (carrinhos de bebê! = null)
{
foreach (parâmetro SqlParameter em carrinhos)
{
if (parâmetro! = nulo)
{
Cmd.Parameters.Add(parâmetro);
}
}
}
retornar Cmd;
}

/// <resumo>
/// 为存储过程生成一个SqlCommand对象
/// </sumário>
/// <param name="procName">存储过程名</param>
/// <param name="prams">存储过程参数</param>
/// <returns>SqlCommand对象</returns>
privado SqlCommand CreateCmd(string procName, SqlParameter[] prams,SqlDataReader Dr)
{
Conexão SqlConnection;
Conn = new SqlConnection(ConnStr);
Conexão.Open();
SqlCommand Cmd = novo SqlCommand(procName, Conn);
Cmd.CommandType = CommandType.StoredProcedure;
if (carrinhos de bebê! = null)
{
foreach (parâmetro SqlParameter em carrinhos)
Cmd.Parameters.Add(parâmetro);
}
Cmd.Parâmetros.Add(
novo SqlParameter("ReturnValue", SqlDbType.Int, 4,
ParâmetroDirection.ReturnValue, falso, 0, 0,
string.Empty, DataRowVersion.Default, null));

retornar Cmd;
}

/// <resumo>
/// 运行存储过程,返回.
/// </sumário>
/// <param name="procName">存储过程名</param>
/// <param name="prams">存储过程参数</param>
/// <param name="dataReader">SqlDataReader对象</param>
public void RunProc(string procName, SqlParameter[] carrinhos, SqlDataReader Dr)
{

SqlCommand Cmd = CreateCmd(procName, carrinhos, Dr);
Dr = Cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
retornar;
}

/// <resumo>
/// 运行存储过程,返回.
/// </sumário>
/// <param name="procName">存储过程名</param>
/// <param name="prams">存储过程参数</param>
string pública RunProc(string procName, SqlParameter[] carrinhos)
{
SqlDataReader Dr;
SqlCommand Cmd = CreateCmd(procName, prams);
Dr = Cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);
if(Dr.Leitura())
{
retornar Dr.GetValue(0).ToString();
}
outro
{
retornar "";
}
}

/// <resumo>
/// 运行存储过程,返回dataset.
/// </sumário>
/// <param name="procName">存储过程名.</param>
/// <param name="prams">存储过程入参数组.</param>
/// <returns>conjunto de dados对象.</returns>
público DataSet RunProc(string procName,SqlParameter[] carrinhos,DataSet Ds)
{
SqlCommand Cmd = CreateCmd(procNome,prams);
SqlDataAdapter Da = new SqlDataAdapter(Cmd);
tentar
{
Da.Preenchimento(Ds);
}
catch(Exceção Ex)
{
lançar Ex;
}
retornar D;
}

}
}