亚洲欧洲无码一区二区三区,亚洲AV无码成人精品区狼人影院 ,亚洲伊人久久大香线蕉啊

��?NET assembly�c�d��

�W�笨 — Sun, 17 Apr 2005 10:35:00 GMT

��?NET assembly�c�d��

作者： silicon.com
2005-03-16 12:7 PM

�l�护头文仉��常是一个冗长乏呛_ƈ且容易出错的�q�程�Q�感�?NET assembly�c�d��抹去了对�q�些文�g的倚赖�?/P>

微��Y.NET的可��理的C++最�l�简化了我们创徏�c�d��的方法，或更准确些，.NET assembly�c�d��Q�这�U�简化得以实��C��要是�׃��assembly�c�d��是可以自我描�q�的。这对一个Managed C++�E�序员意味着什么呢�Q�基本上�Ԍ��一�?assembly�~�译成功�Q�你在编译传�l�C++�c�d��的时谨慎创徏的所有头文�g除了�l�护的需要外�Q�都不再是必需的�?/P>

��׃��言�Q�我感觉�l�护头文件是一�U�痛苦，所以我很高兴看到这�U�对头文件的倚赖正在消失。我�l�常会忘记需要在库中引用的一个或多个头文件的名称�Q��ؓ了找到缺��q��数据�c�d��定义�Q�我不得不对所有含有头文�g的内容进行搜索，更糟�p�的是，��源代码拆分��Z��半增加了我犯错误的机会。我�l�常犯的错误包括忘记��所有的包含头文件打包、��.h文�g�?cpp��q��同步�?/P>

既然对头文�g的程序集不再是必需的，你可以��用一�U�改�q�了的新�Ҏ��来创建源文�g。但在考察�q�种�Ҏ��之前�Q�先让我们先来回��一下创建程序集的传�l�方�?/P>

传统�Ҏ��

在C++中，传统的库文�g创徏�Ҏ��是徏立一�p�d��头文件用以描�q�类库中所有的功能�Q�接下来�Q�你要在一个单独的源文件中实现�q�些头文件所定义了的所有功能。然后，在编译器中运行每一个源代码文�g�q�同其相关的头文�Ӟ��以生成目标文�Ӟ��再将所有的目标文�g�怺�链接来创建库文�g

图A描述了这�U�传�l�方法�?/P>

图A

创徏库的传统�Ҏ��

使用头文件的原因在于�Q�今后引用这个类的时候，所有的�c�R��结构体、变量等�{�都可以很方便的定义�?/P>

�E�序集可以��用同��L��Ҏ��生成�Q�这一�q�程的唯一区别在于Managed C++的标志是事先��定的�?/P>

在下面的例子中，列表A、B、C和D演示了如何用传统C++的方法创��Z��?assembly�?/P>

列表A�l�出了头文�gCards.h的定义，�q�个文�g定义了一个包含扑克牌和Card�cȝ��枚�D(enmu)�Q�注意，使用ManagedC++�Ӟ��关键字public要放在enum和class之前的，因�ؓ�q�两者都需要在全局范围内可以被讉K��?/P>

列表B展示了类的构造器和成员方法的实现�Q�列表C定义了第二个�c�Deck�Q�注意，虽然从来没有在头文�g中定义，但Card�c�L��在Deck�c�M��内��用的�Q��用这一技巧需要�}讎ͼ�在编译过�E�中�Q�头文�g基本上是大批量地�_�脓到源文�g中的。既然是�q�样的情况，我们只需��单地在Deck.cpp源文件的包含文�g列表中将Card.h攑֜�Deck.h的前面，如此操作之后�Q�Card�c�d��首先被粘��_��l�而被定义为Deck�c�L��必需的类�?/P>

列表D昄��了在�q�个�q�你库中的源文�g�Q�注意，正如我们刚刚所提到的，Card.h包含在Deck.h之前�?/P>

在命令行中执行徏�?assembly库的命��o�q�不像火��科学一栯��难，其语法（没有�q�些省略��P��非常��单：

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

C++�~�译器取走这一�p�d��源文件的名称�Q�然后是/CLR参数�Q�它告诉�~�译器我们正在��用managed的扩展，�l��?LD参数告诉�q�接器去创徏一�?dll文�g�Q�最�?o参数��说明这�?dll文�g的名�U��?/P>

��Z��~�译以上的例子，你可能会用到�q�行命��o�Q?/P>

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

新的 assembly�Ҏ��

不再受困于分��d��文�g和源文�g的工作，��׃ؓ新的库文件编码方式提供了可能性。在兜了一个圈子之后，我将开始介�l�我的简便方法，首先�Q�将所有的�c�M��c�L��?.h)形式�q�行�~�码�Q�其中包括所有的定义和实玎ͼ�然后使用一个单独的�q�接器文�?.cpp)来包含所有的�c�L��Ӟ��q�种�Ҏ��唯一有些��手的部分在于，你要��定所有的�c�L��件是按照正确的顺序排列的�Q�以保证一切需要调用的数据�c�d��在��用之前都已经定义好了�Q�即使��用传�l�方法，�q�一问题同样需要处理。图B展示了这�U�新�?assembly�Ҏ��?/P>

图B

新的 assembly�Ҏ��

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

列表E、F和G展示了��用新�Ҏ��生成的同��L��库�?/P>

正如你看到的那样�Q�列表E是传�l�方法中Card.h和Card.cpp�q�两个文件相�l�合而�Ş成的�Q�我基本上只是把实现部分直接攑֜��cȝ��定义中，而不是在一个单独的文�g中进行定义�?/P>

同样的，列表F是传�l�方法中Deck.h和Deck.cpp�q�两个文件相�l�合形成的，如果使用传统�Ҏ��Q�你可以在这个类中访问其他的�c�而不必在文�g中定义他们，�q�接器文仉��要确保所有类的定义是按照正确的顺序排列的�Q�以保证�q�些�c�d��使用之前都已�l�定义好了�?/P>

在列表G中显�C�的�q�接器文件是唯一一个与众不同的文�g�Q�它除了包含语句之外没有��M��其他的东西，ManagedC++�~�译器只�~�译.cpp文�g�Q��ؓ了让�~�译器完成所有的工作�Q�你必须有这个文件。这�U�便利所带来的副作用是从库中��d��或删除类变得�Ҏ��了，而你已经��组成库的类名称记录在了一个单一的地斏V��在开发过�E�中�Q�连接器文�g�q�是一个放�|�测试代码的理想场所�?/P>

以这�U�方法徏立一个assembly�c�d��的额外的优点是，在命令行条�g下��用时�Q�其命��o很简单：

clcards.cpp /CLR /LD

�l�论

��h��自我描述功能�?assembly器简化了我们�~�码的方法，�q�主要是因�ؓ源代码模块不再需要被分离为头文�g和源码文�Ӟ��正因为得益于此，我们展示了一�U�构�?assembly库的新方法�?/P>

责�Q�~�辑�Q?A href="mailto:li_ning@zdnet.com.cn?subject=http://www.zdnet.com.cn/developer/news/story/0,3800066930,39336568,00.htm">李宁

�W�笨 2005-04-17 18:35 发表评论

使用ADO.NET的Connection对象

�W�笨 — Tue, 12 Apr 2005 06:59:00 GMT

http://blog.csdn.net/jabby12/archive/2004/08/03/59602.aspx
在ADO.NET对象模型中，Connection对象代表了与数据源之间的�q�接�?NET框架中有两个Connection对象�Q�一个是OleDbConnection,用于大多数的数据库连接，一个是SqlConnection�Q�是MS开发的专门用于针对SQL Server的连接。在创徏Connection对象之前�Q�你必须先引用System.Data.OleDb或者System.Data.SqlClient和System.Data三个名空间�?

1.SQL Server数据库的�q�接

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

�q�是�q�接到本地数据库�Q�如果你惌��到网�l�上的的数据库，��p��利用集成安全性，同时忽略用户名和密码。如�Q?/P>

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

如果使用的是ODBC�q�接到SQL Server�Q�可以通过使用Trusted_Connection�Q�yes;来��用网�l�数据库�?/P>

2.Oracle数据库的�q�接�Q�（前提�Q�必��d��安装Oracle客户端实用工��L��适当版本�Q��ƈ创徏数据库别名，接着��可以用以下的连接字�W�串�q�行�q�接�Q?/FONT>

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

3.Access数据库的�q�接�Q�（你可以��用以下连接字�W�串来连接）

SqConnection con=new SqlConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=d:\yourdb.mdb;User id=yourid,password=youpwd;);

�q�接到数据库之后卛_��调用Connection对象的Open()�Ҏ��来打开与数据库的连接，同理Close()�Ҏ��用来关闭与数据库的连接�?/P>

�q�接池：

�q�接池是什么？在一个三层结构（或N层）中，当一个客��L��与中间层服务器进行通讯的时候，服务器会创徏一个与数据库连接，�q�执行操作的业务对象�Q�也��是与数据库�q�接的实例）�Q�同时会创徏一�?/FONT>Connection对象�Q�在攑֜�一个池中（实际上是一个线�E�）。当释放�q�个实例的时候，此实例便关闭�Q�此时�ƈ没有真正的关闭数据连接，而是��Connection对象标记为关闭后存储在池中。如果这时再来启动一个新的业务对象，�q�时��׃��查现有的�q�接�Q�如果池中有打开的连接，即��用它�Q�否则再创徏一个新�q�接�?/FONT>

可能你会觉得很奇怪，如果�q�样�Q�那池中不是有很多的对象�Q�岂不是会浪费很多的资源�Q�这个问题的解决�Ҏ��是你可以讄��与数据库的特定连接时��_��默认60�U�）�Q�如果在�q�个旉��内未被��用，.NET提供��׃��关闭此连接�?/FONT>

如何打开�q�接池？默认情况下是打开�?

如何关闭�q�接池？可以使用OleDbConnection.ReleaseConnectionPool()�Ҏ��来关闭连接池�Q�更或者你可以在Ｏ�Q��I　�Q��q�接字符串中加上OLE DB Services= - 4;在用SqlConnection对象时可在连接符中加上Pooling=False。这时你再调用Close()时候便会真正地关闭与数据库的连接�?/P>

�Q�注1�Q�可以��用Ｓ�Q�Ｌ事�g探查器或性能监视器来观察�q�接到数据库中的�q�接数目�Q�以识别�q�接是否真正关闭或是只是攑օ�池中。）

�Q�注2�Q�可以显式调用Dispose()�Ҏ��在垃圾收集器回收之前释放资源�Q�但如果你只是将Connection对象设�ؓ�Q�Ｕ�Q�Ｌ的话�Q�是不会断开与数据源的连接的�Q?/P>

利用Connection对象来创建Command对象�Q?ADO.NET中用Command对象来执行数据查询，更新�Q�例　�Q?/P>

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对象�Q?Transaction对象是ADO.NET中的事务��理对象�Q?/FONT>

例：

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

con.Open();

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

(注：事务是指一�l�单一实体�q�行的语句，可以��保数据的完整性，防止因系�l�故障或其它原因而引��L��数据丢失。概念很抽象�Q�呵呵，看下��d��明白了）

事务有Ａ�Q�ﾃ�Q�四个属性（卛_��子性，一致性，隔离性，持久性）�Q?/FONT>

原子�?/FONT>指在执行事务�q�程中，�q�个�q�程要么成功执行�Q�要么不执行�?/FONT>

一致�?/FONT>指事务前和事务后的数据的一致性，也就是如果事务成功执行的话，�pȝ��p��回成功的状态，��x��有数据的改变标记为已完成�Q�如没完成事务，卛_��滚，�q�回到先前的合法状态�?/FONT>

隔离�?/FONT>指一个事务内的�Q何变化都独立于其它的事务�Q�相对于两个事务的说法）

持久�?/FONT>指事务是持箋的，也就是事务成功完成后的改变是�怹�的�?/FONT>

�Q�注�Q�事务有手动和自动两�U�，本文的主题不在此�Q�事务的介绍在其它篇章会涉及刎ͼ�

取得数据库的架构信息�Q?/FONT>

有时你会发觉有需要获取数据库的架构信息来方便�E�序的运行。可使用OleDbConnection对象的GetOleDbSchemaTable()�Ҏ��来获取，它需要一个参数用来作�q�回的架构信息的�q��o器，卛_��获取表中的列或行信息�Q�不写此参数则获取整个表所有列的信息�?/P>

例：

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的连接对象还有很多有用的�Ҏ��Q�具体查�Q�Ｓ�Q�Ｎ�?/P>

�W�笨 2005-04-12 14:59 发表评论

Using Annotations with a Typed DataSet

�W�笨 — Tue, 12 Apr 2005 06:16:00 GMT

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.

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.

 codegen:typedName="Customer" codegen:typedPlural="Customers">

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.

Annotation	Description
typedName	Name of the object.
typedPlural	Name of a collection of objects.
typedParent	Name of the object when referred to in a parent relationship.
typedChildren	Name of the method to return objects from a child relationship.
nullValue	Value if the underlying value is DBNull. See the following table for nullValue annotations. The default is _throw.

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

nullValue	Description
Replacement Value	Specifies a value to be returned. The returned value must match the type of the element. For example, use `nullValue="0"` to return 0 for null integer fields.
_throw	Throw an exception. This is the default.
_null	Return a null reference or throw an exception if a primitive type is encountered.
_empty	For strings, return String.Empty, otherwise return an object created from an empty constructor. If a primitive type is encountered, throw an exception.

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

Object/Method/Event	Default	Annotation
DataTable	TableNameDataTable	typedPlural
DataTable Methods	NewTableNameRow AddTableNameRow DeleteTableNameRow	typedName
DataRowCollection	TableName	typedPlural
DataRow	TableNameRow	typedName
DataColumn	DataTable.ColumnNameColumn DataRow.ColumnName	typedName
Property	PropertyName	typedName
Child Accessor	GetChildTableNameRows	typedChildren
Parent Accessor	TableNameRow	typedParent
DataSet Events	TableNameRowChangeEvent TableNameRowChangeEventHandler	typedName

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.


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">
  
    
      
         codegen:typedName="Customer" codegen:typedPlural="Customers">
          
            
              codegen:typedName="CustomerID" type="xs:string" minOccurs="0" />
              codegen:typedName="CompanyName" type="xs:string" minOccurs="0" />
              codegen:typedName="Phone" codegen:nullValue="" type="xs:string" minOccurs="0" />
            
          
        
         codegen:typedName="Order" codegen:typedPlural="Orders">
          
            
              codegen:typedName="OrderID" type="xs:int" minOccurs="0" />
              codegen:typedName="CustomerID" codegen:nullValue="" type="xs:string" minOccurs="0" />
              codegen:typedName="EmployeeID" codegen:nullValue="0" type="xs:int" minOccurs="0" />
              codegen:typedName="OrderDate" codegen:nullValue="1980-01-01T00:00:00" type="xs:dateTime" minOccurs="0" />
            
          
        
      
    
    
      
      
    
    codegen:typedParent="Customer" codegen:typedChildren="GetOrders">

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)
{

}

使用ADO.NET��L��操纵数据�?一)

�W�笨 — Tue, 12 Apr 2005 05:52:00 GMT

http://blog.csdn.net/jabby12/archive/2004/08/04/64027.aspx
ADO.NET提供了Connection来连接数据库�Q�同时也提供了Command对象来查询数据库。同Connection对象一��P��Command也有两种�Q�OleDbCommand和SqlCommand.其区别同Connection对象�?

　　要操�U�|��据库�Q�必��d��使用Connection来连接到数据库，再创��Z��个Command来查询。有几种创徏方式�Q�例�Q?/P>

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(); //�q�里使用用Connection对象的CreateCommand�Ҏ��来创��Z��个Command对象�?BR>cmd.CommandText=strqry;
//SqlDataReader reader=cmd.ExecuteReader();

?̔cmd=new SqlCommand();?? //直接使用new 关键字来创徏
cmd.CommandText=strqry;
?cmd.Connection=con;?? //讄��与数据库的连�?/P>

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

　执行方式�Q?/FONT>

�Q�主要有�q�么几种�Q�cmd.ExecuteReader();cmd.ExecuteNonQuery();cmd.ExecuteScalar();cmd.ExecuteXmlReader();�Q?/FONT>

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

使用DataReader可以提高执行效率�Q�有两种方式可以提高代码的性能�Q?FONT style="BACKGROUND-COLOR: #deb887">一�U�是��Z��序号的查找，一个是使用适当的Get�Ҏ��来查找�?/FONT>因�ؓ查询出来的结果一般都不会改变�Q�除非再�ơ改动查询语句，因此可以通过定位列的位置来查找记录。用�q�种�Ҏ��有一个问题，��是可能知道一列的名称而不知道其所在的位置�Q�这个问题的解决�Ҏ��是通过调用DataReader 对象的GetOrdinal()�Ҏ��Q�此�Ҏ��接收一个列名�ƈ�q�回此列名所在的列号。例�Q?/FONT>

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

reader.Close();

?至于�W�二�U�方式很直观�Q�例�Q?/FONT>

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

　DataReader的GetInt32()和GetString()通过接收一个列��h��q�回一个列的��|��q�两�U�是最常用的，其中　　�q�有很多其它的类型�?/FONT>

(注：DataReader对象在调用Close()�Ҏ��卛_��闭与数据库的�q�接�Q�如果在没有关闭之前又重新打开�W�二个连接，则会产生一条异�怿��?

　2.,ExecuteNonQuery()?�q�个�Ҏ��q�不�q�回一个DataReader对象�Q�而是�q�回一个int�c�d��的��|��卛_��执行之后在数据库中所影响的行数�?/FONT>

　例：

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

?3,ExecuteScalar() �q�个�Ҏ��不接受�Q何参敎ͼ�仅仅�q�回查询�l�果集中的第一行第一列，而忽略了其它的行和列�Q�而且�q�回的是一个object�c�d��Q�在使用之前必须先将它强制�{换�ؓ所需�c�d��。如果返回的仅仅是一个单独的数据元，则可以��用此�Ҏ��来提高代码的性能。例�Q?/FONT>

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() 此方法用于��Q�Ｌ操作�Q�返回一个XmlReader对象�Q�由于系�l�默认没有引�?System.Xml名空��_��因此在��用前必须前引入。例�Q?/FONT>

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);　　//�q�里获取当前节点上的属性个�?/FONT>?

xr.Close();

　执行完毕之后�Q�照栯��昑ּ�地调用Close()�Ҏ��Q�否则会抛出异常�?/FONT>

　使用参数化的查询

　　先看一�D�Ｓ�Q�Ｌ语句�Q�select CategoryID,Description from Categories where CategoryID=? 其中的问号就是一个参数。但在��用的时候必��L��带有�Q�前�~�的命名参敎ͼ�因�ؓ.NET数据提供�E�序不支持这个通用的参数标记“？�?使用参数化的查询可以大大地简化编�E�，而且执行效率也比直接查询字符串要高，也更方便�Q�很多情况下都需要更�Ҏ��询字�W�串�Q�这�U�方式就提供了方便，只需更改参数的值即可。例�Q?/FONT>

　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);　//�l�参数赋于同数据库中相同的类�?BR>cmd.Parameters["@CategoryID"].Value="3";　//�l�参数赋��|��可灵�z�L��?BR>SqlDataReader r=cmd.ExecuteReader();　
while(r.Read())
{
Response.Write(r.GetString(2)+"
");　//取出指定参数列的�?BR>}
con.Close();　//切记关闭

　使用存储�q�程�q�行查询

　先看�D�存储过�E�的形式�Q�create procedure cateproc (@CategoryID int(4)) as select * from Categories where CategoryID=@CategoryID? return�?/FONT>

　�q�个是数据库中的存储�q�程实现方式�Q�要在程序中调用存储�q�程�Q�一�U�方法是使用Command对象的　CommandType属性来实现。CommandType有三个枚丑ր�|��Text,TableDirect,StoredProcedure。只需��CommandType属性设为第三个值即可实现调用存储过�E�。例�Q?/FONT>

　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();

　其实在程序中实现调用存储�q�程的方式跟参数化查询很�c�M��Q�有�Ҏ��鞋翻新的味道�?/FONT>

　cmd.CommandType=CommandType.StoredProcedure;�q�种方式有个�~�点�Q�就是当要查询的表，视图或存储过�E�的名称中有�Ҏ��的字�W�（如空��|��的话�Q�则��无法识别。因�?/FONT>�q�有一�U�方式就�?

　cmd.CommandText="{Call cateproc(?)}";　//�q�里是调用存储过�E�，问号为参�?BR>cmd.CommandType=CommandType.Text;　//关键是这里�?/FONT>

　讄��命��o执行��时

　命��o��时是指Command对象在等待结果的旉��Q�（默认为３�Q�秒�Q�如果在�Q�０�U�内没执行查询，则Command抛出一个异常。也可以自己�q�行讄��。例�Q�cmd.CommandTimeout=60;

　取消执行查询

　有时因某�U�原因，需要��时取消命令的执行�Q�可调用Command对象的Cancel()�Ҏ��来退出执行，如果在未执行查询之前�Q�Cancel()��不做�Q何事�?BR>

首先�Q�ADO.NET中��用了DataAdapter 来处理与数据库的联机与脱机。当时开发�h员设计了DataAdapter是�ؓ了能够处理脱机数据，方便操作�Q�关于这一点，只要调用其Fill()�Ҏ��卛_��,�q�时会在DataSet中创��Z��个新的名为“Table“的DataTable.要重新指定名可用DataAdapter.Fill(DataSet,“Tabelname�?。此时connection也关闭了。DataAdapter既可以用来提交查询，�q�将�l�果存储到DataSet中，也可以用来向数据库传递更攏V��仅仅��用其Update�Ҏ��卛_��辑ֈ�向数据库提交存储地DatSet中的更改�?/P>

DataAdapter��查询的�l�果存储在DataSet或DataTable对象中，当执行这一�q�程的时候，DataAdapter使用了一个Command来与数据库通讯�Q��ƈ在内部��用了DataReader来获取查询结果，最后才��结果复制到DataSet新行中去。这也是Fill的过�E�。如果有两个DataAdapter对象�Q�都使用相同的Connection对象�Q�在创徏的时候就会创��Z��个Connection对象�Q�而不是同一个，�q�种情况的解��x��案是�Q?/P>

   SqlConnection con=new SqlConnection("server=localhost;database=Northwind;Trusted_Connection=Yes;")
   SqlDataAdapter da=new SqlDataAdapter("select CategoryID,Description from Categories",con);
   SqlDataAdapter da=new SqlDataAdapter("select CategoryID,Description from Customers",con);

而不是将查询字符�Ԍ��单独写成一行�?/P>

有时候可能�ƈ不希望DataSet中的架构与数据库中的架构相同�Q�这�U�情�늚�解决�Ҏ��之一是可以采用别名的�Ҏ��Q�即select id as Product ID,amount as Product Amount from product;另外一�U�解��x��案就是��用DataAdapter提供的TableMappings集合机制�Q�通过它就可以��查询结果映��到DataSet�l�构中，�q�种�Ҏ��更方便，更灵�z�R��TableMappings属性返回一个DataTableMappingsCollection对象�Q�其中包含了一�l�DataTableMappings�Q�只要DataSet中相应的表名�U�C��数据库中的表名相同，卛_��以��用它来创��Z��个映��?DataSet中可以有多个�?。TableMappings里还有一个ColumnMappings属性，其用法与TableMappings�怼�。其原理是DataAdapter从数据库��d��数据后，利用DataReader从结果集中获取列名称�Q�有一点特别要注意�Q�即只能获取列名�U�而无法获取表名称�Q�DataAdapter事先假定表名�U�CؓTable,接着遇到映射语句则进行表映射。不说了�Q�看代码�Q?/FONT>

DataColumnMapping colMap;
   SqlConnection con=new SqlConnection("server=localhost;database=Northwind;Trusted_Connection=Yes;");
   SqlDataAdapter da=new SqlDataAdapter("select CategoryID,Description from Categories",con);
   DataSet ds=new DataSet();

DataTableMapping tblMap=da.TableMappings.Add("Table","Ca"); //�q�里Table为关键，映射表名为Ca

   colMap=tblMap.ColumnMappings.Add("CategoryID","ID"); //映射列表
   colMap=tblMap.ColumnMappings.Add("Description","描述");
   // Response.Write(tblMap.DataSetTable.ToString());
    da.Fill(ds);
   DataTable dt=ds.Tables["Ca"]; //�q�里是映��后的表名，如果仍�ؓ数据库的表名�Q�则无效�Q�特别注�?BR>   this.DataGrid1.DataSource=dt;
   this.DataGrid1.DataBind();

�q�行代码后就会发现DataGrid1上的列名为ID和描�q?(^_^)

�Q�注�Q��用DataTableMapping 之前要前导入名空间System.Data.Common;�Q?/P>

�q�可以��用AddRange�Ҏ��来简化表和列的映��：(一些代码同上面)

  .......
   DataTableMapping tblMap=da.TableMappings.Add("Table","Ca");       DataColumnMapping[] colMapArray=new DataColumnMapping[]{new DataColumnMapping("CategoryID","�?nbsp; 品号"),new DataColumnMapping("Description","描述")};        tblMap.ColumnMappings.AddRange(colMapArray);
   ......

�q�种映射关系只能从数据库中读取展�C�给用户�Q�如果要��映��后的Table的更�Ҏ��交给数据库，�q�时库发现其中列与库中列不同�Q�便会发生异常，DataAdapter 同时也提供了MissingMappingAction属性来处理�?/FONT>

DataAdapter1.MissingMappingAction=MissingMappingAction.Passthrough/Ignore/Error

它接受MissingMappingAction的枚丑ր�|��Passthrough�q�个��D��C�如果在库中找不��C��DataSet中相同列的话�Q�就��此列映��到库中�Q�Ignore枚�D��D��C�忽略示出现的列�Q�Error表示找不到相应的列则抛出异常�?/P>

分页�Q?/P>

分页在应用中是常有的事，而DataAdapter本��n也提供了分页的简单功能，如：DataAdapter1.Fill(dataset,startrow,rownum,“tablename�?�q�种功能用于数据量较��的查询��可以，但当有大量数据的时候，��׃��发现�q�种分页的问题的存在。它的原理是假如有一百行数据�Q�分成十��，每页十行�Q�当获取每一��늚�时候，�q�回前１�Q�行�Q�再接着�Q�第二页�Q�删除了前１�Q�行而获取接下的�Q�０行，在这一�ơ中�Q�只是�ؓ了获取１�Q�行数据�Q�但数据库却�q�回了２�Q�行�Q�依此类推，�W�１�Q�页的时候就会返回１�Q�０行，而DataAdapter本��n��帮我们删除了９�Q�行�Q�因为我们看上去�q�回的还是１�Q�行�Q�这�U�性能太低。因此本��l�介�l�另外一�U�性能较高的分��|��法。实际上�q�种分页�Ҏ��是将上一��|��后一行的键值存储下来，直接在SQL语句中就�q��o掉了�Q�不象前面那�U�到DataAdapter�q�边才过滤掉。例�Q?/P>

con=new SqlConnection("server=localhost;database=Northwind;Trusted_Connection=Yes;");
da=new SqlDataAdapter("select top 50 CustomerID,CompanyName from Customers where　CustomerID>'BOTTM'",con);
ds=new DataSet();
da.Fill(ds,"Categories");
this.DataGrid1.DataSource=ds.Tables["Categories"]; this.DataGrid1.DataBind();
con.Close();

�q�里假如上一��|��后一个键��gؓ”BOTTM”，可以��它用参数替代掉�Q�这样就查出了在'BOTTM'之后的５�Q�行。这�U�方法实现简单效率也高�?/P>

�W�笨 2005-04-12 13:52 发表评论

Implementing Data Transfer Object in .NET with a Typed DataSet

�W�笨 — Tue, 12 Apr 2005 04:49:00 GMT

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

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:

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:

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:

Development tool support. Because the DataSet class is implemented in ADO.NET, there is no need to design and implement the DTO. There is also extensive support in Visual Studio for automating the creation and filling of DataSet and typed-DataSet objects.

Integration with controls. A DataSet works directly with the built-in controls in Windows Forms and Web Forms, making it a logical choice as a DTO.

Serialization. The DataSet comes complete with the ability to serialize itself into XML. Not only is the content serialized, but the schema for the content is also present in the serialization.

Disconnected database model. The DataSet represents a snapshot of the current contents of the database. This means that you can alter the contents of the DataSet and subsequently use the DataSet as the means to update the database.

An additional benefit that might persuade you to use a typed DataSet as opposed to an ordinary DataSet is the strongly-typed interface of the typed DataSet. A typed DataSet, as described here, generates classes that can be used to access the contained data. The classes present an interface which defines how the class is to be used in a more explicit manner. This removes the need for casting which was present in the DataSet implementation.

Liabilities

The typed DataSet shares the following liabilities with a DataSet when used in the context of a DTO:

Interoperability. Because the DataSet class is part of ADO.NET, it is not the best choice for a DTO in cases requiring interoperability with clients that are not running the .NET Framework.. You can still use DataSet, however, the client will be forced to parse the XML and build its own representation. If interoperability is a requirement, see Implementing Data Transfer Object in .NET with Serialized Objects.

Stale data. The typed DataSet, like a DataSet, is disconnected from the database. It is filled with a snapshot of the data in the database when it is constructed. This implies that the actual data in the database may be different from what is contained in the typed DataSet. For reading primarily static data, this is not a major issue. If the data is constantly changing, however, using any kind of DataSet is not recommended.

Potential for performance degradation. Instantiating and filling a DataSet can be an expensive operation. Serializing and deserializing a DataSet can also be very time consuming. A good rule of thumb for using a DataSet is that a DataSet is a good choice when you are using more than one table or relying on the capability of the DataSet to update the database. If you are displaying the results from a single table, then using a DataReader with strongly-typed objects may offer better performance. For more information, see Implementing Data Transfer Object in .NET with Serialized Objects.

The following are additional liabilities when using a typed DataSet as opposed to an ordinary DataSet:

A typed DataSet is still a DataSet. A typed DataSet can be substituted at runtime with a DataSet. This means that even though the strongly-typed interface exists, programmers can still access the data without the typed interface. A possible result of doing this is that there could be parts of the code which couple the application tightly to the DataSet table and column names.

The need for an XML schema. When using a typed DataSet you have to create and maintain an XML schema to describe the strongly-typed interface. Visual Studio .NET provides a number of tools to assist in this process, but nevertheless you still have to maintain an additional file.

Related Patterns

For more information, see the following related patterns:

Implementing Data Transfer Object in .NET with a DataSet.

Implementing Data Transfer Object in .NET with Serialized Objects.

Assembler. In Enterprise Application Architecture Patterns, Fowler defines Assembler as a specialized instance of the Mapper pattern [Fowler03].

Acknowledgments

[Beau02] Beauchemin, Bob. Essential ADO.NET. Addison-Wesley, 2002.

[Fowler03] Fowler, Martin. Enterprise Application Architecture Patterns. Addison-Wesley, 2003.

[Wildermuth01] Wildermuth, Shawn. "Typed DataSets in ADO.NET." .NET Developer. May 2001.

�W�笨 2005-04-12 12:49 发表评论

�W�笨 — Fri, 18 Mar 2005 07:49:00 GMT

http://ms.mblogger.cn/dotM

http://www.cnblogs.com/tintown/category/12787.html

http://www.hidotnet.com/documents/DotNetTools.htm

http://www.remotesoft.com/dotexplorer/

http://download.cnblogs.com/dahuzizyd/

http://www.phcx.net/yougve/bbs/showthread.asp?threadid=593&goto=prev

http://www.syncfusion.com/FAQ/WinForms/default.asp

http://www.cnblogs.com/tintown/archive/2005/01/16/92730.html

http://www.smartprise.com/tintown/backup/NetAdvantage/2004.3/NetAdvantage2004Vol3ASPNET.rar

�W�笨 2005-03-18 15:49 发表评论

Reflector、PInvoke.NET、XP&ADHelper

�W�笨 — Fri, 18 Mar 2005 07:25:00 GMT

http://blog.joycode.com/liuhuimiao/archive/2004/05/09/21070.aspx

�W�笨 2005-03-18 15:25 发表评论

�W�笨 — Fri, 18 Mar 2005 07:23:00 GMT

http://www.zahui.com/html/14/

�W�笨 2005-03-18 15:23 发表评论

Resharper crack logs

�W�笨 — Fri, 18 Mar 2005 06:45:00 GMT

http://www.cnblogs.com/feidao/archive/2004/08/12/32537.aspx

�W�笨 2005-03-18 14:45 发表评论

不错的工�?Reflector for .NET

�W�笨 — Fri, 18 Mar 2005 06:43:00 GMT

http://www.cnblogs.com/dudu/archive/2004/03/09/2557.aspx

不错的工�?Reflector for .NET

今天��x��一个Class��览工具�Q�就像VS.NET中的对象��览器。后来在http://www.dotnettoolbox.com/toolbox/ViewCategory.aspx?ID=5�Q�这个网站也是个不错的地方）发现�q�个工具�Q�Reflector for .NET �?BR>
�|�址:
http://www.aisto.com/roeder/dotnet/
下蝲地址:
http://www.aisto.com/roeder/dotnet/
注意�Q�下载时要输一些注册信息，输入用户名时�Q�中间要加一个空根{�?BR>功能介绍�Q?BR>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.

�W�笨 2005-03-18 14:43 发表评论

亚洲欧洲无码一区二区三区,亚洲AV无码成人精品区狼人影院 ,亚洲伊人久久大香线蕉啊

����?NET assembly�c�d��

使用ADO.NET的Connection对象

Using Annotations with a Typed DataSet

See Also

使用ADO.NET��L��操纵数据�?一)

Implementing Data Transfer Object in .NET with a Typed DataSet

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

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

Context

Background

Database Schema

Implementing a DTO

Implementation Strategy

Creating a Typed DataSet

RecordingDto.xsd

Filling a Typed DataSet from the Database

Assembler.cs

Using a Typed DataSet in an ASP.NET Page

Tests

AssemblerFixture.cs

Resulting Context

Benefits

Liabilities

Related Patterns

Acknowledgments

Reflector、PInvoke.NET、XP&ADHelper

Resharper crack logs

不错的工�?Reflector for .NET

��?NET assembly�c�d��