数据库操作（增、删、改、查）的封装

Question

ASP.net中的数据库操作的类怎么写呀。
针对的MSSQL数据库，也不会用存储过程有没有些优秀的例子可以参考下哇初学者请多多指教

Answer 1

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.Odbc;/// <summary>
/// DBtools 的摘要说明
/// </summary>
public class DBtools
{
    #region 新方法
    public DBtools()
    {
    }
    /// <summary>
    /// 实例化数据库连接
    /// </summary>
    /// <param name="type">1为SQT数据库连接(ConfigurationManager.AppSettings["ConnectionStringSQT"]),2为UC数据库连接(ConfigurationManager.AppSettings["ConnectionStringUC"])</param>
    public DBtools(int type)
    {
        switch (type)
        {
            case 1:
                connectionString = ConfigurationManager.AppSettings["ConnectionStringSQT"];
                break;
            case 2:
                connectionString = ConfigurationManager.AppSettings["ConnectionStringUC"];
                break;
            default:
                break;
        }
    }
    /// <summary>
    /// 实例化数据库连接
    /// </summary>
    /// <param name="constr">直接传入数据库连接字符串</param>
    public DBtools(string constr)
    {
        connectionString = constr;
    }    public void ConnConnect()
    {
        try
        {
            conn.ConnectionString = connectionString;
            conn.Open();
        }
        catch
        {
            throw;
        }
    }
    //数据库连接
    OdbcConnection conn = new OdbcConnection();    //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
    public string connectionString = null;    #region 常用方法
    /// <summary>
    /// 得到最大值
    /// </summary>
    /// <param name="FieldName"></param>
    /// <param name="TableName"></param>
    /// <returns></returns>
    public int GetMaxID(string FieldName, string TableName)
    {
        string strsql = "select max(" + FieldName + ")+1 from " + TableName;
        object obj = GetSingle(strsql);
        if (obj == null)
        {
            return 1;
        }
        else
        {
            return int.Parse(obj.ToString());
        }
    }
    /// <summary>
    /// 是否存在
    /// </summary>
    /// <param name="strSql"></param>
    /// <returns></returns>
    public bool Exists(string strSql)
    {
        object obj = GetSingle(strSql);
        int cmdresult;
        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
        {
            cmdresult = 0;
        }
        else
        {
            cmdresult = int.Parse(obj.ToString());
        }
        if (cmdresult == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }    /// <summary>
    /// 执行一条计算查询结果语句，返回查询结果（object）。
    /// </summary>
    /// <param name="SQLString">计算查询结果语句</param>
    /// <returns>查询结果（object）</returns>
    public object GetSingle(string SQLString)
    {
        ConnConnect();
        object obj = null;
        OdbcCommand cmd = new OdbcCommand();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            obj = cmd.ExecuteScalar();
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {                obj = null;
            }
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ConnClose();
        }        return obj;
    }    /// <summary>
    /// 执行SQL语句，返回影响的记录数
    /// </summary>
    /// <param name="SQLString">SQL语句</param>
    /// <returns>影响的记录数</returns>
    public int ExecuteSql(string SQLString)
    {
        ConnConnect();
        int num = 0;
        OdbcCommand cmd = new OdbcCommand();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            num = cmd.ExecuteNonQuery();
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ConnClose();
        }
        return num;
    }    /// <summary>
    /// 执行存储过程
    /// </summary>
    /// <param name="procname"></param>
    public DataSet ExecProc(string procname, OdbcParameter[] param)
    {
        ConnConnect();
        OdbcCommand cmd = new OdbcCommand();
        OdbcDataAdapter ss = new OdbcDataAdapter();
        DataSet ds = new DataSet();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.CommandText = procname;
            for (int i = 0; i < param.Length; i++)
            {
                cmd.Parameters.Add(param[i]);
            }
            ss.SelectCommand = cmd;
            ss.Fill(ds);
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ss.Dispose();
            ConnClose();
        }
        return ds;
    }    /// <summary>
    /// 执行查询语句，返回DataSet
    /// </summary>
    /// <param name="SQLString">查询语句</param>
    /// <returns>DataSet</returns>
    public DataSet Query(string SQLString)
    {
        ConnConnect();
        DataSet ds = new DataSet();
        OdbcCommand cmd = new OdbcCommand();
        OdbcDataAdapter ss = new OdbcDataAdapter();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            ss.SelectCommand = cmd;
            ss.Fill(ds);
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ss.Dispose();
            ConnClose();
        }        return ds;
    }    /// <summary>
    /// 关闭数据库连接
    /// </summary>
    public void ConnClose()
    {
        try
        {
            conn.Close();
            conn.Dispose();
        }
        catch
        { }
    }
    #endregion
    #endregion
}

Answer 2

请查看PETSHOP4里面的SQLHelper类，然后自己写一个自用的

Answer 3

...纠结,ADO操作MSSQL 你不会?

Answer 4

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.Odbc;/// <summary>
/// DBtools 的摘要说明
/// </summary>
public class DBtools
{
    #region 新方法
    public DBtools()
    {
    }
    /// <summary>
    /// 实例化数据库连接
    /// </summary>
    /// <param name="type">1为SQT数据库连接(ConfigurationManager.AppSettings["ConnectionStringSQT"]),2为UC数据库连接(ConfigurationManager.AppSettings["ConnectionStringUC"])</param>
    public DBtools(int type)
    {
        switch (type)
        {
            case 1:
                connectionString = ConfigurationManager.AppSettings["ConnectionStringSQT"];
                break;
            case 2:
                connectionString = ConfigurationManager.AppSettings["ConnectionStringUC"];
                break;
            default:
                break;
        }
    }
    /// <summary>
    /// 实例化数据库连接
    /// </summary>
    /// <param name="constr">直接传入数据库连接字符串</param>
    public DBtools(string constr)
    {
        connectionString = constr;
    }    public void ConnConnect()
    {
        try
        {
            conn.ConnectionString = connectionString;
            conn.Open();
        }
        catch
        {
            throw;
        }
    }
    //数据库连接
    OdbcConnection conn = new OdbcConnection();    //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.
    public string connectionString = null;    #region 常用方法
    /// <summary>
    /// 得到最大值
    /// </summary>
    /// <param name="FieldName"></param>
    /// <param name="TableName"></param>
    /// <returns></returns>
    public int GetMaxID(string FieldName, string TableName)
    {
        string strsql = "select max(" + FieldName + ")+1 from " + TableName;
        object obj = GetSingle(strsql);
        if (obj == null)
        {
            return 1;
        }
        else
        {
            return int.Parse(obj.ToString());
        }
    }
    /// <summary>
    /// 是否存在
    /// </summary>
    /// <param name="strSql"></param>
    /// <returns></returns>
    public bool Exists(string strSql)
    {
        object obj = GetSingle(strSql);
        int cmdresult;
        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
        {
            cmdresult = 0;
        }
        else
        {
            cmdresult = int.Parse(obj.ToString());
        }
        if (cmdresult == 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }    /// <summary>
    /// 执行一条计算查询结果语句，返回查询结果（object）。
    /// </summary>
    /// <param name="SQLString">计算查询结果语句</param>
    /// <returns>查询结果（object）</returns>
    public object GetSingle(string SQLString)
    {
        ConnConnect();
        object obj = null;
        OdbcCommand cmd = new OdbcCommand();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            obj = cmd.ExecuteScalar();
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {                obj = null;
            }
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ConnClose();
        }        return obj;
    }    /// <summary>
    /// 执行SQL语句，返回影响的记录数
    /// </summary>
    /// <param name="SQLString">SQL语句</param>
    /// <returns>影响的记录数</returns>
    public int ExecuteSql(string SQLString)
    {
        ConnConnect();
        int num = 0;
        OdbcCommand cmd = new OdbcCommand();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            num = cmd.ExecuteNonQuery();
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ConnClose();
        }
        return num;
    }    /// <summary>
    /// 执行存储过程
    /// </summary>
    /// <param name="procname"></param>
    public DataSet ExecProc(string procname, OdbcParameter[] param)
    {
        ConnConnect();
        OdbcCommand cmd = new OdbcCommand();
        OdbcDataAdapter ss = new OdbcDataAdapter();
        DataSet ds = new DataSet();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.CommandText = procname;
            for (int i = 0; i < param.Length; i++)
            {
                cmd.Parameters.Add(param[i]);
            }
            ss.SelectCommand = cmd;
            ss.Fill(ds);
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ss.Dispose();
            ConnClose();
        }
        return ds;
    }    /// <summary>
    /// 执行查询语句，返回DataSet
    /// </summary>
    /// <param name="SQLString">查询语句</param>
    /// <returns>DataSet</returns>
    public DataSet Query(string SQLString)
    {
        ConnConnect();
        DataSet ds = new DataSet();
        OdbcCommand cmd = new OdbcCommand();
        OdbcDataAdapter ss = new OdbcDataAdapter();
        try
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = SQLString;
            ss.SelectCommand = cmd;
            ss.Fill(ds);
        }
        catch
        {
            throw;
        }
        finally
        {
            cmd.Dispose();
            ss.Dispose();
            ConnClose();
        }        return ds;
    }    /// <summary>
    /// 关闭数据库连接
    /// </summary>
    public void ConnClose()
    {
        try
        {
            conn.Close();
            conn.Dispose();
        }
        catch
        { }
    }
    #endregion
    #endregion
}

Answer 5

using System;   
using System.Data;   
using MySql.Data.MySqlClient;   
  
  
namespace Niunan.BYLW.Utility   
{   
    /// <summary>对MYSQL数据库的操作类   
    ///    
    /// </summary>   
    public class MYSQLHelper   
    {   
        private MySqlConnection conn = null;   
        private MySqlCommand cmd = null;   
        private MySqlDataReader sdr = null;   
  
  
        public MYSQLHelper()   
        {   
            //string connStr = WebConfigurationManager.ConnectionStrings["connStr"].ToString();   
            string connStr = "server=localhost;database=test;uid=root;pwd=123456;charset=utf8";   
            conn = new MySqlConnection(connStr);   
        }   
  
  
        /// <summary>创建Command对象   
        ///    
        /// </summary>   
        /// <param name="sql">SQL语句</param>   
        public void CreateCommand(string sql)   
        {   
            conn.Open();   
            cmd = new MySqlCommand(sql, conn);   
        }   
  
  
        /// <summary>添加参数   
        ///    
        /// </summary>   
        /// <param name="paramName">参数名称</param>   
        /// <param name="value">值</param>   
        public void AddParameter(string paramName, object value)   
        {   
            cmd.Parameters.Add(new MySqlParameter(paramName, value));   
        }   
  
  
        /// <summary>执行不带参数的增删改SQL语句   
        ///     
        /// </summary>   
        /// <param name="cmdText">增删改SQL语句</param>   
        /// <param name="ct">命令类型</param>   
        /// <returns></returns>   
        public bool ExecuteNonQuery()   
        {   
            int res;   
            try  
            {   
                res = cmd.ExecuteNonQuery();   
                if (res > 0)   
                {   
                    return true;   
                }   
            }   
            catch (Exception ex)   
            {   
                throw ex;   
            }   
            finally  
            {   
                if (conn.State == ConnectionState.Open)   
                {   
                    conn.Close();   
                }   
            }   
            return false;   
        }   
  
  
        /// <summary>执行查询SQL语句   
        ///     
        /// </summary>   
        /// <param name="cmdText">查询SQL语句</param>   
        /// <returns></returns>   
        public DataTable ExecuteQuery()   
        {   
            DataTable dt = new DataTable();   
            using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))   
            {   
                dt.Load(sdr);   
            }   
            return dt;   
        }   
  
  
        /// <summary>返回查询SQL语句查询出的结果的第一行第一列的值   
        ///    
        /// </summary>   
        /// <returns></returns>   
        public string ExecuteScalar()   
        {   
            string res = "";   
            try  
            {   
                object obj = cmd.ExecuteScalar();   
                if (obj != null)   
                {   
                    res = obj.ToString();   
                }   
            }   
            catch (Exception ex)   
            {   
                throw ex;   
            }   
            finally  
            {   
                if (conn.State == ConnectionState.Open)   
                {   
                    conn.Close();   
                }   
            }   
            return res;   
        }   
  
  
    }   
}  /**
 * 作者：牛腩
 * 创建时间：2010年3月7日17时35分
 * 类说明：对MYSQL数据库的操作类
 */ 
using System;
using System.Data;
using MySql.Data.MySqlClient;
namespace Niunan.BYLW.Utility
{
    /// <summary>对MYSQL数据库的操作类
    /// 
    /// </summary>
    public class MYSQLHelper
    {
        private MySqlConnection conn = null;
        private MySqlCommand cmd = null;
        private MySqlDataReader sdr = null;
        public MYSQLHelper()
        {
            //string connStr = WebConfigurationManager.ConnectionStrings["connStr"].ToString();
            string connStr = "server=localhost;database=test;uid=root;pwd=123456;charset=utf8";
            conn = new MySqlConnection(connStr);
        }
        /// <summary>创建Command对象
        /// 
        /// </summary>
        /// <param name="sql">SQL语句</param>
        public void CreateCommand(string sql)
        {
            conn.Open();
            cmd = new MySqlCommand(sql, conn);
        }
        /// <summary>添加参数
        /// 
        /// </summary>
        /// <param name="paramName">参数名称</param>
        /// <param name="value">值</param>
        public void AddParameter(string paramName, object value)
        {
            cmd.Parameters.Add(new MySqlParameter(paramName, value));
        }
        /// <summary>执行不带参数的增删改SQL语句
        ///  
        /// </summary>
        /// <param name="cmdText">增删改SQL语句</param>
        /// <param name="ct">命令类型</param>
        /// <returns></returns>
        public bool ExecuteNonQuery()
        {
            int res;
            try
            {
                res = cmd.ExecuteNonQuery();
                if (res > 0)
                {
                    return true;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                {
                    conn.Close();
                }
            }
            return false;
        }
        /// <summary>执行查询SQL语句
        ///  
        /// </summary>
        /// <param name="cmdText">查询SQL语句</param>
        /// <returns></returns>
        public DataTable ExecuteQuery()
        {
            DataTable dt = new DataTable();
            using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
            {
                dt.Load(sdr);
            }
            return dt;
        }
        /// <summary>返回查询SQL语句查询出的结果的第一行第一列的值
        /// 
        /// </summary>
        /// <returns></returns>
        public string ExecuteScalar()
        {
            string res = "";
            try
            {
                object obj = cmd.ExecuteScalar();
                if (obj != null)
                {
                    res = obj.ToString();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                {
                    conn.Close();
                }
            }
            return res;
        }
    }
}

Answer 6

using System; 
using System.Collections.Generic; 
using System.Text; 
using System.Collections; 
using System.Data; 
using System.Data.SqlClient; 
using System.Configuration; 
namespace HelloWinForm.DBUtility 
{ 
class SQLHelper 
{ 
#region 通用方法 
// 数据连接池 
private SqlConnection con; 
///  
/// 返回数据库连接字符串 
///  
///  
public static String GetSqlConnection() 
{ 
String conn = ConfigurationManager.AppSettings["connectionString"].ToString(); 
return conn; 
} 
#endregion 
#region 执行sql字符串 
///  
/// 执行不带参数的SQL语句 
///  
///  
///  
public static int ExecuteSql(String Sqlstr) 
{ 
String ConnStr = GetSqlConnection(); 
using (SqlConnection conn = new SqlConnection(ConnStr)) 
{ 
SqlCommand cmd = new SqlCommand(); 
cmd.Connection = conn; 
cmd.CommandText = Sqlstr; 
conn.Open(); 
cmd.ExecuteNonQuery(); 
conn.Close(); 
return 1; 
} 
} 
///  
/// 执行带参数的SQL语句 
///  
/// SQL语句 
/// 参数对象数组 
///  
public static int ExecuteSql(String Sqlstr, SqlParameter[] param) 
{ 
String ConnStr = GetSqlConnection(); 
using (SqlConnection conn = new SqlConnection(ConnStr)) 
{ 
SqlCommand cmd = new SqlCommand(); 
cmd.Connection = conn; 
cmd.CommandText = Sqlstr; 
cmd.Parameters.AddRange(param); 
conn.Open(); 
cmd.ExecuteNonQuery(); 
conn.Close(); 
return 1; 
} 
} 
///  
/// 返回DataReader 
///  
///  
///  
public static SqlDataReader ExecuteReader(String Sqlstr) 
{ 
String ConnStr = GetSqlConnection(); 
SqlConnection conn = new SqlConnection(ConnStr);//返回DataReader时,是不可以用using()的 
try 
{ 
SqlCommand cmd = new SqlCommand(); 
cmd.Connection = conn; 
cmd.CommandText = Sqlstr; 
conn.Open(); 
return cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection);//关闭关联的Connection 
} 
catch //(Exception ex) 
{ 
return null; 
} 
} 
///  
/// 执行SQL语句并返回数据表 
///  
/// SQL语句 
///  
public static DataTable ExecuteDt(String Sqlstr) 
{ 
String ConnStr = GetSqlConnection(); 
using (SqlConnection conn = new SqlConnection(ConnStr)) 
{ 
SqlDataAdapter da = new SqlDataAdapter(Sqlstr, conn); 
DataTable dt = new DataTable(); 
conn.Open(); 
da.Fill(dt); 
conn.Close(); 
return dt; 
} 
} 
///  
/// 执行SQL语句并返回DataSet 
///  
/// SQL语句 
///  
public static DataSet ExecuteDs(String Sqlstr) 
{ 
String ConnStr = GetSqlConnection(); 
using (SqlConnection conn = new SqlConnection(ConnStr)) 
{ 
SqlDataAdapter da = new SqlDataAdapter(Sqlstr, conn); 
DataSet ds = new DataSet(); 
conn.Open(); 
da.Fill(ds); 
conn.Close(); 
return ds; 
} 
} 
#endregion 
#region 操作存储过程 
///  
/// 运行存储过程(已重载) 
///  
/// 存储过程的名字 
/// 存储过程的返回值 
public int RunProc(string procName) 
{ 
SqlCommand cmd = CreateCommand(procName, null); 
cmd.ExecuteNonQuery(); 
this.Close(); 
return (int)cmd.Parameters["ReturnValue"].Value; 
} 
///  
/// 运行存储过程(已重载) 
///  
/// 存储过程的名字 
/// 存储过程的输入参数列表 
/// 存储过程的返回值 
public int RunProc(string procName, SqlParameter[] prams) 
{ 
SqlCommand cmd = CreateCommand(procName, prams); 
cmd.ExecuteNonQuery(); 
this.Close(); 
return (int)cmd.Parameters[0].Value; 
} 
///  
/// 运行存储过程(已重载) 
///  
/// 存储过程的名字 
/// 结果集 
public void RunProc(string procName, out SqlDataReader dataReader) 
{ 
SqlCommand cmd = CreateCommand(procName, null); 
dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection); 
} 
///  
/// 运行存储过程(已重载) 
///  
/// 存储过程的名字 
/// 存储过程的输入参数列表 
/// 结果集 
public void RunProc(string procName, SqlParameter[] prams, out SqlDataReader dataReader) 
{ 
SqlCommand cmd = CreateCommand(procName, prams); 
dataReader = cmd.ExecuteReader(System.Data.CommandBehavior.CloseConnection); 
} 
///  
/// 创建Command对象用于访问存储过程 
///  
/// 存储过程的名字 
/// 存储过程的输入参数列表 
/// Command对象 
private SqlCommand CreateCommand(string procName, SqlParameter[] prams) 
{ 
// 确定连接是打开的 
Open(); 
//command = new SqlCommand( sprocName, new SqlConnection( ConfigManager.DALConnectionString ) ); 
SqlCommand cmd = new SqlCommand(procName, con); 
cmd.CommandType = CommandType.StoredProcedure; 
// 添加存储过程的输入参数列表 
if (prams != null) 
{ 
foreach (SqlParameter parameter in prams) 
cmd.Parameters.Add(parameter); 
} 
// 返回Command对象 
return cmd; 
} 
///  
/// 创建输入参数 
///  
/// 参数名 
/// 参数类型 
/// 参数大小 
/// 参数值 
/// 新参数对象 
public SqlParameter MakeInParam(string ParamName, SqlDbType DbType, int Size, object Value) 
{ 
return MakeParam(ParamName, DbType, Size, ParameterDirection.Input, Value); 
} 
///  
/// 创建输出参数 
///  
/// 参数名 
/// 参数类型 
/// 参数大小 
/// 新参数对象 
public SqlParameter MakeOutParam(string ParamName, SqlDbType DbType, int Size) 
{ 
return MakeParam(ParamName, DbType, Size, ParameterDirection.Output, null); 
} 
///  
/// 创建存储过程参数 
///  
/// 参数名 
/// 参数类型 
/// 参数大小 
/// 参数的方向(输入/输出) 
/// 参数值 
/// 新参数对象 
public SqlParameter MakeParam(string ParamName, SqlDbType DbType, Int32 Size, ParameterDirection Direction, object Value) 
{ 
SqlParameter param; 
if (Size > 0) 
{ 
param = new SqlParameter(ParamName, DbType, Size); 
} 
else 
{ 
param = new SqlParameter(ParamName, DbType); 
} 
param.Direction = Direction; 
if (!(Direction == ParameterDirection.Output && Value == null)) 
{ 
param.Value = Value; 
} 
return param; 
} 
#endregion 
#region 数据库连接和关闭 
///  
/// 打开连接池 
///  
private void Open() 
{ 
// 打开连接池 
if (con == null) 
{ 
//这里不仅需要using System.Configuration;还要在引用目录里添加 
con = new SqlConnection(GetSqlConnection()); 
con.Open(); 
} 
} 
///  
/// 关闭连接池 
///  
public void Close() 
{ 
if (con != null) 
con.Close(); 
} 
///  
/// 释放连接池 
///  
public void Dispose() 
{ 
// 确定连接已关闭 
if (con != null) 
{ 
con.Dispose(); 
con = null; 
} 
} 
#endregion 
} 
}

Answer 7

把类建好，最好做成dll，这样其他项目直接调用就可以了，只要在config里面修改连接字符串就可以了

Answer 8

纠结 MySql数据库我用的不多耶

Answer 9

mysqlhelper

Answer 10

using System;   
using System.Data;   
using System.Data.SqlClient;   
using System.Web.Configuration;   
  
 
namespace Niunan.Tg029.Hr.Utility   
{   
    public class MSSQLHelper   
    {   
       private SqlConnection conn = null;   
       private SqlCommand cmd = null;   
        private SqlDataReader sdr = null;   
  
 
        public MSSQLHelper()   
        {   
           string connStr = WebConfigurationManager.ConnectionStrings["connStr"].ToString();   
            conn = new SqlConnection(connStr);   
       }   
  
  
       /// <summary>创建Command对象   
        /// 默认是SQL语句   
        /// </summary>   
        /// <param name="sql">SQL语句</param>   
       public void CreateCommand(string sql)   
        {   
           conn.Open();   
           cmd = new SqlCommand(sql, conn);   
       }   
  
 
       /// <summary>创建存储过程的Command对象   
       ///    
       /// </summary>   
        /// <param name="procName">存储过程名称</param>   
       public void CreateStoredCommand(string procName)   
       {   
            conn.Open();   
           cmd = new SqlCommand(procName, conn);   
            cmd.CommandType = CommandType.StoredProcedure;   
        }   
  
        /// <summary>添加参数   
       /// 默认是输入参数   
       /// </summary>   
        /// <param name="paramName">参数名称</param>   
       /// <param name="value">值</param>   
       public void AddParameter(string paramName, object value)   
       {   
           SqlParameter p = new SqlParameter(paramName, value);   
            cmd.Parameters.Add(p);   
        }   
  
 
        /// <summary>添加输出参数   
        /// 用于存储过程   
        /// </summary>   
        /// <param name="paramName">参数名称</param>   
        /// <param name="value">值</param>   
        public void AddOutputParameter(string paramName) {   
            SqlParameter p = new SqlParameter();   
            p.ParameterName = paramName;   
            p.Direction = ParameterDirection.Output;   
            p.Size = 20;   
            cmd.Parameters.Add(p);   
        }   
  
  
        /// <summary>获取输出参数的值   
        ///    
        /// </summary>   
        /// <param name="paramName">输出参数名称</param>   
        /// <returns></returns>   
        public string GetOutputParameter(string paramName) {   
            return cmd.Parameters[paramName].Value.ToString();   
        }   
  
  
        /// <summary>执行增删改SQL语句或存储过程   
        ///     
        /// </summary>   
        /// <returns></returns>   
        public bool ExecuteNonQuery()   
        {   
            int res;   
            try  
            {   
                res = cmd.ExecuteNonQuery();   
              if (res > 0)   
                {   
                    return true;   
                }   
            }   
            catch (Exception ex)   
            {   
                throw ex;   
            }   
            finally  
            {   
                if (conn.State == ConnectionState.Open)   
                {   
                    conn.Close();   
                }   
            }   
            return false;   
        }   
  
  
        /// <summary>执行查询SQL语句或存储过程   
        ///     
        /// </summary>   
        /// <returns></returns>   
        public DataTable ExecuteQuery()   
        {   
            DataTable dt = new DataTable();   
          using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))   
            {   
                dt.Load(sdr);   
            }   
            return dt;   
        }   
  
  
        /// <summary>返回查询SQL语句或存储过程查询出的结果的第一行第一列的值   
        ///    
        /// </summary>   
        /// <returns></returns>   
        public string ExecuteScalar()   
        {   
           string res = "";   
           try  
           {   
                object obj = cmd.ExecuteScalar();   
               if (obj != null)   
                {   
                   res = obj.ToString();   
                }   
           }   
           catch (Exception ex)   
           {   
                throw ex;   
            }   
           finally  
           {   
                if (conn.State == ConnectionState.Open)   
               {   
                   conn.Close();   
               }   
            }   
            return res;   
       }   
 
 
  
  
    }   
}

Answer 11

顺便也发我个  [email protected]  谢谢