在操作Excel的过程中遇到了一些问题. 比如： 访问Com组件权限，无法读取Excel等
   文章描述了怎样双向操作(读取和生成)Excel文件，以及怎样解决遇到的问题!

(二).代码
   开始时用了下面两个方法进行生成和读取 Excel:
   1.生成Excel文件方法一:
      ' <summary>
    '  下载Excel方法1(用流实现)
    ' </summary>
    ' <param name="dt">要转换为Excel文件的表</param>
    ' <param name="page">页面Page对象,用法: 将me.Page传递过来即可</param>
    Public Sub DownLoadExcelToClient1(ByVal dt As DataTable, ByVal FileName As String)
        Dim resp As HttpResponse
        resp = Page.Response
        resp.ContentEncoding = System.Text.Encoding.Default

'System.Text.Encoding.GetEncoding("GB2312")
        resp.AppendHeader("Content-Disposition", "attachment;filename=" + FileName)
        Dim colHeaders As String = "", ls_item = ""
        Dim i As Int16 = 0

        '取得数据表各列标题，各标题之间以\t分割，最后一个列标题后加回车符
        For i = 0 To dt.Columns.Count - 2
            colHeaders += dt.Columns(i).Caption.ToString() & Chr(9)
        Next
        colHeaders += dt.Columns(i).Caption.ToString() & Chr(13)
        '向HTTP输出流中写入取得的数据信息
        resp.Write(colHeaders)

        Dim row As DataRow
        '逐行处理数据  
        For Each row In dt.Rows
            '在当前行中，逐列获得数据，数据之间以\t分割，结束时加回车符\n
            For i = 0 To dt.Columns.Count - 2
                ls_item &= row(i).ToString() & Chr(9)
            Next i
            ls_item &= row(i).ToString() & Chr(13)

            '当前行数据写入HTTP输出流，并且置空ls_item以便下行数据    
            resp.Write(ls_item)
            ls_item = ""
        Next
        '写缓冲区中的数据到HTTP头文件中
        resp.End()
    End Sub
   2.读取Excel文件
     ' <summary>
    '  读取Excel文件
    ' </summary>
    ' <param name="dt">要转换为Excel文件的表</param>
    ' <param name="page">页面Page对象,用法: 将me.Page传递过来即可</param>
    ' <return>数据集DataSet</return>
    Public Function ReadExcelFileToDataSet(ByVal strFileName As String) As DataSet
        Try

            '建立一个专门存放Excel文件的目录
            If Directory.Exists(Page.Server.MapPath("ExcelFolder")) = False Then
                Directory.CreateDirectory(Page.Server.MapPath("ExcelFolder"))
            End If

            Dim strConn As String
            strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" & "Data Source=" &

Page.Server.MapPath(".") & "\ExcelFolder\" & strFileName & ";" & "Extended

Properties=Excel 8.0;"
            Dim conn As OleDb.OleDbConnection = New OleDb.OleDbConnection(strConn)
            Dim strExcel As String = "select * from [sheet1$]"
            Dim ds As DataSet = New DataSet
            conn.Open()
            Dim adapter As OleDbDataAdapter = New OleDbDataAdapter(strExcel, strConn)
            adapter.Fill(ds)
            Return ds
        Catch ex As Exception
            Throw ex
        End Try
    End Function

   生成是成功的，但读取不成功，提示:"数据源格式有误!"
   一直是认为:ReadExcelFileToDataSet方法有误,调试了半天，找了N多资料也不能成功!
   后来经过"时间的流逝",终久确认第二个方法没有错误，是完全正确的，是第一个方法
   生成格式的问题. 于是我将第一个方法换为下面的方法,读取和写入就OK了.
 
 3.生成Excel文件方法二:
     ' <summary>
    '  下载Excel方法2(用office-Excel-Com组件对象实现)
    ' </summary>
    ' <param name="dt">要转换为Excel文件的表</param>
    ' <param name="page">页面Page对象,用法: 将me.Page传递过来即可</param>
    Public Sub DownLoadExcelToClient2(ByVal dt As DataTable)
        '生成Excel操作相关对象
        Dim xlApp As Excel.Application
        Dim xlBook As Excel.Workbook
        Dim xlSheet As Excel.Worksheet
        xlApp = CType(CreateObject("Excel.Application"), Excel.Application)
        xlBook = CType(xlApp.Workbooks.Add, Excel.Workbook)
        xlSheet = CType(xlBook.Worksheets(1), Excel.Worksheet)

        'xlSheet.Range("A1:B1").Merge(0) '合并单元格
        'xlSheet.Cells(1, 1) = "员工资料信息:"

        '赋标题(Excel文件中的标题)
        Dim rowIndex As Integer = 2
        Dim colIndex As Integer = 0
        Dim Col As DataColumn
        Dim Row As DataRow
        For Each Col In dt.Columns
            colIndex = colIndex + 1
            xlApp.Cells(rowIndex, colIndex) = Col.ColumnName
        Next

        '将表dt的所有行写入xlApp对象(Excel文件中的内容)
        For Each Row In dt.Rows
            rowIndex = rowIndex + 1
            colIndex = 0
            For Each Col In dt.Columns
                colIndex = colIndex + 1
                xlApp.Cells(rowIndex, colIndex) = Row(Col.ColumnName)
            Next
        Next

        xlSheet.Application.Visible = True   '置为可见

        '建立一个专门存放Excel文件的目录
        If Directory.Exists(Page.Server.MapPath("ExcelFolder")) = False Then
            Directory.CreateDirectory(Page.Server.MapPath("ExcelFolder"))
        End If

        '删除服务端临时文件: download.xls
        If File.Exists(Page.Server.MapPath(".") & "\ExcelFolder\download.xls") = True Then
            File.Delete(Page.Server.MapPath(".") & "\ExcelFolder\download.xls")
        End If

        '在服务端保存download.xls
        xlSheet.SaveAs(Page.Server.MapPath(".") & "\ExcelFolder\download.xls")

        '杀死Excel进程
        Dim myproc As System.Diagnostics.Process = New System.Diagnostics.Process
        Dim proc As Process
        Dim procs() As Process = Process.GetProcessesByName("excel")   '得到所有打开的进程
        Try
            For Each proc In procs
                If Not proc.CloseMainWindow() Then
                    proc.Kill()
                End If
            Next
        Catch
        End Try

        '这里用到个goto语句,是因为: 线程是异步执行的,下面的代码要访问download.xls文件,但有

少数情况下上面的线程
        '未能及时释放download.xls文件的指针,那么下面代码执行语句时会抛出异常, 当发生异常时

需要等待资源释放后,
        '再重新访问该文件, 保证下载文件能够正确下载
again:  Try
            '输出到客户端()
            If File.Exists(Page.Server.MapPath(".") & "\ExcelFolder\download.xls") Then
                Dim TargetFile As FileInfo = New FileInfo(Page.Server.MapPath(".") &

"\ExcelFolder\download.xls")
                '清除缓冲区流中的所有内容输出.
                Page.Response.Clear()
                '向输出流添加HTTP头 [指定下载/保存 对话框的文件名]
                Page.Response.AppendHeader("Content-Disposition", "attachment; filename="

+ Page.Server.UrlEncode(TargetFile.Name))
                '向输出流添加HTTP头 [指定文件的长度,这样下载文件就会显示正确的进度
                Page.Response.AppendHeader("Content-Length", TargetFile.Length.ToString())
                '表明输出的HTTP为流[stream],因此客户端只能下载.
                Page.Response.ContentType = "application/octet-stream"
                '发送文件流到客户端.
                Page.Response.WriteFile(TargetFile.FullName)
                '停止执行当前页
                Page.Response.End()
            End If
        Catch
            Thread.Sleep(10)
            GoTo again
        End Try
    End Sub
这说明：
    a. 生成Excel文件后，用户经过修改，还要反向读取此Excel文件(比如:反向更新到数据库中)
       就只能用: 3 和 2方法结合使用. 
    b. 如果只是单向输出Excel文件，用1和2方法都可以. 不过用2的话还要安装Office-Excel,
       一般还要设置一下Com组件访问权限

(三).不能读取的原因 以及 权限问题解决

  a. 原因是:  方法 1 是用流的格式实现的,简单的说它不是真正的Excel格式，而 3 是调用的
     Excel Com组件，生成的是真正的Excel文档,所以能读取(1也可以读取，但也要用Stream类读取，

    如果数据有些复杂的话，会很麻烦).  用1和3方法生成的文件及文件图标一模一样，并且用Excel 

    应用程序打开后显示效果也是一样的.  但当用记事本分别打开1和3生成的*.xls文件时，就明
     显看到它们的不同了.(您可以下载一下本示例代码程序，分别生成两个文件，对比一下)

  b.在使用Excel com组件时除了装Office-Excel以外，一般还要设置一下Com的访问权限，步骤如下: 
     I.如果是Window2003 ->控制面版 -> 管理工具 -> 组件服务 ->
       打开树级目录找到子目录DCOM配置 -> Microsoft Excel 应用程序
       -> 右击选“属性” -> 在弹出对话窗口中选“安全”选项卡->
       -> 将启动和激活权限设为自定义->点击编辑按钮->
       ->在新窗口中将Everyone用户加入,选中复选框"启动权限",给予启动权限

     II.如果是WindowXP ->控制面版 -> 管理工具 -> 组件服务(繁体为"元件服务") ->
       打开树级目录找到子目录DCOM配置 -> Microsoft Excel 应用程序
       -> 右击选“属性” -> 在弹出对话窗口中选“安全”选项卡->
       -> 将启动和激活权限设为自定义->点击编辑按钮->
       ->在新窗口中将Everyone用户加入,选中复选框"远程启动",给予远程启动权限
(四).使用Excel模板
       虽然Com组件功能已经比较全面，可以对任意一个单元格设置和赋值.但是如果数据集DataSet比

   较复杂的话，全部用Com提供的方法实现就很麻烦了. 尤其是文档头和尾最难处理.
    这时可以这样处理:
    a.先用Excel应用程序建立一个Excel文件，设置好头/尾样式和以及所有单元格的布局和格式
      (这里就是作用office 家簇的 excel进行表格布局，可以任意操作)   
    b.将此文件保存到工程的一个文夹下面即可.
      用法:
      只需将2中的:
        xlBook = CType(xlApp.Workbooks.Add, Excel.Workbook)
           改为: 
        xlBook = xlApp.Workbooks.Add(page.MapPath(".") + "ExcelTemplate.xls")'使用現有模板
      即可。 这样xlBook实际上是基于自己创建的模板的.
    这样操作，一般表头和标题列，表尾列一般不用设置，只显示DataSet中的主要数据(甚至也不用显

   示DataSet列名)

    最近给客户做一些Excel报表,我们是这样做的，直接把客户给的Excel需求文件作为了模板.
    非常简便，更爽的是这样做报表跟客户要求的完全相同。

(五).代码示例下载

   http://www.cnblogs.com/Files/ChengKing/OPExcel.rar

 此示例在配置环境:   WinXP(繁体) VS.net 2002    WinXP(简体) Vs.net 2003 

                                    Win2003 VS.net 2003  测试能够正确运行!

    http://blog.csdn.net/ChengKing/archive/2005/11/27/538128.aspx     

(二)代码

   1.前台界面代码:

       <%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="数据绑定控件同时显示主表和子表数据.WebForm1" %>
<%@ Import Namespace="System.Data" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
 <HEAD>
  <title>WebForm1</title>
  <meta name="GENERATOR" Content="Microsoft Visual Studio .NET 7.1">
  <meta name="CODE_LANGUAGE" Content="C#">
  <meta name="vs_defaultClientScript" content="JavaScript">
  <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5">
 </HEAD>
 <body MS_POSITIONING="GridLayout">
  <form id="Form1" method="post" runat="server">
   <!-- 绑定主表数据 -->
   <asp:repeater id="myRepeater" runat="server">
    <HeaderTemplate>
     <table border="0" bgcolor="lightblue">
    </HeaderTemplate>
    <ItemTemplate>
     <tr>
      <td style="background-color: lightgray">
       <b>
        <%# DataBinder.Eval(Container.DataItem,"TypeID") %>
        &nbsp;
        <%# DataBinder.Eval(Container.DataItem,"TypeName") %>
       </b>
       <br>
       <!-- 绑定子表数据 -->
       <asp:repeater id="childRepeater" datasource='<%# ((DataRowView)Container.DataItem)
   .Row.GetChildRows("TypeRelation") %>' runat="server">
        <itemtemplate>
         <table border="0" bgcolor="#ffcc33">
          <tr>
           <td>
            &nbsp;&nbsp;
            <%# DataBinder.Eval(Container.DataItem,"[\"TypeID\"]") %>
            &nbsp;
            <%# DataBinder.Eval(Container.DataItem, "[\"TypeDetail\"]")%>
            <br>
           </td>
          </tr>
         </table>
        </itemtemplate>
       </asp:repeater>
      </td>
     </tr>
    </ItemTemplate>
    <FooterTemplate>
     </table>
    </FooterTemplate>
   </asp:repeater>

  </form>
 </body>
</HTML>

  2. 后代代码

 using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace 数据绑定控件同时显示主表和子表数据
{
 /// <summary>
 /// 数据绑定控件同时显示主表和子表数据
 /// </summary>
 public class WebForm1 : System.Web.UI.Page
 {
  protected System.Web.UI.WebControls.Repeater myRepeater;
  private void Page_Load(object sender, System.EventArgs e)
  {
   DataSet ds = new DataSet();
   
   //1.构造主表
   DataTable dtTypeParent=new DataTable();
   dtTypeParent.Columns.Add(new DataColumn("TypeID",typeof(int)));
   dtTypeParent.Columns.Add(new DataColumn("TypeName",typeof(string)));
   //给主表添加两条记录
   DataRow drParent1 = dtTypeParent.NewRow();
   drParent1["TypeID"] = 1; 
   drParent1["TypeName"] = "水果";   
   dtTypeParent.Rows.Add(drParent1);
   DataRow drParent2 = dtTypeParent.NewRow();
   drParent2["TypeID"] = 2; 
   drParent2["TypeName"] = "玩具";
   dtTypeParent.Rows.Add(drParent2);
   dtTypeParent.TableName="TypeParent";   
   dtTypeParent.PrimaryKey = new DataColumn[] {dtTypeParent.Columns["TypeID"]};
   ds.Tables.Add(dtTypeParent);
   
   //2.构造子表
   DataTable dtTypeChild=new DataTable();
   dtTypeChild.Columns.Add(new DataColumn("TypeID",typeof(int)));
   dtTypeChild.Columns.Add(new DataColumn("TypeDetail",typeof(string)));
   //给子表添加五条记录
   DataRow drChild1 = dtTypeChild.NewRow();
   drChild1["TypeID"] = 1; 
   drChild1["TypeDetail"] = "苹果";  
   dtTypeChild.Rows.Add(drChild1);
   DataRow drChild2 = dtTypeChild.NewRow();
   drChild2["TypeID"] = 1; 
   drChild2["TypeDetail"] = "桔子"; 
   dtTypeChild.Rows.Add(drChild2);
   DataRow drChild3 = dtTypeChild.NewRow();
   drChild3["TypeID"] = 1; 
   drChild3["TypeDetail"] = "香蕉";
   dtTypeChild.Rows.Add(drChild3);
   DataRow drChild4 = dtTypeChild.NewRow();
   drChild4["TypeID"] = 2; 
   drChild4["TypeDetail"] = "机器人";
   dtTypeChild.Rows.Add(drChild4);
   DataRow drChild5 = dtTypeChild.NewRow();
   drChild5["TypeID"] = 2; 
   drChild5["TypeDetail"] = "小汽车";
   dtTypeChild.Rows.Add(drChild5);
   dtTypeChild.TableName="TypeChild";  
   ds.Tables.Add(dtTypeChild);

   ds.Relations.Add("TypeRelation",
    ds.Tables["TypeParent"].Columns["TypeID"],
    ds.Tables["TypeChild"].Columns["TypeID"]);
   
   myRepeater.DataSource = ds.Tables["TypeParent"];
   Page.DataBind();      
  }

  #region Web 窗体设计器生成的代码
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {   
   this.Load += new System.EventHandler(this.Page_Load);
  }
  #endregion
 }
}

(三).示例下载

    http://www.cnblogs.com/Files/ChengKing/DataRalationDisplay.rar

   http://blog.csdn.net/ChengKing/archive/2005/11/20/533551.aspx

(二).代码

   1. *.aspx文件代码

         <%@ Page language="c#" Codebehind="WebForm1.aspx.cs" AutoEventWireup="false" Inherits="New_DataGrid自定义分页按钮.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
 <HEAD>
  <title>WebForm1</title>
  <meta name="GENERATOR" Content="Microsoft Visual Studio .NET 7.1">
  <meta name="CODE_LANGUAGE" Content="C#">
  <meta name="vs_defaultClientScript" content="JavaScript">
  <meta name="vs_targetSchema" content="http://schemas.microsoft.com/intellisense/ie5">
 </HEAD>
 <body MS_POSITIONING="GridLayout">
  <form id="Form1" method="post" runat="server">
   <FONT face="宋体"></FONT>
   <asp:datagrid id="DataGrid1" style="Z-INDEX: 101; LEFT: 96px; POSITION: absolute; TOP: 160px"
    runat="server" Width="768px" AllowPaging="True">
    <HeaderStyle BackColor="#999900"></HeaderStyle>
    <PagerStyle NextPageText="下一页" PrevPageText="上一页" Mode="NumericPages"></PagerStyle>
   </asp:datagrid>
  </form>
 </body>
</HTML>

 2. *.cs代码文件

    using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;

namespace New_DataGrid自定义分页按钮
{
 /// <summary>
 /// DataGrid自定义分页按钮
 /// </summary>
 public class WebForm1 : System.Web.UI.Page
 {
  protected System.Web.UI.WebControls.DataGrid DataGrid1;  
    
   
  private void Page_Load(object sender, System.EventArgs e)
  {   
   if(!Page.IsPostBack)
   {
    GetData();        // 生成数据
    this.BindData();  // 绑定数据到DataGrid    
   }     
  }

  /// <summary>
  /// 生成数据
  /// </summary>
  private void GetData()
  {
   DataTable table = new DataTable();
   DataColumnCollection columns = table.Columns;

   //定义结构
   columns.Add("学号",typeof(System.Int32));
   columns.Add("分数",typeof(System.Int32));  
   
   Random myRandom = new Random();
   int intScore = 0;
   for(int i = 1;i < 101; i++)
   {               
    intScore = myRandom.Next(100);
    DataRow drNew = table.NewRow();
    drNew[0] = i.ToString();
    drNew[1] = intScore.ToString();
    table.Rows.Add(drNew);
   }
   this.ViewState.Add("table",table);   
  }

  /// <summary>
  /// 绑定DataGrid
  /// </summary>
  private void BindData()
  {   
   DataTable table = (DataTable)this.ViewState["table"];
   this.DataGrid1.DataSource = table;
   this.DataGrid1.DataBind();
  }  
  

  #region Web 窗体设计器生成的代码
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {   
   this.DataGrid1.PageIndexChanged += new System.Web.UI.WebControls.DataGridPageChangedEventHandler(this.DataGrid1_PageIndexChanged);
   this.Load += new System.EventHandler(this.Page_Load);
   this.DataGrid1.ItemCreated +=new DataGridItemEventHandler(DataGrid1_ItemCreated);

  }
  #endregion

  private void DataGrid1_PageIndexChanged(object source, System.Web.UI.WebControls.DataGridPageChangedEventArgs e)
  {
   try
   {
    this.DataGrid1.CurrentPageIndex = e.NewPageIndex;
   }
   catch
   {
    this.DataGrid1.CurrentPageIndex = 0;
   }
   this.BindData();
  }

  private void DataGrid1_ItemCreated(object sender, DataGridItemEventArgs e)
  {
   System.Web.UI.WebControls.ListItemType elemType = e.Item.ItemType;
   if (elemType == System.Web.UI.WebControls.ListItemType.Pager)
   {
    TableCell pager = (TableCell) e.Item.Controls[0];
    for (int i=0; i<pager.Controls.Count; i+=2)
    {
     Object o = pager.Controls[i];
     if (o is LinkButton)
     {
      LinkButton h = (LinkButton) o;
      h.Text = " " + h.Text + " ";
     }
     else
     {
      Label l = (Label) o;
      l.Text = String.Format("<font color='red'>[第{0}页]</font>", l.Text);
     }
    }
   }
  }
 }
  
}

(三).源代码下载(创建虚拟目录后就可以直接运行)

    http://www.cnblogs.com/Files/ChengKing/自定义分页example.rar

2.使用接口可以使继承它的类: 命名统一/规范,易于维护.比如:  两个类 "狗"和"猫",如果它
们都继承了接口"动物",其中动物里面有个方法Behavior(),那么狗和猫必须得实现Behavior()方法，
并且都命名为Behavior这样就不会出现命名太杂乱的现象.如果命名不是Behavior()，接口会约束
即不按接口约束命名编译不会通过.

3.提供永远的接口。 当类增加时，现有接口方法能够满足继承类中的大多数方法，没必要
  重新给新类设计一组方法，也节省了代码，提高了开发效率.
  举个代码示例:
 
  //公共接口: "动物"
  public Interface IAnimal
  {
      int EyeNumber;
      private void Behavior();  //行为方法，描述各种动物的特性
  }

  //类: 狗
  public Dog : IAnimal
  {
      string ActiveTime = "白天";
      private void Behavior()
      {               {
         Console.Write("我晚上睡觉,白天活动");
      }
  }

  //类: 猫
  public Cat: IAnimal
  {
      string ActiveTime = "夜晚";
      private void Behavior()
      {               {
         Console.Write("我白天睡觉,晚上活动");
      }
  }

  //简单的应用:
  public static Main()
  {
      Dog myDog = new Dog();
      myDog.Behavior();   //输出: "我晚上睡觉,白天活动"
      Cat myCat = new Cat();
      myCat.Behavior();   //输出: "我白天睡觉,晚上活动"
  }
  以上调用不同的类的相同名方法，会输出不同的东东，也就是说每个类里面的同名方法完成的
  功能可以是完全不同的.

  更进一步，不是用上面Main方法这样一个一个调用类的方法，用多态性实现其调用.
  看一下下面这个方法:
  public Behavior(IAnimal myIanimal)
  {
      myIanimal.Behavior();
  }

  其参数是<<接口类型>>，任何继承它的类都可以调用此方法，此方法能根据类的不同调用不同的类
  中的方法. 也即能够自己根据不同的类，完成不同的类的功能.
  多态性代码示例: 
  Dog myDog = new Dog();
  Cat myCat = new Cat();
  Behavior(myDog);  //Behavior接受“狗”类实例
  Behavior(myCat);  //Behavior接受“狗”类实例

  这样Behavior方法写一次就能完成所有继承它的类中的相同名方法的不同功能. 非常方便，

  同样，由于“动物软件”功能需求，需要再增加一个"龟"类:
  //类: 龟
  public Tortoise: IAnimal
  {
      string ActiveTime = "很难说";
      private void Behavior()
      {               {
         Console.Write("我可以不活动，一睡就睡五千年!");
      }
  }
  那么也可以调用上面多态方法，所以说接口使方法具有较好扩展性.
  如果继承它的类很多的话，有多少好处是可想而知的!

  上面是个人对接口某些方面的一些认识,当然接口的作用不只是这些.
  不对的地方请读者批评指正!
 
 

        一般情况下,使用DataGrid自带的翻页按钮就能够实现所有翻页操作了，但有时候想定制自己的翻页样式

    或美化其显示效果，这时可以自已写个翻页用户控件.

(二).显示效果载图

    http://blog.csdn.net/ChengKing/archive/2005/11/20/533539.aspx

  (三)代码

   1.*.aspx代码文件:

    <%@ Page language="c#" Codebehind="DGCustomerPagination.aspx.cs" AutoEventWireup="false" Inherits="New_DataGrid自定义分页事件.WebForm1" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" >
<HTML>
  <HEAD>
  <title>WebForm1</title>
  <meta content="Microsoft Visual Studio .NET 7.1" name="GENERATOR">
  <meta content="C#" name="CODE_LANGUAGE">
  <meta content="JavaScript" name="vs_defaultClientScript">
  <meta content="http://schemas.microsoft.com/intellisense/ie5" name="vs_targetSchema">
  </HEAD>
 <body MS_POSITIONING="GridLayout">
  <form id="Form1" method="post" runat="server">
   <asp:datagrid id="DataGrid1" style="Z-INDEX: 101; LEFT: 96px; POSITION: absolute; TOP: 160px"
    runat="server" Width="768px" AllowPaging="True">
    <HeaderStyle BackColor="#999900"></HeaderStyle>
    <PagerStyle NextPageText="下一页" PrevPageText="上一页" Mode="NumericPages"></PagerStyle>
   </asp:datagrid><asp:linkbutton id="lbLastPage" style="Z-INDEX: 105; LEFT: 808px; POSITION: absolute; TOP: 120px"
    onclick="ChangePageClick" runat="server" CommandArgument="last">最后页</asp:linkbutton><asp:linkbutton id="lbNextPage" style="Z-INDEX: 104; LEFT: 744px; POSITION: absolute; TOP: 120px"
    onclick="ChangePageClick" runat="server" CommandArgument="next">下一页</asp:linkbutton><asp:linkbutton id="lbPrevPage" style="Z-INDEX: 103; LEFT: 680px; POSITION: absolute; TOP: 120px"
    onclick="ChangePageClick" runat="server" CommandArgument="prev">上一页</asp:linkbutton><asp:linkbutton id="lbFirstPage" style="Z-INDEX: 102; LEFT: 616px; POSITION: absolute; TOP: 120px"
    onclick="ChangePageClick" runat="server" CommandArgument="first">最前页</asp:linkbutton>
   <asp:Label id="lblDisplayPosition" style="Z-INDEX: 106; LEFT: 240px; POSITION: absolute; TOP: 120px"
    runat="server" Width="64px"></asp:Label>
   <asp:TextBox id="txtSelectPage" style="Z-INDEX: 107; LEFT: 360px; POSITION: absolute; TOP: 120px"
    runat="server" Width="104px"></asp:TextBox>
   <asp:Button id="btnSelectPage" style="Z-INDEX: 108; LEFT: 472px; POSITION: absolute; TOP: 120px"
    runat="server" Text="确定"></asp:Button>
   <asp:Label id="lblError" style="Z-INDEX: 109; LEFT: 520px; POSITION: absolute; TOP: 120px"
    runat="server" Width="88px">Label</asp:Label>
   <asp:Label id="lbTotal" style="Z-INDEX: 110; LEFT: 104px; POSITION: absolute; TOP: 120px" runat="server"
    Width="136px"></asp:Label></form>
 </body>
</HTML>

  2.*.aspx.cs代码文件

      using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;

namespace New_DataGrid自定义分页事件
{
 /// <summary>
 /// DataGrid自定义分页
 /// </summary>
 public class WebForm1 : System.Web.UI.Page
 {
  protected System.Web.UI.WebControls.DataGrid DataGrid1;
  protected System.Web.UI.WebControls.LinkButton lbLastPage;
  protected System.Web.UI.WebControls.LinkButton lbNextPage;
  protected System.Web.UI.WebControls.LinkButton lbPrevPage;
  protected System.Web.UI.WebControls.LinkButton lbFirstPage;
  protected System.Web.UI.WebControls.Label lblDisplayPosition;
  protected System.Web.UI.WebControls.Button btnSelectPage;
  protected System.Web.UI.WebControls.TextBox txtSelectPage;
  protected System.Web.UI.WebControls.Label lblError;
  protected System.Web.UI.WebControls.Button Button1;
  
  protected System.Web.UI.WebControls.Label lbTotal;  //显示记录总数
  private static int intRecord = 0;   //显示总记录数
   
  private void Page_Load(object sender, System.EventArgs e)
  {
   this.lblError.Text = "";   
   if(!Page.IsPostBack)
   {
    GetData();  // 生成数据
    this.BindData();  //绑定数据到DataGrid
    DisPlayStats();   //显示这样的表示: 2/100  意思是:共100页，当前为第二页
   }     
  }

  /// <summary>
  /// 生成数据
  /// </summary>
  private void GetData()
  {
   DataTable table = new DataTable();
   DataColumnCollection columns = table.Columns;

   //定义结构
   columns.Add("学号",typeof(System.Int32));
   columns.Add("分数",typeof(System.Int32));   
   
   Random myRandom = new Random();
   int intScore = 0;
   for(int i = 1;i < 101; i++)
   {               
    intScore = myRandom.Next(100);
    DataRow drNew = table.NewRow();
    drNew[0] = i.ToString();
    drNew[1] = intScore.ToString();
    table.Rows.Add(drNew);
   }
   this.ViewState.Add("table",table);

   intRecord = table.Rows.Count;
   this.lbTotal.Text = "总共:"+intRecord.ToString()+"条记录";
  }

  /// <summary>
  /// 绑定DataGrid
  /// </summary>
  private void BindData()
  {   
   DataTable table = (DataTable)this.ViewState["table"];
   this.DataGrid1.DataSource = table;
   this.DataGrid1.DataBind();

  }

  /// <summary>
  /// 自定义控件按钮事件
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  public void ChangePageClick(object sender, EventArgs e)
  {
   string CommandName = ((LinkButton)sender).CommandArgument.ToString();
   switch(CommandName)
   {
    case "next":
     if (DataGrid1.CurrentPageIndex < DataGrid1.PageCount - 1 )
     {
      DataGrid1.CurrentPageIndex += 1;
     }
     break;
    case "prev":
     if (DataGrid1.CurrentPageIndex > 0)
     {
      DataGrid1.CurrentPageIndex -= 1;
     }
     break;
    case "last":
     DataGrid1.CurrentPageIndex = (DataGrid1.PageCount - 1);
     break;
    default:
     DataGrid1.CurrentPageIndex = 0;
     break;
   }   
   DisPlayStats();
  }

  public void DisPlayStats()
  {
   this.lblDisplayPosition.Text = (DataGrid1.CurrentPageIndex + 1).ToString() + "/";
   this.lblDisplayPosition.Text += DataGrid1.PageCount.ToString();
   this.txtSelectPage.Text = (DataGrid1.CurrentPageIndex + 1).ToString();
  }

  #region Web 窗体设计器生成的代码
  override protected void OnInit(EventArgs e)
  {
   //
   // CODEGEN: 该调用是 ASP.NET Web 窗体设计器所必需的。
   //
   InitializeComponent();
   base.OnInit(e);
  }
  
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {   
   this.DataGrid1.PageIndexChanged += new System.Web.UI.WebControls.DataGridPageChangedEventHandler(this.DataGrid1_PageIndexChanged);
   this.btnSelectPage.Click += new System.EventHandler(this.btnSelectPage_Click);
   this.Load += new System.EventHandler(this.Page_Load);

  }
  #endregion

  private void DataGrid1_PageIndexChanged(object source, System.Web.UI.WebControls.DataGridPageChangedEventArgs e)
  {
   try
   {
    this.DataGrid1.CurrentPageIndex = e.NewPageIndex;
   }
   catch
   {
    this.DataGrid1.CurrentPageIndex = 0;
   }
   this.BindData();
  }

  private void btnSelectPage_Click(object sender, System.EventArgs e)
  {
   int intPage = 0;
   try
   {
    intPage = int.Parse(this.txtSelectPage.Text);
   }
   catch
   {
    this.lblError.Text = "只能输入数字!";    
    return;
   }

   try
   {
    this.DataGrid1.CurrentPageIndex = intPage-1;
    this.BindData();
   }
   catch
   {
    this.DataGrid1.CurrentPageIndex = 0;
    this.BindData();
                this.lblError.Text = "超出页码范围!";    
   }
    
   DisPlayStats();
  }
 }
}

(四).示例源代码下载(可以直接运行)

    http://www.cnblogs.com/Files/ChengKing/自定义分页example.rar

1. 使用起来也相当方便,举个简单的例子,例如Button的生成:
Html控件是将庞大控件集合全部弄到页面中，用到哪个功能，就设置一下属性,如下:
<input type=submit/button runat=server>  
这样会占用相当大的控件资源

Web控件是将集成式的拆解成单功能的：
<asp:button id="btnOK" />
这样就可以节省不必要的控件所占用的资源了

2.Web控件具有回送功能,能够用ViewState维持控件的状态.
  Html控件则不能,当点击页面的操作，其状态就会丢失.
  可以做这样的一个实验:
  I. 分别建立两个文件:  a.html  b.aspx
  II.在a.html页面中加Html控件的RadioButton和一个button，
     在b.aspx中加Web控件的RadioButton和一个button
  III.a.html直接双击浏览器运行,b.aspx通过IIS运行
  IV.在a.html运行界面中，选中RadioButton,再单击Button按钮，会发现RadioButton会
   取消选中(丢失其状态),但在b.aspx页面执行同样的操作，RadioButton不会丢失，因为ViewState
   给它保存了状态. 您可以在运行界面点击浏览器菜单"查看"->“源文件",打开Html代码文件，
   找到加密后的ViewState,类似于下面:
   <input type="hidden" name="_VIEWSTATE" value="dDw0ajfmafmjfzzmj4"/> 
   其实ViewState实现原理也是将一些信息放到隐藏的一个控件中，并且asp.net生成的ViewState信息

   是存储在客户端的  
   这里要注意的一点是：
       只有当格式为*.aspx文件，并且控件具有属性:"runat=server"时，回送功能才能打开
    

3. Html控件与Web控件最大的区别是它们对事件处理的方法不同。对于Html窗体控件，
当引发一个事件时，浏览器会处理它。但对于Web控件，事件仅由浏览器生成，但浏览
器不会处理它，客户端要给服务器发个信息，告诉服务器处理事件。 不过有些事件，
比如:
  按下键/移动/鼠标等事件，Asp.net中没有这些事件
  (因为这些事件即时性强，服务器处理得不够及时)，这时候Html控件就发挥其作用了，结合Html事件

  协助完成.

如下是一些Html常用的事件:
在浏览器上执行的Html控件事件:

单击时触发:
<INPUT type="button" value="Click Me" onclick="alert('Hi,你好!');">

鼠标弹起时触发:
<INPUT type="button" value="Click Me" onmouseup="alert('Hi,你好!');">

//悬浮在控件上方时触发
<INPUT type="button" value="Click Me" onmouseover="alert('Hi,你好!');">

//鼠标在控件上方移动时触发
<INPUT type="button" value="Click Me" onmousemove="alert('Hi,你好!');">

//双击控件时触发
<INPUT type="button" value="Click Me" ondblclick="alert('Hi,你好!');">

//当焦点在控件时，按键时触发
<INPUT type="button" value="Click Me" onkeypress="alert('Hi,你好!');">

//按键按下时触发
<INPUT type="button" value="Click Me" onkeydown="alert('Hi,你好!');">

  public Form1()
  {   
   InitializeComponent();
  }  
  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if (components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

  #region Windows 窗体设计器生成的代码
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {
   this.textBox1 = new System.Windows.Forms.TextBox();
   this.label1 = new System.Windows.Forms.Label();
   this.button1 = new System.Windows.Forms.Button();
   this.SuspendLayout();
   //
   // textBox1
   //
   this.textBox1.Location = new System.Drawing.Point(40, 88);
   this.textBox1.Multiline = true;
   this.textBox1.Name = "textBox1";
   this.textBox1.Size = new System.Drawing.Size(336, 176);
   this.textBox1.TabIndex = 0;
   this.textBox1.Text = "";
   //
   // label1
   //
   this.label1.Location = new System.Drawing.Point(40, 32);
   this.label1.Name = "label1";
   this.label1.TabIndex = 1;
   this.label1.Text = "请输入信息:";
   //
   // button1
   //
   this.button1.Location = new System.Drawing.Point(296, 32);
   this.button1.Name = "button1";
   this.button1.TabIndex = 2;
   this.button1.Text = "发送";
   this.button1.Click += new System.EventHandler(this.button1_Click);
   //
   // Form1
   //
   this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
   this.ClientSize = new System.Drawing.Size(416, 302);
   this.Controls.Add(this.button1);
   this.Controls.Add(this.label1);
   this.Controls.Add(this.textBox1);
   this.Name = "Form1";
   this.Text = "发送信息";
   this.Load += new System.EventHandler(this.Form1_Load);
   this.ResumeLayout(false);

  }
  #endregion
  
  [STAThread]
  static void Main()
  {
   Application.Run(new Form1());   
  }
  
  private void Form1_Load(object sender, System.EventArgs e)
  {
      //载入信道，用于侦听客户端请求，配置文件记载客户端地址等信息.
   System.Runtime.Remoting.RemotingConfiguration.Configure("Simpleclient.exe.config");   
  }

  private void button1_Click(object sender, System.EventArgs e)
  {
   //开始调用远程对象(发送信息)
   RemoteObjects.RemoteObject.Method(this.textBox1.Text);
  }
  }
    }
3.客户端工程SimpleClient项目中的SimpleClient.exe.config:
   <?xml version="1.0" encoding="utf-8" ?>
   <configuration>
 <system.runtime.remoting>
  <application name="simpleclient">
   <!-- 指定请求的服务端地址和端口号-->
   <!-- url中的:localhost是测试的本机，可以使用Intenet上的其它机器名或ip地址-->
   <client url="tcp://localhost:8080/simpleserver">
    <activated type="RemoteObjects.RemoteObject,RemoteObjects">
    </activated>
   </client>
   <channels>
     <!-- 指定信道,有两种信道可选:Tcp(基于TCP协议)和Http(无连续连接协议)信道-->
    <channel ref="tcp client"/>  
   </channels>
  </application>
 </system.runtime.remoting>
    </configuration>
4.服务端工程SimpleServer项目中的Form1.cs:
   using System;
   using System.Drawing;
   using System.Collections;
   using System.ComponentModel;
   using System.Windows.Forms;
   using System.Data;
   using System.Runtime.Remoting;

   namespace SimpleServer
   {
 /// <summary>
 /// Form1 的摘要说明。
 /// </summary>
 public class Form1 : System.Windows.Forms.Form
 {
  /// <summary>
  /// 必需的设计器变量。
  /// </summary>
  private System.ComponentModel.Container components = null;

  public Form1()
  {
   //
   // Windows 窗体设计器支持所必需的
   //
   InitializeComponent();

   //
   // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
   //
  }

  /// <summary>
  /// 清理所有正在使用的资源。
  /// </summary>
  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if (components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

  #region Windows 窗体设计器生成的代码
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {
   //
   // Form1
   //
   this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
   this.ClientSize = new System.Drawing.Size(292, 266);
   this.Name = "Form1";
   this.Text = "Form1";
   this.Load += new System.EventHandler(this.Form1_Load);

  }
  #endregion

  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main()
  {
   //Application.Run(new Form1());   
   Run();
  }

  private static void Run()
  {
   System.Runtime.Remoting.RemotingConfiguration.Configure("SimpleServer.exe.config");
  }

  private void Form1_Load(object sender, System.EventArgs e)
  {
   
  }
   }
    }
5.服务端工程SimpleServer项目中的SimpleServer.exe.config:
  <?xml version="1.0" encoding="utf-8" ?>
  <configuration>
 <system.runtime.remoting>
  <application name="simpleserver">
   <service>
    <activated type="RemoteObjects.RemoteObject,RemoteObjects">
    </activated>
   </service>
   <channels>
    <channel ref="tcp server" port="8080" />
   </channels>
  </application>
 </system.runtime.remoting>
  </configuration>
(四).注意点
   1.由于配置文件默认是添加在根目录下的，要把两个配置文件拷贝到:根目录/bin/debug下面,要让它与执行文件在同一个目录下面。
   2.右击RemoteObject项目，选“常规”下的，输入类型为：“类库”.  它默认为应用程序，这里作为类库使用. 
     设置好后，按: Ctrl+Shift+B生成类库Dll.
   3.在工程SimpleServer和SimpleClient中分别添加引用： 即将RemoteObject项目刚生成的DLL: RemoteObjects.dll添加到各自的工程中.
     具体方法：右击“引用“->”添加引用“->"浏览"，找到生成的RemoteObjects.dll分别添加进来.
   4.右击解决方案，选择“属性”-> “选中多启动项目单选框”->"选SimpleServer和SimpleClient同时启动".
     因为： 当服务端宿主程序运行时，客户端才能正确调用远程对象.
   5.按F5运行.  输入信息，点“发送”按钮，就可以调用远程对象了.
(五).扩展
     可以修改客户端配置文件:<client url="tcp://localhost:8080/simpleserver">  中的localhost为其它的机器名称，只要另一台
     机器运行了宿主程序,并处于运行状态. 那么当调用时，会在服务端弹出信息，即实现了发送信息功能.

以上代码已经测试，不正确的地方望批评指正!

(一).XML WebService作用
  XML WebService在应用程序中所起的作用与.Net远程调用处理组件相同.
  用户不能直接使用WebService,只能通过Asp.net Web应用程序或Windows桌面
  客户端来调用.
(二).XML WebService与.Net远程处理区别
  1. XML WebService比.Net远程处理对象所受的限制更多。它类似于.Net远程处理
     的单独调用对象的工作机制。 不能创建一个单独的或是由客户端激活的对象.
  2.XML WebService的创建和设计比远程组件更容易/简单.
  3.Net远程处理二进制通信要比XML WebService SOAP格式通信要快捷.
  4.XML WebService较.Net远程处理扩展性强。 它支持以跨平台使用为目的的开放标准.
  5.XML WebService不需要专门的宿主程序，而是由Asp.net承载。 可以访问一些重要的
    平台服务，如：数据缓存/网络会话状态管理/身份验证/全局共享应用程序集合等。而.Net
    远程处理则很难实现这些功能.
  6.XML WebService运行在IIS和ASP.NET之上，使用http信道(80端口)与客户通信。
    可以自由跨越防火墙.
(三).XML WebService创建与调用过程
  I.服务端创建
     1.使用IIS，在Web服务器上新建一个虚拟目录来存放XML Web服务.
     2.建立XML WebService类，使用[WebMethod]属性来标记方法可以被远程调用.
     3.在虚拟目录中部署XML Web服务的文件.
  II.客户端使用
     1.客户端通过URL或文件查询或UDDI注册，发现XML WebService
     2.客户端请求描述XML WebService的WSDL文档。
     3.客户端在WSDL文档的基础上生成一个代理类。
     4.客户端生成代理类的实例，并调用XML Webservice，发送消息并接受处理后结果.
       也就是说调用XML WebService是由客户端生成的代理类实例对象完成的.
(四).IIS作用
  1.IIS通过虚拟目录提供对Web服务器进行访问。简单的说： 就是将"c:\MyWeb"映射
    一个URL地址形式的虚拟目录:"http://192.168.83.66/MyWeb",供本机或Internet
    上计算机访问Webservice.
  2.虚拟目录的权限与普通目录不同。根据默认设置，不允许远程用户浏览虚拟目录，运行
    可执行文件，新建文件和下载某些文件类型文件。可以根据需要自定义IIS虚拟目录权限设置.
  3.IIS对Internet进行公开处理. IIS并不负责运行Asp或Asp.net布面 或XML Webservice,而是
    维护一个注册的文件扩展名列表。如果IIS收到对某一种文件类型的请求，就把工作提交给
    Asp.net工作进程，由Asp.net工作进程处理剩下的工作.
(五).XML WebService和SOAP标准支持的数据类型
  不知道读者有没有遇到这种情况，在调用WebService并给一个方法传递了一个DataRow参数时，运行
  时会抛出异常： "没法将参数序列化！"，如果把DataRow加入到DataSet中，并将DataSet作为参数
  传递再运行就OK了。 这是因为：XML WebService只能对数据集DataSet对象类型进行XML序列化，
  不能对DataRow对象类型进行XML序列化造成的错误.  所以了解一下XML WebService支持序列化的基
  本数据类型是比较重要的.它支持的数据类型如下:
  1.基本数据类型. 
      标准类型，如：int float bool DateTime string等基本数据类型
  2.枚举.
      支持枚举Enum定义的类型
  3.自定义对象.
      可以传递任意基于自定义类或结构创建的对象。 但要注意一点： 它只能传输数据成员(变量和属性).
      如果定义了方法，则方法不能进行序列化传输,序列化后只剩下数据成员.
  4.DataSet对象
      支持DataSet,切记：不支持DataTable和DataRow,DataSet已经是XML Webservice能够支持的最小的可序列化对象.
  5.XmlNode对象
      基于XmlNode的对象可以表示XML文档的一部分.
  6.数组和集合
      可以使用任何被支持的类型的数组和简单集合，包括: DataSet对象/XmlNode对象和自定义对象.

另外，关于创建XML WebService实例代码示例，几乎任何一本涉及到WebService的书籍都会讲的。而且创建一个
WebService非常简单. 这里就不多说了.

哦,已经: 00:43点了，该睡觉了.  :)
 
 
 

    Windows Registry Editor Version 5.00
    [HKEY_LOCAL_MACHINE\SOFTWARE\Test]
    "server"="192.168.66.22"
    "database"="NorthWind"
    "user"="XiaoWang"
    "Password"="123456"
    其中:
     I.
       [HKEY_LOCAL_MACHINE\SOFTWARE\Test] : 表示路径,如果路径不存在，系统会自动创建路径
     II.
       "server"="192.168.66.22"
       "database"="NorthWind"
       "user"="XiaoWang"
       "Password"="123456"
        表示: 键和值，左边是键，右边是键的值。 在读取时根据键读取.      
    2.双击运行即可。 它会自动将键值放到配置好的路径下面.

(二) 读取
   打开命名空间:   using Microsoft.Win32;
   1.方法
     //参数1表示路径. 如: HKEY_LOCAL_MACHINE\SOFTWARE
     //参数2表示键.  自定义的
     public static object GetRegValue(string strRegPath,string strName)
  {
   strRegPath = strRegPath.Trim();
   //接收值的对象  
                 object objRet;

   // 如果名称为空，则抛出一个参数为空的异常。   
                        if (strName == "")
   {
    throw new ArgumentNullException(strName,"键值不能为空!");
   }       

   //去除"\"字符
   if ( strRegPath.StartsWith("\\") )
   {
    strRegPath = strRegPath.Substring(1,strRegPath.Length - 1);
   }
   if ( strRegPath.EndsWith("\\") )
   {
    strRegPath = strRegPath.Substring(0,strRegPath.Length - 1);
   }

   //拆分根键和路径   
                        string strRootKey,strPath;
   int intIndex = strRegPath.IndexOf("\\");

   strRootKey = strRegPath.Substring(0,intLoc).ToUpper();

   strPath = strRegPath.Substring(intIndex  + 1,strRegPath.Length - intIndex - 1);
   RegistryKey _root;
   switch( strRootKey )
   {
    case "HKEY_CLASSES_ROOT":
     _root = Registry.ClassesRoot;
     break;
    case "HKEY_CURRENT_CONFIG":
     _root = Registry.CurrentConfig;
     break;
    case "HKEY_CURRENT_USER":
     _root = Registry.CurrentUser;
     break;
    case "HKEY_DYN_DATA":
     _root = Registry.DynData;
     break;
    case "HKEY_LOCAL_MACHINE":
     _root = Registry.LocalMachine;
     break;
    case "HKEY_PERFORMANCE_DATA":
     _root = Registry.PerformanceData;
     break;
    case "HKEY_USERS":
     _root = Registry.Users;
     break;
    default:
     throw new Exception("找不到路径!");
   }

   try
   {
    //打开注册表路径的键    
                                RegistryKey regKey = _root.OpenSubKey(@strPath);
    //取值 
                objRet = regKey.GetValue(strName);
   }
   catch(Exception e)
   {
    throw e;
   }

   return objRet;
  }

    2.用法:
         string strConnectString = GetRegValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\Test","strConnString").ToString();

  分为页面级别调试和应用程序级别跟踪调试:
     1.页级别跟踪: 在页的开头包括如下的页指令<%@ Page Trace="True"   TraceMode="SortByCategory/SortByTime" %>
       I.自定义消息示例:
         Trace.Write("这里为要输出结果的变量或自定义字符串");
         Trace.Warn("这里为要显示的字符串");   //与Trace.Write相同,只是字体为红色
                检查是否使用了跟踪
      
       II.判断是否启用了跟踪输出:       
          if(Trace.IsEnabled) { Trace.Warn("已启用跟踪")} 

     2.应用程序级别跟踪:
       在Web.config文件的<System.Web>节中 <trace enabled="true" pageOutput="true"/>
       这样就不用在一个一个页面中设置了.

用Trace跟踪调试最大的好处是：  程序员用完后只要将 页面或应用程序跟踪设为:false即可.

不用将其删除或注释. 因为编译器编译到Trace输出
语句时，不会将其编译，会略过Trace语句继续编译下面的语句。 

 从程序员角度看,即Trace相当于已经注释掉了

      3.尽量少用:
        try
        {}
        catch
        {}
        finally
        {}
        语句.此语句执行效率比较低.

     
(六).ADO.Net使用方面优化
     1.数据库连接打开和关闭。  在需要连接时打开，当访问完数据库要立刻关闭连接.
       举例说明,还是看两个代码段:
 
        I.
           DataSet ds = new DataSet();
           SqlConnection MyConnection = new SqlConnection("server=localhost; uid=sa; pwd=; database=NorthWind");
           SqlCommand myCommand = new SqlCommand(strSql,MyConnection);  
           SqlDataAdapter myAdapter=new SqlDataAdapter(queryStr,connectionStr);
        MyConnection.Open();      //打开连接
         for(int i=0;i<1000;i++)   //for循环模拟取得数据前的商业逻辑操作
         {
            Thread.Sleep(1000);
       }
       myAdapter.Fill(ds);
        for(int i=0;i<1000;i++)   //for循环模拟取得数据后的商业逻辑操作
        {
           Thread.Sleep(1000);
        }
        MyConnection.Close();     //关闭连接
        II.
           DataSet ds = new DataSet();
           SqlConnection MyConnection = new SqlConnection("server=localhost; uid=sa; pwd=; database=NorthWind");
           SqlCommand myCommand = new SqlCommand(strSql,MyConnection);  
           SqlDataAdapter myAdapter=new SqlDataAdapter(queryStr,connectionStr);       
         for(int i=0;i<1000;i++)   //for循环模拟取得数据前的商业逻辑操作
         {
            Thread.Sleep(1000);
       }
       MyConnection.Open();      //打开连接
           myAdapter.Fill(ds);
          MyConnection.Close();     //关闭连接
        for(int i=0;i<1000;i++)   ////for循环模拟取得数据后的商业逻辑操作
        {
           Thread.Sleep(1000);
        }
         显示II代码比I代码好的多，I中早早占着连接不放，如果用户很多的话，容易出现连接池满情况。严重时出现死机现象.
       2.数据库查询
          I.  直接生成SQL语句。 Sql Server每次都要对其进行编译，在性能方面不会有很大的提高。 另外也不够安全。容易被攻击.
          II. 使用带参数的SQL命令。这种方式Sql Server只对其编译一次，对于不同的参数可以重复使用编译后的命令。提高了性能.
          III.使用Sql Server存储过程. 编译一次. 具有独立性，便于修改和维护.  一次能完成用语句发送多次的功能.减少了网络的
              流量。  并不一定存储过程一定比语句效率要高，如果商业逻辑很复杂的话，有时候用语句比存储过程效率要高.
(六).缓存优化
     缓存分为两种： 页面缓存和API缓存.
    1.使用页面缓存和片段缓存 
        <%@ OutputCache Duration="5" VaryByParam="None"%> 
        <%@ OutputCache Duration=60 VaryByParam=”TextBox1,TextBox2” %>
      说明: Duration是设置Cache的过期时间;
          VarByParam是设置是否根据参数而变化,None时所有参数使用同一Cache, 
          设置TextBox1时则根据TextBox1的不同值分别缓存;当有多个参数时则要组合缓存;
    2.API缓存。用于在应用程序中使用
       I. 一个Cache使用的例子:
           http://blog.csdn.net/chengking/archive/2005/10/03/494545.aspx
       II.使用时注意Page.Cache和HttpContext.Current.Cache区别:
          它们指的同一个对象，在Page里，用Page.Cache，如果在global.asax或自己的类里用:HttpContext.Current.Cache
          在有些事件中，由于其没有HttpContext，就用HttpRuntime.Cache.

不对的地方请读者批评指正!

  1.打开命名空间:
    using System.Web.Security;

  2.在用户注册界面,简要代码:   
    Regist(UserID.Text,FormsAuthentication.HashPasswordForStoringInConfigFile(Password.Text,"MD5"));       //其中: "MD5",可以替换为:"SHA1",用另一种加密方式

    其中: UserID.Text表示用户ID，即注册登录帐号;  Password.Text表示注册密码
          Regist实现将账号和加密后的密码字符串存储到数据库中.   

  3.在登录界面,简要代码:

    Check(UserID.Text,FormsAuthentication.HashPasswordForStoringInConfigFile(Password.Text,"MD5"));    //其中: "MD5",可以替换为:"SHA1",用另一种加密方式
    其中: UserID.Text表示注册成功用户ID，即已经存在的登录帐号;  Password.Text表示登录用户的密码
          Regist实现用户输入的账号和加密后的密码 与数据库中的帐号密码是否匹配.
        
        数据库其实只是存储了加密后的字符串而已。 除了密码加密，还可以对“提示问题”“提示问题答案”等其它存储，
    实现原理是一样的.

(二).跨语言字符串替换
    System.Text.RegularExpressions.Regex.Replace(str1,@"<{1}[^<>]*>{1}","").Replace("&nbsp;","").Replace("&#092;","\\").Replace("&#045;","-").Replace("&amp;","&").Replace("&lt;","<").Replace("&gt;",">").Replace("br","\n");

(三).关闭窗体
   1.
      this.btnClose.Attributes.Add("onclick",  "window.close();return false;");
   2.关闭本窗体间跳转到另一个页面
      this.HyperLink1.NavigateUrl = "javascript:onclick=window.opener.location.assign
         ('" + "index.aspx"+ "?&Func=Edit&AutoID=" + intAutoid + ');window.close();";
   3.关闭父窗体:
      <INPUT type="reset" value='<%=this._Cancel%>' onclick="window.parent.close()"  Class="Button">

(四).Web MessageBox  
   1.
      Response.Write("<script language=javascript> window.alert('保存成功1');</script>");
   2.
      Response.Write("<script>alert('"+"保存成功!"+"');</script>");
   3.
      this.Page.RegisterStartupScript("ChiName","<script language='javascript'>alert('" + "保存成功!" + "')</script>");

(五).DataGrid中加CheckBox控件模板列.
   请看:  http://blog.csdn.net/chengking/archive/2005/10/08/497520.aspx

(六). window.open() 方法
 语法：window.open(pageurl,name,parameters);
 window对象的open()方法用于创建一个新的窗口实例，新创建的窗口的外观由参数：parameters指定。新窗口中打开的文档由参数：         pageurl指定。系统能够根据参数：name确定的名称访问该窗口。

        下表为parameters参数表：
        参数          衩始值           说明
        alwaysLowered yes/no 指定窗口隐藏在所有窗口之下。
        alwaysRaised yes/no 指定窗口浮在所有窗口之上。
        dependent yes/no 指定打开的窗口为父窗口的一个了窗口。并随父窗口的关闭而关闭。
        directions yes/no 指定Navigator 2和3的目录栏是否在新窗口中可见。
        height pixel value 设定新窗口的像素高度。
        hotkeys yes/no 在没有菜单栏的新窗口设置安全退出热键。
        innerHeight pixel value 设置新窗口中文档的像素高度。
        innerWidth pixel value 设置新窗口中文档的像素宽度。
        location yes/ no 指明位置栏在新窗口中是否可见。
        menubar yes /no 指明菜单栏在新窗口中是否可见。
        outerHeight pixel value 设定窗口（包括装饰边框）的像素高度。
        outerWidth pixel value 设定窗口（包括装饰边框）的像素宽度。
        resizable yes /no 指明新窗口是否可以调整。
        screenX pixel value 设定新窗口离屏幕边界的像素长度。
        screenY pixel value 设定新窗口离屏幕上边界的像素长度。
        scrollbars yes /no 指明滚动栏在新窗口中是否可见。
        titlebar yes /no 指明菜单题目栏在新窗口是否可见。
        toolbar yes /no 指明工具栏在新窗口中是否可见。
        Width pixel value 设定窗口的像素宽度。
        z-look yes /no 在文档中包含各个<pplet>标签的数组。
        fullscreen yes / no 打开的窗体是否进行全屏显示
        left pixel value 设定新窗口距屏幕左方的距离
        top pixel value 设定新窗口距屏幕上方的距离
 
       例子:
        <html>
           <head>
               <title>window.open函数</title>
           </head>
           <body>
              <script language="javascript">
                   <!--
                 window.open("","name1","width=100,height=200,toolbar=no,scrollbars=no,menubar=no,screenX=100,screenY=100");
                    //-->
              </script>
           </body>
        </html>

(七).location对象    
    href 整个URL字符串.
    protocol 含有URL第一部分的字符串,如http:
    host 包含有URL中主机名:端口号部分的字符串.如//www.cenpok.net/server/
    hostname 包含URL中主机名的字符串.如http://www.cenpok.net
    port 包含URL中可能存在的端口号字符串.
    pathname URL中"/"以后的部分.如~list/index.htm
    hash "#"号(CGI参数)之后的字符串.
    search "?"号(CGI参数)之后的字符串.

(八).按键捕捉
   1.Ctrl+Enter按键捕捉方法
    <body onkeydown="doKeyDown()">
    <script language="JavaScript">
    <!--
    function doKeyDown()
     {
        if (event.ctrlKey && event.keyCode == 13)
         {
           alert("You pressed the Ctrl + Enter")
         }
     }
    //-->
    </script>
    </body>
   2.Alt加快捷键: Alt+A
     <button accessKey=A title="Alt+A" onclick="alert('Button clicked!')">Alt+A</button>
(九).控制输入，非法字符不能输入到TextBox.
    <asp:textbox class="Text"
        onkeypress="if (event.keyCode < 48 || event.keyCode >57) event.returnValue = false;"
 id="txtY_Revenue" style="TEXT-ALIGN: right" runat="server" Width="90%" MaxLength="12">
    </asp:textbox>
    说明： 此方法控制TextBox只收数字：0~9 , 也自可以定义其它可输入字符,如改成: 65~123,只允许输入: a~z和A~Z 等.

    1. JavaScript检索CheckBox并实现全选和全消功能

         用C#等写的CheckBox需要回发到服务端执行，
         而用JavaScript可以在直接客户端实现,效率高些

(二).代码

       1. DataGrid中的代码主要片段:

        <Columns>

            <HeaderTemplate>       //头模板代码
                   <asp:CheckBox id="chkHeader" runat="server" AutoPostBack="False"   //AutoPostBack设为假，不需要回发

                            onclick="javascript:SelectAll(this);"></asp:CheckBox>
            </HeaderTemplate>

           <ItemTemplate>            //项模板代码
                   <asp:CheckBox id="chkItem" runat="server"></asp:CheckBox>
           </ItemTemplate>

        </Columns>

2.  在当页加入:

  <script language="javascript">
       function SelectAll(tempControl)
       {
           //将除头模板中的其它所有的CheckBox取反 

            var theBox=tempControl;
             xState=theBox.checked;   

            elem=theBox.form.elements;
            for(i=0;i<elem.length;i++)
            if(elem[i].type=="checkbox" && elem[i].id!=theBox.id)
             {
                  if(elem[i].checked!=xState)
                        elem[i].click();
            }
  }  
</script>

using DxVBLib;

namespace 播放音乐
{
 /// <summary>
 /// Form1 的摘要说明。
 /// </summary>
 public class Form1 : System.Windows.Forms.Form
 {
  /// <summary>
  /// 必需的设计器变量。
  /// </summary>
  private System.ComponentModel.Container components = null;

  public Form1()
  {
   //
   // Windows 窗体设计器支持所必需的
   //
   InitializeComponent();

   
   directX=new DirectX7Class();
   performance=directX.DirectMusicPerformanceCreate();
   composer=directX.DirectMusicComposerCreate();
   loader=directX.DirectMusicLoaderCreate();

   performance.Init(null,0);
   performance.SetPort(-1,4);
   performance.SetMasterAutoDownload(true);

   
   //chordMap=loader.LoadChordMap(@"F:\游戏音乐(mid)\GAME01FM.MID");
   try
   {
    chordMap=loader.LoadChordMap("CHORDMAP.CDM");
   }
   catch (Exception)
   {
    MessageBox.Show("Could not load ChordMap."+"Please ensure that CHORDMAP.CDM is"+"in the directory of this exectutable.");
   }

   //
   // TODO: 在 InitializeComponent 调用后添加任何构造函数代码
   //
  }

  /// <summary>
  /// 清理所有正在使用的资源。
  /// </summary>
  protected override void Dispose( bool disposing )
  {
   if( disposing )
   {
    if (components != null)
    {
     components.Dispose();
    }
   }
   base.Dispose( disposing );
  }

  #region Windows 窗体设计器生成的代码
  /// <summary>
  /// 设计器支持所需的方法 - 不要使用代码编辑器修改
  /// 此方法的内容。
  /// </summary>
  private void InitializeComponent()
  {
   this.button1 = new System.Windows.Forms.Button();
   this.SuspendLayout();
   //
   // button1
   //
   this.button1.Location = new System.Drawing.Point(96, 192);
   this.button1.Name = "button1";
   this.button1.TabIndex = 0;
   this.button1.Text = "button1";
   this.button1.Click += new System.EventHandler(this.button1_Click);
   //
   // Form1
   //
   this.AutoScaleBaseSize = new System.Drawing.Size(6, 14);
   this.ClientSize = new System.Drawing.Size(292, 266);
   this.Controls.Add(this.button1);
   this.Name = "Form1";
   this.Text = "Form1";
   this.ResumeLayout(false);

  }
  #endregion

  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  private DirectX7 directX;
  private DirectMusicChordMap chordMap;
  private DirectMusicComposer composer;
  private DirectMusicPerformance performance;
  private DirectMusicSegment segment;
  private DirectMusicLoader loader;
  private System.Windows.Forms.Button button1;
  private DirectMusicStyle style;
  [STAThread]
  static void Main()
  {
   Application.Run(new Form1());
  }
  private void button1_Click(object sender, System.EventArgs e)
  {   
   try
   {
    style=loader.LoadStyle(@"F:\游戏音乐(mid)\GAME01FM.MID");
    segment=composer.ComposeSegmentFromShape(style,64,0,2,false,false,chordMap);
    composer.AutoTransition(performance,segment,(int)CONST_DMUS_COMMANDT_TYPES.DMUS_COMMANDT_FILL,(int)CONST_DMUS_COMPOSEF_FLAGS.DMUS_COMPOSEF_IMMEDIATE,chordMap);
   }
   catch(Exception)
   {
    MessageBox.Show("不能播放音乐");
   }
  }
 }
}

       初学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();
  }

机数
 //采用一个简单的算法以保证生成随机数的不同
 Random rand =new Random();
 for ( int i = 1 ; i < n+1 ; i++ )
 {   
  if ( temp != -1)
  {
   rand =new Random(i*temp*unchecked((int)

DateTime.Now.Ticks));
  }   
  //int t =  rand.Next(35) ;
  int t=rand.Next(10);
  if (temp != -1 && temp == t)
  {
   return RndNum( n);
  }
  temp = t  ;
  VNum += VcArray[t];
  }
 return VNum ;//返回生成的随机数
}
生成随机数后,将值赋值给一个Label控件,然后改一下Label背景的颜色,OK了

当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也就没有结构（没有结构不能存储数据），这时这个类就起作用了.

不对的地方请批评指正！

namespace Common
{     
        /// <summary>
 /// 存储类(存储UserInfo信息)
 /// </summary>
 public class Storage
 {
  public Storage()
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }

  #region 方法

  //实现“一键一值”存储方法,最普通的存储方法  
                //（“一键一值”指一个Identify存储一个值,下面还有一个“一键多值”方法，因为有时候需要一个键存储多个变量对象值）
                public static bool InsertIdentify(string strIdentify,object Info)
  {   
   if(strIdentify != null && strIdentify.Length != 0 && userInfo != null)
   {
    //建立回调委托的一个实例
　　   CacheItemRemovedCallback callBack =new CacheItemRemovedCallback(onRemove);
    
    //以Identify为标志，将userInfo存入Cache
    HttpContext.Current.Cache.Insert(strIdentify,userInfo,null,
　　　　　　   System.DateTime.Now.AddSeconds(300),
　　　　　　   System.Web.Caching.Cache.NoSlidingExpiration,
　　　　　　   System.Web.Caching.CacheItemPriority.Default,
　　　　　　   callBack);
    return true;
   }   
   else
   {
    return false;
   }
  }
  
  //判断存储的"一键一值"值是否还存在（有没有过期失效或从来都未存储过）
                public static bool ExistIdentify(string strIdentify)
  {
   if(HttpContext.Current.Cache[strIdentify] != null)
   {
    return true;
   }
   else
   {
    return false;
   }
  }

                //插入"一键多值"方法
                //***其中 StorageInfType是一个Enum,里面存有三种类型: UserInf SysInf PageInf
                //这个枚举如下:
                /*
                  public enum StorageInfType
            {
        /// <summary>用户信息</summary>
            UserInf = 0,
  
        /// <summary>页面信息</summary>
        PageInf = 1,  
  
        /// <summary>系统信息</summary>
               SysInf = 2
              }
                //此枚举是自己定义的.可根据需要定义不同的枚举 
                //加个枚举目的是实现“一键多值”存储方法，事实上Cache中是存放了多个变量的，只不过被这个类封装了，
                //程序员感到就好像是“一键一值”.   这样做目的是可以简化开发操作,否则程序员要存储几个变量就得定义几个Identify.
  public static bool InsertCommonInf(string strIdentify,StorageInfType enumInfType,object objValue)
  {   
   if(strIdentify != null && strIdentify != "" && strIdentify.Length != 0 && objValue != null)
   {
    //RemoveCommonInf(strIdentify,enumInfType); 
    
    //建立回调委托的一个实例
  　　         CacheItemRemovedCallback callBack =new CacheItemRemovedCallback(onRemove);

    if(enumInfType == StorageInfType.UserInf)
    {    
       //以用户UserID+信息标志(StorageInfType枚举)，将userInfo存入Cache
        HttpContext.Current.Cache.Insert(strIdentify+StorageInfType.UserInf.ToString(),objValue,null,
  　　　　　　    System.DateTime.Now.AddSeconds(18000),       //单位秒
  　　　　　　    System.Web.Caching.Cache.NoSlidingExpiration,
  　　　　　　    System.Web.Caching.CacheItemPriority.Default,
  　　　　　　    callBack);  
    }
    if(enumInfType == StorageInfType.PageInf)
    {
     //以用户UserID+信息标志(StorageInfType枚举)，将PageInfo存入Cache
         HttpContext.Current.Cache.Insert(strIdentify+StorageInfType.PageInf.ToString(),objValue,null,
  　　　　　　      System.DateTime.Now.AddSeconds(18000),
  　　　　　　      System.Web.Caching.Cache.NoSlidingExpiration,
  　　　　　　      System.Web.Caching.CacheItemPriority.Default,
  　　　　　　      callBack);  
    }
    if(enumInfType == StorageInfType.SysInf)
    {
     //以用户UserID+信息标志(StorageInfType枚举)，将SysInfo存入Cache
         HttpContext.Current.Cache.Insert(strIdentify+StorageInfType.SysInf.ToString(),objValue,null,
  　　　　　　      System.DateTime.Now.AddSeconds(18000),
     　　　　　　      System.Web.Caching.Cache.NoSlidingExpiration,
  　　　　　　      System.Web.Caching.CacheItemPriority.Default,
  　　　　　　      callBack);  
    }
    return true;
   }
   return false;
  }
                //读取“一键多值”Identify的值
                public static bool ReadIdentify(string strIdentify,out UserInfo userInfo)
  {
   //取出值
   if((UserInfo)HttpContext.Current.Cache[strIdentify] != null)
   {
    userInfo = (UserInfo)HttpContext.Current.Cache[strIdentify];
    if(userInfo == null)
    {
     return false;
    }
    return true;
   }   
   else
   {
    userInfo = null;
    return false;
   }   
  }

  //手动移除“一键一值”对应的值
                public static bool RemoveIdentify(string strIdentify)
  {
   //取出值
   if((UserInfo)HttpContext.Current.Cache[strIdentify] != null)
   {
    HttpContext.Current.Cache.Remove(strIdentify);        
   }   
   return true;  
  }

                //此方法在值失效之前调用，可以用于在失效之前更新数据库，或从数据库重新获取数据
  private static void onRemove(string strIdentify, object userInfo,CacheItemRemovedReason reason)
  {
   
  }

  #endregion
 } 
}

不对的地方请批评指正！

      1.
        在实际的软件开发中大部分都是团队合作开发的,经常会出现这种情况,
        一个程序员只设计好数据库,由另一个程序员写程式.这就出现一个问
        题. 设计数据库的程序员 设计数据库字段名称命名习惯 与 写程式码
        程序员数据库命名习惯有些不同.  例如: 数据库程序员对 客户名称习
        惯命名"CustomerName" ,而写程式代码程序员习惯命名"CusName",
        这样,写程式代码程序员在使用时,可能会大量使用类似:
        DataSet.Row[0]["CusName"],这样在更新时就会报错,如果大量出
        现这种情况的话,不但增加开发时修改BUG所耗时间,而且更重要的是
       会使整个项目各代码页面很难统一.
    2.可以实现客户端命名不受数据库的约束.  例如数据库中两个表中的
       两个名称字段分别为: CustomerName和ProjectName;  客户端
       在相关界面,命名字段时没必要知道是哪个表中字段的名称,直接写
       Name就可以了.
  此文章就是解决上面两点的要求.

(二). 解决方法

      1.

         其实SqlDataAdapter就已经实现此功能了. 它可以实现列映射,即将数据库的列

         程序员自定义的列对应起来. 举例说明:

         设有个客户表 Customer ,下面将对其内字段进行映射,具体 代码如下:

               SqlDataAdapter myAdapter = new DqlDataAdapter();        

               DataTableMapping myMapping = new DataTableMapping();

              myMapping = myAdapter.TableMappings.Add("Customer","Customer");  //告诉桥接器并添加映射对象

             myMapping.ColumnMappings.Add("CustomerID","id");   //实际数据库中字段名为: CustomerID, 在实际

                                                                                                     //对其操作时可以用ID字段名称.  例如:

                                                                                                    // ds.Table["Customer"].Row[0]["id"];     就表示

                                                                                                    //客户编号列

             myMapping.ColumnMappings.Add("CustomerName","name");

             myMapping.ColumnMappings.Add("CustomerEmail","email");

             myAdapter.Fill(ds,"Customer");

      以上在使用时只需用映射后的操作就可以啦.  映射后的这段名称可以自定义.  SqlDataAdapter会将它们

      对应起来,即将它们看作是同一列.

    2 .解决站点统一问题 : 

         a.

           假设在十个页面中都用了代码:

              ds.Table["Customer"].Row[0]["CustomerName"];

          现在由于某原因,要修改数据库表字段,需要将物理数据库中的字段:CustomerName改为: CusName

          基于现在的情况,还要到这十个页面中去,找出所有的:

               ds.Table["Customer"].Row[0]["CustomerName"];

         并将其改为:  ds.Table["Customer"].Row[0]["CusName"];

         呵,就改一个字段就带来这么多麻烦,如果改好多个表的多个字段的话呢,时间消耗多少和维护难易程

         度就可想而知了.      下面就解决这个问题.

        b.

           定义一个类,并继承DataSet. 代码如下:

           public Class Customer : DataSet

           {

                   public Enum Field

                   {

                          ID = 0;           //这些列与 DataSet内部表获得数据后实际字段名称对应要正确.  这里自己控制

                          Name = 1;

                         Email = 2;

                         Password = 3;

                  }                

          }

        OK, 最后一步了,使用方法是这样的:

                ds.Table["Customer"].Row[0][Customer.Field.ID];   //取某列值

                比起:             ds.Table["Customer"].Row[0]["CustomerID"];

               方便多了吧?

              这样,如果物理数据库字段怎么修改,程式代码根本不用修改(连这个类本身也不用修改).

不对的地方请批评指正！  

         <%= %>不能绑定数据的，可以这样用:  
         *.aspx中： <%= aaa %>
         *.cs中:   protected string aaa="姓名";

          <% %>，里面可以在页面文件*.aspx或*.ascx文件里面写后台代码，如C#
          例如: 
          <%
          for(int i=0;i<100;i++)
          {
                Reaponse.Write(i.ToString());
          }
          %>

2.控件接收哪些类型数据?
      答:接收Bind的控件，一般有DropDownList,DataList,DataGrid,ListBox这些集合性质的控件，而被捆绑   的主要是ArrayList(数组),Hashtable(哈稀表),DataView(数据视图),DataReader这四个，以后我们就可以   对号入座，不会出现DataTable被捆绑的错误了：）

3.DataBind,获得的数据，系统会将其默认为String,怎样转化为其它的类型?
  DataBinder.Eval(Container.DataItem,"转换的类型","格式")
  最后一个"格式"是可选的，一般不用去管他，Container.DataItem是捆绑的数据项,"转换类型"指的是    Integer,String,Boolean这一类东西.

4.主要命名空间:
  <% @ Import Namespace="System.Data" %>    处理数据时用到
  <% @ Import Namespace="System.Data.ADO" % >  使用ADO.net ; 时用到
  <% @ Import Namespace="System.Data.SQL" %>   SQL Server 数据库专用
  <% @ Import Namespace="System.Data.XML" %>   不用看处理XML用到
  <% @ Import Namespace="System.IO" %>   处理文件时用到
  <% @ Import Namespace="System.Web.Util" %>   发邮件时大家会用到
  <% @ Import Namespace="System.Text" %>    文本编码时用到

5.Connections(SQLConection 或者 ADOConnection)的常用属性和方法:
  | ConnectionString 取得或设置连结数据库的语句
  | ConnectionTimeout 取得或设置连结数据库的最长时间，也是就超时时间
  | DataBase 取得或设置在数据库服务器上要打开的数据库名
  | DataSource 取得或设置DSN,大家不会陌生吧：）
  | Password 取得或设置密码
  | UserID 取得或设置登陆名
  | State 取得目前联结的状态
  | Open() 打开联结
  | Close() 关闭联结
  | Clone() 克隆一个联结。（呵呵，绵羊可以Connection我也可以)
 示例:
     SQLConnection myConnection = new SQLConnection();
     myConnection.DataSource = "mySQLServer";
     myConnection.Password = "";
     myConnection.UserID = "sa";
     myConnection.ConnectionTimeout = 30;
     myConnection.Open();
     myConnection.Database = "northwind";
     myConnection.IsolationLevel = IsolationLevel.ReadCommitted
6.Command常用的方法和属性
   | ActiveConnection 取得或设置联结Connections
   | CommandText 执行的SQL语句或储存过程(StoredProcedure)名
   | CommandTimeout 执行的最长时间
   | CommandType Command操作的类型(StoredProcedure,Text,TableDirect)三种,默认Text
   | Parameters 操作储存过程时使用
   | Execute() 执行SQL语句或储存过程
   | ExecuteNonQuery() 同上，区别在于不返回记录集
   | Clone() 克隆Command
  示例：
     string mySelectQuery = "SELECT * FROM Categories ORDER BY CategoryID";
     stringmyConnectString="userid=sa;password=;database=northwind;server=mySQLServer";
     SQLCommand myCommand = new SQLCommand(mySelectQuery);
     myCommand.ActiveConnection = new SQLConnection(myConnectString);
     myCommand.CommandTimeout = 15;
     myCommand.CommandType = CommandType.Text;< /FONT >

7.打开和关闭数据库两种方法:
      1.MyConnection.Open();    //打开联结
        MyConnection.Close();
      2.MyCommand.ActiveConnection.Open();
        MyCommand.ActiveConnection.Close() 

8.使用DataSet，在数据库中增加、修改、删除一个数据
      a.添加数据
            DataRow dr=MyDataSet.Tables["UserList"].NewRow();
            dr["UserName"] = "周讯";
            dr["ReMark"] = "100";
            dr["Comment"] = "漂亮MM"；
            MyDataSet.Tables.Rows.Add(dr);

      b.修改数据
            MyDataSet.Tables["UserList"].Rows[0]["UserName"]="飞刀大哥";

      c.删除数据
            MyDataSet.Tables["UserList"],Rows[0].Delete();

      d.恢复数据
            if(MyDataSet.HasErrors)
             {
               MyDataSet.RejectChanges();
             }
     
      e.探测DataSet是否有改动
            if(MyDataSet.HasChanges)
             {
                //保存代码
             }else{
                //因为没有变化,所以不用保存,以节省时间
             }

      f.更新数据库
            MyComm.Update(MyDataSet);   //更新数据库中所有的表
            MyComm.Update(MyDataSet,"UserList");  //更新某个表
9.DataGrid实现分页功能
     AllowPaging="True"   //是指允许分页，这个是最主要的。有了它，我们才能分页。
     PageSize="5"         //是指定每页显示的记录数，如果不写，就会默认为10条。
     PagerStyle-HorizontalAlign="Right"  //是指定分面显示的定位，默认是Left

     PagerStyle-NextPageText="下一页"    //把<>改为上一页和下一页字符串
     PagerStyle-PrevPageText="上一页"

     PagerStyle-Mode="NumericPages"       //把<>改为123数字显示
10.显示一共有多少页，并且报告当前为第几页
     当前页是：<font color=red><%=DataGrid1.CurrentPageIndex+1%></font><br>
     总页数是：<font color=red><%=DataGrid1.PageCount%></font><br>
11.个性化分页
     程序员大本营之"亲密接触ASP.Net(14)"有完整代码

12.要将页面重置为有效的状态
 IValidator val;
        foreach(val in Validators)
         {
            Val.IsValid = true;
         }
13.重新执行整个验证序列   
        IValidator val;
        foreach(val in Validators)
         {
            Val.Validate();
         }
14.禁用客户端验证
 <%@ Page Language="c#" clienttarget=downlevel %>
15.Repeater、DataList和DataGrid控件用途"
     这些控件可以简化几种常见的 Web 应用程序方案，包括报表、购物车、产品列表、查询
 结果和导航菜单。  Repeater是唯一允许在其模板中存在 HTML片段的控件.
16.Server.Execute("another.aspx")和Server.Transfer("another.aspx")区别:
       Execute是从当前页面转移到指定页面,并将执行返回到当前页面
 Transfer是将执行完全转移到指定页面
17.XML文件中可以自己存有架构,也可以存在于*.xsl文件中,但必须通过xmlns属性在xml文档的根节点中指定该信息,如下所示:
 <rootelement xmlns="x-schema:scheduledSchema.xsl">
18.XML文件的读取
 FileStream myfs=new Filestream(Server.MapPath("xmldtagrid.xml"),FileMode.Open,FileAccess.Read);
 StreamReader myreader=new StreamReader(myfs);
 DataSet myds=new DataSet();
 myds.ReadXml(myreader);
19.正则表达式 控件RegularExpressionValidator
 符号   含义
 ^   指定检查开始处
 $   指定检查结束处
 []   检查输入的值是否与方括弧中的字符之一相匹配
 \W   允许输入任何值
 \d{}   "\d"指定输入的值是一个数字,{}表示已指定数据类型的出现次数
 +   表明一个或多个元素将被添加到正在检查的表达式
    示例:电子邮件格式(具有@号,且以.com/.net/.org/.edu结尾) 
     validationexpression="^[\w-]+@[\w-]+\.(com|net|org|edu)$"
20.DataGrid控件中数据操作重要语句:
 属性:DataKeyField="userid"  //设userid为表的主键,无法将该字段的值更新到数据库，最好设表的主键为DataGrid的主键
 SqlCommand.Parameters["@userid"].Value=dg.DataKeys[(int)e.Item.ItemIndex]; //检索所要更新的行的主键(将当前选定的行的               主键值赋给命令的一个参)数
 SqlCommand.Parameters["@fname"].Value=((TextBox)e.Item.Cells[2].Controls[0]).Text; //为参数赋予已修改的行值
21.自定义控件:
 a.用户控件(ASP创建页面一样)
  (I).  创建页面,拖入控件,设置属性/方法.   <% @Control Language="C#" Debug="True" %>中的@Control指令来定义此页         将包含控件代码
  (II)  保存为*.ascx文件,如a.ascx.
  (III).使用: 头<%@Register Tagprefix="MyFirstControl" TagName="MyLbl" Src="a.axcs" %>
    //Tagprefix为控件的前缀,像ASP:TextBox中的ASP
    //TagName用于指定自定义控件的名称
    //Src指定控件文件源
      身体:<MyFirstControl:MyLbl runat="Server" id="AllMine" MyText="成功了" />    
 b.使用C#创建自定义控件
  (I). 创建纯代码文件,继承基类Control,并保存为*.cs,如a.cs.
  (II).将代码编译生成程序集: csc /t:library /r:System.dll,System.Web.Dll a.cs 
      //library告诉C#编译器生成程序集
      //  /r:System.dll System.Web.Dll告诉C#编译器引用指定的程序集
  (III).将生成dll文件放在bin目录中
  (IV).使用: <% @Register TagPrefix="Mine" Namespace="MyOwnControls" Assembly="a" %>
22.复合控件注意事项:
 public class MyCompositin:Control,INamingContainer   //INamingContainer:如果在页面上有多个此控件实例,则此结口可以给每         {}           //个实例有唯一标志

 this.EnsureChildControls();//表示将复合控件的子控件都呈现到页面上,此方法检查服务器控件是否包含子控件

 CreateChildControls
23.Button/LinkButton/ImageButton/HyperLink什么时候用?
         1.Button和ImageButton用于将数据传递回服务器.
         2.Hyperlink用于在页面之间导航
         3.LinkButton用于将数据保存到服务器或访问服务器上的数据
24.跟踪调试
     跟踪:
 1.页级别跟踪: 在页的开头包括如下的页指令<%@ Page Trace="True" TraceMode="SortByCategory/SortByTime" %>
  自定义消息:
        Trace.Write("这里为要显示的字符串");
        Trace.Warn("这里为要显示的字符串");   //与Trace.Write相同,只是字体为红色
                检查是否使用了跟踪
        例句: if(Trace.IsEnabled) { Trace.Warn("已启用跟踪")}   
 2.应用程序级别跟踪: 在Web.config文件的<System.Web>节中 <trace enabled="true" pageOutput="true"/>
25.设置缓存:
 1.输出缓存:
            I.页面设置: 将  <%@ OutputCache Duration="120" VaryByParam="none" %>  加在需要缓存页的开头 
                               注释:在请求该页的后两分钟之内,输出内容不变
     II.编程方式设置:
                   主要使用类System.Web.HttpCachePolicy类下的方法
         (1). Response.Cache.SetExpires(DateTime.Now.AddSeconds(120));  //在此方法中必须指定到期时间,如本语                                                                                       //句为两分钟
         (2). Response.Cache.SetExpires(DateTime.Now.AddSeconds(120));
                            Response.Cache.SetSlidingExpiration(true);  //"可调到期",主要用于那些开始访问量大,但随后访问                                                                              //量平衡的情况
                            功能:第一句设置缓存到期时间,第二行打开 sliding expiration(可调到期).
         2.数据缓存:
               (1).DataView mySource; (2).给mySource赋值;
               (3).Cache["myCache"]=mySource; (4).mySource=(DataView)Cache["myCache"]
26.部署: 直接复制到产品服务器即可 复制语句: XCOPY <source_path> <destination_path> //XOPY只接受物理路径,不接受虚拟路径

26.自定义分页按钮

      1. 

           protected void ItemCreated(object sender, System.Web.UI.WebControls.DataGridItemEventArgs  e)
   {
          System.Web.UI.WebControls.ListItemType elemType = e.Item.ItemType;
          if (elemType == System.Web.UI.WebControls.ListItemType.Pager)
          {
                 TableCell pager = (TableCell) e.Item.Controls[0];
                 for (int i=0; i<pager.Controls.Count; i+=2)
                 {
                            Object o = pager.Controls[i];
                            if (o is LinkButton)
                            {
                                    LinkButton h = (LinkButton) o;
                                    h.Text = " " + h.Text + " ";
                            }
                            else
                            {
                                      Label l = (Label) o;
                                      l.Text = String.Format("[第{0}页]", l.Text);
                             }
                   }
           }
    }

   2.  引用:zhangzs8896(小二)

    private void MyDataGrid_ItemCreated(object sender, System.Web.UI.WebControls.DataGridItemEventArgs e)
     {
            ListItemType lit_item=e.Item.ItemType;
            TableCell tc_item=(TableCell)e.Item.Controls[0];
            if (lit_item==ListItemType.Pager)
            {
                   for (int i=0;i<tc_item.Controls.Count;i+=2)
                   {
                          object obj_item=tc_item.Controls[i];
                   
                          if (obj_item is LinkButton)
                          {
                                    LinkButton lbn_item=(LinkButton)obj_item;
                                    lbn_item.Text=lbn_item.Text;
                                    lbn_item.Font.Size=10;
                                    lbn_item.ForeColor=Color.FromName("#666666");
                                    lbn_item.Attributes.Add ("onmouseover","currentcolor=this.style.color;this.style.color='#14AC05'");
                                    lbn_item.Attributes.Add("onmouseout","this.style.color=currentcolor");
                          }
                          else
                          {
                                    Label lbl_item=(Label)obj_item;
                                    lbl_item.ForeColor=Color.Blue;
                                    lbl_item.Font.Bold=true;
                                    lbl_item.Font.Underline=true; 
                                    lbl_item.Text="<font color='#666666'>" + lbl_item.Text + "</font>";
                                    lbl_item.Font.Size=10;

                           }
                  }
              }

          }     

要注意以下几点:
1.如果数据很多,最好不要把数据集放到缓存中(viewstate),影响性能

2. ViewState中存放上次是哪个e.expression并且存放此e.expression是升序还是降序

示例如下:
1.现有的排序事件是这样写的,这个是点击上面排序标题时用:
  private void grdProjTrace_SortCommand(object source, DataGridSortCommandEventArgs e)
{
 this.grdProjTrace.CurrentPageIndex = 0;
 DataView dv = 得到数据代码;
 string strSort = "";
 string strOrder ="";//排序方式。0，降序，1升序
 if(ViewState["SortExpresstion"] != null)
 {
  strSort = ViewState["SortExpresstion"].ToString();
  strSort = strSort.Substring(0,strSort.Length -1);
  strOrder = ViewState["SortExpresstion"].ToString();
  strOrder = strOrder.Substring(strOrder.Length -1);
 }
 if(e.SortExpression == "CustomerName")
 {
  if(strSort != "CustomerName")
  {
   this.ViewState["SortExpresstion"] = ustomerName0";
   dv.Sort = "CustomerName DESC";
  }
  else
  {
   if(strOrder == "0")
   {
    this.ViewState["SortExpresstion"] = "CustomerName1";
    dv.Sort = "CustomerName ASC";
   }
   else
   {
    this.ViewState["SortExpresstion"] = "CustomerName0";
    dv.Sort = "CustomerName DESC";
   }
  }
 }
if(e.SortExpression == "fullName")
 {
  if(strSort != "fullName")
  {
   this.ViewState["SortExpresstion"] = "fullName0";
   dv.Sort = "fullName DESC";
  }
  else
  {
   if(strOrder == "0")
   {
    this.ViewState["SortExpresstion"] = "fullName1";
    dv.Sort = "fullName ASC";
   }
   else
   {
    this.ViewState["SortExpresstion"] = "fullName0";
    dv.Sort = "fullName DESC";
   }
  }
 }   
        this.grdProjTrace.DataSource = dv;
 this.grdProjTrace.DataBind();
}

2.下面这个方法是自己写的，翻页事件中调用。
private void ChangePageDataBind()  
{
 DataView dv = 得到数据代码;
 string strSort = "";
 string strOrder ="";//排序方式。0，降序，1升序
 if(ViewState["SortExpresstion"] != null)
 {
  strSort = ViewState["SortExpresstion"].ToString();
  strSort = strSort.Substring(0,strSort.Length -1);
  strOrder = ViewState["SortExpresstion"].ToString();
  strOrder = strOrder.Substring(strOrder.Length -1);
 }
 if(this.ViewState["SortExpresstion"] != null)
 {    
  if(strSort == "CustomerName")
  {
   if(strOrder == "1")
   {
    this.ViewState["SortExpresstion"] = "CustomerName1";
    dv.Sort = "CustomerName ASC";
   }
   else
   {
    this.ViewState["SortExpresstion"] = "CustomerName0";
    dv.Sort = "CustomerName DESC";
   }
  }
 }
 if(this.ViewState["SortExpresstion"] != null)
 {    
  if(strSort == "fullName")
  {
   if(strOrder == "1")
   {
    this.ViewState["SortExpresstion"] = "fullName1";
    dv.Sort = "fullName ASC";
   }
   else
   {
    this.ViewState["SortExpresstion"] = "fullName0";
    dv.Sort = "fullName DESC";
   }
  }
 }   
this.grdProjTrace.DataSource = dv;
this.grdProjTrace.DataBind();
}

上面两方法只要修改要排序的字段名，就可以直接调用了.
1方法很简单使用,这里就不说了.
2方法是这样用的:
private void grdProjTrace_PageIndexChanged(object source, DataGridPageChangedEventArgs e)
{
 try
 {    
  try
  {
     this.grdProjTrace.CurrentPageIndex = e.NewPageIndex;
  }
  catch
  {
   this.grdProjTrace.CurrentPageIndex = 0;
  }

  
  this.ChangePageDataBind();
 }
 catch(System.Exception errWS)
 {  
         //异常
 }
}

         学了一段时间ComponentOne的图表，感觉ComponenOne图表控件还可以，图表样式也较丰富

  不过它的帮助全是英文的，而且有些地方写的比较粗糙，示例程序也不够详细. 我把它总结了一下.

（二）.使用方法        

        1.安装好ComponentOne软件.

         2.建立一个WEB应用程序项目，名称为: TextChart

         3.将ComponentOne软件自带的控件集DLL文件(不一定全部，只把需要的一部分)拷贝到自己刚建的

            项目TextChart的Bin目录下面 (这里要手动放的原因是ComponentOne有时会找不到Dll)  

         4.双击项目里任何一个*.aspx文件，打开设计界面。 打开工具栏，在工具栏空白处右击，选“添加/删除”

             项,打开自定义控件窗口，在.net frame 组件选项卡下选择ComponentOne相应的组件，如果有清楚，

             就将所有的C1开头的全部勾选，点“确定按钮".  则ComponentOne的控件就显示在工具箱里面了  :)

         5. 到了这一步，就可以将ComponentOne控件像一般控件一样直接拖动使用了. 拖C1WebChart控件到

            窗体页面上.  然后右击控件，选 "Chart wizard..."就可以为其设置显示的样式(饼图/柱状图/折线图等)和

            属性了，用法跟一般控件差不多。(如果感觉还是陌生的话，请看下面（三）,除了用设计器设置外，

           还可以代码用代码设置)

(三) . 代码设置

         1. 限于篇幅，只讲解主要的属性

         2.所有的图表样式原理差不多都一样的，这里只讲一下饼图的实现方法

          using C1.Web.C1WebChart;            //命名空间，必需加入,否则找不到里面的类和方法等
          using C1.Web.C1WebChartBase;
          using C1.Win.C1Chart;

           protected C1.Web.C1WebChart.C1WebChart C1WebChart1;   // 控件声明

         1)  <summary>主要属性</summary>

          C1WebChart1.Header.Text="Chart 头";               //图表头标题
          C1WebChart1.Footer.Text="Chart 尾";                 //图表尾文本
          C1WebChart1.BackColor = Color.LightSteelBlue;   //背景色
          C1WebChart1.ImageFormat = System.Drawing.Imaging.ImageFormat.Png;  //图像存储格式         

           C1WebChart1.ChartGroups.Group0.ChartType = Chart2DTypeEnum.Bar;   //图表

                                                       // 类型,Chart2DTypeEnum枚举下有所有的图表样式，如饼图/柱状图等

                                                                                                                     
           C1WebChart1.Width=800;     //图表宽度

          2) <summary>主要方法</summary>

            a .X轴标签(坐标)的方法，直接调用即可

               public void AddAxisX()
               {  
                       // label x axis with product names
                      Axis ax = C1WebChart1.ChartArea.AxisX;
                      ax.ValueLabels.Clear();  
                     ax.AnnoMethod = AnnotationMethodEnum.ValueLabels;
                     for(int i = 0; i < 100; i++)
                     {
                              //DataRowView drv = dv[i];
                             ax.ValueLabels.Add(i, (i+1).ToString());
                     }
                     try
                     {
                             ax.Max = 10 - .5;
                     }
                    catch {}  
                }
            a .Y轴标签(坐标)的方法，直接调用即可

                public void AddAxisY()
                { 
                      // label y axis with product names
                     Axis ay = C1WebChart1.ChartArea.AxisY;
                    ay.ValueLabels.Clear();  
                   ay.AnnoMethod = AnnotationMethodEnum.ValueLabels;
                    for(int i = 0; i < 10; i++)
                    {
                          //DataRowView drv = dv[i];
                         ay.ValueLabels.Add(i, (50*i).ToString());
                   }
                   try
                    {
                            ay.Max = 20 - .5;
                    }
                   catch {}  
                }

              c.画图表的方法
                public void GetPieData()
                {  
                       C1WebChart1.Legend.Visible = true;  //图表区块注释.
                       this.AddAxisX();   //上面方法a
                       this.AddAxisY();   //上面方法b
   
                       //生成数据
                        PointF[] data = new PointF[10];
                        for (int i = 0; i < data.Length; i++)
                        {
                                float y = float.Parse((3*i+5).ToString());
                                data[i] = new PointF(i, y);
                        }    
   
                        //清除现有的饼图
                       ChartDataSeriesCollection dscoll = C1WebChart2.ChartGroups[0].ChartData.SeriesList;   
                       dscoll.Clear();

                       //汇图,即将点数组交给控件，它会自己分配,并画出图形
                        ChartDataSeries series = C1WebChart1.ChartGroups[0].ChartData.SeriesList[0];
                       series.PointData.CopyDataIn(data);// 这里的data是PointF类型  
           
                        //给区块加标签
                        for(int i=0; i < data.Length; i++)
                       {
                               ChartDataSeries series = dscoll.AddNewSeries();
                               series.PointData.Length = 1;
                               series.Y[0] = data[i].Y;
                              series.Label="我是:"+(i+1).ToString();

                               //加标签
                               C1.Win.C1Chart.Label lbl = C1WebChart1.ChartLabels.LabelsCollection.AddNewLabel();
                               lbl.Text = string.Format("{0} ({1:c})","第:"+i.ToString()+"扇区", data[i].Y);
                               lbl.Compass = LabelCompassEnum.Radial;
                               lbl.Offset = 20;
                               lbl.Connected = true;
                               lbl.Visible = true;
                               lbl.AttachMethod = AttachMethodEnum.DataIndex;
                               AttachMethodData am = lbl.AttachMethodData;
                              am.GroupIndex  = 0;
                             am.SeriesIndex = i;
                             am.PointIndex  = 0;
                         }
                  } 

不对的地方请批评指正！

整个后台文件如下:

using System;
using System.Data;
using System.DirectoryServices;
using System.Collections;
using System.Threading;
namespace Aspcn.Management
{
/// <summary>
/// IISManager 的摘要说明。
/// </summary>
public class IISManager
{
/// <summary>
/// 应用程序的主入口点。
/// </summary>
[STAThread]
static void Main(string[] args)
{
IISManager test = new IISManager();
test.Connect();
VirtualDirectory vd = new VirtualDirectory();
vd.Path = @"c:\Inetpub\wwwroot\项目文件夹名称";
vd.Name = "BKDEIP/WEBUI/Mobile";

//if(test.Exists(vd.Name))  
//{
//test.Delete(vd.Name);
//}
//else
//{
//test.Create(vd);
//}
test.Create(vd);
}

//定义需要使用的
private string _server,_website;
private VirtualDirectories _virdirs;
protected System.DirectoryServices.DirectoryEntry rootfolder;
private bool _batchflag;
public IISManager()
{
//默认情况下使用localhost，即访问本地机
_server = "localhost";
_website = "1";
_batchflag = false;
}
public IISManager(string strServer)
{
_server = strServer;
_website = "1";
_batchflag = false;
}
/// <summary>
/// 定义公共属性
/// </summary>

//Server属性定义访问机器的名字，可以是IP与计算名
public string Server
{
get{ return _server;}
set{ _server = value;}
}
//WebSite属性定义，为一数字，为方便，使用string
//一般来说第一台主机为1,第二台主机为2，依次类推
public string WebSite
{
get{ return _website; }
set{ _website = value; }
}

//虚拟目录的名字
public VirtualDirectories VirDirs
{
get{ return _virdirs; }
set{ _virdirs = value;}
}
///<summary>
///定义公共方法
///</summary>

//连接服务器
public void Connect()
{
ConnectToServer();
}
//为方便重载
public void Connect(string strServer)
{
_server = strServer;
ConnectToServer();
}
//为方便重载
public void Connect(string strServer,string strWebSite)
{
_server = strServer;
_website = strWebSite;
ConnectToServer();
}
//判断是否存这个虚拟目录
public bool Exists(string strVirdir)
{
return _virdirs.Contains(strVirdir);
}
//添加一个虚拟目录
public void Create(VirtualDirectory newdir)
{
string strPath = "IIS://" + _server + "/W3SVC/" + _website + "/ROOT/" + newdir.Name;           
if(!_virdirs.Contains(newdir.Name) || _batchflag )
{
try
{
//加入到ROOT的Children集合中去
DirectoryEntry newVirDir = rootfolder.Children.Add(newdir.Name,"IIsWebVirtualDir");
newVirDir.Invoke("AppCreate",true);
newVirDir.CommitChanges();
rootfolder.CommitChanges();
//然后更新数据
UpdateDirInfo(newVirDir,newdir);
}
catch(Exception ee)
{
throw new Exception(ee.ToString());
}
}
else
{
throw new Exception("This virtual directory is already exist.");
}
}
//得到一个虚拟目录
public VirtualDirectory GetVirDir(string strVirdir)
{
VirtualDirectory tmp = null;
if(_virdirs.Contains(strVirdir))
{
tmp = _virdirs.Find(strVirdir);
((VirtualDirectory)_virdirs[strVirdir]).flag = 2;
}
else
{
throw new Exception("This virtual directory is not exists");
}
return tmp;
}

//更新一个虚拟目录
public void Update(VirtualDirectory dir)
{
//判断需要更改的虚拟目录是否存在
if(_virdirs.Contains(dir.Name))
{
DirectoryEntry ode = rootfolder.Children.Find(dir.Name,"IIsWebVirtualDir");
UpdateDirInfo(ode,dir);
}
else
{
throw new Exception("This virtual directory is not exists.");
}
}
　
//删除一个虚拟目录
public void Delete(string strVirdir)
{
if(_virdirs.Contains(strVirdir))
{
object[] paras = new object[2];
paras[0] = "IIsWebVirtualDir"; //表示操作的是虚拟目录
paras[1] = strVirdir;
rootfolder.Invoke("Delete",paras);
rootfolder.CommitChanges();
}
else
{
throw new Exception("Can't delete " + strVirdir + ",because it isn't exists.");
}
}
//批量更新
public void UpdateBatch()
{
BatchUpdate(_virdirs);
}
//重载一个：-)
public void UpdateBatch(VirtualDirectories vds)
{
BatchUpdate(vds);
}
　
///<summary>
///私有方法
///</summary>

//连接服务器
private void ConnectToServer()
{
string strPath = "IIS://" + _server + "/W3SVC/" + _website +"/ROOT";
try
{
this.rootfolder = new DirectoryEntry(strPath);
_virdirs = GetVirDirs(this.rootfolder.Children);
}
catch(Exception e)
{
throw new Exception("Can't connect to the server ["+ _server +"] ...",e);
}
}
//执行批量更新
private void BatchUpdate(VirtualDirectories vds)
{
_batchflag = true;
foreach(object item in vds.Values)
{
VirtualDirectory vd = (VirtualDirectory)item;
switch(vd.flag)
{
case 0:
break;
case 1:
Create(vd);
break;
case 2:
Update(vd);
break;
}
}
_batchflag = false;
}
//更新东东
private void UpdateDirInfo(DirectoryEntry de,VirtualDirectory vd)
{
de.Properties["AnonymousUserName"][0] = vd.AnonymousUserName;
de.Properties["AnonymousUserPass"][0] = vd.AnonymousUserPass;
de.Properties["AccessRead"][0] = vd.AccessRead;
de.Properties["AccessExecute"][0] = vd.AccessExecute;
de.Properties["AccessWrite"][0] = vd.AccessWrite;
de.Properties["AuthBasic"][0] = vd.AuthBasic;
de.Properties["AuthNTLM"][0] = vd.AuthNTLM;
de.Properties["ContentIndexed"][0] = vd.ContentIndexed;
de.Properties["EnableDefaultDoc"][0] = vd.EnableDefaultDoc;
de.Properties["EnableDirBrowsing"][0] = vd.EnableDirBrowsing;
de.Properties["AccessSSL"][0] = vd.AccessSSL;
de.Properties["Accessscript"][0] = vd.Accessscript;
de.Properties["DefaultDoc"][0] = vd.DefaultDoc;
de.Properties["Path"][0] = vd.Path;
de.CommitChanges();
}

//获取虚拟目录集合
private VirtualDirectories GetVirDirs(DirectoryEntries des)
{
VirtualDirectories tmpdirs = new VirtualDirectories();
foreach(DirectoryEntry de in des)
{
if(de.SchemaClassName == "IIsWebVirtualDir")
{
VirtualDirectory vd = new VirtualDirectory();
vd.Name = de.Name;
vd.AccessRead = (bool)de.Properties["AccessRead"][0];
vd.AccessExecute = (bool)de.Properties["AccessExecute"][0];
vd.AccessWrite = (bool)de.Properties["AccessWrite"][0];
vd.AnonymousUserName = (string)de.Properties["AnonymousUserName"][0];
vd.AnonymousUserPass = (string)de.Properties["AnonymousUserName"][0];
vd.AuthBasic = (bool)de.Properties["AuthBasic"][0];
vd.AuthNTLM = (bool)de.Properties["AuthNTLM"][0];
vd.ContentIndexed = (bool)de.Properties["ContentIndexed"][0];
vd.EnableDefaultDoc = (bool)de.Properties["EnableDefaultDoc"][0];
vd.EnableDirBrowsing = (bool)de.Properties["EnableDirBrowsing"][0];
vd.AccessSSL = (bool)de.Properties["AccessSSL"][0];
vd.Accessscript = (bool)de.Properties["Accessscript"][0];
vd.Path = (string)de.Properties["Path"][0];
vd.flag = 0;
vd.DefaultDoc = (string)de.Properties["DefaultDoc"][0];
tmpdirs.Add(vd.Name,vd);
}
}
return tmpdirs;
}

}
/// <summary>
/// VirtualDirectory类
/// </summary>
public class VirtualDirectory
{
private bool _read,_execute,_script,_ssl,_write,_authbasic,_authntlm,_indexed,_endirbrow,_endefaultdoc;
private string _ausername,_auserpass,_name,_path;
private int _flag;
private string _defaultdoc;
/// <summary>
/// 构造函数
/// </summary>
public VirtualDirectory()
{
SetValue();
}
public VirtualDirectory(string strVirDirName)
{
_name = strVirDirName;
SetValue();
}
private void SetValue()
{
_read = true;_execute = false;_script = false;_ssl= false;_write=false;_authbasic=false;_authntlm=false;
_indexed = false;_endirbrow=false;_endefaultdoc = false;
_flag = 1;
_defaultdoc = "default.htm,default.aspx,default.asp,index.htm";
_path = "C:\\";
_ausername = "";_auserpass ="";_name="";
}
///<summary>
///定义属性,IISVirtualDir太多属性了
///我只搞了比较重要的一些，其它的大伙需要的自个加吧。
///</summary>

public int flag
{
get{ return _flag;}
set{ _flag = value;}
}
public bool AccessRead
{
get{ return _read;}
set{ _read = value;}
}
public bool AccessWrite
{
get{ return _write;}
set{ _write = value;}
}
public bool AccessExecute
{
get{ return _execute;}
set{ _execute = value;}
}
public bool AccessSSL
{
get{ return _ssl;}
set{ _ssl = value;}
}
public bool Accessscript
{
get{ return _script;}
set{ _script = value;}
}
public bool AuthBasic
{
get{ return _authbasic;}
set{ _authbasic = value;}
}
public bool AuthNTLM
{
get{ return _authntlm;}
set{ _authntlm = value;}
}
public bool ContentIndexed
{
get{ return _indexed;}
set{ _indexed = value;}
}
public bool EnableDirBrowsing
{
get{ return _endirbrow;}
set{ _endirbrow = value;}
}
public bool EnableDefaultDoc
{
get{ return _endefaultdoc;}
set{ _endefaultdoc = value;}
}
public string Name
{
get{ return _name;}
set{ _name = value;}
}
public string Path
{
get{ return _path;}
set{ _path = value;}
}
public string DefaultDoc
{
get{ return _defaultdoc;}
set{ _defaultdoc = value;}
}
public string AnonymousUserName
{
get{ return _ausername;}
set{ _ausername = value;}
}
public string AnonymousUserPass
{
get{ return _auserpass;}
set{ _auserpass = value;}
}
}
/// <summary>
/// 集合VirtualDirectories
/// </summary>

public class VirtualDirectories : System.Collections.Hashtable
{
public VirtualDirectories()
{
}
//添加新的方法
public VirtualDirectory Find(string strName)
{
return (VirtualDirectory)this[strName];
}
}
}

  有没有人遇到这种情况，用 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,就是这句，要确认是哪个表，除非是很大的数据量，
        一般是感觉不到的)，效率稍微有些慢

不对的地方望批评指正！