教研室

标题: ASP.NET中SQL Server数据库访问通用类 [打印本页]

作者: 教研室 时间: 2012-3-23 18:12:36 标题: ASP.NET中SQL Server数据库访问通用类

因为帮同学做毕设需要，着手学习ASP.NET。做这种B/S系统，听得最多的就是MVC三层架构。在这个常见的三层架构中，数据库访问层DAL对数据库的操作最常见的有如下四种：
　　1.非连接式查询，利用SqlDataAdapter对象的Fill()返回DataTable的结果集；
　　2.连接式查询，利用SqlReader()返回DataReader对象实例；
　　3.查询结果只有1行1列，利用SqlCommand的ExecuteScalar()进行。
　　4.对数据库进行增、删、改、查操作，利用ExecuteNonQuery()进行。

　　针对以上情况，分享的一个SQL Server数据库访问通用类。

1.非连接式查询，利用SqlDataAdapter对象的Fill()返回DataTable的结果集

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql)
{
      return ExecuteDataTable(sql, CommandType.Text, null);
}

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">查询语句类型，存储过程或SQL文本命令</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql, CommandType commandType)
{
      return ExecuteDataTable(sql, commandType, null);
}

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">查询语句类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数组</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
{
      //实例化DataTable，用于装载查询结果集
      DataTable data = new DataTable();
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            //指定CommandType
            command.CommandType = commandType;
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            //实例化SqlDataAdapter
            SqlDataAdapter adapter = new SqlDataAdapter(command);
            //填充DataTable
            adapter.Fill(data);
         }
      }
      return data;
}[url=]复制代码[/url]

2.连接式查询，利用SqlReader()返回DataReader对象实例

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql)
{
      return ExecuteReader(sql, CommandType.Text, null);
}

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql, CommandType commandType)
{
      return ExecuteReader(sql, commandType, null);
}

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
{
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            //参数CommandBehavior.CloseConnection表示，关闭Reader对象的同时关闭Connection对象
            return command.ExecuteReader(CommandBehavior.CloseConnection);
         }
      }
}[url=]复制代码[/url]

3.查询结果只有1行1列，利用SqlCommand的ExecuteScalar()

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql)
{
      return ExecuteScalar(sql, CommandType.Text, null);
}

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql, CommandType commandType)
{
      return ExecuteScalar(sql, commandType, null);
}

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)
{
      object result = null;
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            command.CommandType = commandType;
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            result = command.ExecuteScalar();
         }
      }
      return result;
}4.对数据库进行增、删、改、查操作，利用ExecuteNonQuery()

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql)
{
      return ExecuteNonQuery(sql, CommandType.Text, null);
}

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql, CommandType commandType)
{
      return ExecuteNonQuery(sql, commandType, null);
}

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)
{
      int count = 0;
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            command.CommandType = commandType;

            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            count = command.ExecuteNonQuery();
         }
      }
      return count;
}该类全部代码

View Code using System;
using System.Data;
using System.Data.SqlClient;

public class SqlDbHelper
{
//私有字段
private string connectionString;
//公共属性数据库连接字符串
public string ConnectiongString
{
      set { connectionString = value; }
}

#region 构造函数

/// <summary>
/// 构造函数
/// </summary>
public SqlDbHelper()
{
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="strConnectionString">数据库连接字符串</param>
public SqlDbHelper(string strConnectionString)
{
      this.connectionString = strConnectionString;
}

#endregion

#region 执行一个查询，并返回结果集

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql)
{
      return ExecuteDataTable(sql, CommandType.Text, null);
}

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">查询语句类型，存储过程或SQL文本命令</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql, CommandType commandType)
{
      return ExecuteDataTable(sql, commandType, null);
}

/// <summary>
/// 执行一个查询，并返回结果集
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">查询语句类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数组</param>
/// <returns>查询结果集</returns>
public DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
{
      //实例化DataTable，用于装载查询结果集
      DataTable data = new DataTable();
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            //指定CommandType
            command.CommandType = commandType;
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            //实例化SqlDataAdapter
            SqlDataAdapter adapter = new SqlDataAdapter(command);
            //填充DataTable
            adapter.Fill(data);
         }
      }
      return data;

}

#endregion

#region 返回一个DataReader对象实例

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql)
{
      return ExecuteReader(sql, CommandType.Text, null);
}

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql, CommandType commandType)
{
      return ExecuteReader(sql, commandType, null);
}

/// <summary>
/// 返回一个DataReader对象实例
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>DataReader对象实例</returns>
public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
{
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            //参数CommandBehavior.CloseConnection表示，关闭Reader对象的同时关闭Connection对象
            return command.ExecuteReader(CommandBehavior.CloseConnection);
         }
      }
}
#endregion

#region 执行查询结果，返回第一行的第一列

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql)
{
      return ExecuteScalar(sql, CommandType.Text, null);
}

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql, CommandType commandType)
{
      return ExecuteScalar(sql, commandType, null);
}

/// <summary>
/// 执行查询结果，返回第一行的第一列
/// </summary>
/// <param name="sql">要查询的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>返回第一行的第一列</returns>
public object ExecuteScalar(string sql, CommandType commandType, SqlParameter[] parameters)
{
      object result = null;
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            command.CommandType = commandType;
            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            result = command.ExecuteScalar();
         }

      }
      return result;
}

#endregion

#region 对数据库进行增删改查操作

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql)
{
      return ExecuteNonQuery(sql, CommandType.Text, null);
}

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql, CommandType commandType)
{
      return ExecuteNonQuery(sql, commandType, null);
}

/// <summary>
/// 对数据库进行增删改查操作
/// </summary>
/// <param name="sql">要执行的SQL文本命令</param>
/// <param name="commandType">要执行的查询语句的类型，存储过程或SQL文本命令</param>
/// <param name="parameters">T-SQL语句或存储过程的参数数组</param>
/// <returns>返回受影响的函数</returns>
public int ExecuteNonQuery(string sql, CommandType commandType, SqlParameter[] parameters)
{
      int count = 0;
      using (SqlConnection connection = new SqlConnection(connectionString))
      {
         using (SqlCommand command = new SqlCommand(sql, connection))
         {
            command.CommandType = commandType;

            if (parameters != null)
            {
                  foreach (SqlParameter parameter in parameters)
                  {
                     command.Parameters.Add(parameter);
                  }
            }
            connection.Open();
            count = command.ExecuteNonQuery();
         }
      }
      return count;
}

#endregion

}

欢迎光临教研室 (http://jiaoyanshi.com/)