初学ADO.Net会被ADO.Net访问数据库方式弄得头晕,感觉无从下手.
本文将它们整合在一起,文章并没有涉及太多深层知识. 只是我觉得将它们集中在一起,
在比较中学习更快,更清晰一些:
本文列举了用ADO.Net访问数据库的所有方式:
1.用Sql语句访问数据库
2.用无参存储过程访问数据库
3.用有参存储过程访问数据库
4.使用 CommandBuilder.DeriveParameters 来填充 Command 对象的 Parameters 集合,来访问数据库
5.使用SqlDataReader对象输出数据.

(二).代码示例

private DataSet GetDataSet(int sign)  
  {

   //*******自定义连接字符串********/
   string connectionStr="server=(localhost);uid=sa;pwd=;database=NorthWind";  
   
   SqlConnection myConnection=new SqlConnection(connectionStr);
   DataSet myDataSet=new DataSet();
   string sqlProcedureName="myprocedure";  //此存储过程必须事先已经定义好了.
   if(sign==1)//执行语句.  (最常用的情况)

   {    
    string queryStr="select * from products";    
    SqlDataAdapter myAdapter=new SqlDataAdapter(queryStr,connectionStr);
    
    myAdapter.Fill(myDataSet);
    return myDataSet;
   }

   if(sign==2)//调用SQL无参存储过程,此存储过程返回select查询结果
   {    
    SqlCommand myCommand=new SqlCommand(sqlProcedureName,myConnection);
    myCommand.CommandType=CommandType.StoredProcedure;
    SqlDataAdapter myAdapter=new SqlDataAdapter(sqlProcedureName,myConnection);
    myAdapter.Fill(myDataSet);
    return myDataSet;    
   }
   if(sign==3)//调用SQL有参存储过程，此存储过程返回select查询结果，且传递参数
   {
    SqlCommand myCommand=new SqlCommand(sqlProcedureName,myConnection);
    myCommand.CommandType=CommandType.StoredProcedure;
    
    SqlParameter start=new SqlParameter("@start",SqlDbType.Int,4); // 定义第一个参数

    start.Value=1;
    myCommand.Parameters.Add(start);

    SqlParameter end=new SqlParameter("@end",SqlDbType.Int,4); // 定义第二个参数

    end.Value=5;
    myCommand.Parameters.Add(end);
    
    SqlDataAdapter myAdapter=new SqlDataAdapter(sqlProcedureName,myConnection);
    myAdapter.SelectCommand=myCommand;               
    
    myAdapter.Fill(myDataSet);
    return myDataSet; 
   }
   if(sign==4)  //演示如何使用 CommandBuilder.DeriveParameters 来填充 Command 对象的 Parameters 集合
   {
    SqlCommand myCommand=new SqlCommand(sqlProcedureName,myConnection);
    myCommand.CommandType=CommandType.StoredProcedure;
    SqlDataAdapter myAdapter=new SqlDataAdapter(sqlProcedureName,myConnection);
    
    myConnection.Open();  //如果不打开连接，下一句将不知道从哪里去取所需的存储过程
    SqlCommandBuilder.DeriveParameters(myCommand);              
    myCommand.Parameters["@start"].Value=1;
    myCommand.Parameters["@end"].Value=5;
    myAdapter.SelectCommand=myCommand;               
    
    myAdapter.Fill(myDataSet);
    return myDataSet; 

   }
   if(sign==5)//练习使用SqlDataReader,结果在控制台输出
   {
    SqlCommand myCommand=new SqlCommand(sqlProcedureName,myConnection);
    myCommand.CommandType=CommandType.StoredProcedure;
    
    SqlParameter start=new SqlParameter("@start",SqlDbType.Int,4); // 把4改变或去掉
    start.Value=1;
    myCommand.Parameters.Add(start);

    SqlParameter end=new SqlParameter("@end",SqlDbType.Int,4); // 把4改变或去掉
    end.Value=5;
    myCommand.Parameters.Add(end);
    
    SqlDataAdapter myAdapter=new SqlDataAdapter(sqlProcedureName,myConnection);
    myAdapter.SelectCommand=myCommand;        

    myConnection.Open();
    SqlDataReader myReader = myCommand.ExecuteReader();

    Console.WriteLine("{0}, {1}", myReader.GetName(0), myReader.GetName(1));

    while (myReader.Read())
    {
     //Console.WriteLine("{0},{1}", myReader.GetString(0), myReader.GetString(1));  //？不对
     Console.WriteLine("{0},{1}", myReader.GetValue(0), myReader.GetValue(1));
    }
               
    myConnection.Close();
    DataTable myTable=new DataTable();
    myDataSet.Tables.Add(myTable);
    return myDataSet;
   }
     return new DataSet();
  }

当DataSet中同时包含主/子表(主键表/外键表)时,有时候关系约束太严格:
   比如, 关系数据库完整性规则:
      1.实体完整性. 主键表中主键不准为空.  
      2.参照完整性. 外键表中外键的值必须与主键表中的主键对应. 
         要么为空,要么为主键表中的一主键值.
      3.自定义完整性.   
  如果DataSet表中定义的多表关系约束太严密,直接用Update方法
  将DataSet中多表一起提交时,有可能不满足完整性规则,会发生错误,
    原因: 举个例子,设为两个表: CompanyMain(公司主表)和CompanySon(公司子表)
   CompanyMain(公司主表)主要存储一个公司的基本信息,CompanySon(公司子表)
   主要存储此公司的一些客户的信息. 并且公司主表中的(ID)与子表中的(BelongID)
   建立关联,即主外键关系; 一个公司对应着多个客户,即ID:BelongID = 1 : n关系.
   主表的ID为自动生成编号.
   那么:
   在新增公司界面,一起提交时,系统是不会遵守"数据库完整性规则"来更新到数据库的.
   如果它先更新子表,再更新主表有可能就会报错.  原因是主表的公司信息还没有插入
  到数据库中的表,也就没有生成公司编号: ID,则子表更新时就会没有对应的BelongID.
   这时如果设置了: "外键表中的外键不为null"完整性规则,就会引发异常.
   这只是一种出错的可能,还有更多的出错可能性,在分布式设计中更容易出现这样的错误.

(二). 解决办法

   一般遵守以下几条规则,就会避免大量的出错机率.

   1规则.   在DataSet更新之前按 <表> 和 <表的RowState属性>进行拆分提交

          I.  按 <表> 进行拆分提交意思是说:

                         对DataSet 中的表不是一起提交,而是一次提交一个表,进行多次提交

          II.按 <表的RowState属性>进行拆分提交意思是说:

                       对DataSet中的单个表根据RowState属性,再进行拆分,对RowState

                       相同的进行一次提交,也是提交多次

   2.规则.      

       在规则1基础上, 先更新状态为<新增> 和 <修改> 的,再更新<删除的>

       即: 先更新DataRowState 值为: Added和Modified的,再更新: Deleted的.

  3.规则

       在规则1和规则2基础上,如果DataRowState为Added和Modified,则先更新主表,后更新子表.

       在规则1和规则2基础上,如果DataRowState为Deleted,则先更新子表,后更新主表.

(三) 归纳一下上面三条规则,如下:

        1.将DataSet中的表拆分,并根据RowState将各个表记录进行分组并存储在不同的数据集中

            //这里要存储在DataSet中,是因为: Update接受的是DataSet的参数,还有WebService只支持

            //DataSet,对其进行序列化操作

              代码示例:

                     设待更新的数据集为: dsCompany(里面包括两个表,分别为主表和子表,并存储了

数据,待更新)

             //dtCompanyMain存储公司主表信息,dtCompanySon存储公司子表信息

             DataTable dtCompanyMail = ds.Tables["dtCompanyMain"].Clone();  //分离出主表数据

并存储另一对象

             DataTable dtCompanySon  = ds.Talbes["dtCompanySon"].Clone();  //分离出子表数据

并存储另一对象

             DataSet dsAdded = new DataSet();            //存放主表 新增 的数据

             DataSet dsMidified = new DataSet();          //存储主表  编辑 的行记录

             DataSet dsDeleted = new DataSet();         //存储主表 删除 的行记录

              dsAdded = dtCompanyMain.GetChanges(DataRowState.Added);   //取得主表中新增的行

记录集

              dsMidified = dtCompanyMain.GetChanges(DataRowState.Modified);  //取得主表中编

辑的行记录集

             dsDeleted = dtCompanyMain.GetChanges(DataRowState.Deleted);  //取得主表中删除的

行记录集             

        2.更新主表DataRowState状态为: Added和Modified的记录.

              SqlDataAdapter.Update(dsAdded,"dtCompanyMain");   //更新添加的记录集到数据库

              SqlDataAdapter.Update(dsModified,"dtCompanyMain");   //更新修改的记录集到数据

库

        3.更新子表DataRowState状态为: Added和Modified的记录

               .............  //代码省略,跟2主表更新类似

        4.更新子表DataRowState状态为: Deleted的记录.

              ............   // 代码省略,与下面5类似

        5.更新主表DataRowState状态为: Deleted的记录

            SqlDataAdapter.Update(dsDeleted,"dtCompanyMain");   //更新修改的记录集到数据库

不对的地方请批评指正!

namespace SchemeDataSet
{
 /// <summary>
 /// 包含客户信息的自定义的可序列化的数据集（DataSet）

 /// </summary>
 [System.ComponentModel.DesignerCategory("Code")]
 [SerializableAttribute]
 public class Customers : DataSet    //继承DataSet，这样可以调用DataSet中的所有方法
 {
  #region 以下为常量的声明
  
  /// <summary>常量定义客户资料表 Customer 的表名称</summary>
  public const string CRMPSCUSTOMERS_TABLE = "Customer";

  /// <summary>该常量定义客户编号的栏位名</summary>
  public const string CUSNO_FIELD = "CUSNO";

  /// <summary>该常量定义客户名称的栏位名</summary>
  public const string CUSTOMERNAME_FIELD = "CustomerName";

  /// <summary>该常量定义客户地址的栏位名</summary>
  public const string ADDRESS_FIELD = "Address";
  
  #endregion 以下变量、常量、及对象的声明

  #region 以下为方法声明

  public Customers()
  {
      BuildDataTables();
  }

  /// <summary>
  ///     支持序列化的构造函数

  ///     <param name="info">对象的序列化信息</param>
  ///     <param name="context">关于被呼叫方法的上下文</param>
  /// </summary>
  private Customers(SerializationInfo info, StreamingContext context) : base(info, context)
  {}

  /// <summary>
  /// 创建带结构的表：Customer
  /// </summary>
  private void BuildDataTables()
  {
   //
   // 创建CRMPSCustomers的数据表
   //

   DataTable table = new DataTable(CRMPSCUSTOMERS_TABLE);
   DataColumnCollection columns = table.Columns;

   //定义结构
   columns.Add(CUSNO_FIELD,typeof(System.String));
   columns.Add(CUSTOMERNAME_FIELD,typeof(System.String));
   columns.Add(ADDRESS_FIELD,typeof(System.String));

   this.Tables.Add(table);
   Contact contact = new Contact();
   this.Merge(contact);   //合并
  }

  #endregion 以下为方法声明

 }
}

OK.
(三).使用
1.
  当定义了这样一个类后，在程式中应该这样使用： 
  ds.Table[Customers.CRMPSCUSTOMERS_TABLE].Row[n][Customers.CUSTOMERNAME_FIELD];
  这样就把所有的任务交给本类代码文件了。  当修改数据库时不用修改类似这些语句。 只修改一下结构类相关属性的值即可.
 2.
 定义此带结构的数据集，还有一种情况用到，就是在有些界面，UI层与数据库交互是单向的，即往数据库添加数据之前
 没有读取架构，则DataSet也就没有结构（没有结构不能存储数据），这时这个类就起作用了.

不对的地方请批评指正！

  有没有人遇到这种情况，用 SqlDataAdapter.Update(ds)更新时出错?

  answer:   一般是这样的，如果用设计器将SqlDataAdapter拖到页面中使用时，不会出现这种情况，因为

                  系统会自动生成SqlDataAdapter的属性命令，比如:  .UpdateCommane insertCommand

                  selectCommand等。  但是有些程序员不喜欢用设计器，或者是有些地方没必要拖动

                  SqlDataAdapter这么个庞大物来实现,那么SqlDataAdapter就不会自动生成相关的查询或更新

                  语句了.   所以当执行到SqlDataAdapter.Update(ds)语句时，SqlDataAdapter桥接器不知道更

                 新哪个表.就报错了. 

(二)

  解决方法:

  用SqlCommandBuilder 实现批量更新

  1.功能：

   可以实现你对DataSet在UI层做任意操作后，直接丢给这个方法，这个方法就可以自动把你的修改更 新到数 据库中,而没必要每次都更新到

   数据库

  2.使用方法
  public DataSetUpdateByDataSet(DataSet ds,string strTblName,string strConnection)
  {
      SqlConnection  conn = new SqlConnection(strConnection));
        
     SqlDataAdapter myAdapter = new SqlDataAdapter();
     SqlCommand myCommand = new SqlCommand("select * from "+strTblName),(SqlConnection) conn);   
     myAdapter.SelectCommand = myCommand;
     SqlCommandBuilder myCommandBuilder = new SqlCommandBuilder(myAdapter);    
  try

      {  

               lock(this)            //处理并发情况(分布式情况)

              {

               myAdapter.Update(ds,strTblName); 

              }

      }  
 
  catch(Exception err)
 {

   conn.Close();   
   throw new BusinessException(err);
 }

    return ds;    //数据集的行状态在更新后会都变为: UnChange,在这次更新后客户端要用返回的ds

}

或

public DataSet UpdateByDataSet(DataSet ds,string strTblName,string strConnection)
  {
   
  
      SqlConnection  conn = new SqlConnection(strConnection));         
      SqlCommand myCommand = new SqlCommand("select * from "+strTblName),(SqlConnection) conn);   

      SqlDataAdapter myAdapter = new SqlDataAdapter(myCommand );   

      SqlCommandBuilder myCommandBuilder = new SqlCommandBuilder(myAdapter);     
      
      myAdapter.InsertCommand = myCommandBuilder .GetInsertCommand();

      myAdapter.UpdateCommand = myCommandBuilder .GetUpdateCommand();

     myAdapter.DeleteCommand = myCommandBuilder .GetDeleteCommand();

   try

  {

        lock(this)                              //处理并发情况(分布式情况)

       {

              conn.Open();

              myAdapter.Update(ds,strTblName);  

              conn.Close();

       }
  
         return ds;    //数据集的行状态在更新后会都变为: UnChange,在这次更新后客户端要用返回的ds }
 catch(Exception err)
 { 

      conn.Close(); 
      throw new BusinessException(err);
 }
}

直接调用这两个方法的任意一个就OK啦,说明的一点是select * from "+strTblName是一定要的，
作用大家也应该想到了，主要是告诉 SqlDataAdapter更新哪个表

3.什么时候用?

    a. 有时候需要缓存的时候，比如说在一个商品选择界面，选择好商品，并且进行编辑/删除/更新后，

       最后一并交给数据库，而不是每一步操作都访问数据库，因为客户选择商品可能进行n次编辑/删除

       更新操作，如果每次都提交，不但容易引起数据库冲突,引发错误，而且当数据量很大时在用户执行

       效率上也变得有些慢

    b.有的界面是这样的有的界面是这样的，需求要求一定用缓存实现，确认之前的操作不提交到库,点击

      页面专门提交的按钮时才提交商品选择信息和商品的其它信息. 我经常遇到这样的情况

    c.有些情况下只往数据库里更新，不读取. 也就是说没有从数据库里读，SqlDataAdapter也就不知道是
    
      更新哪张表了，调用Update就很可能出错了。这样的情况下可以用SqlCommandBuilder 了.
        

4.
 注意点:
  1.只能更新一个表，如果此数据集是从两个或者两个以上的表关联而来的,则不能用此方法自动更新
  2.表中必须设置主键
  3.更新的表中字段不能有image类型的

5.优点:

    节省代码量，节省时间，这个方法可以代替所有的:  更新/删除/插入操作语句

6.缺点:
        访问两次数据库(select * TableName,就是这句，要确认是哪个表，除非是很大的数据量，
        一般是感觉不到的)，效率稍微有些慢

不对的地方望批评指正！