C# 数据库访问通用类 (ADO.NET)

注意：本内容来自： https://www.oschina.net/code/snippet_12_1317

[1].[代码] SqlDbHelper.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
 
namespace ADODoNETDemo
{
    /// <summary>
    /// 针对SQL Server数据库操作的通用类
    /// 作者：周公
    /// 日期：2009-01-08
    /// Version:1.0
    /// </summary>
    public class SqlDbHelper
    {
        private string connectionString;
        /// <summary>
        /// 设置数据库连接字符串
        /// </summary>
        public string ConnectionString
        {
            set { connectionString = value; }
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public SqlDbHelper()
            : this(ConfigurationManager.ConnectionStrings["Conn"].ConnectionString)
        {
 
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="connectionString">数据库连接字符串</param>
        public SqlDbHelper(string connectionString)
        {
            this.connectionString = connectionString;
        }
        /// <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">Transact-SQL 语句或存储过程的参数数组</param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            DataTable data = new DataTable();//实例化DataTable，用于装载查询结果集
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand command = new SqlCommand(sql, connection))
                {
                    command.CommandType = commandType;//设置command的CommandType为指定的CommandType
                    //如果同时传入了参数，则添加这些参数
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    //通过包含查询SQL的SqlCommand实例来实例化SqlDataAdapter
                    SqlDataAdapter adapter = new SqlDataAdapter(command);
 
                    adapter.Fill(data);//填充DataTable
                }
            }
            return data;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要执行的查询SQL文本命令</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql)
        {
            return ExecuteReader(sql, CommandType.Text, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要执行的SQL语句</param>
        /// <param name="commandType">要执行的查询语句的类型，如存储过程或者SQL文本命令</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql, CommandType commandType)
        {
            return ExecuteReader(sql, commandType, null);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sql">要执行的SQL语句</param>
        /// <param name="commandType">要执行的查询语句的类型，如存储过程或者SQL文本命令</param>
        /// <param name="parameters">Transact-SQL 语句或存储过程的参数数组</param>
        /// <returns></returns>
        public SqlDataReader ExecuteReader(string sql, CommandType commandType, SqlParameter[] parameters)
        {
            SqlConnection connection = new SqlConnection(connectionString);
            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);
        }
        /// <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">Transact-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;//设置command的CommandType为指定的CommandType
                    //如果同时传入了参数，则添加这些参数
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();//打开数据库连接
                    result = command.ExecuteScalar();
                }
            }
            return result;//返回查询结果的第一行第一列，忽略其它行和列
        }
        /// <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">Transact-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;//设置command的CommandType为指定的CommandType
                    //如果同时传入了参数，则添加这些参数
                    if (parameters != null)
                    {
                        foreach (SqlParameter parameter in parameters)
                        {
                            command.Parameters.Add(parameter);
                        }
                    }
                    connection.Open();//打开数据库连接
                    count = command.ExecuteNonQuery();
                }
            }
            return count;//返回执行增删改操作之后，数据库中受影响的行数
        }
        /// <summary>
        /// 返回当前连接的数据库中所有由用户创建的数据库
        /// </summary>
        /// <returns></returns>
        public DataTable GetTables()
        {
            DataTable data = null;
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();//打开数据库连接
                data = connection.GetSchema("Tables");
            }
            return data;
        }
 
    }
}


[2].[代码] ADODotNetCRUD.cs 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
 
namespace ADODoNETDemo
{
    /// <summary>
    /// 用ADO.NET实现CRUD功能
    /// </summary>
    public class ADODotNetCRUD
    {
        /// <summary>
        /// 统计用户总数
        /// </summary>
        /// <returns></returns>
        public int Count()
        {
            string sql = "select count(1) from UserInfo";
            SqlDbHelper db = new SqlDbHelper();
            return int.Parse(db.ExecuteScalar(sql).ToString());
        }
        /// <summary>
        /// 创建用户
        /// </summary>
        /// <param name="info">用户实体</param>
        /// <returns></returns>
        public bool Create(UserInfo info)
        {
            string sql = "insert UserInfo(UserName,RealName,Age,Sex,Mobile,Email,Phone)values(@UserName,@RealName,@Age,@Sex,@Mobile,@Email,@Phone)";
            SqlParameter[] paramters = new SqlParameter[]{
                new SqlParameter("@UserName",info.UserName),
                new SqlParameter("@RealName",info.RealName),
                new SqlParameter("@Age",info.Age),
                new SqlParameter("@Sex",info.Sex),
                new SqlParameter("@Mobile",info.Mobile),
                new SqlParameter("@Email",info.Email),
                new SqlParameter("@Phone",info.Phone),
            };
            SqlDbHelper db = new SqlDbHelper();
            return db.ExecuteNonQuery(sql, CommandType.Text, paramters) > 0;
        }
        /// <summary>
        /// 读取用户信息
        /// </summary>
        /// <param name="userId">用户编号</param>
        /// <returns></returns>
        public UserInfo Read(int userId)
        {
            string sql = "select * from UserInfo Where UserId="+userId;
            SqlDbHelper db = new SqlDbHelper();
            DataTable data = db.ExecuteDataTable(sql);
            if (data.Rows.Count > 0)
            {
                DataRow row = data.Rows[0];
                UserInfo info = new UserInfo()
                {
                    UserId=int.Parse(row["UserId"].ToString()),
                    UserName=row["UserName"].ToString(),
                    Age=byte.Parse(row["Age"].ToString()),
                    Email=row["Email"].ToString(),
                    Mobile=row["Mobile"].ToString(),
                    Phone=row["Phone"].ToString(),
                    RealName=row["RealName"].ToString(),
                    Sex=bool.Parse(row["Sex"].ToString())
                };
                return info;
            }
            else
            {
                return null;
            }
        }
        /// <summary>
        /// 更新用户信息
        /// </summary>
        /// <param name="info">用户实体</param>
        /// <returns></returns>
        public bool Update(UserInfo info)
        {
            string sql = "update UserInfo set UserName=@UserName,RealName=@RealName,Age=@Age,Sex=@Sex,Mobile=@Mobile,Email=@Email,Phone=@Phone where UserID=@UserID";
            SqlParameter[] paramters = new SqlParameter[]{
                new SqlParameter("@UserName",info.UserName),
                new SqlParameter("@RealName",info.RealName),
                new SqlParameter("@Age",info.Age),
                new SqlParameter("@Sex",info.Sex),
                new SqlParameter("@Mobile",info.Mobile),
                new SqlParameter("@Email",info.Email),
                new SqlParameter("@Phone",info.Phone),
                new SqlParameter("@UserID",info.UserId),
            };
            SqlDbHelper db = new SqlDbHelper();
            return db.ExecuteNonQuery(sql, CommandType.Text, paramters) > 0;
        }
        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="userId">用户编号</param>
        /// <returns></returns>
        public bool Delete(int userId)
        {
            string sql = "delete from UserInfo where UserId=" + userId;
            SqlDbHelper db = new SqlDbHelper();
            return db.ExecuteNonQuery(sql) > 0;
        }
        /// <summary>
        /// 获取用户表中编号最大的用户
        /// </summary>
        /// <returns></returns>
        public int GetMaxUserId()
        {
            string sql = "select max(userId) from UserInfo";
            SqlDbHelper db = new SqlDbHelper();
            return int.Parse(db.ExecuteScalar(sql).ToString());
        }
    }
}


[3].[代码] 单元测试 ADODotNetTest.cs 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using ADODoNETDemo;
using NUnit.Framework;
 
namespace NUnitTest
{
    [TestFixture]
    class ADODotNetTest
    {
        private ADODotNetCRUD instance = null;
        [SetUp]
        public void Initialize()
        {
            instance = new ADODotNetCRUD();
        }
        [Test]
        /// <summary>
        /// 统计用户总数
        /// </summary>
        /// <returns></returns>
        public void Count()
        {
            Assert.Greater(instance.Count(), 0);
        }
        [Test]
        /// <summary>
        /// 创建用户
        /// </summary>
        /// <param name="info">用户实体</param>
        /// <returns></returns>
        public void Create()
        {
            UserInfo info = new UserInfo()
            {
                Age = 12,
                Email = "zzz@ccav.com",
                Mobile = "13812345678",
                Phone = "01012345678",
                RealName = "测试" + DateTime.Now.Millisecond.ToString(),
                Sex = true,
                UserName = "zhoufoxcn" + DateTime.Now.Millisecond.ToString()
            };
            instance.Create(info);
        }
        [Test]
        /// <summary>
        /// 读取用户信息
        /// </summary>
        /// <param name="userId">用户编号</param>
        /// <returns></returns>
        public void Read()
        {
            UserInfo info = instance.Read(1);
            Assert.NotNull(info);
        }
        [Test]
        /// <summary>
        /// 更新用户信息
        /// </summary>
        /// <param name="info">用户实体</param>
        /// <returns></returns>
        public void Update()
        {
            UserInfo info = instance.Read(1);
            info.RealName = "测试" + DateTime.Now.Millisecond.ToString();
            instance.Update(info);
        }
        [Test]
        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="userId">用户编号</param>
        /// <returns></returns>
        public void DeleteByID()
        {
            int userId = instance.GetMaxUserId();
            instance.Delete(userId);
        }
    }
}