保证C# 多线程 UI 响应

Form1.cs

using System; 
using System.Collections.Generic; 
using System.ComponentModel; 
using System.Data; 
using System.Drawing; 
using System.Text; 
using System.Windows.Forms; 
using System.Threading; 
 
namespace WindowsApplication 
{ 
    public partial class Form1 : Form 
    { 
        public Form1() 
        { 
            InitializeComponent(); 
        } 
 
        class myclass 
        { 
            //单参数构造 
            public myclass(DataGridView dw1) 
            { 
                dw = dw1; 
            } 
            
            public delegate void mydelegate(); 
            public DataGridView dw = new DataGridView(); 
 
            //Invoke 
            public void C() 
            { 
                mydelegate mc = new mydelegate(B); 
                mc.Invoke(); 
 
            } 
 
            //DynamicInvoke 
            public void D() 
            { 
                mydelegate mc = new mydelegate(B); 
                mc.DynamicInvoke(); 
 
            } 
            
            //BeginInvoke 
            public void E() 
            { 
                mydelegate mc = new mydelegate(B); 
                AsyncCallback asc = new AsyncCallback(F); 
              //  mc.BeginInvoke(asc,1); 
                mc.BeginInvoke(null, null); //不回调 
 
               
                
 
            } 
 
            //E的回调方法 
              public void F( IAsyncResult result) 
            { 
                MessageBox.Show("方法E完成,此为回调函数"); 
                 
            } 
 
  
           //基本方法 
            public void B() 
            { 
 
                  CheckForIllegalCrossThreadCalls = false;   
                  dw.DataSource = SQLServerDAL.DbHelperSQL.Query("select  top 200000 *  from  费用表").Tables[0].DefaultView; 
                 
                  
            } 
 
            //A方法用线程处理C方法 
            public void A() 
            { 
                Thread thread = new Thread(C); 
                thread.IsBackground = true; 
                thread.Start(); 
                
 
            } 
 
        } 
 
 
 
        private void buttonB_Click(object sender, EventArgs e) 
        { 
            myclass mc = new myclass(dataGridView1); 
            Thread thread = new Thread(mc.B); 
            thread.IsBackground = true; 
            thread.Start(); 
        } 
 
        private void buttonRefresh_Click(object sender, EventArgs e) 
        { 
            //解决方法A的问题，之后滚动条可以滚动了 
            dataGridView1.RightToLeft = RightToLeft.Yes; 
            dataGridView1.RightToLeft = RightToLeft.No; 
 
            //this.Refresh(); 没有作用 
            //dataGridView1.Refresh(); 没有作用 
        } 
 
        private void buttonE_Click(object sender, EventArgs e) 
        { 
            //E方法刚开始不死,一会就假死了 
            myclass mc = new myclass(dataGridView1); 
            Thread thread = new Thread(mc.E); 
            thread.IsBackground = true; 
            thread.Start(); 
        } 
 
        private void buttonC_Click(object sender, EventArgs e) 
        { 
            myclass mc = new myclass(dataGridView1); 
            Thread thread = new Thread(mc.C); 
            thread.IsBackground = true; 
            thread.Start(); 
        } 
 
        private void buttonD_Click(object sender, EventArgs e) 
        { 
            myclass mc = new myclass(dataGridView1); 
            Thread thread = new Thread(mc.D); 
            thread.IsBackground = true; 
            thread.Start(); 
        } 
 
        private void buttonA_Click(object sender, EventArgs e) 
        { 
            myclass mc = new myclass(dataGridView1); 
            mc.A(); 
 
            //或者 
 
            //myclass mc = new myclass(dataGridView1); 
            //Thread thread = new Thread( mc.A); 
            //thread.IsBackground = true; 
            //thread.Start(); 
  
        } 
 
       
    } 
} 
 
//除了E方法，其他方法UI都始终有响应,但是数据加载完成之后 有共同点问题,那就是滚动条可能没有，或者没有响应, 

 

Form1.Designer.cs

 

namespace WindowsApplication 
{ 
    partial class Form1 
    { 
        /// <summary> 
        /// 必需的设计器变量。 
        /// </summary> 
        private System.ComponentModel.IContainer components = null; 
 
        /// <summary> 
        /// 清理所有正在使用的资源。 
        /// </summary> 
        /// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param> 
        protected override void Dispose(bool disposing) 
        { 
            if (disposing && (components != null)) 
            { 
                components.Dispose(); 
            } 
            base.Dispose(disposing); 
        } 
 
        #region Windows 窗体设计器生成的代码 
 
        /// <summary> 
        /// 设计器支持所需的方法 - 不要 
        /// 使用代码编辑器修改此方法的内容。 
        /// </summary> 
        private void InitializeComponent() 
        { 
            this.dataGridView1 = new System.Windows.Forms.DataGridView(); 
            this.buttonA = new System.Windows.Forms.Button(); 
            this.buttonC = new System.Windows.Forms.Button(); 
            this.buttonD = new System.Windows.Forms.Button(); 
            this.buttonE = new System.Windows.Forms.Button(); 
            this.buttonRefresh = new System.Windows.Forms.Button(); 
            this.buttonB = new System.Windows.Forms.Button(); 
            ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).BeginInit(); 
            this.SuspendLayout(); 
            //  
            // dataGridView1 
            //  
            this.dataGridView1.ColumnHeadersHeightSizeMode = System.Windows.Forms.DataGridViewColumnHeadersHeightSizeMode.AutoSize; 
            this.dataGridView1.Dock = System.Windows.Forms.DockStyle.Left; 
            this.dataGridView1.Location = new System.Drawing.Point(0, 0); 
            this.dataGridView1.Name = "dataGridView1"; 
            this.dataGridView1.RowTemplate.Height = 23; 
            this.dataGridView1.Size = new System.Drawing.Size(635, 608); 
            this.dataGridView1.TabIndex = 0; 
            //  
            // buttonA 
            //  
            this.buttonA.Location = new System.Drawing.Point(686, 109); 
            this.buttonA.Name = "buttonA"; 
            this.buttonA.Size = new System.Drawing.Size(120, 39); 
            this.buttonA.TabIndex = 1; 
            this.buttonA.Text = "A"; 
            this.buttonA.UseVisualStyleBackColor = true; 
            this.buttonA.Click += new System.EventHandler(this.buttonA_Click); 
            //  
            // buttonC 
            //  
            this.buttonC.Location = new System.Drawing.Point(686, 181); 
            this.buttonC.Name = "buttonC"; 
            this.buttonC.Size = new System.Drawing.Size(120, 32); 
            this.buttonC.TabIndex = 2; 
            this.buttonC.Text = "C"; 
            this.buttonC.UseVisualStyleBackColor = true; 
            this.buttonC.Click += new System.EventHandler(this.buttonC_Click); 
            //  
            // buttonD 
            //  
            this.buttonD.Location = new System.Drawing.Point(686, 237); 
            this.buttonD.Name = "buttonD"; 
            this.buttonD.Size = new System.Drawing.Size(120, 36); 
            this.buttonD.TabIndex = 3; 
            this.buttonD.Text = "D"; 
            this.buttonD.UseVisualStyleBackColor = true; 
            this.buttonD.Click += new System.EventHandler(this.buttonD_Click); 
            //  
            // buttonE 
            //  
            this.buttonE.Location = new System.Drawing.Point(686, 302); 
            this.buttonE.Name = "buttonE"; 
            this.buttonE.Size = new System.Drawing.Size(120, 35); 
            this.buttonE.TabIndex = 4; 
            this.buttonE.Text = "E"; 
            this.buttonE.UseVisualStyleBackColor = true; 
            this.buttonE.Click += new System.EventHandler(this.buttonE_Click); 
            //  
            // buttonRefresh 
            //  
            this.buttonRefresh.Location = new System.Drawing.Point(686, 438); 
            this.buttonRefresh.Name = "buttonRefresh"; 
            this.buttonRefresh.Size = new System.Drawing.Size(120, 39); 
            this.buttonRefresh.TabIndex = 6; 
            this.buttonRefresh.Text = "界面刷新"; 
            this.buttonRefresh.UseVisualStyleBackColor = true; 
            this.buttonRefresh.Click += new System.EventHandler(this.buttonRefresh_Click); 
            //  
            // buttonB 
            //  
            this.buttonB.Location = new System.Drawing.Point(686, 361); 
            this.buttonB.Name = "buttonB"; 
            this.buttonB.Size = new System.Drawing.Size(120, 34); 
            this.buttonB.TabIndex = 7; 
            this.buttonB.Text = "B"; 
            this.buttonB.UseVisualStyleBackColor = true; 
            this.buttonB.Click += new System.EventHandler(this.buttonB_Click); 
            //  
            // Form1 
            //  
            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F); 
            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; 
            this.ClientSize = new System.Drawing.Size(961, 608); 
            this.Controls.Add(this.buttonB); 
            this.Controls.Add(this.buttonRefresh); 
            this.Controls.Add(this.buttonE); 
            this.Controls.Add(this.buttonD); 
            this.Controls.Add(this.buttonC); 
            this.Controls.Add(this.buttonA); 
            this.Controls.Add(this.dataGridView1); 
            this.Name = "Form1"; 
            this.Text = "Form1"; 
            ((System.ComponentModel.ISupportInitialize)(this.dataGridView1)).EndInit(); 
            this.ResumeLayout(false); 
 
        } 
 
        #endregion 
 
        private System.Windows.Forms.DataGridView dataGridView1; 
        private System.Windows.Forms.Button buttonA; 
        private System.Windows.Forms.Button buttonC; 
        private System.Windows.Forms.Button buttonD; 
        private System.Windows.Forms.Button buttonE; 
        private System.Windows.Forms.Button buttonRefresh; 
        private System.Windows.Forms.Button buttonB; 
    } 
} 

 

sql.cs

    using System; 
    using System.Collections; 
    using System.Collections.Specialized; 
    using System.Data; 
    using System.Data.SqlClient; 
    using System.Configuration; 
 
    namespace  SQLServerDAL //可以修改成实际项目的命名空间名称 
    { 
     /**//// <summary> 
     /// Copyright (C) 2010 qanholas  
     /// 数据访问基础类(基于SQLServer) 
     /// 用户可以修改满足自己项目的需要。 
     /// </summary> 
     public abstract class DbHelperSQL 
     { 
      //数据库连接字符串(web.config来配置) 
      //<add key="ConnectionString" value="server=127.0.0.1;database=DATABASE;uid=sa;pwd=" />   
         protected static string connectionString = @"Data Source=.\sql2005;Initial Catalog=ycmis;User Id=sa;Password=123456"; 
      public DbHelperSQL() 
      {    
      } 
    #region 公用方法 
 
      public static 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()); 
       } 
      } 
      public static bool Exists(string strSql, params SqlParameter[] cmdParms) 
      { 
       object obj = GetSingle(strSql, cmdParms); 
       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; 
       } 
      } 
      #endregion 
 
 
 
      /**//// <summary> 
      /// 执行SQL语句，返回影响的记录数 
      /// </summary> 
      /// <param name="SQLString">SQL语句</param> 
      /// <returns>影响的记录数</returns> 
      public static int ExecuteSql(string SQLString) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       {     
        using (SqlCommand cmd = new SqlCommand(SQLString,connection)) 
        { 
         try 
         {   
          connection.Open(); 
          int rows=cmd.ExecuteNonQuery(); 
          return rows; 
         } 
         catch(System.Data.SqlClient.SqlException E) 
         {      
          connection.Close(); 
          throw new Exception(E.Message); 
         } 
        }     
       } 
      } 
       
      /**//// <summary> 
      /// 执行多条SQL语句，实现数据库事务。 
      /// </summary> 
      /// <param name="SQLStringList">多条SQL语句</param>   
      public static void ExecuteSqlTran(ArrayList SQLStringList) 
      { 
       using (SqlConnection conn = new SqlConnection(connectionString)) 
       { 
        conn.Open(); 
        SqlCommand cmd = new SqlCommand(); 
        cmd.Connection=conn;     
        SqlTransaction tx=conn.BeginTransaction();    
        cmd.Transaction=tx;     
        try 
        {      
         for(int n=0;n<SQLStringList.Count;n++) 
         { 
          string strsql=SQLStringList[n].ToString(); 
          if (strsql.Trim().Length>1) 
          { 
           cmd.CommandText=strsql; 
           cmd.ExecuteNonQuery(); 
          } 
         }           
         tx.Commit();      
        } 
        catch(System.Data.SqlClient.SqlException E) 
        {   
         tx.Rollback(); 
         throw new Exception(E.Message); 
        } 
       } 
      } 
      /**//// <summary> 
      /// 执行带一个存储过程参数的的SQL语句。 
      /// </summary> 
      /// <param name="SQLString">SQL语句</param> 
      /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param> 
      /// <returns>影响的记录数</returns> 
      public static int ExecuteSql(string SQLString,string content) 
      {     
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        SqlCommand cmd = new SqlCommand(SQLString,connection);   
        System.Data.SqlClient.SqlParameter  myParameter = new System.Data.SqlClient.SqlParameter ( "@content", SqlDbType.NText); 
        myParameter.Value = content ; 
        cmd.Parameters.Add(myParameter); 
        try 
        { 
         connection.Open(); 
         int rows=cmd.ExecuteNonQuery(); 
         return rows; 
        } 
        catch(System.Data.SqlClient.SqlException E) 
        {     
         throw new Exception(E.Message); 
        } 
        finally 
        { 
         cmd.Dispose(); 
         connection.Close(); 
        }  
       } 
      }   
      /**//// <summary> 
      /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例) 
      /// </summary> 
      /// <param name="strSQL">SQL语句</param> 
      /// <param name="fs">图像字节,数据库的字段类型为image的情况</param> 
      /// <returns>影响的记录数</returns> 
      public static int ExecuteSqlInsertImg(string strSQL,byte[] fs) 
      {   
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        SqlCommand cmd = new SqlCommand(strSQL,connection);  
        System.Data.SqlClient.SqlParameter  myParameter = new System.Data.SqlClient.SqlParameter ( "@fs", SqlDbType.Image); 
        myParameter.Value = fs ; 
        cmd.Parameters.Add(myParameter); 
        try 
        { 
         connection.Open(); 
         int rows=cmd.ExecuteNonQuery(); 
         return rows; 
        } 
        catch(System.Data.SqlClient.SqlException E) 
        {     
         throw new Exception(E.Message); 
        } 
        finally 
        { 
         cmd.Dispose(); 
         connection.Close(); 
        }     
       } 
      } 
       
      /**//// <summary> 
      /// 执行一条计算查询结果语句，返回查询结果（object）。 
      /// </summary> 
      /// <param name="SQLString">计算查询结果语句</param> 
      /// <returns>查询结果（object）</returns> 
      public static object GetSingle(string SQLString) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        using(SqlCommand cmd = new SqlCommand(SQLString,connection)) 
        { 
         try 
         { 
          connection.Open(); 
          object obj = cmd.ExecuteScalar(); 
          if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value))) 
          {      
           return null; 
          } 
          else 
          { 
           return obj; 
          }     
         } 
         catch(System.Data.SqlClient.SqlException e) 
         {       
          connection.Close(); 
          throw new Exception(e.Message); 
         }  
        } 
       } 
      } 
      /**//// <summary> 
      /// 执行查询语句，返回SqlDataReader 
      /// </summary> 
      /// <param name="strSQL">查询语句</param> 
      /// <returns>SqlDataReader</returns> 
      public static SqlDataReader ExecuteReader(string strSQL) 
      { 
       SqlConnection connection = new SqlConnection(connectionString);    
       SqlCommand cmd = new SqlCommand(strSQL,connection);     
       try 
       { 
        connection.Open();  
        SqlDataReader myReader = cmd.ExecuteReader(); 
        return myReader; 
       } 
       catch(System.Data.SqlClient.SqlException e) 
       {         
        throw new Exception(e.Message); 
       }    
        
      }   
      /**//// <summary> 
      /// 执行查询语句，返回DataSet 
      /// </summary> 
      /// <param name="SQLString">查询语句</param> 
      /// <returns>DataSet</returns> 
      public static DataSet Query(string SQLString) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        DataSet ds = new DataSet(); 
        try 
        { 
         connection.Open(); 
         SqlDataAdapter command = new SqlDataAdapter(SQLString,connection);     
         command.Fill(ds,"ds"); 
        } 
        catch(System.Data.SqlClient.SqlException ex) 
        {     
         throw new Exception(ex.Message); 
        }    
        return ds; 
       }    
      } 
 
 
 
 
      /**//// <summary> 
      /// 执行SQL语句，返回影响的记录数 
      /// </summary> 
      /// <param name="SQLString">SQL语句</param> 
      /// <returns>影响的记录数</returns> 
      public static int ExecuteSql(string SQLString,params SqlParameter[] cmdParms) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       {     
        using (SqlCommand cmd = new SqlCommand()) 
        { 
         try 
         {   
          PrepareCommand(cmd, connection, null,SQLString, cmdParms); 
          int rows=cmd.ExecuteNonQuery(); 
          cmd.Parameters.Clear(); 
          return rows; 
         } 
         catch(System.Data.SqlClient.SqlException E) 
         {     
          throw new Exception(E.Message); 
         } 
        }     
       } 
      } 
       
        
      /**//// <summary> 
      /// 执行多条SQL语句，实现数据库事务。 
      /// </summary> 
      /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param> 
      public static void ExecuteSqlTran(Hashtable SQLStringList) 
      {    
       using (SqlConnection conn = new SqlConnection(connectionString)) 
       { 
        conn.Open(); 
        using (SqlTransaction trans = conn.BeginTransaction())  
        { 
         SqlCommand cmd = new SqlCommand(); 
         try  
         { 
          //循环 
          foreach (DictionaryEntry myDE in SQLStringList) 
          {  
           string  cmdText=myDE.Key.ToString(); 
           SqlParameter[] cmdParms=(SqlParameter[])myDE.Value; 
           PrepareCommand(cmd,conn,trans,cmdText, cmdParms); 
           int val = cmd.ExecuteNonQuery(); 
           cmd.Parameters.Clear(); 
 
           trans.Commit(); 
          }      
         } 
         catch  
         { 
          trans.Rollback(); 
          throw; 
         } 
        }     
       } 
      } 
      
         
      /**//// <summary> 
      /// 执行一条计算查询结果语句，返回查询结果（object）。 
      /// </summary> 
      /// <param name="SQLString">计算查询结果语句</param> 
      /// <returns>查询结果（object）</returns> 
      public static object GetSingle(string SQLString,params SqlParameter[] cmdParms) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        using (SqlCommand cmd = new SqlCommand()) 
        { 
         try 
         { 
          PrepareCommand(cmd, connection, null,SQLString, cmdParms); 
          object obj = cmd.ExecuteScalar(); 
          cmd.Parameters.Clear(); 
          if((Object.Equals(obj,null))||(Object.Equals(obj,System.DBNull.Value))) 
          {      
           return null; 
          } 
          else 
          { 
           return obj; 
          }     
         } 
         catch(System.Data.SqlClient.SqlException e) 
         {     
          throw new Exception(e.Message); 
         }      
        } 
       } 
      } 
       
      /**//// <summary> 
      /// 执行查询语句，返回SqlDataReader 
      /// </summary> 
      /// <param name="strSQL">查询语句</param> 
      /// <returns>SqlDataReader</returns> 
      public static SqlDataReader ExecuteReader(string SQLString,params SqlParameter[] cmdParms) 
      {   
       SqlConnection connection = new SqlConnection(connectionString); 
       SqlCommand cmd = new SqlCommand();     
       try 
       { 
        PrepareCommand(cmd, connection, null,SQLString, cmdParms); 
        SqlDataReader myReader = cmd.ExecuteReader(); 
        cmd.Parameters.Clear(); 
        return myReader; 
       } 
       catch(System.Data.SqlClient.SqlException e) 
       {         
        throw new Exception(e.Message); 
       }      
        
      }   
       
      /**//// <summary> 
      /// 执行查询语句，返回DataSet 
      /// </summary> 
      /// <param name="SQLString">查询语句</param> 
      /// <returns>DataSet</returns> 
      public static DataSet Query(string SQLString,params SqlParameter[] cmdParms) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        SqlCommand cmd = new SqlCommand(); 
        PrepareCommand(cmd, connection, null,SQLString, cmdParms); 
        using( SqlDataAdapter da = new SqlDataAdapter(cmd) ) 
        { 
         DataSet ds = new DataSet();  
         try 
         {             
          da.Fill(ds,"ds"); 
          cmd.Parameters.Clear(); 
         } 
         catch(System.Data.SqlClient.SqlException ex) 
         {     
          throw new Exception(ex.Message); 
         }    
         return ds; 
        }     
       }    
      } 
 
 
      private static void PrepareCommand(SqlCommand cmd,SqlConnection conn,SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)  
      { 
       if (conn.State != ConnectionState.Open) 
        conn.Open(); 
       cmd.Connection = conn; 
       cmd.CommandText = cmdText; 
       if (trans != null) 
        cmd.Transaction = trans; 
       cmd.CommandType = CommandType.Text;//cmdType; 
       if (cmdParms != null)  
       { 
        foreach (SqlParameter parm in cmdParms) 
         cmd.Parameters.Add(parm); 
       } 
      } 
 
 
 
      /**//// <summary> 
      /// 执行存储过程 
      /// </summary> 
      /// <param name="storedProcName">存储过程名</param> 
      /// <param name="parameters">存储过程参数</param> 
      /// <returns>SqlDataReader</returns> 
      public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters ) 
      { 
       SqlConnection connection = new SqlConnection(connectionString); 
       SqlDataReader returnReader; 
       connection.Open(); 
       SqlCommand command = BuildQueryCommand( connection,storedProcName, parameters ); 
       command.CommandType = CommandType.StoredProcedure; 
       returnReader = command.ExecuteReader();     
       return returnReader;    
      } 
       
       
      /**//// <summary> 
      /// 执行存储过程 
      /// </summary> 
      /// <param name="storedProcName">存储过程名</param> 
      /// <param name="parameters">存储过程参数</param> 
      /// <param name="tableName">DataSet结果中的表名</param> 
      /// <returns>DataSet</returns> 
      public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName ) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        DataSet dataSet = new DataSet(); 
        connection.Open(); 
        SqlDataAdapter sqlDA = new SqlDataAdapter(); 
        sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters ); 
        sqlDA.Fill( dataSet, tableName ); 
        connection.Close(); 
        return dataSet; 
       } 
      } 
 
       
      /**//// <summary> 
      /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值) 
      /// </summary> 
      /// <param name="connection">数据库连接</param> 
      /// <param name="storedProcName">存储过程名</param> 
      /// <param name="parameters">存储过程参数</param> 
      /// <returns>SqlCommand</returns> 
      private static SqlCommand BuildQueryCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters) 
      {    
       SqlCommand command = new SqlCommand( storedProcName, connection ); 
       command.CommandType = CommandType.StoredProcedure; 
       foreach (SqlParameter parameter in parameters) 
       { 
        command.Parameters.Add( parameter ); 
       } 
       return command;    
      } 
       
      /**//// <summary> 
      /// 执行存储过程，返回影响的行数   
      /// </summary> 
      /// <param name="storedProcName">存储过程名</param> 
      /// <param name="parameters">存储过程参数</param> 
      /// <param name="rowsAffected">影响的行数</param> 
      /// <returns></returns> 
      public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected ) 
      { 
       using (SqlConnection connection = new SqlConnection(connectionString)) 
       { 
        int result; 
        connection.Open(); 
        SqlCommand command = BuildIntCommand(connection,storedProcName, parameters ); 
        rowsAffected = command.ExecuteNonQuery(); 
        result = (int)command.Parameters["ReturnValue"].Value; 
        //Connection.Close(); 
        return result; 
       } 
      } 
       
      /**//// <summary> 
      /// 创建 SqlCommand 对象实例(用来返回一个整数值)  
      /// </summary> 
      /// <param name="storedProcName">存储过程名</param> 
      /// <param name="parameters">存储过程参数</param> 
      /// <returns>SqlCommand 对象实例</returns> 
      private static SqlCommand BuildIntCommand(SqlConnection connection,string storedProcName, IDataParameter[] parameters) 
      { 
       SqlCommand command = BuildQueryCommand(connection,storedProcName, parameters ); 
       command.Parameters.Add( new SqlParameter ( "ReturnValue", 
        SqlDbType.Int,4,ParameterDirection.ReturnValue, 
        false,0,0,string.Empty,DataRowVersion.Default,null )); 
       return command; 
      } 
 
     } 
    }