简化.NET assembly类库 作者： silicon.com
2005-03-16 12:7 PM

维护头文件通常是一个冗长乏味并且容易出错的过程，感谢.NET  assembly类库抹去了对这些文件的倚赖。

微软.NET的可管理的C++最终简化了我们创建类库的方法，或更准确些，.NET assembly类库，这种简化得以实现主要是由于assembly类库是可以自我描述的。这对一个Managed C++程序员意味着什么呢？基本上讲，一旦 assembly编译成功，你在编译传统C++类库的时谨慎创建的所有头文件除了维护的需要外，都不再是必需的。

就个人而言，我感觉维护头文件是一种痛苦，所以我很高兴看到这种对头文件的倚赖正在消失。我经常会忘记需要在库中引用的一个或多个头文件的名称，为了找到缺失的数据类型定义，我不得不对所有含有头文件的内容进行搜索，更糟糕的是，将源代码拆分为两半增加了我犯错误的机会。我经常犯的错误包括忘记将所有的包含头文件打包、使.h文件和.cpp脱离同步。

既然对头文件的程序集不再是必需的，你可以使用一种改进了的新方法来创建源文件。但在考察这种方法之前，先让我们先来回顾一下创建程序集的传统方法

传统方法

在C++中，传统的库文件创建方法是建立一系列头文件用以描述类库中所有的功能；接下来，你要在一个单独的源文件中实现这些头文件所定义了的所有功能。然后，在编译器中运行每一个源代码文件连同其相关的头文件，以生成目标文件；再将所有的目标文件相互链接来创建库文件

图A描述了这种传统方法。

图A 

创建库的传统方法

使用头文件的原因在于，今后引用这个类的时候，所有的类、结构体、变量等等都可以很方便的定义。

程序集可以使用同样的方法生成，这一过程的唯一区别在于Managed C++的标志是事先确定的。

在下面的例子中，列表A、B、C和D演示了如何用传统C++的方法创建一个 assembly。

列表A给出了头文件Cards.h的定义，这个文件定义了一个包含扑克牌和Card类的枚举(enmu)，注意，使用ManagedC++时，关键字public要放在enum和class之前的，因为这两者都需要在全局范围内可以被访问。

列表B展示了类的构造器和成员方法的实现，列表C定义了第二个类Deck，注意，虽然从来没有在头文件中定义，但Card类是在Deck类之内使用的，使用这一技巧需要谨记：在编译过程中，头文件基本上是大批量地粘贴到源文件中的。既然是这样的情况，我们只需简单地在Deck.cpp源文件的包含文件列表中将Card.h放在Deck.h的前面，如此操作之后，Card类将首先被粘贴，继而被定义为Deck类所必需的类。

列表D显示了在这个迷你库中的源文件，注意，正如我们刚刚所提到的，Card.h包含在Deck.h之前。

在命令行中执行建立 assembly库的命令并不像火箭科学一样艰难，其语法（没有这些省略号）非常简单：

cl source1.cpp source2.cpp ... sourceN.cpp /CLR /LD /o OutputName.dll

C++编译器取走这一系列源文件的名称，然后是/CLR参数，它告诉编译器我们正在使用managed的扩展，继而/LD参数告诉连接器去创建一个.dll文件，最后/o参数将说明这个.dll文件的名称。

为了编译以上的例子，你可能会用到这行命令：

clcard.cppdeck.cpp /CLR /LD /o cards.dll

新的 assembly方法

不再受困于分离头文件和源文件的工作，就为新的库文件编码方式提供了可能性。在兜了一个圈子之后，我将开始介绍我的简便方法，首先，将所有的类以类文件(.h)形式进行编码，其中包括所有的定义和实现；然后使用一个单独的连接器文件(.cpp)来包含所有的类文件；这种方法唯一有些棘手的部分在于，你要确定所有的类文件是按照正确的顺序排列的，以保证一切需要调用的数据类型在使用之前都已经定义好了，即使使用传统方法，这一问题同样需要处理。图B展示了这种新的 assembly方法。

图B

新的 assembly方法

采用这种方法，你只需维护半数文件，既然定义和源码是一同定义的，就不会造成不同步的。这样一来，维护库的工作就简单了很多，另外，开发文档只需保存在一个地方，也就更容易阅读，所有这些都说说明了这是一种更好的方法。

列表E、F和G展示了使用新方法生成的同样的库。

正如你看到的那样，列表E是传统方法中Card.h和Card.cpp这两个文件相结合而形成的，我基本上只是把实现部分直接放在类的定义中，而不是在一个单独的文件中进行定义。

同样的，列表F是传统方法中Deck.h和Deck.cpp这两个文件相结合形成的，如果使用传统方法，你可以在这个类中访问其他的类而不必在文件中定义他们，连接器文件需要确保所有类的定义是按照正确的顺序排列的，以保证这些类在使用之前都已经定义好了。

在列表G中显示的连接器文件是唯一一个与众不同的文件，它除了包含语句之外没有任何其他的东西，ManagedC++编译器只编译.cpp文件，为了让编译器完成所有的工作，你必须有这个文件。这种便利所带来的副作用是从库中添加或删除类变得容易了，而你已经将组成库的类名称记录在了一个单一的地方。在开发过程中，连接器文件还是一个放置测试代码的理想场所。

以这种方法建立一个assembly类库的额外的优点是，在命令行条件下使用时，其命令很简单：

clcards.cpp /CLR /LD

结论

具有自我描述功能的 assembly器简化了我们编码的方法，这主要是因为源代码模块不再需要被分离为头文件和源码文件，正因为得益于此，我们展示了一种构造 assembly库的新方法。

1.SQL Server数据库的连接   

   你可以使用Connection对象的属性来指定数据源的位置及其它参数来连接数据库。如：SqConnection con=new SqlConnection("Provider=SQLOLEDB;Data Source=MyServer;Initial Catalog=database;use id=yourid,password=yourpassword;");

这是连接到本地数据库，如果你想连到网络上的的数据库，就要利用集成安全性，同时忽略用户名和密码。如：

SqConnection con=new SqlConnection("Provider=SQLOLEDB;Data Source=MyServer;Initial Catalog=database;Integrated Security=SSPI");

如果使用的是ODBC连接到SQL Server，可以通过使用Trusted_Connection＝yes;来使用网络数据库。

2.Oracle数据库的连接：（前提：必须先安装Oracle客户端实用工具的适当版本，并创建数据库别名，接着就可以用以下的连接字符串进行连接）

SqConnection con=new SqlConnection("Provider=MSDAORA;Data Source=dbAlias;User id=yourid,password=youpwd;);

3.Access数据库的连接：（你可以使用以下连接字符串来连接）

连接到数据库之后即可调用Connection对象的Open()方法来打开与数据库的连接，同理Close()方法用来关闭与数据库的连接。

连接池：

      连接池是什么？在一个三层结构（或N层）中，当一个客户端与中间层服务器进行通讯的时候，服务器会创建一个与数据库连接，并执行操作的业务对象（也就是与数据库连接的实例），同时会创建一个Connection对象，在放在一个池中（实际上是一个线程）。当释放这个实例的时候，此实例便关闭，此时并没有真正的关闭数据连接，而是将Connection对象标记为关闭后存储在池中。如果这时再来启动一个新的业务对象，这时就会检查现有的连接，如果池中有打开的连接，即使用它，否则再创建一个新连接。

可能你会觉得很奇怪，如果这样，那池中不是有很多的对象，岂不是会浪费很多的资源，这个问题的解决方案是你可以设置与数据库的特定连接时间（默认60秒），如果在这个时间内未被使用，.NET提供就会关闭此连接。

      如何打开连接池？默认情况下是打开的.

      如何关闭连接池？可以使用OleDbConnection.ReleaseConnectionPool()方法来关闭连接池，更或者你可以在ＯＬＥ　ＤＢ连接字符串中加上OLE DB Services= - 4;在用SqlConnection对象时可在连接符中加上Pooling=False。这时你再调用Close()时候便会真正地关闭与数据库的连接。

（注1：可以使用ＳＱＬ事件探查器或性能监视器来观察连接到数据库中的连接数目，以识别连接是否真正关闭或是只是放入池中。）

（注2：可以显式调用Dispose()方法在垃圾收集器回收之前释放资源，但如果你只是将Connection对象设为ＮＵＬＬ的话，是不会断开与数据源的连接的）

      利用Connection对象来创建Command对象：(ADO.NET中用Command对象来执行数据查询，更新）例　：

SqConnection con=new SqlConnection("Provider=SQLOLEDB;Data Source=MyServer;Initial Catalog=database;Integrated Security=SSPI");

using (OleDbCommand cmd=con.CreateCommadn())

{

      cmd.CommandText="select * from table";

      cmd.ExecuteNonQuery();

}

(注：此处使用using 的好处是在进行此次操作后便可释放资源。)

利用Connection对象来创建Transaction对象：(Transaction对象是ADO.NET中的事务管理对象）

例：

SqConnection con=new SqlConnection("Provider=SQLOLEDB;Data Source=MyServer;Initial Catalog=database;Integrated Security=SSPI");

con.Open();

OleDbTransaction tran=con.BeginTransaction(); (注：调用此方法会在连接时返回一个新的打开的Transaction对象来进行事务管理）

(注：事务是指一组单一实体运行的语句，可以确保数据的完整性，防止因系统故障或其它原因而引起的数据丢失。概念很抽象，呵呵，看下去就明白了）

事务有ＡＣＩＤ四个属性（即原子性，一致性，隔离性，持久性）：

原子性指在执行事务过程中，这个过程要么成功执行，要么不执行。

一致性指事务前和事务后的数据的一致性，也就是如果事务成功执行的话，系统就返回成功的状态，即所有数据的改变标记为已完成，如没完成事务，即回滚，并回到先前的合法状态。

隔离性指一个事务内的任何变化都独立于其它的事务（相对于两个事务的说法）

持久性指事务是持续的，也就是事务成功完成后的改变是永久的。

（注：事务有手动和自动两种，本文的主题不在此，事务的介绍在其它篇章会涉及到）

      取得数据库的架构信息：

  有时你会发觉有需要获取数据库的架构信息来方便程序的运行。可使用OleDbConnection对象的GetOleDbSchemaTable()方法来获取，它需要一个参数用来作返回的架构信息的过滤器，即只获取表中的列或行信息，不写此参数则获取整个表所有列的信息。

例：

OleDbConnectioncon=new OleDbConnection("Provider=SQLOLEDB;Data Source=MyServer;Initial Catalog=database;Integrated Security=SSPI");

con.Open();

DataTable dt=con.GetOleDbSchemaTable(OleDbSchamaGuid,null);

foreach(DataRow row in dt.Rows)

Console.WriteLine(row["column_name"].ToString());

---------------------------------------------------------------

关于AD.NET的连接对象还有很多有用的方法，具体查ＭＳＤＮ。

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconusingannotationswithtypeddataset.asp

Annotations enable you to modify the names of the elements in your typed DataSet without modifying the underlying schema. Modifying the names of the elements in your underlying schema would cause the typed DataSet to refer to objects that do not exist in the data source, as well as losing a reference to the objects that do exist in the data source.

Using annotations, you can customize the names of objects in your typed DataSet with more meaningful names, making code more readable and your typed DataSet easier for clients to use, while leaving underlying schema intact. For example, the following schema element for the Customers table of the Northwind database would result in a DataRow object name of CustomersRow and a DataRowCollection named Customers.

<xs:element name="Customers">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="CustomerID" type="xs:string" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>
</xs:element>

A DataRowCollection name of Customers is meaningful in client code, but a DataRow name of CustomersRow is misleading because it is a single object. Also, in common scenarios, the object would be referred to without the Row identifier and instead would be simply referred to as a Customer object. The solution is to annotate the schema and identify new names for the DataRow and DataRowCollection objects. Following is the annotated version of the previous schema.

<xs:element name="Customers" codegen:typedName="Customer" codegen:typedPlural="Customers">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="CustomerID" type="xs:string" minOccurs="0" />
    </xs:sequence>
  </xs:complexType>
</xs:element>

Specifying a typedName value of Customer will result in a DataRow object name of Customer. Specifying a typedPlural value of Customers preserves the DataRowCollection name of Customers.

The following table shows the annotations available for use.

The following table shows the values that can be specified for the nullValue annotation.

The following table shows default values for objects in a typed DataSet and the available annotations.

To use typed DataSet annotations, you must include the following xmlns reference in your XML Schema definition language (XSD) schema.

xmlns:codegen="urn:schemas-microsoft-com:xml-msprop"

The following is a sample, annotated schema that exposes the Customers table of the Northwind database with a relation to the Orders table included.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="CustomerDataSet" 
      xmlns:codegen="urn:schemas-microsoft-com:xml-msprop"
      xmlns="" 
      xmlns:xs="http://www.w3.org/2001/XMLSchema" 
      xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
  <xs:element name="CustomerDataSet" msdata:IsDataSet="true">
    <xs:complexType>
      <xs:choice maxOccurs="unbounded">
        <xs:element name="Customers" codegen:typedName="Customer" codegen:typedPlural="Customers">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="CustomerID" codegen:typedName="CustomerID" type="xs:string" minOccurs="0" />
              <xs:element name="CompanyName" codegen:typedName="CompanyName" type="xs:string" minOccurs="0" />
              <xs:element name="Phone" codegen:typedName="Phone" codegen:nullValue="" type="xs:string" minOccurs="0" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
        <xs:element name="Orders" codegen:typedName="Order" codegen:typedPlural="Orders">
          <xs:complexType>
            <xs:sequence>
              <xs:element name="OrderID" codegen:typedName="OrderID" type="xs:int" minOccurs="0" />
              <xs:element name="CustomerID" codegen:typedName="CustomerID" codegen:nullValue="" type="xs:string" minOccurs="0" />
              <xs:element name="EmployeeID" codegen:typedName="EmployeeID" codegen:nullValue="0" type="xs:int" minOccurs="0" />
              <xs:element name="OrderDate" codegen:typedName="OrderDate" codegen:nullValue="1980-01-01T00:00:00" type="xs:dateTime" minOccurs="0" />
            </xs:sequence>
          </xs:complexType>
        </xs:element>
      </xs:choice>
    </xs:complexType>
    <xs:unique name="Constraint1">
      <xs:selector xpath=".//Customers" />
      <xs:field xpath="CustomerID" />
    </xs:unique>
    <xs:keyref name="CustOrders" refer="Constraint1" codegen:typedParent="Customer" codegen:typedChildren="GetOrders">
      <xs:selector xpath=".//Orders" />
      <xs:field xpath="CustomerID" />
    </xs:keyref>
  </xs:element>
</xs:schema>

The following code example uses a strongly typed DataSet created from the sample schema. It uses one DataAdapter to populate the Customers table and another DataAdapter to populate the Orders table. The strongly typed DataSet defines the DataRelations.

[Visual Basic]
Dim nwindConn As SqlConnection = New SqlConnection("Data Source=localhost;Integrated Security=SSPI;" & _
                                                   "Initial Catalog=northwind")
Dim custDA As SqlDataAdapter = New SqlDataAdapter("SELECT CustomerID, CompanyName, Phone FROM Customers", &
                                                  nwindConn)
Dim orderDA As SqlDataAdapter = New SqlDataAdapter("SELECT OrderID, CustomerID, EmployeeID, OrderDate FROM Orders", &
                                                   nwindConn)

' Populate a strongly typed DataSet.
nwindConn.Open()
Dim custDS As CustomerDataSet = New CustomerDataSet()
custDA.Fill(custDS, "Customers")
orderDA.Fill(custDS, "Orders")
nwindConn.Close()

' Add a strongly typed event.
AddHandler custDS.Customers.CustomerChanged, &
           New CustomerDataSet.CustomerChangeEventHandler(AddressOf OnCustomerChanged)

' Add a strongly typed DataRow.
Dim newCust As CustomerDataSet.Customer = custDS.Customers.NewCustomer()
newCust.CustomerID = "NEW01"
newCust.CompanyName = "My New Company"
custDS.Customers.AddCustomer(newCust)

' Navigate the child relation.
Dim customer As CustomerDataSet.Customer
Dim order As CustomerDataSet.Order

For Each customer In custDS.Customers
  Console.WriteLine(customer.CustomerID)
  For Each order In customer.GetOrders()
    Console.WriteLine(vbTab & order.OrderID)
  Next
Next

Private Shared Sub OnCustomerChanged(sender As Object, e As CustomerDataSet.CustomerChangeEvent)

End Sub
[C#]
SqlConnection nwindConn = new SqlConnection("Data Source=localhost;Integrated Security=SSPI;Initial Catalog=northwind");
SqlDataAdapter custDA = new SqlDataAdapter("SELECT CustomerID, CompanyName, Phone FROM Customers", nwindConn);
SqlDataAdapter orderDA = new SqlDataAdapter("SELECT OrderID, CustomerID, EmployeeID, OrderDate FROM Orders", nwindConn);

// Populate a strongly typed DataSet.
nwindConn.Open();
CustomerDataSet custDS = new CustomerDataSet();
custDA.Fill(custDS, "Customers");
orderDA.Fill(custDS, "Orders");
nwindConn.Close();

// Add a strongly typed event.
custDS.Customers.CustomerChanged += new 
  CustomerDataSet.CustomerChangeEventHandler(OnCustomerChanged);

// Add a strongly typed DataRow.
CustomerDataSet.Customer newCust = custDS.Customers.NewCustomer();
newCust.CustomerID = "NEW01";
newCust.CompanyName = "My New Company";
custDS.Customers.AddCustomer(newCust);

// Navigate the child relation.
foreach(CustomerDataSet.Customer customer in custDS.Customers)
{
  Console.WriteLine(customer.CustomerID);
  foreach(CustomerDataSet.Order order in customer.GetOrders())
    Console.WriteLine("\t" + order.OrderID);
}

protected static void OnCustomerChanged(object sender, CustomerDataSet.CustomerChangeEvent e)
{

}

See Also

Working with a Typed DataSet | Creating and Using DataSets | DataColumnCollection Class | DataSet Class

　　要操纵数据库，必须先使用Connection来连接到数据库，再创建一个Command来查询。有几种创建方式，例：

SqlCommand cmd;

string strCon="server=localhost;database=Northwind;Trusted_Connection=Yes;";
string strqry="select * from Categories";
SqlConnection con=new SqlConnection(strCon);
con.Open();
¹cmd=con.CreateCommand(); //这里使用用Connection对象的CreateCommand方法来创建一个Command对象。
cmd.CommandText=strqry;
//SqlDataReader reader=cmd.ExecuteReader();

?²cmd=new SqlCommand();?? //直接使用new 关键字来创建
cmd.CommandText=strqry;
?cmd.Connection=con;?? //设置与数据库的连接

　³cmd=new SqlCommand(strqry,con);　//直接在new的时候带两个参数来创建

　执行方式：

（主要有这么几种，cmd.ExecuteReader();cmd.ExecuteNonQuery();cmd.ExecuteScalar();cmd.ExecuteXmlReader();）

　１，ExecuteReader();返回一个SqlDataReader对象或OleDbDataReader对象，这个看你的程序的需要去　　做。可以通过这个对象来检查查询结果，它提供了“游水”式的执行方式，即从结果中读取一行之后，移动到另一行，则前一行就无法再用。有一点要注意的是执行之后，要等到手动去调用Read()方法之后，DataReader对象才会移动到结果集的第一行，同时此方法也返回一个Bool值，表明下一行是否可用，返回True则可用，返回False则到达结果集末尾。

使用DataReader可以提高执行效率，有两种方式可以提高代码的性能：一种是基于序号的查找，一个是使用适当的Get方法来查找。因为查询出来的结果一般都不会改变，除非再次改动查询语句，因此可以通过定位列的位置来查找记录。用这种方法有一个问题，就是可能知道一列的名称而不知道其所在的位置，这个问题的解决方案是通过调用DataReader 对象的GetOrdinal()方法，此方法接收一个列名并返回此列名所在的列号。例：

int id=reader.GetOrdinal("CategoryName");
while(reader.Read())
{
Response.Write(reader[id]);

reader.Close();

?至于第二种方式很直观，例：

　while(reader.Read())
{
　　?Response.Write(reader.GetInt32(0).ToString()+" "+reader.GetString(1).ToString()+"
");
}

　DataReader的GetInt32()和GetString()通过接收一个列号来返回一个列的值，这两种是最常用的，其中　　还有很多其它的类型。

(注：DataReader对象在调用Close()方法即关闭与数据库的连接，如果在没有关闭之前又重新打开第二个连接，则会产生一条异常信息)

　2.,ExecuteNonQuery()?这个方法并不返回一个DataReader对象，而是返回一个int类型的值，即在执行之后在数据库中所影响的行数。

　例：

　int affectrows=cmd.ExecuteNonQuery();
Response.Write(affectrows +" 条记录受影响");

?3,ExecuteScalar() 这个方法不接受任何参数，仅仅返回查询结果集中的第一行第一列，而忽略了其它的行和列，而且返回的是一个object类型，在使用之前必须先将它强制转换为所需类型。如果返回的仅仅是一个单独的数据元，则可以使用此方法来提高代码的性能。例：

string strCon="server=localhost;database=Northwind;Trusted_Connection=Yes;";
string strqry="select count(*) from Categories";
SqlConnection con=new SqlConnection(strCon);
con.Open();
SqlCommand cmd=con.CreateCommand();
int i=Convert.ToInt32(cmd.ExecuteScalar());　//必须强制转换

　4,ExecuteXmlReader() 此方法用于ＸＭＬ操作，返回一个XmlReader对象，由于系统默认没有引用 System.Xml名空间，因此在使用前必须前引入。例：

string strCon="server=localhost;database=Northwind;Trusted_Connection=Yes;";
SqlConnection con=new SqlConnection(strCon);
con.Open();
SqlCommand cmd = new SqlCommand("select * from Categories FOR XML AUTO, XMLDATA", con);
XmlReader xr=cmd.ExecuteXmlReader();
Response.Write(xr.AttributeCount);　　//这里获取当前节点上的属性个数?

xr.Close();

　执行完毕之后，照样要显式地调用Close()方法，否则会抛出异常。

　使用参数化的查询

　　先看一段ＳＱＬ语句：select CategoryID,Description from Categories where CategoryID=? 其中的问号就是一个参数。但在使用的时候必须是带有＠前缀的命名参数，因为.NET数据提供程序不支持这个通用的参数标记“？”.使用参数化的查询可以大大地简化编程，而且执行效率也比直接查询字符串要高，也更方便，很多情况下都需要更改查询字符串，这种方式就提供了方便，只需更改参数的值即可。例：

　string strCon="server=localhost;database=Northwind;Trusted_Connection=Yes;";
SqlConnection con=new SqlConnection(strCon);
con.Open();
string strqry="select * from Categories where CategoryID=@CategoryID";　//带参数的查询
SqlCommand cmd=new SqlCommand(strqry,con);
cmd.Parameters.Add("@CategoryID",SqlDbType.Int,4);　//给参数赋于同数据库中相同的类型
cmd.Parameters["@CategoryID"].Value="3";　//给参数赋值，可灵活改变
SqlDataReader r=cmd.ExecuteReader();　
while(r.Read())
{
Response.Write(r.GetString(2)+"
");　//取出指定参数列的值
}
con.Close();　//切记关闭

　使用存储过程进行查询

　先看段存储过程的形式：create procedure cateproc (@CategoryID int(4)) as select * from Categories where CategoryID=@CategoryID? return。

　这个是数据库中的存储过程实现方式，要在程序中调用存储过程，一种方法是使用Command对象的　CommandType属性来实现。CommandType有三个枚举值：Text,TableDirect,StoredProcedure。只需将CommandType属性设为第三个值即可实现调用存储过程。例：

　string strCon="server=localhost;database=Northwind;Trusted_Connection=Yes;";
SqlConnection con=new SqlConnection(strCon);
con.Open();
SqlCommand cmd=con.CreateCommand();
cmd.CommandText="cateproc";
cmd.CommandType=CommandType.StoredProcedure;
cmd.Parameters.Add("@CategoryID",SqlDbType.Int,4);
cmd.Parameters["CategoryID"].Value="2";
SqlDataReader r=cmd.ExecuteReader();
while(r.Read())
{
Response.Write(r.GetString(2)+"
");
}
con.Close();

　其实在程序中实现调用存储过程的方式跟参数化查询很类似，有点旧鞋翻新的味道。

　cmd.CommandType=CommandType.StoredProcedure;这种方式有个缺点，就是当要查询的表，视图或存储过程的名称中有特殊的字符（如空格）的话，则将无法识别。因此还有一种方式就是:

　cmd.CommandText="{Call cateproc(?)}";　//这里是调用存储过程，问号为参数
cmd.CommandType=CommandType.Text;　//关键是这里。

　设置命令执行超时

　命令超时是指Command对象在等待结果的时间，（默认为３０秒）如果在３０秒内没执行查询，则Command抛出一个异常。也可以自己进行设置。例：cmd.CommandTimeout=60;

　取消执行查询

　有时因某种原因，需要临时取消命令的执行，可调用Command对象的Cancel()方法来退出执行，如果在未执行查询之前，Cancel()将不做任何事。


首先，ADO.NET中使用了DataAdapter 来处理与数据库的联机与脱机。当时开发人员设计了DataAdapter是为了能够处理脱机数据，方便操作，关于这一点，只要调用其Fill()方法即可,这时会在DataSet中创建一个新的名为“Table“的DataTable.要重新指定名可用DataAdapter.Fill(DataSet,“Tabelname“)。此时connection也关闭了。DataAdapter既可以用来提交查询，并将结果存储到DataSet中，也可以用来向数据库传递更改。仅仅使用其Update方法即可达到向数据库提交存储地DatSet中的更改。

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconworkingwithtypeddataset.asp

Implementing Data Transfer Object in .NET with a Typed DataSet

Version 1.0.0

GotDotNet community for collaboration on this pattern

Complete List of patterns & practices

Context

You are implementing a distributed application with the .NET Framework. The client application displays a form that requires making multiple calls to an ASP.NET Web service to satisfy a single user request. Based on performance measurements you have found that making multiple calls degrades application performance. To increase performance, you would like to retrieve all the data that the user request requires in a single call to the Web service.

Background

Note: The following is the same sample application that is described in Implementing Data Transfer Object in .NET with a DataSet.

The following is a simplified Web application that communicates with an ASP.NET Web service to deliver recording and track information to the user. The Web service in turn calls a database to provide the data that the client requests. The following sequence diagram depicts the interaction among the application, the Web service, and the database for a typical page.

Figure 1: Behavior of a typical user request

Figure 1 illustrates the sequence of calls needed to fulfill the entire user request. The first call retrieves the recording information, and the second call retrieves the track information for the specified recording. In addition, the Web service must make separate calls to the database to retrieve the required information.

Database Schema

The schema that is used in the example shown in Figure 2 depicts a recording record that has a one-to-many relationship with a track record.

Figure 2: Schema for sample application

Implementing a DTO

One way to improve the performance of this user request is to package all the required data into a data transfer object (DTO) that can be sent with a single call to the Web service. This reduces the overhead associated with two separate calls and allows you to use a single connection with the database to retrieve both the recording and the track information. For a detailed description of how this improves performance, see the Data Transfer Object pattern.

Implementation Strategy

A typed DataSet is a generated subclass of System.Data.DataSet. You provide an XML schema file which is then used to generate a strongly-typed wrapper around the DataSet. The following two code samples illustrate the differences. The first sample is implemented with an ordinary DataSet:

 

DataTable dataTable = dataSet.Tables["recording"];
DataRow row = dataTable.Rows[0];
string artist = (string)row["artist"];
 

This sample indicates that you need to know the table and column names to access the tables and fields contained in the DataSet. You also have to know the return type of the Artist field to ensure that the correct cast is done. If you do not use the correct type, you will get a runtime error. The following is the same example implemented with a typed DataSet:

 

   Recording recording = typedDataSet.Recordings[0];
   string artist = recording.Artist; 
 

This example demonstrates the benefits that the typed interface provides. You no longer have to refer to table or column by name and you do not have to know that the return type of the Artist column is a string. A typed DataSet defines a much more explicit interface that is verifiable at compile time instead of at runtime. In addition to the strongly-typed interface a typed DataSet also can be used in all places a DataSet can be used; therefore, it also can be used as a DTO. It is loaded in a similar fashion as a DataSet and it can be serialized to and from XML. In comparison to an ordinary DataSet you do have to write and maintain an XML schema that describes the typed interface. The Microsoft Visual Studio .NET development system provides a number of tools that simplify the creation and maintenance of the schema.The rest of this implementation strategy outlines the steps required in creating a typed DataSet for the sample application just described.

Creating a Typed DataSet

A typed DataSet is generated from an XML schema. Visual Studio .NET provides a drag-and-drop tool which automates the creation of the schema (see Figure 3) and the generation of the typed DataSet classes. If you do not use Visual Studio.NET, you can write the XML schema and use a command-line tool called XSD.exe to generate the typed DataSet. For detailed instructions on both of these methods, see "Typed DataSets in ADO.NET" from the May 2001 issue of .NET Developer [Wildermuth02].

Figure 3: Visual Studio .NET DataSet file type

RecordingDto.xsd

The following is the XML schema for the DTO to be used in this example. It combines both the recording table along with its associated track records in a single typed DataSet named RecordingDto:

 

<?xml version="1.0" encoding="utf-8" ?>
<xs:schema id="RecordingDto" targetNamespace="http://msdn.microsoft.com/practices/RecordingDto.xsd"
   elementFormDefault="qualified" attributeFormDefault="qualified" xmlns="http://tempuri.org/RecordingDTO.xsd"
   xmlns:mstns="http://msdn.microsoft.com/practices/RecordingDto.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema"
   xmlns:msdata="urn:schemas-microsoft-com:xml-msdata" xmlns:codegen="urn:schemas-microsoft-com:xml-msprop">
   <xs:element name="RecordingDto" msdata:IsDataSet="true">
      <xs:complexType>
         <xs:choice maxOccurs="unbounded">
            <xs:element name="recording" codegen:typedName="Recording" codegen:typedPlural="Recordings"
               codegen:typedChildren="Track">
               <xs:complexType>
                  <xs:sequence>
                     <xs:element name="id" type="xs:long" codegen:typedName="Id" />
                     <xs:element name="title" type="xs:string" codegen:typedName="Title" />
                     <xs:element name="artist" type="xs:string" codegen:typedName="Artist" />
                  </xs:sequence>
               </xs:complexType>
            </xs:element>
            <xs:element name="track" codegen:typedName="Track" codegen:typedPlural="Tracks" codegen:typedParent="Recording">
               <xs:complexType>
                  <xs:sequence>
                     <xs:element name="id" type="xs:long" codegen:typedName="Id" />
                     <xs:element name="title" type="xs:string" codegen:typedName="Title" />
                     <xs:element name="duration" type="xs:string" codegen:typedName="Duration" />
                     <xs:element name="recordingId" type="xs:long" codegen:typedName="RecordingId" />
                  </xs:sequence>
               </xs:complexType>
            </xs:element>
         </xs:choice>
      </xs:complexType>
      <xs:unique name="RecordingDTOKey1" msdata:PrimaryKey="true">
         <xs:selector xpath=".//mstns:recording" />
         <xs:field xpath="mstns:id" />
      </xs:unique>
      <xs:unique name="RecordingDTOKey2" msdata:PrimaryKey="true">
         <xs:selector xpath=".//mstns:track" />
         <xs:field xpath="mstns:id" />
      </xs:unique>
      <xs:keyref name="recordingtrack" refer="mstns:RecordingDTOKey1">
         <xs:selector xpath=".//mstns:track" />
         <xs:field xpath="mstns:recordingId" />
      </xs:keyref>
   </xs:element>
</xs:schema>
 

This schema is not the exact file produced by Visual Studio .NET. It is annotated with a number of attributes that are prefixed from the codegen namespace. This modification is desirable because the code that is generated does not adhere to the .NET naming conventions. For example, without the modification, Visual Studio .NET would generate a track class that corresponds to the track table, whereas according to conventions used in the .NET Framework the class should be named Track. To change the name of the class that is generated, you must add the codegen:typedName attribute to the element definition in the XML schema:

 

<xs:element name="track" codegen:typedName="Track">
   
</element>
 

There are a number of other attributes besides codegen:typedName. For a detailed description of all the attributes, see "Typed DataSets in ADO.NET" from the May 2001 issue of .NET Developer [Wildermuth02].

Filling a Typed DataSet from the Database

The following code example demonstrates how to fill a typed DataSet with the data that the sample application requires. This includes the specific recording record and all of its associated track records. The difference between this code and filling an ordinary DataSet is that you do not need to explicitly define the relationship between the recording and track records.

Assembler.cs

Just as in Implementing a Data Transfer Object in .NET with a DataSet, an Assembler class maps the actual database calls into the typed DataSet:

 

using System;
using System.Data;
using System.Data.SqlClient;

using Recording;

public class Assembler
{
   public static RecordingDto CreateRecordingDto(long id)
   {
      string selectCmd = 
         String.Format(
         "select * from recording where id = {0}",
         id);

      SqlConnection myConnection = 
         new SqlConnection(
         "server=(local);database=recordings;Trusted_Connection=yes;");
      SqlDataAdapter myCommand = new SqlDataAdapter(selectCmd, 
         myConnection);

      RecordingDto dto = new RecordingDto();
      myCommand.Fill(dto, "recording");

      String trackSelect = 
         String.Format(
         "select * from Track where recordingId = {0} order by Id",
         id);

      SqlDataAdapter trackCommand = 
         new SqlDataAdapter(trackSelect, myConnection);
      trackCommand.Fill(dto, "track");

      return dto;
   }
}
 

Note: The example shown here is not meant to describe the only way to fill the typed DataSet. There are many ways to retrieve this data from the database. For example, you could use a stored procedure.

Using a Typed DataSet in an ASP.NET Page

As mentioned previously, a typed DataSet inherits from System.Data.DataSet. This means that it can be substituted for a DataSet. For example, when using the .NET user interface controls (Web Forms or Windows Forms) a typed DataSet can be used in all places you could use a DataSet. The sample application page shown in the following code example uses two DataGrid controls, RecordingGrid and TrackGrid. You can use the typed DataSet, RecordingDto when setting the DataSource properties on the controls because a typed DataSet inherits from DataSet.

 

using System;
using System.Data;
using RecordingApplication.localhost;

public class RetrieveForm : System.Web.UI.Page
{
   private RecordingCatalog catalog = new RecordingCatalog();
 
   // 

   protected void Button1_Click(object sender, System.EventArgs e)
   {
      string stringId = TextBox1.Text;
      long id = Convert.ToInt64(stringId);

      RecordingDTO dto = catalog.Get(id);
      RecordingGrid.DataSource = dto.recording;
      RecordingGrid.DataBind();

      TrackGrid.DataSource = dto.track;
      TrackGrid.DataBind();
   }
}
 

Tests

Because the typed DataSet is generated by tools in the .NET Framework, you do not need to write tests to verify that it functions correctly. In the following tests, you are testing that the Assembler class loaded the typed DataSet correctly.

AssemblerFixture.cs

 

using NUnit.Framework;
using System.Data;
using Recording;

[TestFixture]
public class AssemblerFixture
{
   private RecordingDto dto;
   private RecordingDto.Recording recording;
   private RecordingDto.Track[] tracks; 
   
   [SetUp]
   public void Init()
   {
      dto = Assembler.CreateRecordingDto(1234);
      recording = dto.Recordings[0];
      tracks = recording.GetTracks();
   }

   [Test]
   public void RecordingCount()
   {
      Assert.Equals(1, dto.Recordings.Rows.Count);
   }

   [Test]
   public void RecordingTitle()
   {
      Assert.Equals("Up", recording.Title.Trim());
   }


   [Test]
   public void RecordingChild()
   {
      Assert.Equals(10, tracks.Length);

      foreach(RecordingDto.Track track in tracks)
      {
         Assert.Equals(recording.Id, track.RecordingId);
      }
   }

   [Test]
   public void TrackParent()
   {
      RecordingDto.Track track = tracks[0];
      RecordingDto.Recording parent = track.Recording;
      Assert.Equals("Up", parent.Title.Trim());
   }

   [Test]
   public void TrackContent()
   {
      RecordingDto.Track track = tracks[0];
      Assert.Equals("Darkness", track.Title.Trim());
   }

   [Test]
   public void InvalidRecording()
   {
      RecordingDto dto = Assembler.CreateRecordingDto(-1);
      Assert.Equals(0, dto.Recordings.Rows.Count);
      Assert.Equals(0, dto.Tracks.Rows.Count);
   }
}
 

These tests describe how to access the individual elements of the DataSet. Because of the use of a typed DataSet, the test code does not require the actual column names and does not require the return type to be cast. Comparing these tests with the ones described in Implementing Data Transfer Object in .NET with a DataSet reveals the differences between using a strongly-typed interface and a generic interface. The strongly-typed interface is easier to use and understand. It also provides the added benefit of compile-time checking on return types.

Resulting Context

Implementing DTO with a typed DataSet shares a number of the same benefits and liabilities as implementing DTO with a DataSet; however, certain benefits and liabilities are unique to a typed-DataSet implementation.

Benefits

The typed DataSet shares the following benefits with a DataSet when used as a DTO:

今天想找一个Class浏览工具，就像VS.NET中的对象浏览器。后来在http://www.dotnettoolbox.com/toolbox/ViewCategory.aspx?ID=5（这个网站也是个不错的地方）发现这个工具：Reflector for .NET 。

网址:
http://www.aisto.com/roeder/dotnet/
下载地址:
http://www.aisto.com/roeder/dotnet/
注意：下载时要输一些注册信息，输入用户名时，中间要加一个空格。
功能介绍：
Reflector is a class browser for .NET components (assemblies). It supports assembly and namespace views, type and member search, C# XML documentation viewer, reference search, IL disassembler, VB and C# decompiler, dependency trees, supertype/subtype hierarchies and resource viewers. Function prototypes are displayed in C# and VB syntax.