如何操作数据库

Question

新手求助，想实现这样的功能。在一个在一个类文件里根据传入的参数从数据库里查询，并返回结果。但是不知道怎么连接及查询及返回结果。看了一些资料还是没有头绪，大家帮帮忙，新手，让大家见笑了。

Answer 1

现在最流行的还是SQlHelper类，这个类里面几乎包括了所有的方法，网上可以下载得到，如果找不到，可以加我QQ：360518412，我给你。

Answer 2

连接数据库、我建议你使用Dataset
1.
连接字符串
2.
sqlconnction conn =new sqlconnction(连接字符串)连接对象
3.
slqcommand (sql语句,conn) 执行命令对象
4.
DataSet ds 数据集对象
5.
sqlDataAdatpter da 对象、
6.
da.fill(ds,'自定义表名');
7.
datagridview.datasourse = ds.tables['自定义表名']; 绑定数据源.

Answer 3

string strSql= "SELECT * FROM [User]";
string strConn=@"Provider=Microsoft.Jet.OLEDB.4.0;" +
@"Data Source= D:\CsExample\ch10\BIBLIO.MDB"; OleDbConnectionconn= new OleDbConnection( strConn);
OleDbDataAdapterdaAdapter= new OleDbDataAdapter(strSql, conn);
OleDbCommandBuildercmdbld= new OleDbCommandBuilder( daAdapter);
DataSetdsMyData= new DataSet();
daAdapter.Fill(dsMyData);

Answer 4

多谢andy，我只需要返回的结果，这个结果再作为参数传递给别的函数使用，并不需要显示出来，也需要用datagridview吗？

Answer 5

我给你个我自己写的。刚写的。
根据传入的查询SQL语句返回datatble
///连接类
 public class ClassDB
    {
        public SqlConnection con=new SqlConnection ();
        public SqlCommand cmd=new SqlCommand ();
        public static string ConfigWebNode = "ConnectionString";
        public string GetConnString()
        {
            return ConfigurationManager.AppSettings[ConfigWebNode].ToString();
        }
        public bool  OpenCon()
        {
            if (con.State  == ConnectionState.Closed)
            {
                try
                {
                    con = new SqlConnection(GetConnString());
                    cmd.Connection = con;
                    con.Open();
                    return true;
                }
                catch
                {
                    return false;
                }
            }
            return false;
                    }
        public void CloseCon()
        {
            if (con.State == ConnectionState.Open)
            {
                con.Close();
                cmd.Dispose();
            }
        }
    }
///查询类
  public DataTable ExecuteDataTble(String SQL)
        {
            DataTable dt = new DataTable();
            DB.OpenCon();
            SqlDataAdapter da = new SqlDataAdapter(SQL, DB.con);
            da.Fill(dt);
            DB.con.Close();
            da.Dispose();
            return dt;
        }
///用的时候先实例化类，
类.方法（传入参数）返回表经行操作即可。
这样可以吗？

Answer 6

多谢“dong547785510 ”，你就费下心，把使用的例子也贴下呗。
比如我的sql语句是 select top 1 * from cUser where cName = "&cName&" 
要取得返回值 cTelNum

Answer 7

SQlHelper类
这个类是只针对SQL还是Oracle也可以用的？

Answer 8

dgv 只是又来显示数据比较方便、 我开始没有理解你的意思。你是只要查询、 然后得到查询的返回值嘛、
        private bool Query()
        {
            bool result=true;
            SqlConnection conn = new SqlConnection("连接字符串");
            string sql = "select * from 表";
            SqlCommand cmd = new SqlCommand(sql, conn);
            SqlDataReader dr = cmd.ExecuteReader();//这里的如果是cmd.ExecuteScalar;就只需要做个返回值为int型的方法就OK            if (dr.HasRows)//这里是看数据库里面有没一条数据
            {
                result = false;
            }            return result;        }

Answer 9

to be simple, just use sqlhelper class

Answer 10

http://hi.baidu.com/%C0%E1%D3%EA%B5%C4%D1%DB%C0%E1/blog/item/aff2f702a37bf98fd43f7c31.html
http://blog.csdn.net/hew222/archive/2009/02/23/3927876.aspx

Answer 11

http://hi.baidu.com/yandavid/blog/item/a2fd7e09cab7bfcb3ac76336.htmlusing System.Data;
    using System.Data.Common;
    using System.Configuration;    public class DbHelper
    {
        private static string dbProviderName = ConfigurationManager.AppSettings["DbHelperProvider"];
        private static string dbConnectionString = ConfigurationManager.AppSettings["DbHelperConnectionString"];        private DbConnection connection;
        public DbHelper()
        {
            this.connection = CreateConnection(DbHelper.dbConnectionString);
        }
        public DbHelper(string connectionString)
        {
            this.connection = CreateConnection(connectionString);
        }
        public static DbConnection CreateConnection()
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbConnection dbconn = dbfactory.CreateConnection();
            dbconn.ConnectionString = DbHelper.dbConnectionString;
            return dbconn;
        }
        public static DbConnection CreateConnection(string connectionString)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbConnection dbconn = dbfactory.CreateConnection();
            dbconn.ConnectionString = connectionString;
            return dbconn;
        }        public DbCommand GetStoredProcCommond(string storedProcedure)
        {
            DbCommand dbCommand = connection.CreateCommand();
            dbCommand.CommandText = storedProcedure;
            dbCommand.CommandType = CommandType.StoredProcedure;
            return dbCommand;
        }
        public DbCommand GetSqlStringCommond(string sqlQuery)
        {
            DbCommand dbCommand = connection.CreateCommand();
            dbCommand.CommandText = sqlQuery;
            dbCommand.CommandType = CommandType.Text;
            return dbCommand;
        }        增加参数#region 增加参数
        public void AddParameterCollection(DbCommand cmd, DbParameterCollection dbParameterCollection)
        {
            foreach (DbParameter dbParameter in dbParameterCollection)
            {
                cmd.Parameters.Add(dbParameter);
            }
        }
        public void AddOutParameter(DbCommand cmd, string parameterName, DbType dbType, int size)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Size = size;
            dbParameter.Direction = ParameterDirection.Output;
            cmd.Parameters.Add(dbParameter);
        }
        public void AddInParameter(DbCommand cmd, string parameterName, DbType dbType, object value)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Value = value;
            dbParameter.Direction = ParameterDirection.Input;
            cmd.Parameters.Add(dbParameter);
        }
        public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
        {
            DbParameter dbParameter = cmd.CreateParameter();
            dbParameter.DbType = dbType;
            dbParameter.ParameterName = parameterName;
            dbParameter.Direction = ParameterDirection.ReturnValue;
            cmd.Parameters.Add(dbParameter);
        }
        public DbParameter GetParameter(DbCommand cmd, string parameterName)
        {
            return cmd.Parameters[parameterName];
        }        #endregion        执行#region 执行
        public DataSet ExecuteDataSet(DbCommand cmd)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataSet ds = new DataSet();
            dbDataAdapter.Fill(ds);
            return ds;
        }        public DataTable ExecuteDataTable(DbCommand cmd)
        {
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataTable dataTable = new DataTable();
            dbDataAdapter.Fill(dataTable);
            return dataTable;
        }        public DbDataReader ExecuteReader(DbCommand cmd)
        {
            cmd.Connection.Open();
            DbDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);            
            return reader;
        }
        public int ExecuteNonQuery(DbCommand cmd)
        {
            cmd.Connection.Open();
            int ret = cmd.ExecuteNonQuery();
            cmd.Connection.Close();
            return ret;
        }        public object ExecuteScalar(DbCommand cmd)
        {
            cmd.Connection.Open();
            object ret = cmd.ExecuteScalar();
            cmd.Connection.Close();
            return ret;
        }
        #endregion               执行事务#region 执行事务
        public DataSet ExecuteDataSet(DbCommand cmd,Trans t)
        {
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataSet ds = new DataSet();
            dbDataAdapter.Fill(ds);
            return ds;
        }        public DataTable ExecuteDataTable(DbCommand cmd, Trans t)
        {
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;
            DbProviderFactory dbfactory = DbProviderFactories.GetFactory(DbHelper.dbProviderName);
            DbDataAdapter dbDataAdapter = dbfactory.CreateDataAdapter();
            dbDataAdapter.SelectCommand = cmd;
            DataTable dataTable = new DataTable();
            dbDataAdapter.Fill(dataTable);
            return dataTable;
        }        public DbDataReader ExecuteReader(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans;            
            DbDataReader reader = cmd.ExecuteReader();
            DataTable dt = new DataTable();            
            return reader;
        }
        

Answer 12

public int ExecuteNonQuery(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans; 
            int ret = cmd.ExecuteNonQuery();            
            return ret;
        }        public object ExecuteScalar(DbCommand cmd, Trans t)
        {
            cmd.Connection.Close();
            cmd.Connection = t.DbConnection;
            cmd.Transaction = t.DbTrans; 
            object ret = cmd.ExecuteScalar();            
            return ret;
        }
        #endregion
    }    public class Trans : IDisposable
    {
        private DbConnection conn;
        private DbTransaction dbTrans;
        public DbConnection DbConnection
        {
            get { return this.conn; }
        }
        public DbTransaction DbTrans
        {
            get { return this.dbTrans; }
        }        public Trans()
        {
            conn = DbHelper.CreateConnection();
            conn.Open();
            dbTrans = conn.BeginTransaction();
        }
        public Trans(string connectionString)
        {
            conn = DbHelper.CreateConnection(connectionString);
            conn.Open();
            dbTrans = conn.BeginTransaction();
        }
        public void Commit()
        {
            dbTrans.Commit();
            this.Colse();
        }        public void RollBack()
        {
            dbTrans.Rollback();
            this.Colse();
        }        public void Dispose()
        {
            this.Colse();
        }        public void Colse()
        {
            if (conn.State == System.Data.ConnectionState.Open)
            {
                conn.Close();
            }
        }
    }
那么如何使用它呢?下面我给出一些基本的使用示例,基本能满足你大部分的数据库操作需要了.
1)直接执行sql语句        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetSqlStringCommond("insert t1 (id)values('haha')");
        db.ExecuteNonQuery(cmd);
2)执行存储过程        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetStoredProcCommond("t1_insert");
        db.AddInParameter(cmd, "@id", DbType.String, "heihei");
        db.ExecuteNonQuery(cmd);
3)返回DataSet        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetSqlStringCommond("select * from t1");
        DataSet ds = db.ExecuteDataSet(cmd);
4)返回DataTable
        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetSqlStringCommond("t1_findall");
        DataTable dt = db.ExecuteDataTable(cmd);
5)输入参数/输出参数/返回值的使用(比较重要哦)        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetStoredProcCommond("t2_insert");
        db.AddInParameter(cmd, "@timeticks", DbType.Int64, DateTime.Now.Ticks);
        db.AddOutParameter(cmd, "@outString", DbType.String, 20);
        db.AddReturnParameter(cmd, "@returnValue", DbType.Int32);        db.ExecuteNonQuery(cmd);        string s = db.GetParameter(cmd, "@outString").Value as string;//out parameter
        int r = Convert.ToInt32(db.GetParameter(cmd, "@returnValue").Value);//return value6)DataReader使用      DbHelper db = new DbHelper();
        DbCommand cmd = db.GetStoredProcCommond("t2_insert");
        db.AddInParameter(cmd, "@timeticks", DbType.Int64, DateTime.Now.Ticks);
        db.AddOutParameter(cmd, "@outString", DbType.String, 20);
        db.AddReturnParameter(cmd, "@returnValue", DbType.Int32);        using (DbDataReader reader = db.ExecuteReader(cmd))
        {
            dt.Load(reader);
        }        
        string s = db.GetParameter(cmd, "@outString").Value as string;//out parameter
        int r = Convert.ToInt32(db.GetParameter(cmd, "@returnValue").Value);//return value7)事务的使用.(项目中需要将基本的数据库操作组合成一个完整的业务流时,代码级的事务是必不可少的哦)
    pubic void DoBusiness()
    {
        using (Trans t = new Trans())
        {
            try
            {
                D1(t);
                throw new Exception();//如果有异常,会回滚滴
                D2(t);
                t.Commit();
            }
            catch
            {
                t.RollBack();
            }
        }
    }
    public void D1(Trans t)
    {
        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetStoredProcCommond("t2_insert");
        db.AddInParameter(cmd, "@timeticks", DbType.Int64, DateTime.Now.Ticks);
        db.AddOutParameter(cmd, "@outString", DbType.String, 20);
        db.AddReturnParameter(cmd, "@returnValue", DbType.Int32);        if (t == null) db.ExecuteNonQuery(cmd);
        else db.ExecuteNonQuery(cmd,t);        string s = db.GetParameter(cmd, "@outString").Value as string;//out parameter
        int r = Convert.ToInt32(db.GetParameter(cmd, "@returnValue").Value);//return value
    }
    public void D2(Trans t)
    {
        DbHelper db = new DbHelper();
        DbCommand cmd = db.GetSqlStringCommond("insert t1 (id)values('..')");        
        if (t == null) db.ExecuteNonQuery(cmd);
        else db.ExecuteNonQuery(cmd, t);
    }
以上我们好像没有指定数据库连接字符串,大家如果看下DbHelper的代码,就知道要使用它必须在config中配置两个参数,如下:
    <appSettings>
        <add key="DbHelperProvider" value="System.Data.SqlClient"/>
        <add key="DbHelperConnectionString" value="Data Source=(local);Initial Catalog=DbHelperTest;Persist Security Info=True;User ID=sa;Password=sa"/>
    </appSettings>其实,DbHelper需要的仅仅是两个字符串,你可以自己修改,作成加密什么的...

Answer 13

how?
i'm a fresh man。

Answer 14

using System.Data;
using System.Data.Common;
using System.Data.SqlClient;public static DataTable ExecuteQuery(string sql)
        {            using (SqlConnection conn = new SqlConnection("连接字符串"))
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                SqlDataAdapter da = new SqlDataAdapter(cmd);
                DataSet ds = new DataSet();
                conn.Open();
                da.Fill(ds);
                conn.Close();
                return ds.Tables[0];
            }
        }
sql：传入SQL语句
连接字符串（例）：
Data Source=.\SS;Initial Catalog=Statistic;Persist Security Info=True;User ID=sa;Password=sa;
Data Source 服务器名
Initial Catalog 数据库名
User ID 数据库登录ID
Password 数据库登录密码

Answer 15

非常感谢，弱弱的问一句，如何使用这个函数呢？
string aa = DataTable ExecuteQuery("select top 1 * from cUser where cName = "&cName&" 
")
这样吗？

Answer 16

protected static SqlConnection conn = new SqlConnection();
        protected static SqlCommand comm = new SqlCommand();
        private static void openConnection()
        {
            if (conn.State == ConnectionState.Closed)
            {
                ConnectionString ="server =127.0.0.1;database=master;uid=sa;pwd=sa";
                conn.ConnectionString = ConnectionString;// SysConfig.ConnectionString;
                comm.Connection = conn;
                try
                {
                    conn.Open();
                }
                catch (Exception e)
                {
                    throw new Exception(e.Message);
                }
            }
        }
        private static void closeConnection()
        {
            if (conn.State == ConnectionState.Open)
            {
                conn.Close();
            }
            conn.Dispose();
            comm.Dispose();
        }
        public static void ExecuteSql(string sqlstr)
        {
            try
            {
                openConnection();
                comm.CommandType = CommandType.Text;
                comm.CommandText = sqlstr;
                comm.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                throw new Exception(e.Message  );
            }
            finally
            {
                closeConnection();
            }
        }
  
 public static void ExecuteSql(string sqlstr)
        {
            try
            {
                openConnection();
                comm.CommandType = CommandType.Text;
                comm.CommandText = sqlstr;
                comm.ExecuteNonQuery();
            }
            catch (Exception e)
            {
                throw new Exception(e.Message  );
            }
            finally
            {
                closeConnection();
            }
        }
下载petshop看看，操作很全或到51aspx.com看看，代码很多

Answer 17

petshop我下的有，看了很久也看不太懂。

Answer 18

不知道楼主用的是SQL的数据库还是Access的，贴个Access的代码。          //连接字符串,把Data Source后面的字符换成你的数据库的位置
          string myConStr = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=f:\kong\HandwritingVerification.mdb";//公共连接字符串
           //连接对象
            OleDbConnection conn = new OleDbConnection(myConStr);
            try
            {
                conn.Open();
                //comStr是SQL执行字符串,在这替换成你的SQL语句
                string comStr="select * from studentInfo";
                OleDbDataAdapter myDA = new OleDbDataAdapter(comStr, conn);
                DataSet myDS = new DataSet();
                //把查询结果用myDA填充数据集myDS
                myDA.Fill(myDS, "searchResult");
                //显示出来的话，可以用DataGridView或者用ListView也行
                  //用DataGridView显示数据
                DataGridView1.DataSource=myDS.Tables[0];
                //用ListView显示数据
                  for (int i = 0; i < myDS.Tables[0].Rows.Count; i++)
                {
                  ListViewItem lvi = new ListViewItem();
                  if (i % 2 == 0)
                  {
                    //控制背景颜色
                       lvi.BackColor = Color.LightGray;
                  }
                  lvi.Text = myDS.Tables["AllInfo"].Rows[i][0].ToString();
                  lvi.SubItems.AddRange(new string[] { myDS.Tables[0].Rows[i][1].ToString(), myDS.Tables[0].Rows[i][2].ToString()});
                  listView1.Items.Add(lvi);
                }
                
            }
            catch (OleDbException oe)
            {
                MessageBox.Show("程序好像碰到了点麻烦！", "请注意", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }
            finally
            {
                if (conn.State == ConnectionState.Open)
                    conn.Close();
            }以上是显示数据的两种方法，希望对楼主有所帮助

Answer 19

1、 Microsoft Access 
连接数据库 
string strConnection = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" +Server.MapPath(".") + ".\\user.mdb;"; 
//或者使用Server.MapPath("user.mdb");当前文件所在的目录 
myConn = new OleDbConnection(strConnection); 
string sqlString = "select * from [user] where 用户名='" + userName + "'"; 
OleDbCommand myCmd = new OleDbCommand(sqlString, myConn); 
myConn.Open();//或者myCmd.Connection.Open(); 
操作数据库 
OleDbDataReader Dr; 
Dr = myCmd.ExecuteReader(); 
while (Dr.Read()) 
{ 
…… 
} 
关闭数据集、连接 
myCmd.Connection.Close(); 
Dr.Close(); 2、 Microsoft SQL Server 
访问SQL Server数据库 
/* 导入命名空间 */ 
using System.Data.SqlClient; //连接SQLServer数据库专用 
/* 创建连接 */ 
SqlConnection conn = New SqlConnection("Server=服务器名字或IP;Database=数据库名字;uid=用户名;pwd=密码"); 
/* 判断数据库连接是否为空，不为空，则打开连接，真正与数据库连接*/ 
if(conn != null) 
conn.Open(); 
/* 向数据库发送SQL命令 */ 
SqlCommand cmd = new SqlCommand(); //创建命令对象 
cmd.CommandText = "这里是SQL语句"; //写SQL语句 
cmd.Connection = conn; //指定连接对象，即前面创建的 
/* 仅仅执行SQL命令，不返回结果集，用于建表、批量更新等不需要返回结果的操作 */ 
cmd.ExecuteNonQuery(); 
/* 执行SQL命令，并以DataReader的结构返回结果集 */ 
SqlDataReader reader = cmd.ExecuteReader(); 
/* 以DataSet的结构反回结果集 */ 
SqlDataAdapter dbAdapter = new SqlDataAdapter(cmd); //注意与上面的区别 
DataSet ds = new DataSet(); //创建数据集对象 
dbAdapter.Fill(ds); //用返回的结果集填充数据集，此数据集可以绑定到能操作数据的控件 
/* 关闭连接 */ 
conn.Close(); 

Answer 20

        #region 属性字段
        /// <summary>
        /// 数据库连接
        /// </summary>
        private OleDbConnection conn = null;
        /// <summary>
        /// 对数据源执行的 SQL 语句和过程
        /// </summary>
        private OleDbCommand comm = null;
        /// <summary>
        /// 用于填充 DataSet 和更新数据源
        /// </summary>
        private OleDbDataAdapter adapter = null;
        /// <summary>
        /// 读取数据行的只进流
        /// </summary>
        private OleDbDataReader reader = null;
        #endregion        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="strconn">连接字符串</param>
        public CDBOperate(string strconn)
        {
            try
            {
                if (null == this.conn || ConnectionState.Closed == this.conn.State)
                {
                    this.conn = new OleDbConnection(strconn);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        
        /// <summary>
        /// 获得读取数据行的只进流
        /// </summary>
        /// <param name="sqlstr">被执行的Sql语句</param>
        /// <returns></returns>
        public IDataReader executeReader(string sqlstr)
        {
            try
            {
                this.comm = new OleDbCommand();
                this.comm.Connection = this.conn;
                this.comm.CommandText = sqlstr;
                this.conn.Open();
                this.reader = this.comm.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                this.Close();
            }
            return this.reader;
        }        /// <summary>
        /// 获得DataSet数据集
        /// </summary>
        /// <param name="sqlstr">被执行的Sql语句</param>
        /// <returns></returns>
        public DataSet getDataSet(string sqlstr)
        {
            DataSet ds = new DataSet();
            try
            {
                this.adapter = new OleDbDataAdapter(sqlstr, this.conn);
                this.adapter.Fill(ds);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                this.Close();
            }
            return ds;
        }        /// <summary>
        /// 对数据库执行查询，删除，插入，更新操作
        /// </summary>
        /// <param name="sqlstr">被执行的Sql语句</param>
        /// <returns>数据库受影响行</returns>
        public int executeSql(string sqlstr)
        {
            int num = 0;
            try
            {
                this.comm = new OleDbCommand();
                this.comm.CommandText = sqlstr;
                this.comm.Connection = this.conn;
                this.conn.Open();
                num = this.comm.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                this.Close();
            }
            return num;
        }

Answer 21

ADO.NET.. 你少打了四个字母

Answer 22

这个东东，网上一搜一大把，可能是认真看
建议你学习下ado。net  ，这是基础