.NET 数据访问体系结构指南

简介

如果您要为基于 .NET 的应用程序设计数据访问层，应该使用 Microsoft?ADO.NET 作为数据访问模型。ADO.NET 功能丰富，支持松耦合的多层 Web 应用程序和 Web 服务的数据访问要求。像其他功能丰富的对象模型一样，ADO.NET 提供了多种方法来解决特定问题。

《.NET 数据访问体系结构指南》提供的信息可帮助您选择最适合的数据访问方法。它通过描述一系列广泛的常见数据访问方案、提供性能提示以及推荐最佳实施策略来达到此目的。本指南还提供了对常见问题的解答，这些问题包括：哪里是存储数据库连接字符串的最佳场所？如何实现连接池？如何处理事务？如何实现分页以使用户能够在大量记录中滚动？

本指南集中讨论如何使用 ADO.NET 并通过 SQL Server .NET 数据提供程序（ADO.NET 随附的两个数据提供程序之一）来访问 Microsoft SQL?Server?2000。在适当的时候，本指南将明确指出您在使用 OLE DB .NET 数据提供程序来访问其他支持 OLE DB 的数据源时应该了解的差异。

有关使用本文中讨论的指南和最佳实施策略开发的数据访问组件的具体实现，请参阅 Data Access Application Block。Data Access Application Block 包含该实现的源代码，您可以在基于 .NET 的应用程序中直接使用这些代码。

《.NET 数据访问体系结构指南》分为以下几个部分：

本页内容

	ADO.NET 简介
	管理数据库连接
	错误处理
	性能
	通过防火墙进行连接
	处理 BLOB
	通过数据集执行数据库更新
	使用强类型数据集对象
	处理空数据字段
	事务处理
	数据分页
	附录

本文档的目标读者

本文档为需要生成基于 .NET 的应用程序的应用程序设计人员和企业开发人员提供指南。如果您负责设计和开发基于 .NET 的多层应用程序的数据层，请阅读本文档。

预备知识

要使用本指南来生成基于 .NET 的应用程序，您必须具有使用 ActiveX?Data Objects (ADO) 和/或 OLE DB 开发数据访问代码以及 SQL Server 方面的经验。您必须了解如何为 .NET 平台开发托管代码，并且必须了解 ADO.NET 数据访问模型引入的根本性的变化。有关 .NET 开发的详细信息，请参阅 http://msdn.microsoft.com/net。

新增功能

本文档已经进行了更新，以便包含有关执行数据集更新、使用类型化 DataSet 以及使用空数据字段的部分。

如正文中所指出的那样，本指南中的一些内容特别适用于 Microsoft Visual Studio?2003 开发系统和 .NET 框架 SDK 1.1 版。

下载《.NET 数据访问体系结构指南》

单击可从 MS.com 下载中心下载《.NET 数据访问体系结构指南》

ADO.NET 简介

ADO.NET 是基于 .NET 的应用程序的数据访问模型。可以使用它来访问关系数据库系统（如 SQL Server 2000、Oracle）和其他许多具有 OLE DB 或 ODBC 提供程序的数据源。在某种程度上，ADO.NET 代表 ADO 技术的最新进展。不过，ADO.NET 引入了一些重大变化和革新，旨在解决 Web 应用程序的松耦合特性以及在本质上互不关联的特性。有关 ADO 与 ADO.NET 的比较，请参阅 MSDN 文章“ADO.NET for the ADO Programmer”，网址为：http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/adonetprogmsdn.asp。

ADO.NET 引入的主要变化之一是用 DataTable、DataSet、DataAdapter 和 DataReader 对象的组合取代了 ADO Recordset 对象。DataTable 表示单个表中行的集合，在这一方面类似于 Recordset。DataSet 表示 DataTable 对象的集合，同时包括将各种表绑定在一起的关系和约束。实际上，DataSet 是带有内置 XML 支持的、内存中的关系结构。

DataSet 的主要特性之一是它不了解可能用来填充它的基础数据源。它是一个不连续的、独立的实体，用于表示数据集合，并且可以通过多层应用程序的不同层在组件之间传递。它还可以作为 XML 数据流进行序列化，这使其非常适合于在不同种类的平台之间进行数据传输。ADO.NET 使用 DataAdapter 对象将数据传送到 DataSet 和基础数据源，或者从数据源传出。DataAdapter 对象还提供以前与 Recordset 关联的增强的批量更新功能。

图 1 显示了完整的 DataSet 对象模型。

图 1.1.DataSet 对象模型

.NET 数据提供程序

ADO.NET 依赖于 .NET 数据提供程序的服务。这些提供程序提供对基础数据源的访问，并且包括四个主要对象（Connection、Command、DataReader 和 DataAdapter）。

目前，ADO.NET 随附了两类提供程序：Bridge 提供程序和 Native 提供程序。通过 Bridge 提供程序（如那些为 OLE DB 和 ODBC 提供的提供程序），可以使用为以前的数据访问技术设计的数据库。Native 提供程序（如 SQL Server 和 Oracle 提供程序）通常能够提供性能方面的改善，部分原因在于少了一个抽象层。

其他目前正处于测试阶段的 .NET 数据提供程序包括：

有关不同数据提供程序的详细概述，请参阅《.NET 框架开发人员指南》中的“.NET 框架数据提供程序”，网址为：http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconadonetproviders.asp。

命名空间组织结构

与各个 .NET 数据提供程序相关联的类型（类、结构、枚举等）位于其各自的命名空间中：

在各自的关联命名空间内，每个提供程序都提供了对 Connection、Command、DataReader 和 DataAdapter 对象的实现。SqlClient 实现的前缀为“Sql”，而 OleDb 实现的前缀为“OleDb”。例如，Connection 对象的 SqlClient 实现是 SqlConnection，而 OleDb 实现则为 OleDbConnection。同样，DataAdapter 对象的两个实现分别为 SqlDataAdapter 和 OleDbDataAdapter。

在本指南中，所用示例取自 SQL Server 对象模型。尽管此处未加说明，Oracle/OLEDB 和 ODBC 中提供了类似的功能。

一般编程

如果您可能要面向不同的数据源，并且需要将您的代码从一个数据源移至另一个数据源，请考虑编程以支持 System.Data 命名空间中的 IDbConnection、IDbCommand、IDataReader 和 IDbDataAdapter 接口。Connection、Command、DataReader 和 DataAdapter 对象的所有实现都必须支持这些接口。

有关实现 .NET 数据提供程序的详细信息，请参阅 http://msdn.microsoft.com/library/en-us/cpguidnf/html/cpconimplementingnetdataprovider.asp。

还应该注意，如果应用程序使用单对象模型来访问多个数据库，则 OLE DB 和 ODBC 桥接提供程序都可以使用。在此情况下，需要考虑与应用程序的性能需要相比，要求应用程序具有多大的灵活性，以及在何种程度上需要数据库特有的功能。

图 2 阐明了数据访问栈，并说明了 ADO.NET 与其他数据访问技术（包括 ADO 和 OLE DB）之间的关系。它还说明了 ADO.NET 模型内的两个托管提供程序和主要对象。

图 1.2.数据访问栈

有关 ADO 向 ADO.NET 的演变的详细信息，请参阅文章“Introducing ADO+:Data Access Services for the Microsoft .NET Framework”（MSDN Magazine，2000 年 11 月号），网址为：http://msdn.microsoft.com/msdnmag/issues/1100/adoplus/default.aspx。

存储过程与直接 SQL

本文档中显示的大多数代码片段使用 SqlCommand 对象来调用存储过程，以执行数据库操作。在某些情况下，您将不会看到 SqlCommand 对象，因为存储过程名被直接传递给 SqlDataAdapter 对象。在内部，这仍然会导致创建 SqlCommand 对象。

您应该使用存储过程而不是嵌入的 SQL 语句，原因如下：

SQL Server 联机文档强烈建议您不要使用“sp_”作为名称前缀来创建任何存储过程，因为此类名称已经被指定给系统存储过程。SQL Server 始终按以下顺序来查找以 sp_ 开头的存储过程：

属性与构造函数参数

可以通过构造函数参数来设置 ADO.NET 对象的特定属性值，也可以直接设置属性值。例如，下面的代码片段在功能上是等效的。

// Use constructor arguments to configure command object
SqlCommand cmd = new SqlCommand( "SELECT * FROM PRODUCTS", conn );

// The above line is functionally equivalent to the following
// three lines which set properties explicitly
sqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = "SELECT * FROM PRODUCTS";

从性能角度看，这两种方法之间的差异是微不足道的，因为针对 .NET 对象设置和获取属性要比针对 COM 对象执行类似操作更为高效。

选择哪种方法取决于个人喜好和编码风格。不过，对属性进行明确设置确实能够使代码更易理解（尤其是当您不熟悉 ADO.NET 对象模型时）和调试。

注 过去，Microsoft Visual Basic? 开发系统的开发人员被告诫避免使用“Dim x As New…”构造来创建对象。在 COM 领域里，上述代码会导致 COM 对象创建过程出现短路现象，从而带来一些微小和重大的错误。然而，在 .NET 领域里，这不再是一个问题。

返回页首

管理数据库连接

数据库连接代表一种关键的、昂贵的和有限的资源，尤其是在多层 Web 应用程序中。正确地管理连接是十分必要的，因为您采取的方法可能显著影响应用程序的总体可伸缩性。同时，还要认真考虑在何处存储连接字符串。需要使用可配置的且安全的位置。

在管理数据库连接和连接字符串时，应该努力做到：

本节讨论连接池，并且帮助您选择适当的连接池策略。本节还将考虑应该如何管理、存储和操纵数据库连接字符串。最后，本节将给出两种编码模式，可用来帮助确保连接被可靠地关闭，并被返回到连接池。

使用连接池

通过数据库连接池，应用程序可以重用池中现有的连接，而不必反复与数据库建立新的连接。该技术可显著提高应用程序的可伸缩性，因为有限数量的数据库连接可以为数量大得多的客户端提供服务。同时，由于可以节省建立新连接所需的大量时间，该技术还能够改善性能。

像 ODBC 和 OLE DB 这样的数据访问技术提供了多种形式的连接池，可以在不同程度上进行配置。这两种方法对于数据库客户端应用程序而言在很大程度上是透明的。OLE DB 连接池经常被称为会话或资源池。

有关 Microsoft Data Access Components (MDAC) 内部的池机制的一般性讨论，请参阅“Pooling in the Microsoft Data Access Components”，网址为 http://msdn.microsoft.com/library/en-us/dnmdac/html/pooling2.asp。

ADO.NET 数据提供程序提供了透明的连接池，这些连接池的确切技术细节对于各个提供程序而言是不同的。本节针对下列提供程序来讨论连接池：

SQL Server .NET 数据提供程序的池机制

如果您使用的是 SQL Server .NET 数据提供程序，请使用该提供程序提供的连接池支持。这是一种由该提供程序在内部实现的支持事务处理并且非常高效的机制，它存在于托管代码中。池是以每个应用程序的域为基础创建的，并且在应用程序域卸载之前不会销毁。

可以透明地使用这种形式的连接池，但应该知道池的管理方式以及可用来微调连接池的各种配置选项。

在许多情况下，对于您的应用程序而言，SQL Server .NET 数据提供程序的默认连接池设置可能已经足够了。在开发和测试基于 .NET 的应用程序的过程中，建议您对规划通信模式进行模拟，以确定是否需要修改连接池大小。

需要生成可伸缩的高性能应用程序的开发人员应该最大限度地减少使用连接的时间，只在检索或更新数据时才使连接保持打开状态。连接关闭时，将被返回到连接池，并可供重用。在此情况下，到数据库的实际连接不会被切断；不过，如果连接池被禁用，则到数据库的实际连接将被关闭。

开发人员应该十分小心，不要依赖垃圾回收器来释放连接，因为当引用离开作用范围时，连接未必能够关闭。这是连接泄漏的一种常见根源，当请求新连接时，这会导致连接异常。

配置 SQL Server .NET 数据提供程序连接池

可以使用一组名称-值对（通过连接字符串提供）来配置连接池。例如，可以配置是否启用连接池（默认情况下启用）、池的最大容量和最小容量，以及要打开连接的排队请求可以阻塞的时间长度。下面是一个示例连接字符串，用于配置池的最大容量和最小容量。

"Server=(local); Integrated Security=SSPI; Database=Northwind; 
Max Pool Size=75; Min Pool Size=5"

打开连接并创建池以后，会将多个连接添加到池中，以便将连接数量提高到所配置的最小数量。随后，可以继续向该池中添加连接，直至达到所配置的最大池数量。当达到最大数量时，要打开连接的新请求将排队等待一段可配置的时间。

选择池大小

对于管理成千上万个客户端的并发请求的大规模系统而言，能够建立最大值阈值是非常重要的。您需要监控连接池和应用程序的性能，以便确定系统的最佳池大小。最佳大小还取决于用来运行 SQL Server 的硬件。

在部署过程中，您可能希望减小默认的最大池大小（目前为 100）以帮助查找连接泄漏。

如果您设立最小池大小，将会产生一点性能开销，因为在开始时对池进行填充以使其达到该尺寸，尽管头几个进行连接的客户端会因此受益。注意，创建新连接的过程是按顺序执行的，这意味着在最初填充池时，服务器不会被同时到来的大量请求所淹没。

有关监控连接池的详细信息，请参阅本文档中的监控连接池一节。有关连接池连接字符串关键字的完整列表，请参阅《.NET 框架开发人员指南》中的“Connection Pooling for the .NET Framework Data Provider for SQL Server”一节，网址为：http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconconnectionpoolingforsqlservernetdataprovider.asp。

更多信息

当使用 SQL Server .NET 数据提供程序连接池时，请注意以下几个方面：

SqlConnection conn = new SqlConnection(
         "Integrated Security=SSPI;Database=Northwind");
conn.Open(); // Pool A is created

SqlConmection conn = new SqlConnection(
         "Integrated Security=SSPI ; Database=Northwind");
conn.Open(); // Pool B is created (extra spaces in string)

OLE DB .NET 数据提供程序的池机制

OLE DB .NET 数据提供程序通过使用基础 OLE DB 资源池来池化连接。有多个用于配置资源池的选择：

为避免出现与注册表相关的部署问题，请不要使用注册表来配置 OLE DB 资源池。

有关 OLE DB 资源池的详细信息，请参阅《OLE DB 程序员参考》第 19 章“OLE DB Services”中的“Resource Pooling”，网址为：http://msdn.microsoft.com/library/default.asp?url=/library/en-us/oledb/htm/olprcore_chapter19.asp。

使用池对象管理连接池

作为 Windows DNA 开发人员，鼓励您禁用 OLE DB 资源池和/或 ODBC 连接池，并使用 COM+ 对象池作为池化数据库连接的技术。这有两个主要原因：

然而，因为 SQL Server .NET 数据提供程序在内部使用池机制，所以您不再需要开发自己的对象池机制（在使用该提供程序时）。因此，您可以避免执行与手动事务登记相关联的复杂任务。

如果您使用的是 OLE DB .NET 数据提供程序，您可能需要考虑使用 COM+ 对象池，以便充分利用卓越的配置和改善的性能。如果您为此目的开发池对象，则必须禁用 OLE DB 资源池和自动事务登记（例如，通过在连接字符串中包含 "OLE DB Services=-4"）。您必须在自己的池对象实现中处理事务登记。

监控连接池

要对应用程序使用连接池的情况进行监控，可以使用 SQL Server 随附的事件探查器工具，或者使用 Microsoft Windows? 2000 操作系统随附的性能监视器工具。

使用 SQL Server 事件探查器监控连接池

使用性能监视器监控连接池

管理安全性

尽管数据库连接池提高了应用程序的总体可伸缩性，但这意味着您不再能够在数据库级别管理安全性。这是因为，要支持连接池，连接字符串必须完全相同。如果您需要跟踪每个用户的数据库操作，请考虑添加一个参数，以便能够传递用户标识并在数据库中手动记录用户操作。您需要将该参数添加到每个操作中。

使用 Windows 身份验证

在连接到 SQL Server 时，应该使用 Windows 身份验证，因为它提供了许多好处：

更多信息

在使用 Windows 身份验证来访问 SQL Server 时，请遵循以下指导原则：

有关开发安全的 ASP.NET 和 Web 应用程序的一般性指导，请参阅下面的 Microsoft patterns & practices 指南：

存储连接字符串

要存储数据库连接字符串，可以有多种选择，这些选择具有不同级别的灵活性和安全性。尽管在源代码中对连接字符串进行硬编码可提供最佳性能，但文件系统缓存可确保在外部将该字符串存储到文件系统中所带来的性能下降是微不足道的。几乎在所有情况下，人们都首选外部连接字符串所提供的额外的灵活性（它支持管理员配置）。

当您选择连接字符串存储方法时，需要注意的两个最重要的事项是安全性和配置简易性，然后紧跟着的是性能。

可以选择下列位置来存储数据库连接字符串：

通过使用 Windows 身份验证来访问 SQL Server，可以避免将用户名和密码存储在连接字符串中。如果您的安全要求需要采取更严格的措施，请考虑以加密格式存储连接字符串。

对于 ASP.NET Web 应用程序而言，在 Web.config 文件内以加密格式存储连接字符串，代表着一种安全的、可配置的解决方案。

注 可以在连接字符串中将 Persist Security Info 命名值设置为 false，以禁止通过 SqlConnection 或 OleDbConnection 对象的 ConnectionString 属性返回对安全敏感的细节（如密码）。

下面几小节讨论了如何使用各种选择来存储连接字符串，并介绍了各种方法的相对优点和缺点。这些内容有助于您根据自己特定的应用程序方案做出明智的选择。

注 通过“配置应用程序管理”块，可以管理从数据库连接到复杂层次结构数据的各种配置设置。有关详细信息，请参阅 http://msdn.microsoft.com/practices。

使用 XML 应用程序配置文件

可以使用 <appSettings> 元素在应用程序配置文件的自定义设置节中存储数据库连接字符串。该元素支持任意的密钥-值对，如以下代码片段所示：

<configuration>
 <appSettings>
  <add key="DBConnStr"
     value="server=(local);Integrated Security=SSPI;database=northwind"/>
 </appSettings>
</configuration>

注 <appSettings> 元素出现在 <configuration> 元素下面，并且不是紧跟在 <system.web> 的后面。

优点

缺点

更多信息

using System.Configuration;
private string GetDBaseConnectionString()
{
  return ConfigurationSettings.AppSettings["DBConnStr"];
}

使用 UDL 文件

OLE DB .NET 数据提供程序在其连接字符串中支持通用数据链接 (UDL) 文件名。您可以通过使用 OleDbConnection 对象的构建参数来传递连接字符串，或者通过使用该对象的 ConnectionString 属性来设置连接字符串。

注 SQL Server .NET 数据提供程序在其连接字符串中不支持 UDL 文件。因此，只有在您使用 OLE DB .NET 数据提供程序时，才可使用该方法。

对于 OLE DB 提供程序，要通过连接字符串引用 UDL 文件，请使用“File Name=name.udl”。

优点

缺点

更多信息

使用 Windows 注册表

您还可以在 Windows 注册表中使用自定义键来存储连接字符串，尽管由于部署问题不鼓励这样做。

优点

缺点

部署。必须与应用程序一起部署相关注册表设置，这在一定程度上抵消了 xcopy 部署的优点。

使用自定义文件

可使用自定义文件来存储连接字符串。然而，该技术没有任何优点，建议不要使用该技术。

优点

缺点

使用构建参数和 COM+ 目录

可以在 COM+ 目录中存储数据库连接字符串，并通过对象构建字符串将其自动传递给您的对象。COM+ 将在实例化该对象后立即调用该对象的 Construct 方法，同时提供所配置的构建字符串。

注 该方法仅对服务组件有效。仅当您的托管组件使用其他服务（如分布式事务处理支持或对象池）时，才应考虑该方法。

优点

缺点

更多信息

连接使用模式

无论您使用哪种 .NET 数据提供程序，您都必须始终遵循下列原则：

要保证在方法返回之前关闭连接，请考虑使用下面的两个代码示例中阐明的方法之一。第一个方法使用 finally 块。第二个方法使用 C# using 语句，它确保调用对象的 Dispose 方法。

以下代码确保 finally 块关闭连接。注意，该方法对 Visual Basic .NET 和 C# 都有效，因为 Visual Basic .NET 支持结构化异常处理。

public void DoSomeWork()
{
  SqlConnection conn = new SqlConnection(connectionString);
  SqlCommand cmd = new SqlCommand("CommandProc", conn );
  cmd.CommandType = CommandType.StoredProcedure;

  try
  {
    conn.Open();
    cmd.ExecuteNonQuery();
  }
  catch (Exception e)
  {
    // Handle and log error
  }
  finally
  {
    conn.Close();
  }
}
  

以下代码显示了一个备选方法，该方法使用了 C# using 语句。注意，Visual Basic .NET 不提供 using 语句或任何等效功能。

public void DoSomeWork()
{
  // using guarantees that Dispose is called on conn, which will
  // close the connection.
  using (SqlConnection conn = new SqlConnection(connectionString))
  {
    SqlCommand cmd = new SqlCommand("CommandProc", conn);
    fcmd.CommandType = CommandType.StoredProcedure;
    conn.Open();
    cmd.ExecuteQuery();
  }
}
  

您还可以将该方法应用于其他必须关闭才能使用当前连接执行其他任何任务的对象，例如 SqlDataReader 或 OleDbDataReader。

返回页首

错误处理

ADO.NET 错误是通过 .NET 框架所固有的基础结构化异常处理支持来产生和处理的。因此，在数据访问代码内部处理错误的方法与在应用程序的其他地方一样。可以通过标准的 .NET 异常处理语法和技术来检测和处理异常。

本节向您说明如何开发健壮的数据访问代码，并解释如何处理数据访问错误。同时，本节还提供了与 SQL Server .NET 数据提供程序相关的具体异常处理指导。

.NET 异常

.NET 数据提供程序将数据库特有的错误状况转换为标准异常类型，供您在自己的数据访问代码中进行处理。数据库特有的错误细节是通过相关异常对象的属性提供给您的。

所有 .NET 异常类型归根结底都是从 System 命名空间中的 Exception 类派生出来的。.NET 数据提供程序引发提供程序特有的异常类型。例如，每当 SQL Server 返回错误状况时，SQL Server .NET 数据提供程序都会引发 SqlException 对象。类似地，OLE DB .NET 数据提供程序引发 OleDbException 类型的异常，它含有基础 OLE DB 提供程序所公开的细节。

图 3 显示了 .NET 数据提供程序异常层次。注意，OleDbException 类是从 ExternalException（它是所有 COM Interop 异常的基类）派生的。该对象的 ErrorCode 属性存储了由 OLE DB 产生的 COM HRESULT。

图 1.3..NET 数据提供程序异常层次

捕获和处理 .NET 异常

要处理数据访问异常状况，请将数据访问代码放在 try 块内部，并使用 catch 块通过适当的筛选器来捕获产生的任何异常。例如，当使用 SQL Server .NET 数据提供程序来编写数据访问代码时，应该捕获 SqlException 类型的异常，如以下代码所示：

try
{
  // Data access code
}
catch (SqlException sqlex) // more specific
{
}
catch (Exception ex) // less specific
{
}
  

如果您提供多个具有不同筛选条件的 catch 语句，请记住将这些语句按其类型的特殊程度从高到低排序。这样，对于任何给定的异常类型，都会执行最特殊类型的 catch 块。

该 SqlException 类公开了含有异常状况细节的属性。这些属性包括：

以下代码片段阐明了如何使用 SQL Server .NET 数据提供程序来处理 SQL Server 错误状况：

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

// Method exposed by a Data Access Layer (DAL) Component
public string GetProductName( int ProductID )
{
  SqlConnection conn = null;
  // Enclose all data access code within a try block
  try
  {
    conn = new SqlConnection(
        "server=(local);Integrated Security=SSPI;database=northwind");
    conn.Open();
    SqlCommand cmd = new SqlCommand("LookupProductName", conn );
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add("@ProductID", ProductID );
    SqlParameter paramPN = 
         cmd.Parameters.Add("@ProductName", SqlDbType.VarChar, 40 );
    paramPN.Direction = ParameterDirection.Output;

    cmd.ExecuteNonQuery();
    // The finally code is executed before the method returns
    return paramPN.Value.ToString();  
  }
  catch (SqlException sqlex)
  {
    // Handle data access exception condition
    // Log specific exception details
    LogException(sqlex);
    // Wrap the current exception in a more relevant
    // outer exception and re-throw the new exception
    throw new DALException(
                  "Unknown ProductID: " + ProductID.ToString(), sqlex );
  }
  catch (Exception ex)
  {
    // Handle generic exception condition . . .
    throw ex;
  }
  finally
  {
    if(conn != null) conn.Close(); // Ensures connection is closed
  }
}

// Helper routine that logs SqlException details to the 
// Application event log
private void LogException( SqlException sqlex )
{
  EventLog el = new EventLog();
  el.Source = "CustomAppLog";
  string strMessage;
  strMessage = "Exception Number : " + sqlex.Number + 
               "(" + sqlex.Message + ") has occurred";
  el.WriteEntry( strMessage );

  foreach (SqlError sqle in sqlex.Errors)
  {
    strMessage = "Message: " + sqle.Message +
                 " Number: " + sqle.Number +
                 " Procedure: " + sqle.Procedure +
                 " Server: " + sqle.Server +
                 " Source: " + sqle.Source +
                 " State: " + sqle.State +
                 " Severity: " + sqle.Class +
                 " LineNumber: " + sqle.LineNumber;
    el.WriteEntry( strMessage );
  }
}

在 SqlException catch 块内部，代码首先使用 LogException 辅助函数记录异常细节。该函数使用 foreach 语句来枚举 Errors 集合内部的特定于提供程序的细节，并将错误细节记录到错误日志中。catch 块中的代码随后将 SQL Server 特有的异常包装在 DALException 类型的异常内部，后者对于 GetProductName 方法的调用方更有意义。异常处理程序使用 throw 关键字将该异常传播回调用方。

更多信息

从存储过程中产生错误

Transact-SQL (T-SQL) 提供了一个 RAISERROR函数（请注意拼写），可用来产生自定义错误并将其返回到客户端。对于 ADO.NET 客户端，SQL Server .NET 数据提供程序会截获这些数据库错误，并将其转换为 SqlError 对象。

使用 RAISERROR 函数的最简单方法是将消息正文包含为第一个参数，然后指定严重度和状态参数，如以下代码片段所示。

RAISERROR( 'Unknown Product ID: %s', 16, 1, @ProductID )

在该示例中，使用了一个替代参数将当前产品 ID 作为错误消息正文的一部分返回。第二个参数是消息严重度，第三个参数是消息状态。

更多信息

RAISERROR( 50001, 16, 1, @ProductID )

适当地使用严重度级别

请认真选择错误严重度级别，并注意各个级别的影响。错误严重度级别的范围为 0 到 25，用于表示 SQL Server 2000 已经遇到的问题类型。在客户端代码中，可以通过检查 SqlError 对象的 Class 属性获得错误的严重度，该对象位于 SqlException 类的 Errors 集合中。表 1 指出了各种严重度级别的影响和含义。

表 1. 错误严重度级别 — 影响和含义

控制自动事务处理

对于所遇到的任何严重度超过 10 的错误，SQL Server .NET 数据提供程序都会引发 SqlException。当自动 (COM+) 事务处理中的某个组件检测到 SqlException 时，该组件必须确保它赞成中止该事务处理。这可能是也可能不是自动过程，具体取决于是否用 AutoComplete 属性对该方法进行了标记。

有关在自动事务处理的上下文中处理 SqlException 的详细信息，请参阅本文档中的确定事务处理结果一节。

检索指示性消息

严重度级别 10 及更低级别用于表示指示性消息，并且不会导致引发 SqlException。

检索指示性消息：

public delegate void SqlInfoMessageEventHandler( object sender, 
                                                     SqlInfoMessageEventArgs e );

消息数据可通过传递给事件处理程序的 SqlInfoMessageEventArgs 对象获得。该对象公开了一个 Errors 属性，该属性包含一组 SqlError 对象 — 每条指示性消息对应一个对象。以下代码片段阐明了如何注册一个用于记录指示性消息的事件处理程序。

public string GetProductName( int ProductID )
{
  SqlConnection conn = null;
  try
  {
    conn = new SqlConnection(
        "server=(local);Integrated Security=SSPI;database=northwind");
    // Register a message event handler
    conn.InfoMessage += new SqlInfoMessageEventHandler( MessageEventHandler );
    conn.Open();
    // Setup command object and execute it
    . . .
  }
  catch (SqlException sqlex)
  {
    // log and handle exception
    . . .
  }
  finally
  {
    if(conn != null) conn.Close();
  }
}
// message event handler
void MessageEventHandler( object sender, SqlInfoMessageEventArgs e )
{
  foreach( SqlError sqle in e.Errors )
  {
    // Log SqlError properties
    . . .
  }
}

返回页首

性能

本节介绍一些常见的数据访问方案，对于每种方案，都提供了就 ADO.NET 数据访问代码而言性能最高、可伸缩性最强的解决方案的有关详细信息。在适当的地方，对性能、功能和开发工作进行了比较。本节考虑了下列功能方案：

检索多行

在该方案中，您希望检索一组表格形式的数据，并对检索到的行进行迭代以执行操作。例如，您可能希望检索一组数据，以不连续的方式处理这些数据，并将其作为 XML 文档传递给客户端应用程序（可能是通过 Web 服务传递）。或者，您还可能希望以 HTML 表的形式显示这些数据。

要帮助确定最适当的数据访问方法，请考虑您是需要（不连续的）DataSet 对象所提供的额外的灵活性，还是需要 SqlDataReader 对象（它非常适合于企业对用户 (B2C) Web 应用程序中的数据展示）所提供的原始性能。图 4 显示了这两种基本方案。

注 用于在内部填充 DataSet 的 SqlDataAdapter 使用 SqlDataReader 来访问数据。

图 1.4.多行数据访问方案

比较几种选择

当从数据源中检索多个行时，您具有下列选择：

选择 SqlDataReader 还是 DataSet/DataTable，从根本上说是一个注重性能还是注重功能的问题。SqlDataReader 可提供最佳性能；DataSet 可提供额外的功能和灵活性。

数据绑定

上述所有三个对象都可以充当数据绑定控件的数据源，尽管 DataSet 和 DataTable 可以充当比 SqlDataReader 更多种控件的数据源。这是因为 DataSet 和 DataTable 实现了 IListSource（产生 IList），而 SqlDataReader 则实现了 IEnumerable。一些支持数据绑定的 WinForm 控件需要实现了 IList 的数据源。

这一差异的原因在于为其设计各种对象类型的方案的类型。DataSet（它包含 DataTable）是一种丰富的、不连续的结构，同时适用于 Web 和桌面 (WinForm) 这两种方案。另一方面，数据读取器对需要执行优化的只进数据访问的 Web 应用程序进行了优化。

请检查您希望绑定到的特定控件类型的数据源要求。

在应用程序层之间传递数据

DataSet 为可以根据需要作为 XML 进行操作的数据提供了关系视图，并且使您可以在应用程序层和组件之间传递不连续的缓存数据副本。然而，SqlDataReader 提供了最佳性能，因为它避免了与 DataSet 的创建关联的性能和内存开销。请记住，DataSet 对象的创建可导致多个子对象（包括 DataTable、DataRow 和 DataColumn 对象）以及用作这些子对象的容器的集合对象的创建。

使用数据集

在下列情况下，请使用由 SqlDataAdapter 对象填充的 DataSet：

更多信息

如果您使用 SqlDataAdapter 来生成 DataSet 或 DataTable，请注意下列事项：

使用 SqlDataReader

在下列情况下，请使用通过调用 SqlCommand 对象的 ExecuteReader 方法得到的 SqlDataReader：

更多信息

如果您使用 SqlDataReader，请注意以下事项：

使用 XmlReader

在以下情况下，请使用通过调用 SqlCommand 对象的 ExecuteXmlReader 方法得到的 XmlReader：

更多信息

如果您使用 XmlReader，请注意以下事项：

检索单个行

在该方案中，您希望从数据源中检索包含指定列集的单行数据。例如，您有一个客户 ID 并希望查找相关的客户详细信息，或者您有一个产品 ID 并希望检索产品信息。

比较几种选择

如果您希望使用从数据源中检索到的单行执行数据绑定，可以使用 SqlDataAdapter，以与前面讨论的“多行检索和迭代”方案中介绍的相同方式来填充 DataSet 或 DataTable。然而，除非您特别需要 DataSet/DataTable 功能，否则应该避免创建这些对象。

如果您需要检索单个行，请使用下列选择之一：

这两个选择都可以避免由于在服务器上创建结果集和在客户端上创建 DataSet 而带来的不必要的开销。各个方法的相对性能取决于压力级别以及是否启用了数据库连接池。当启用了数据库连接池时，性能测试表明，存储过程方法在高压力条件（同时存在 200 个以上的连接）下的性能比 SqlDataReader 方法高将近 30%。

使用存储过程输出参数

当您希望从已经启用连接池的多层 Web 应用程序中检索单个行时，请使用存储过程输出参数。

更多信息

有关说明如何使用存储过程输出参数的代码示例，请参阅附录中的如何使用存储过程输出参数来检索单个行。

使用 SqlDataReader

在以下情况下，请使用 SqlDataReader：

更多信息

如果您使用 SqlDataReader，请注意以下事项：

检索单个项

在该方案中，您希望检索单个数据项。例如，您可能希望查找单个产品名（给定了产品 ID）或单个客户信用等级（给定了客户名称）。在此类方案中，您通常不希望在检索单个项时产生 DataSet 的开销，甚至不希望产生 DataTable 的开销。

您可能还希望简单地检查一下数据库中是否存在特定行。例如，当新用户在网站上注册时，您需要检查选择的用户名是否已存在。这是单项查找的特殊情况，但在此情况下，简单的 Boolean 类型返回值就足够了。

比较几种选择

当您从数据源中检索单个数据项时，请考虑下列选择：

ExecuteScalar 方法直接返回数据项，因为它专用于只返回单个值的查询。它所需要的代码比存储过程输出参数和 SqlDataReader 方法需要的代码都要少。

从性能角度而言，应该使用存储过程输出或返回参数，因为测试表明，存储过程方法在低压力条件和高压力条件下（从同时存在的浏览器连接少于 100 个到同时存在 200 个浏览器连接）都能够提供一致的性能。

更多信息

在检索单个项时，请注意以下事项：

返回页首

通过防火墙进行连接

您将经常需要配置 Internet 应用程序以通过防火墙连接到 SQL Server。例如，许多 Web 应用程序及其防火墙的关键体系结构组件是外围网络（也称为 DMZ，即非管制区），它用于将前端 Web 服务器与内部网络隔离。

通过防火墙连接到 SQL Server 时，要求对防火墙、客户端和服务器进行特殊的配置。SQL Server 提供了客户端网络实用工具和服务器网络实用工具程序来帮助进行配置。

选择网络库

在通过防火墙进行连接时，可使用 SQL Server TCP/IP 网络库来简化配置。这是 SQL Server 2000 安装的默认配置。如果您使用的是较低版本的 SQL Server，请确保已经分别通过使用客户端网络实用工具和服务器网络实用工具，在客户端和服务器上将 TCP/IP 配置为默认网络库。

除了配置方面的好处以外，使用 TCP/IP 库结果还意味着您可以：

您必须将客户端计算机和服务器计算机配置为使用 TCP/IP。因为大多数防火墙都对允许通信的端口集进行限制，所以您还必须对 SQL Server 使用的端口号给予认真的考虑。

配置服务器

SQL Server 的默认实例在端口 1433 上侦听。同时，还使用了 UDP 端口 1434，以使 SQL 客户端能够定位其网络中的其他 SQL 服务器。然而，SQL?Server?2000 的命名实例在首次启动时动态分配端口号。网络管理员不希望在防火墙上打开一系列端口号；因此，在使用带防火墙的 SQL Server 命名实例时，请使用服务器网络实用工具来配置该实例，以使其在特定端口号上侦听。然后，您的管理员可以配置防火墙，以允许通信到达该服务器实例正在侦听的特定 IP 地址和端口号。

注 客户端网络库使用的源端口是在范围 1024 - 5000 中动态分配的。对于 TCP/IP 客户端应用程序，这是标准做法，但这意味着您的防火墙必须允许来自该范围内任意端口的通信。有关 SQL Server 使用的端口的详细信息，请参阅 Microsoft 知识库文章 287932“INF:TCP Ports Needed for Communication to SQL Server Through a Firewall”。

动态发现命名实例

如果您更改 SQL Server 所侦听的默认端口号，请配置客户端以连接到此端口。有关详细信息，请参阅本文档中的配置客户端一节。

在为 SQL Server 2000 的默认实例更改端口号后，如果未能修改客户端，将导致连接错误。如果有多个 SQL Server 实例，最新版本的 MDAC 数据访问栈 (2.6) 将使用动态发现，并且使用用户数据文报协议 (UDP) 协商（通过 UDP 端口 1434）来查找命名实例。尽管这可能在开发环境中有效，但却不太可能在实际应用环境中起作用，因为防火墙通常会阻塞 UDP 协商通信。

要避免这一问题，请始终配置客户端以连接到已配置的目标端口号。

配置客户端

应该配置客户端以使用 TCP/IP 网络库连接到 SQL?Server，并且应确保客户端库使用正确的目标端口号。

使用 TCP/IP 网络库

您可以使用 SQL Server 客户端网络实用工具来配置客户端。在某些安装中，客户端（例如，您的 Web 服务器）上可能尚未安装该实用工具。在此情况下，您可以执行下列操作之一：

指定端口

如果您的 SQL Server 实例被配置为在除默认的 1433 以外的端口上侦听，可以通过以下方法指定要连接到端口号：

"Data Source=ServerName, PortNumber"

分布式事务处理

如果您已经开发了使用 COM+ 分布式事务处理以及 Microsoft 分布式事务处理协调器 (DTC) 的服务的服务组件，您可能还需要配置您的防火墙以允许 DTC 通信在独立的 DTC 实例之间流动，以及在 DTC 和资源管理器（如 SQL Server）之间流动。

有关为 DTC 打开端口的详细信息，请参阅 INFO:Configuring Microsoft Distributed Transaction Coordinator (DTC) to Work Through a Firewall。

返回页首

处理 BLOB

现在，许多应用程序除了处理较为传统的字符和数值数据以外，还需要处理诸如图形和声音之类的数据格式，甚至需要处理更为复杂的数据格式，如视频。存在许多不同类型的图形、声音和视频格式。不过，从存储角度而言，它们都可以视为二进制数据块，通常称为二进制大对象，即 BLOB。

SQL Server 提供了 binary、varbinary 和 image 数据类型来存储 BLOB。尽管具有现在的名称，BLOB 数据还可以指基于文本的数据。例如，您可能希望存储可以与特定行关联的任意长的注释字段。为此，SQL Server 提供了 ntext 和 text 数据类型。

通常，对于小于 8 KB 的二进制数据，请使用 varbinary 数据类型。对于超过此大小的二进制数据，请使用 image。表 2 介绍了每个数据类型的主要功能。

表 2. 数据类型功能

注 Microsoft? SQL Server 2000 能够在数据行中存储小型到中等大小的 text、ntext 和 image 值。该功能对于具有以下特征的表最为适用：表的 text、ntext 和 image 列中的数据通常作为一个单元读/写，并且大多数引用该表的语句都使用 text、ntext 和 image 数据。有关详细信息，请参阅 SQL Server 联机图书中的“text in row”主题。

将 BLOB 数据存储在何处

SQL Server 7.0 及更高版本已经改善了使用数据库中存储的 BLOB 数据时的性能。原因之一是数据库页大小已经增加到 8 KB。因此，小于 8 KB 的文本或图像数据不再需要存储在单独的二元树页结构中，而可以存储在一行中。这意味着读/写 text、ntext 或 image 数据可以像读/写字符和二进制字符串一样快。当数据大于 8 KB 时，将在行内维护一个指针，而将数据本身保存在单独数据页的二元树结构中 — 从而不可避免地影响性能。

有关将 text、ntext 和 image 数据强行存储在一行中的详细信息，请参阅 SQL Server 联机图书中的“Using Text and Image Data”主题。

处理 BLOB 数据的常用备选方法是将 BLOB 数据存储在文件系统中，并且在数据库列中存储一个指针（最好是统一资源定位符 [URL] 链接）以引用相应的文件。对于低于 SQL?Server 7.0 的版本而言，在数据库外部将 BLOB 数据存储到文件系统中可以改善性能。

然而，由于在 SQL Server 2000 中改善了 BLOB 支持，再加上 ADO.NET 对读/写 BLOB 数据的支持，因此在数据库中存储 BLOB 数据成为一种可行的方法。

在数据库中存储 BLOB 数据的优点

在数据库中存储 BLOB 数据可提供许多优点：

在数据库中存储 BLOB 数据的缺点

请认真考虑哪些资源存储在文件系统中可能比存储在数据库中更好。通常通过 HTTP HREF 引用的图像就是很好的例子。这是因为：

将 BLOB 数据写入数据库

以下代码说明了如何使用 ADO.NET 将从文件中得到的二进制数据写入 SQL Server 中的 image 字段。

public void StorePicture( string filename )
{
  // Read the file into a byte array
  using(FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
  {
    byte[] imageData = new Byte[fs.Length];
    fs.Read( imageData, 0, (int)fs.Length );
  }

  using( SqlConnection conn = new SqlConnection(connectionString) )
  {
    SqlCommand cmd = new SqlCommand("StorePicture", conn);
    cmd.CommandType = CommandType.StoredProcedure;
    cmd.Parameters.Add("@filename", filename );
    cmd.Parameters["@filename"].Direction = ParameterDirection.Input;
    cmd.Parameters.Add("@blobdata", SqlDbType.Image);
    cmd.Parameters["@blobdata"].Direction = ParameterDirection.Input;
    // Store the byte array within the image field
    cmd.Parameters["@blobdata"].Value = imageData;
    conn.Open();
    cmd.ExecuteNonQuery();
  }
}

从数据库中读取 BLOB 数据

在通过 ExecuteReader 方法创建 SqlDataReader 对象以读取包含 BLOB 数据的行时，请使用 CommandBehavior.SequentialAccess 枚举值。如果不使用该枚举值，读取器会每次一行地将数据从服务器提取到客户端。如果行中包含 BLOB 列，可能需要占用大量内存。通过使用枚举值，可以进行更精确的控制，因为仅在 BLOB 数据被引用（例如，通过 GetBytes 方法，该方法可用于控制所读取的字节数）时才会进行提取。以下代码片段对此进行了说明。

// Assume previously established command and connection
// The command SELECTs the IMAGE column from the table
conn.Open();
using(SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
  reader.Read();
  // Get size of image dataa€“pass null as the byte array parameter
  long bytesize = reader.GetBytes(0, 0, null, 0, 0);
  // Allocate byte array to hold image data
  byte[] imageData = new byte[bytesize];
  long bytesread = 0;
  int curpos = 0;
  while (bytesread < bytesize)
  {
    // chunkSize is an arbitrary application defined value 
    bytesread += reader.GetBytes(0, curpos, imageData, curpos, chunkSize);
    curpos += chunkSize;
  }
}
// byte array 'imageData' now contains BLOB from database

注 使用 CommandBehavior.SequentialAccess 时，要求按照严格的顺序次序访问列数据。例如，如果 BLOB 数据位于第 3 列，并且您还需要第 1 列和第 2 列中的数据，则必须在读取第 3 列之前读取第 1 列和第 2 列。

返回页首

通过数据集执行数据库更新

在引入 ADO.NET 以后，执行数据库更新的体系结构已经显著改变。ADO.NET 的目标是使得开发能够适应大型数据库和大量客户端的多层应用程序变得更加容易。这已经产生了一些重要的结果，尤其是：

更新使用模式

使用 ADO.NET 从 DataSet 中更新数据的过程可以按如下方式加以概述：

（还有另外一种执行更新的方法。可以使用 ExecuteNonQuery 方法直接执行 SQL 更新查询。当您希望以编程方式更新特定的行并且不使用 DataSet 对象时，适合使用该技术。）

初始化 DataAdapter 以进行更新

在 ADO.NET 中，必须添加您自己的代码来向 DataAdapter 对象提交数据库更新。有三种完成该任务的方法：

建议您提供自己的更新逻辑。要节省时间，您可以使用“数据适配器配置向导”，但如果您确实使用了该向导，请尽量不要在运行时生成更新逻辑。除非迫不得已，否则请不要依赖于 CommandBuilder 对象，因为它会导致性能下降，并且您无法控制该对象生成的更新逻辑。此外，CommandBuilder 不会帮助您使用存储过程来提交更新。

对于动态生成数据访问逻辑的应用程序，如报告工具或数据提取工具，您可以使用 CommandBuilder。使用 CommandBuilder 可免除这些工具编写其自身的代码生成模块的需要。

使用存储过程

通过使用存储过程来进行更新，可以使数据库管理员实现比使用动态 SQL 时粒度更低的安全性，以及更完善的数据完整性检查。例如，存储过程除了执行请求的更新以外，还可以向审核日志中插入一项。因为数据库内部对存储过程执行脱机查询优化，所以存储过程还能够提供最佳性能。最后，因为存储过程在数据库结构和应用程序之间提供了隔离，所以更加易于维护。

因为使用存储过程的 ADO.NET 应用程序提供了许多好处，并且不比那些直接对数据库进行更改的应用程序更难实现，所以建议在几乎所有情况下都使用该方法。例外情况是当您必须使用多个后端或不支持存储过程的数据库（如 Microsoft Access）时。在这些情况下，请使用基于查询的更新。

管理并发

DataSet 对象的目的是鼓励对长期运行的活动（例如，当您远程处理数据时以及当用户与数据进行交互时）使用开放式并发。在从 DataSet 向数据库服务器提交更新时，有四种管理开放式并发的主要方法：

注意，后三种方法维护了数据完整性；第一种方法则没有。

仅包括主键列

该选项造成了这样一种情况，即最后的更新覆盖了所有以前的更改。CommandBuilder 不支持此选项，而“数据适配器配置向导”却支持。要使用此选项，请转至 AdvancedOptions 选项卡并清除 UseConcurrency 复选框。

该方法不是推荐的实施策略，因为它允许用户无意中改写其他用户的更改。损害其他用户更新的完整性永远是不可取的。（该技术仅适用于单用户数据库。）

包括 WHERE 子句中的所有列

使用该选项，可防止您改写由其他用户在您的代码取出行和您的代码提交该行中挂起的更改之间这段时间内进行的更改。该选项是“数据适配器配置向导”与 SqlCommandBuilder 生成的 SQL 代码二者的默认行为。

由于以下原因，该方法不是推荐的实施策略：

包括唯一键列和时间戳列

使用该选项，数据库会在每次更新行后，将时间戳列更新为唯一值。（您必须在表中提供时间戳列。）目前，CommandBuilder 与“数据适配器配置向导”都不支持该选项。

包括唯一键列和已修改的列

通常，不推荐使用该选项，因为如果您的应用程序逻辑依赖于过期的数据字段甚至它不更新的字段，则可能会产生错误。例如，如果用户甲更改了订单数量，而用户乙更改了单价，则可能计算出错误的订单总值（数量乘以价格）。

正确地更新空字段

当数据库中的字段不包含数据值时，通常可以方便地将这些空字段视为包含特殊的空值。然而，这一心理却可能是编程错误的根源，因为数据库标准要求对空值进行特殊处理。

空字段的核心问题在于：当两个操作数都为空值或其中一个为空值时，普通的 SQL = 运算符总是返回 false。在 SQL 查询中，运算符 ISNULL 是检查是否存在空字段的唯一正确方法。

如果应用程序通过指定 WHERE 子句，使用上面介绍的技术来管理并发，则您必须在字段可能为空的任何地方包括显式的 IS NULL 表达式。例如，如果 OldLastName 为空，下面的查询将总是失败：

SET LastName = @NewLastName WHERE StudentID = @StudentID AND 
                                  LastName = @OldLastName

应该按如下方式重写该查询：

SET LastName = @NewLastName WHERE (StudentID = @StudentID) AND
                                  ((LastName = @OldLastName) OR
                                   (OldLastName IS NULL AND LastName IS NULL))

要了解如何编写上述种类的更新逻辑，一种好方法是阅读 CommandBuilder 工具生成的输出。

更多信息

有关数据库更新的完整论述，请参阅 David Sceppa 的《Microsoft ADO.NET》(Microsoft Press, 2002) 第 11 和 12 章。

返回页首

使用强类型数据集对象

强类型 DataSet 对象将数据库表和列呈现为对象和属性。访问是按名称执行的，而不是通过对集合进行索引来执行的。这意味着您可以使用访问字段的方法来识别强类型和非类型化 DataSet 对象之间的区别：

string n1 = myDataSet.Tables["Students"].Rows[0]["StudentName"];  // untyped
string n2 = myDataSet.Students[0].StudentName;           // strongly typed

使用强类型 DataSet 对象有以下几点好处：

何时使用强类型数据集

强类型 DataSet 很有用，因为它们使应用程序开发变得更加容易并且更少出错误。对于多层应用程序的客户端而言尤其如此，在此类客户端上，重点在于需要进行多字段访问操作的图形用户界面和数据验证。

不过，如果数据库结构改变（例如，当字段名和表名被修改时），则强类型 DataSet 可能会很麻烦。在此情况下，必须重新生成类型化 DataSet 类，并且必须修改所有相关类。

可以在同一应用程序中使用强类型方法和非类型化方法。例如，一些开发人员在客户端使用强类型 DataSet，在服务器上使用非类型化记录。强类型 DataSet 的 .Merge 方法可用来从非类型化 DataSet 中导入数据。

生成 DataSet 类

.NET 框架 SDK 和 Visual Studio.NET 都提供了实用工具，帮助您生成必要的 DataSet 子类。.NET 框架 SDK 涉及到使用命令行工具和编写代码。很显然，Visual Studio .NET 方法依赖于 Visual Studio .NET 开发环境，并且不要求您打开命令窗口。

无论如何生成 DataSet 类，都必须将新类部署到所有引用该类型化 DataSet 的层上。（这种情形不太常见，但如果通过使用远程处理技术在多个层中传递类型化 DataSet，则需要考虑这种情况。）

使用 .NET 框架实用工具

.NET 框架 SDK 包含一个称为 XML 架构定义工具的命令行实用工具，可帮助您基于 XML 架构 (.xsd) 文件生成类文件。请将该实用工具与 DataSet 对象的 WriteXmlSchema 方法结合使用，以将非类型化 DataSet 转化为强类型 DataSet。

以下命令阐明了如何从 XML 架构文件生成类文件。打开一个命令窗口，并键入以下内容：

C:\>xsd MyNewClass.xsd /d

该命令中的第一个参数是 XML 架构文件的路径。第二个参数表示要创建的类派生于 DataSet 类。默认情况下，该工具会生成 Visual C# .NET 类文件，但它还可以通过添加适当的选项来生成 Visual Basic .NET 类文件。要列出该工具的可用选项，请键入以下内容：

xsd /?

在创建了新的类文件以后，请将其添加到项目中。现在，可以创建强类型 DataSet 类的实例，如下面的 Visual C# .NET 代码片段所示：

MyNewClass ds = new MyNewClass();

使用 Visual Studio .NET

要在 Visual Studio .NET 中生成强类型 DataSet，请右键单击窗体设计器窗口，然后单击 Generate Dataset。这将创建一个 .xsd（XML 架构定义）文件以及一个类文件，然后将其添加到项目中。在执行此操作之前，请确保已经将一个或多个 DataAdapter 添加到 Windows 窗体中。注意，类文件是隐藏的。要查看该文件，请单击位于解决方案资源管理器窗口工具栏中的 Show All Files 按钮。该类文件与 .xsd 文件相关联。

要向强类型 DataSet 添加关系，请通过双击解决方案资源管理器窗口中的架构文件打开 XML 架构设计器，然后右键单击您要向其添加约束的表。在快捷菜单上，单击 Add New Relation。

在 Visual Studio .NET 中生成强类型 DataSet 的另一种方法是，右键单击项目资源管理器中的项目，选择 Add Files，然后选择 dataset。将创建一个新的 .xsd 文件。此时您可以使用服务器资源管理器连接到数据库，并将表拖到 xsd 文件上。

返回页首

处理空数据字段

以下是几点帮助您在 .NET 数据体系结构中正确使用空字段值的提示：

rowStudents["Nickname"] = DBNull.Value   // correct!

If (tds.rowStudent[0].IsPhoneNoNull()) {a€_.}
tds.rowStudent[0].SetPhoneNoNull()

int i = rowStudent["ZipCode"];         // throws exception if null!

返回页首

事务处理

几乎所有更新数据源的、面向商业的应用程序都需要事务处理支持。事务处理用来确保一个或多个数据源中包含的系统状态的完整性，其方法是提供以下四项由著名的缩写词 ACID 表示的基本保证：原子性、一致性、隔离性和持久性。

例如，考虑一个处理采购订单的基于 Web 的零售应用程序。每个订单都需要三种截然不同的操作，这些操作涉及三种数据库更新：

将上述三种截然不同的操作作为一个单位以原子方式执行是至关重要的。它们必须或者全部成功，或者全部失败：任何其他情况都将损害数据完整性。事务处理能够提供这一保证以及其他一些保证。

有关事务处理基本原理的详细信息，请参阅 http://msdn.microsoft.com/library/en-us/cpguidnf/html/cpcontransactionprocessingfundamentals.asp。

有许多可以用来将事务管理集成到数据访问代码中的方法。每种方法都适用于两种基本编程模型中的一种：

这两种技术都可以用来执行本地事务（即针对单个资源管理器如 SQL Server 2000 执行的事务）或分布式事务（即针对远程计算机上的多个资源管理器执行的事务），尽管原子事务处理模型大大简化了分布式事务处理。

您可能倾向于使用原子 (COM+) 事务处理，以便从更容易的编程模型中受益。在有很多执行数据库更新的组件的系统中，这种编程模型的好处尤其明显。但是，在许多方案中，您应该避免这种事务处理模式所带来的额外开销和性能损失。

本节将提供一些指导，帮助您基于特定的应用程序方案来选择最合适的模型。

选择事务处理模型

在选择事务处理模型之前，您应该考虑是否真正需要事务处理。事务是服务器应用程序所使用的最昂贵的单一资源，如果不必要地加以使用，还会降低可伸缩性。考虑下列对事务的使用进行控制的准则：

原子事务处理与手动事务处理

尽管自动事务处理的编程模型在某种程度上得到了简化，尤其是在多个组件都执行数据库更新时，但手动执行本地事务处理总是要快很多，因为它们不需要与 Microsoft DTC 进行交互。即使您要针对单个本地资源管理器（如 SQL Server）使用原子事务，也是这样的（尽管可以减少性能损失），原因是手动的本地事务处理能够避免与 DTC 进行任何不必要的进程间通讯 (IPC)。

在以下情况下，请使用手动事务处理：

在以下情况下，请使用自动事务处理：

在认为性能可以满足要求的应用程序场合中，选择使用自动事务处理（即使针对单个数据库）以简化编程模型是合理的。自动事务处理使得多个组件可以容易地执行属于同一事务的操作。

使用手动事务处理

使用手动事务处理时，可以直接在组件代码或存储过程中分别编写使用 ADO.NET 或 Transact-SQL 事务处理支持功能的代码。在大多数情况下，应该选择在存储过程中控制事务处理，因为该方法提供了优良的封装，并且从性能角度看也与使用 ADO.NET 代码执行事务处理相当。

通过 ADO.NET 执行手动事务处理

ADO.NET 支持一种事务对象，可以使用该对象来开始新的事务，然后对应该提交还是回滚该事务进行显式控制。该事务对象与单个数据库连接相关联，并且通过该连接对象的 BeginTransaction 方法获得。调用该方法并不暗示着随后的命令是在该事务的上下文中发出的。必须将各个命令与事务显式关联，方法是设置相应命令的 Transaction 属性。可以将多个命令对象与事务对象相关联，从而将针对单个数据库的多个操作组合到单个事务中。

有关使用 ADO.NET 事务处理代码的示例，请参阅附录中的如何编写 ADO.NET 手动事务处理代码。

更多信息

通过存储过程执行手动事务处理

还可以通过在存储过程中使用 Transact-SQL 语句来直接控制手动事务处理。例如，可以通过使用单个存储过程（该存储过程使用 Transact-SQL 事务处理语句，如 BEGIN TRANSACTION、END TRANSACTION 和 ROLLBACK TRANSACTION）来执行事务性操作。

更多信息

使用自动事务处理

自动事务处理简化了编程模型，因为它们不要求显式开始新事务或者显式提交或中止事务。然而，自动事务处理的最大优势是它们与 DTC 协同工作，这使得单个事务可以跨越多个分布式数据源。在大型分布式应用程序中，这一优势可能很有意义。尽管可以通过直接编写 DTC 来手动控制分布式事务，但自动事务处理大幅度地简化了该任务，并且非常适合于基于组件的系统。例如，很容易以声明方式配置多个组件来执行组成单个事务的工作。

自动事务处理依赖于 COM+ 提供的分布式事务处理支持功能，因此，只有服务组件（即从 ServicedComponent 类派生的组件）可以使用自动事务处理。

配置类以执行自动事务处理：

更多信息

配置事务隔离级别

COM+ 1.0 版（即在 Windows 2000 上运行的 COM+）的事务隔离级别是 Serialized。尽管这提供了最高程度的隔离，这样的保护是以牺牲性能为代价的。系统的总吞吐量会降低，因为涉及到的资源管理器（通常是数据库）必须在事务处理期间同时拥有读锁和写锁。在此过程中，所有其他事务都将被阻塞，这可能对应用程序的伸缩能力产生重大影响。

COM+ 1.5 版（它随附在 Microsoft Windows .NET 中）允许在 COM+ 目录中以组件为单位对事务隔离级别进行配置。与事务中的根组件相关联的设置确定了该事务的隔离级别。此外，属于同一事务流的内部子组件所具有的事务级别不得高于由根组件所定义的事务级别。如果不满足此项要求，当相关子组件被实例化时，将产生错误。

对于 .NET 托管类，Transaction 属性支持公共 Isolation 属性。可以使用该属性以声明方式指定特定的隔离级别，如下面的代码所示。

 [Transaction(TransactionOption.Supported, Isolation=TransactionIsolationLevel.ReadCommitted)]
public class Account : ServicedComponent
{
  . . .
}

更多信息

确定事务结果

自动事务处理的结果由事务中止标志以及一致性标志（它们位于单事务流中的所有事务性组件的上下文中）的状态控制。当事务流中的根组件被停用（并且控制被返回到调用方）时，将确定事务结果。图 5 对此进行了说明，该图显示了一个传统的银行资金转帐事务。

图 1.5.事务流和上下文

事务的结果是在根对象（在该示例中，为 Transfer 对象）被停用并且客户端的方法调用返回时确定的。如果任意上下文中的任意一致性标志被设置为 false，或者如果事务中止标志被设置为 true，则底层的物理 DTC 事务被中止。

可以用下列两种方式之一从 .NET 对象中控制事务结果：

严重度大于 10 的 SQL Server 错误会导致托管数据提供程序引发 SqlException 类型的异常。如果您的方法捕获并处理了该异常，请确保手动表决以中止该事务，或者（对于被标记为 [AutoComplete] 的方法）确保将该异常传播给调用方。

[AutoComplete] 方法

对于用 AutoComplete 属性标记的方法，请执行以下任意一种操作：

如果不传播该异常，将导致对象不会表决以中止该事务（尽管发生了数据库错误）。这意味着：由共享同一事务流的其他对象所进行的其他成功操作可能被提交。

下面的代码捕获了 SqlException，然后将其直接传播到调用方。该事务最终将中止，因为该对象的一致性标志将在其被停用时自动设置为 false。

 [AutoComplete]
void SomeMethod()
{
  try
  {
    // Open the connection, and perform database operation
    . . .
  }
  catch (SqlException sqlex )
  {
    LogException( sqlex ); // Log the exception details
    throw;                 // Rethrow the exception, causing the consistent 
                           // flag to be set to false.
  }
  finally
  {
    // Close the database connection
    . . .
  }
}

非 [AutoComplete] 方法

对于没有用 AutoComplete 属性进行标记的方法，必须执行以下操作：

以下代码阐明了该方法。

void SomeOtherMethod()
{
  try
  {
    // Open the connection, and perform database operation
    . . .
    ContextUtil.SetComplete(); // Manually vote to commit the transaction
  }
  catch (SqlException sqlex)
  {
    LogException( sqlex );   // Log the exception details
    ContextUtil.SetAbort();  // Manually vote to abort the transaction
    // Exception is handled at this point and is not propagated to the caller
  }
  finally
  {
    // Close the database connection
    . . .
  }
}
  

注 如果有多个 catch 块，则在方法开头调用一次 ContextUtil.SetAbort，并且在 try 块结尾调用 ContextUtil.SetComplete 将会更加容易。这样，就不需要在每个 catch 块中重复调用 ContextUtil.SetAbort。这些方法所确定的一致性标志设置仅当方法返回时才有意义。

必须始终将异常（或被包装的异常）沿调用堆栈向上传播，因为这样可使调用代码知道该事务将失败。这使得调用代码可以进行优化。例如，在银行资金转帐方案中，如果借记操作已经失败，则转帐组件可以决定不执行贷记操作。

如果您将一致性标志设置为 false，然后返回并且不引发异常，则调用代码无法知道事务将要失败。尽管可以返回一个 Boolean 值或者设置一个 Boolean 输出参数，您应该始终如一并引发异常以表明发生了错误。这样会产生更加清晰、更加一致的代码，并且具有标准的错误处理方法。

返回页首

数据分页

对数据进行分页是分布式应用程序中的共同要求。例如，可能要向用户展示一个书籍清单，此时，同时显示整个清单可能被禁止。用户将希望对数据执行熟悉的操作，如查看下一页或上一页数据，或者跳到该清单的开头或结尾。

本节将讨论用于实现此功能的选项，以及每个选项对可伸缩性和性能的影响。

比较几种选择

数据分页的选择包括：

数据分页的最佳选择取决于下面列出的因素：

性能测试表明，使用存储过程的手动方法在广泛的压力级别下提供了最佳性能。不过，因为手动方法在服务器上完成其工作，所以如果网站的大部分功能都依赖于数据分页功能，则服务器压力级别可能成为一个重要问题。要确保该方法适合您的特定环境，应该针对您的特定要求测试所有选择。

下面讨论了各种选择。

使用 SqlDataAdapter 的 Fill 方法

如上所述，可通过 SqlDataAdapter 用数据库中的数据来填充 DataSet。重载的 Fill 方法之一（如以下代码所示）采用两个整数索引值作为参数。

public int Fill(
   DataSet dataSet,
   int startRecord,
   int maxRecords,
   string srcTable
);
  

startRecord 值表示起始记录的从零开始的索引。maxRecords 值表示要复制到新 DataSet 中的记录数（从 startRecord 开始）。

SqlDataAdapter 在内部使用 SqlDataReader 来执行查询并返回结果。SqlDataAdapter 读取结果并基于从 SqlDataReader 中读取的数据创建一个 DataSet。SqlDataAdapter 通过 startRecord 和 maxRecords 将所有结果复制到刚生成的 DataSet 中，并且丢弃它不需要的结果。这意味着可能会将大量不需要的数据通过网络提取到数据访问客户端，而这正是该方法的主要缺点。

例如，如果有 1,000 条记录，并且只需要记录 900 到 950，则仍然会将前面的 899 条记录通过网络提取到客户端并丢弃。这一开销对于小型结果集而言可能很小，但当您对较大的数据集进行分页时，这一开销可能会很大。

使用 ADO

另一种实现分页的选择是使用基于 COM 的 ADO 进行分页。该选项背后的主要动机是获取对服务器端游标的访问，该游标通过 ADO Recordset 对象公开。可以将 Recordset 游标位置设置为 adUseServer。如果您的 OLE DB 提供程序支持它（SQLOLEDB 就支持），这将导致对服务器端游标的使用。然后，您可以使用该游标直接导航到起始记录，而无须将所有记录通过网络提取到数据访问客户端代码。

该方法有以下两个主要缺点：

使用手动实现

本节讨论的最后一个对数据进行分页的选择是，通过使用存储过程为应用程序手动实现分页功能。对于包含唯一键的表而言，可以相对容易地实现存储过程。对于不包含唯一键的表（您不应该具有许多这样的表）而言，该过程更复杂一些。

对包含唯一键的表进行分页

如果表包含唯一键，可以在 WHERE 子句中使用该键来创建从特定行开始的结果集。将这种方法与用于限制结果集大小的 SET ROWCOUNT 语句或 SQL Server TOP 语句结合起来，可以提供一种有效的分页机制。下面的存储过程代码阐明了这一方法：

CREATE PROCEDURE GetProductsPaged
@lastProductID int,
@pageSize int
AS
SET ROWCOUNT @pageSize
SELECT *
FROM Products
WHERE [standard search criteria]
AND ProductID > @lastProductID
ORDER BY [Criteria that leaves ProductID monotonically increasing]
GO

该存储过程的调用方简单地维护 lastProductID 值，并且在连续调用之间将其递增或递减所选的页面大小。

对不包含唯一键的表进行分页

如果您要对其进行分页的表不包含唯一键，可以考虑通过某种方法（例如，使用标识列）添加一个唯一键。这将使您能够实现前面讨论的分页解决方案。

对于不包含唯一键的表，只要您能够通过将属于结果集的其他两个或更多个字段组合起来生成唯一性，则仍然能够实现有效的分页解决方案。

例如，请考虑下表：

对于该表，可以通过组合 Col1、Col2 和 Col3 来生成唯一性。因此，可以通过使用以下存储过程中阐明的方法来实现分页机制。

CREATE PROCEDURE RetrieveDataPaged
@lastKey char(40),
@pageSize int
AS
SET ROWCOUNT @pageSize
SELECT
Col1, Col2, Col3, Col4, Col1+Col2+Col3 As KeyField
FROM SampleTable
WHERE [Standard search criteria]
AND Col1+Col2+Col3 > @lastKey
ORDER BY Col1 ASC, Col2 ASC, Col3 ASC
GO

客户端保持由存储过程返回的 KeyField 列的最后值，并将其重新插入到存储过程中以控制表分页。

尽管手动实现增加了数据库服务器的负担，但它能够避免通过网络传递不必要的数据。性能测试表明，该方法能够在广泛的压力级别下正常工作。然而，根据与数据分页功能有关的网站工作量的不同，在服务器上执行手动分页可能会影响应用程序的可伸缩性。您应该在自己的环境中运行性能测试，以便找到适合于特定应用程序方案的最佳方法。

返回页首

附录

如何启用 .NET 类的对象构建

可以使用企业 (COM+) 服务来启用 .NET 托管类，以便进行对象构建。

启用 .NET 托管类

using System.EnterpriseServices;
public class DataAccessComponent : ServicedComponent

 [ConstructionEnabled(Default="default DSN")]
public class DataAccessComponent : ServicedComponent

public override void Construct( string constructString )
{
  // Construct method is called next after constructor.
  // The configured DSN is supplied as the single argument
}

 [assembly:AssemblyKeyFile("DataServices.snk")]

// the ApplicationName attribute specifies the name of the
// COM+ Application which will hold assembly components
[assembly : ApplicationName("DataServices")]

// the ApplicationActivation.ActivationOption attribute specifies 
// where assembly components are loaded on activation
// Library : components run in the creator's process
// Server : components run in a system process, dllhost.exe
[assembly: ApplicationActivation(ActivationOption.Library)]

以下代码片段显示了一个名为 DataAccessComponent 的服务组件，它使用 COM+ 构建字符串来获取数据库连接字符串。

using System;
using System.EnterpriseServices;

// the ApplicationName attribute specifies the name of the
// COM+ Application which will hold assembly components
[assembly : ApplicationName("DataServices")]

// the ApplicationActivation.ActivationOption attribute specifies 
// where assembly components are loaded on activation
// Library : components run in the creator's process
// Server : components run in a system process, dllhost.exe
[assembly: ApplicationActivation(ActivationOption.Library)]

// Sign the assembly. The snk key file is created using the 
// sn.exe utility
[assembly: AssemblyKeyFile("DataServices.snk")]

[ConstructionEnabled(Default="Default DSN")]
public class DataAccessComponent : ServicedComponent
{
    private string connectionString;
    public DataAccessComponent()
    {
      // constructor is called on instance creation
    }
    public override void Construct( string constructString )
    {
      // Construct method is called next after constructor.
      // The configured DSN is supplied as the single argument
      this.connectionString = constructString;
    }
}

如何使用 SqlDataAdapter 来检索多个行

以下代码阐明了如何使用 SqlDataAdapter 对象发出可生成 DataSet 或 DataTable 的命令。它从 SQL Server Northwind 数据库中检索一组产品类别。

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

public DataTable RetrieveRowsWithDataTable()
{
  using ( SqlConnection conn = new SqlConnection(connectionString) )
  {
    conn.Open();
    SqlCommand cmd = new SqlCommand("DATRetrieveProducts", conn);
    cmd.CommandType = CommandType.StoredProcedure;
    SqlDataAdapter adapter = new SqlDataAdapter( cmd );
    DataTable dataTable = new DataTable("Products");
    adapter .Fill(dataTable);
    return dataTable;
  }
}

使用 SqlAdapter 生成 DataSet 或 DataTable

如何使用 SqlDataReader 来检索多个行

以下代码片段阐明了可检索多个行的 SqlDataReader 方法。

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

public SqlDataReader RetrieveRowsWithDataReader()
{
  SqlConnection conn = new SqlConnection(
         "server=(local);Integrated Security=SSPI;database=northwind");
  SqlCommand cmd = new SqlCommand("DATRetrieveProducts", conn );
  cmd.CommandType = CommandType.StoredProcedure;
  try
  {
    conn.Open();
    // Generate the reader. CommandBehavior.CloseConnection causes the
    // the connection to be closed when the reader object is closed
    return( cmd.ExecuteReader( CommandBehavior.CloseConnection ) );
  }
  catch
  {
    conn.Close();
    throw;
  }
}

// Display the product list using the console
private void DisplayProducts()
{
  SqlDataReader reader = RetrieveRowsWithDataReader();
  try
  {
    while (reader.Read())
    {
      Console.WriteLine("{0} {1} {2}", 
                        reader.GetInt32(0).ToString(), 
                        reader.GetString(1) );
    }
  }
  finally
  {
    reader.Close(); // Also closes the connection due to the
                    // CommandBehavior enum used when generating the reader
  }
}

使用 SqlDataReader 检索行

如何使用 XmlReader 检索多个行

可以使用 SqlCommand 对象来生成 XmlReader 对象，后者可提供对 XML 数据的基于流的只进访问。命令（通常为存储过程）必须产生基于 XML 的结果集，对于 SQL Server 2000 而言，该结果集通常包含一个带有有效 FOR XML 子句的 SELECT 语句。以下代码片段阐明了该方法：

public void RetrieveAndDisplayRowsWithXmlReader()
{
  using( SqlConnection conn = new SqlConnection(connectionString) )
  {;
    SqlCommand cmd = new SqlCommand("DATRetrieveProductsXML", conn );
    cmd.CommandType = CommandType.StoredProcedure;
try
  {
      conn.Open();
    XmlTextReader xreader = (XmlTextReader)cmd.ExecuteXmlReader();
    while ( xreader.Read() )
    {
      if ( xreader.Name == "PRODUCTS" ) 
      {
        string strOutput = xreader.GetAttribute("ProductID");
        strOutput += " ";
        strOutput += xreader.GetAttribute("ProductName");
        Console.WriteLine( strOutput );
      }
    }
    xreader.Close();  // XmlTextReader does not support IDisposable so it can't be
                      // used within a using keyword 
  }
}
  

上述代码使用了以下存储过程：

CREATE PROCEDURE DATRetrieveProductsXML
AS
SELECT * FROM PRODUCTS 
FOR XML AUTO
GO

使用 XmlReader 检索 XML 数据

如何使用存储过程输出参数来检索单个行

借助于命名的输出参数，可以调用在单个行内返回检索到的数据项的存储过程。以下代码片段使用存储过程来检索 Northwind 数据库的 Products 表中包含的特定产品的产品名称和单价。

void GetProductDetails( int ProductID, 
                        out string ProductName, out decimal UnitPrice )
{
  using( SqlConnection conn = new SqlConnection(
        "server=(local);Integrated Security=SSPI;database=Northwind") )
  {
    // Set up the command object used to execute the stored proc
    SqlCommand cmd = new SqlCommand( "DATGetProductDetailsSPOutput", conn )
    cmd.CommandType = CommandType.StoredProcedure;
    // Establish stored proc parameters.
    //  @ProductID int INPUT
    //  @ProductName nvarchar(40) OUTPUT
    //  @UnitPrice money OUTPUT

    // Must explicitly set the direction of output parameters
    SqlParameter paramProdID = 
             cmd.Parameters.Add( "@ProductID", ProductID );
    paramProdID.Direction = ParameterDirection.Input;
    SqlParameter paramProdName = 
             cmd.Parameters.Add( "@ProductName", SqlDbType.VarChar, 40 );
    paramProdName.Direction = ParameterDirection.Output;
    SqlParameter paramUnitPrice = 
             cmd.Parameters.Add( "@UnitPrice", SqlDbType.Money );
    paramUnitPrice.Direction = ParameterDirection.Output;

    conn.Open();
    // Use ExecuteNonQuery to run the command. 
    // Although no rows are returned any mapped output parameters 
    // (and potentially return values) are populated 
    cmd.ExecuteNonQuery( );
    // Return output parameters from stored proc
    ProductName = paramProdName.Value.ToString();
    UnitPrice = (decimal)paramUnitPrice.Value; 
  }
}

使用存储过程输出参数来检索单个行

上述代码片段调用了以下存储过程。

CREATE PROCEDURE DATGetProductDetailsSPOutput
@ProductID int,
@ProductName nvarchar(40) OUTPUT,
@UnitPrice money OUTPUT
AS
SELECT @ProductName = ProductName, 
       @UnitPrice = UnitPrice 
FROM Products 
WHERE ProductID = @ProductID
GO

如何使用 SqlDataReader 来检索单个行

可以使用 SqlDataReader 对象来检索单个行，尤其是可以从返回的数据流中检索需要的列值。以下代码片段对此进行了说明。

void GetProductDetailsUsingReader( int ProductID, 
                        out string ProductName, out decimal UnitPrice )
{
  using( SqlConnection conn = new SqlConnection(
         "server=(local);Integrated Security=SSPI;database=Northwind") )
  {
    // Set up the command object used to execute the stored proc
    SqlCommand cmd = new SqlCommand( "DATGetProductDetailsReader", conn );
    cmd.CommandType = CommandType.StoredProcedure;
    // Establish stored proc parameters.
    //  @ProductID int INPUT

    SqlParameter paramProdID = cmd.Parameters.Add( "@ProductID", ProductID );
    paramProdID.Direction = ParameterDirection.Input;
    conn.Open();
    using( SqlDataReader reader = cmd.ExecuteReader() )
    {
      if( reader.Read() ) // Advance to the one and only row
      {
        // Return output parameters from returned data stream
        ProductName = reader.GetString(0);
        UnitPrice = reader.GetDecimal(1);
       }
    }
  }
}

使用 SqlDataReader 对象来返回单个行

上述代码片段调用了以下存储过程。

CREATE PROCEDURE DATGetProductDetailsReader
@ProductID int
AS
SELECT ProductName, UnitPrice FROM Products
WHERE ProductID = @ProductID
GO

如何使用 ExecuteScalar 来检索单个项

ExecuteScalar 方法专门适用于仅返回单个值的查询。如果查询返回多个列和/或行，ExecuteScalar 将只返回第一行的第一列。

以下代码说明了如何查找与特定产品 ID 相对应的产品名称：

void GetProductNameExecuteScalar( int ProductID, out string ProductName )
{
  using( SqlConnection conn = new SqlConnection(
         "server=(local);Integrated Security=SSPI;database=northwind") )
  {
    SqlCommand cmd = new SqlCommand("LookupProductNameScalar", conn );
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add("@ProductID", ProductID );
    conn.Open();
    ProductName = (string)cmd.ExecuteScalar();
  }
}

使用 ExecuteScalar 来检索单个项

上述代码使用了以下存储过程：

CREATE PROCEDURE LookupProductNameScalar
@ProductID int
AS
SELECT TOP 1 ProductName
FROM Products
WHERE ProductID = @ProductID
GO

如何使用存储过程输出或返回参数来检索单个项

可以使用存储过程输出或返回参数来查找单个值。以下代码阐明了输出参数的用法：

void GetProductNameUsingSPOutput( int ProductID, out string ProductName )
{
  using( SqlConnection conn = new SqlConnection(
        "server=(local);Integrated Security=SSPI;database=northwind") )
  {
    SqlCommand cmd = new SqlCommand("LookupProductNameSPOutput", conn );
    cmd.CommandType = CommandType.StoredProcedure;

    SqlParameter paramProdID = cmd.Parameters.Add("@ProductID", ProductID );
    ParamProdID.Direction = ParameterDirection.Input;
    SqlParameter paramPN = 
           cmd.Parameters.Add("@ProductName", SqlDbType.VarChar, 40 );
    paramPN.Direction = ParameterDirection.Output;

    conn.Open();
    cmd.ExecuteNonQuery();
    ProductName = paramPN.Value.ToString();  
  }
}

使用存储过程输出参数来检索单个值

上述代码使用了以下存储过程。

CREATE PROCEDURE LookupProductNameSPOutput 
@ProductID int,
@ProductName nvarchar(40) OUTPUT
AS
SELECT @ProductName = ProductName
FROM Products
WHERE ProductID = @ProductID
GO

以下代码阐明了如何使用返回值来指明是否存在特定行。从编码角度来看，这类似于使用存储过程输出参数，不同之处在于必须将 SqlParameter 方向显式设置为 ParameterDirection.ReturnValue。

bool CheckProduct( int ProductID )
{
  using( SqlConnection conn = new SqlConnection(
       "server=(local);Integrated Security=SSPI;database=northwind") )
  {
    SqlCommand cmd = new SqlCommand("CheckProductSP", conn );
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add("@ProductID", ProductID );
    SqlParameter paramRet =  
           cmd.Parameters.Add("@ProductExists", SqlDbType.Int );
    paramRet.Direction = ParameterDirection.ReturnValue;
    conn.Open();
    cmd.ExecuteNonQuery();
  }
  return (int)paramRet.Value == 1;
}

通过使用存储过程返回值来检查是否存在特定行

上述代码使用了以下存储过程。

CREATE PROCEDURE CheckProductSP 
@ProductID int
AS
IF EXISTS( SELECT ProductID
           FROM Products
           WHERE ProductID = @ProductID )
  return 1
ELSE
  return 0
GO

如何使用 SqlDataReader 来检索单个项

可以使用 SqlDataReader 对象并通过调用命令对象的 ExecuteReader 方法来获取单个输出值。这要求编写稍微多一点的代码，因为必须调用 SqlDataReader Read 方法，然后通过该读取器的访问器方法之一来检索需要的值。以下代码阐明了 SqlDataReader 对象的用法。

bool CheckProductWithReader( int ProductID )
{
  using( SqlConnection conn = new SqlConnection(
         "server=(local);Integrated Security=SSPI;database=northwind") )
  {
    SqlCommand cmd = new SqlCommand("CheckProductExistsWithCount", conn );
    cmd.CommandType = CommandType.StoredProcedure;

    cmd.Parameters.Add("@ProductID", ProductID );
    cmd.Parameters["@ProductID"].Direction = ParameterDirection.Input;
    conn.Open();
    using( SqlDataReader reader = cmd.ExecuteReader(
                                CommandBehavior.SingleResult ) )
    {
    if( reader.Read() )
    {
      return (reader.GetInt32(0) > 0);
    }
    return false;
  }
}

上述代码采用了以下存储过程。

CREATE PROCEDURE CheckProductExistsWithCount 
@ProductID int
AS
SELECT COUNT(*) FROM Products
WHERE ProductID = @ProductID
GO

如何编写 ADO.NET 手动事务处理代码

以下代码显示了如何充分利用 SQL Server .NET 数据提供程序所提供的事务处理支持，通过事务来保护资金转帐操作。该操作在同一数据库中的两个帐户之间转移资金。

public void TransferMoney( string toAccount, string fromAccount, decimal amount )
{
  using ( SqlConnection conn = new SqlConnection(
            "server=(local);Integrated Security=SSPI;database=SimpleBank" ) )
  {
    SqlCommand cmdCredit = new SqlCommand("Credit", conn );
    cmdCredit.CommandType = CommandType.StoredProcedure;
    cmdCredit.Parameters.Add( new SqlParameter("@AccountNo", toAccount) );
    cmdCredit.Parameters.Add( new SqlParameter("@Amount", amount ));

    SqlCommand cmdDebit = new SqlCommand("Debit", conn );
    cmdDebit.CommandType = CommandType.StoredProcedure;
    cmdDebit.Parameters.Add( new SqlParameter("@AccountNo", fromAccount) );
    cmdDebit.Parameters.Add( new SqlParameter("@Amount", amount ));

    conn.Open();
    // Start a new transaction
    using ( SqlTransaction trans = conn.BeginTransaction() )
    {
      // Associate the two command objects with the same transaction
      cmdCredit.Transaction = trans;
      cmdDebit.Transaction = trans;
      try
      {
        cmdCredit.ExecuteNonQuery();
        cmdDebit.ExecuteNonQuery();
        // Both commands (credit and debit) were successful
        trans.Commit();
      }
      catch( Exception ex )
      {
        // transaction failed
        trans.Rollback();
        // log exception details . . .
        throw ex;
      }
    }
  }
}

如何使用 Transact-SQL 执行事务处理

以下存储过程阐明了如何在 Transact-SQL 存储过程内部执行事务性资金转帐操作。

CREATE PROCEDURE MoneyTransfer
@FromAccount char(20),
@ToAccount char(20),
@Amount money
AS
BEGIN TRANSACTION
-- PERFORM DEBIT OPERATION
UPDATE Accounts
SET Balance = Balance - @Amount
WHERE AccountNumber = @FromAccount
IF @@RowCount = 0
BEGIN
  RAISERROR('Invalid From Account Number', 11, 1)
  GOTO ABORT
END
DECLARE @Balance money
SELECT @Balance = Balance FROM ACCOUNTS
WHERE AccountNumber = @FromAccount
IF @BALANCE < 0
BEGIN
  RAISERROR('Insufficient funds', 11, 1)
  GOTO ABORT
END
-- PERFORM CREDIT OPERATION
UPDATE Accounts 
SET Balance = Balance + @Amount 
WHERE AccountNumber = @ToAccount
IF @@RowCount = 0
BEGIN
  RAISERROR('Invalid To Account Number', 11, 1)
  GOTO ABORT
END
COMMIT TRANSACTION
RETURN 0
ABORT:
  ROLLBACK TRANSACTION
GO

该存储过程使用 BEGIN TRANSACTION、COMMIT TRANSACTION 和 ROLLBACK TRANSACTION 语句来手动控制该事务。

如何编写事务性 .NET 类

以下示例代码显示了三个服务性 .NET 托管类，这些类经过配置以执行自动事务处理。每个类都使用 Transaction 属性进行了批注，该属性的值确定是否应该启动新的事务流，或者该对象是否应该共享其直接调用方的事务流。这些组件协同工作来执行银行资金转帐任务。Transfer 类被使用 RequiresNew 事务属性进行了配置，而 Debit 和 Credit 被使用 Required 进行了配置。结果，所有这三个对象在运行时都将共享同一事务。

using System;
using System.EnterpriseServices;

[Transaction(TransactionOption.RequiresNew)]
public class Transfer : ServicedComponent
{
  [AutoComplete]
  public void Transfer( string toAccount, 
                        string fromAccount, decimal amount )
  {
    try
    {
      // Perform the debit operation
      Debit debit = new Debit();
      debit.DebitAccount( fromAccount, amount );
      // Perform the credit operation
      Credit credit = new Credit();
      credit.CreditAccount( toAccount, amount );
    }
    catch( SqlException sqlex )
    {
      // Handle and log exception details
      // Wrap and propagate the exception
      throw new TransferException( "Transfer Failure", sqlex );    
    }
  }
}
[Transaction(TransactionOption.Required)]
public class Credit : ServicedComponent
{
  [AutoComplete]
  public void CreditAccount( string account, decimal amount )
  {
    try
    {
      using( SqlConnection conn = new SqlConnection(
              "Server=(local); Integrated Security=SSPI"; database="SimpleBank") )
      {
        SqlCommand cmd = new SqlCommand("Credit", conn );
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.Add( new SqlParameter("@AccountNo", account) );
        cmd.Parameters.Add( new SqlParameter("@Amount", amount ));
        conn.Open();
        cmd.ExecuteNonQuery();
      }
    }
  }catch( SqlException sqlex ){
     // Log exception details here
     throw; // Propagate exception
  }
}
[Transaction(TransactionOption.Required)]
public class Debit : ServicedComponent
{
  public void DebitAccount( string account, decimal amount )
  {
    try
    {
      using( SqlConnection conn = new SqlConnection(
              "Server=(local); Integrated Security=SSPI"; database="SimpleBank") )
      {
        SqlCommand cmd = new SqlCommand("Debit", conn );
        cmd.CommandType = CommandType.StoredProcedure;
        cmd.Parameters.Add( new SqlParameter("@AccountNo", account) );
        cmd.Parameters.Add( new SqlParameter("@Amount", amount ));
        conn.Open();
        cmd.ExecuteNonQuery();
      } 
    }
    catch (SqlException sqlex)
    {
      // Log exception details here
      throw; // Propagate exception back to caller
    }
  }
}

合作者

非常感谢下列投稿人和审阅者：

Bill Vaughn、Mike Pizzo、Pablo Castro、Doug Rothaus、Kevin White、Blaine Dokter、David Schleifer、Graeme Malcolm (Content Master)、Bernard Chen (Sapient)、Matt Drucker (Turner Broadcasting)、Steve Kirk、David Sceppa、Scott Densmore、Diego González (Lagash Systems)

有关 .NET 最佳实施策略的详细信息，请访问 patterns & practices 网页。

要参与有关此主题的联机协作开发环境，请加入 GotDotNet 工作区：Microsoft Patterns & Practices Data Access for .NET Workspace。请与该工作区中的社区共享您的数据访问阻塞问题、建议和自定义。

您是否有任何问题、意见和建议？要对本文内容进行反馈，请给我们发送电子邮件至：devfdbck@microsoft.com。

转到原英文页面

返回页首