System.Data

描述用户定义的方法或函数所使用的用户数据访问类型。

该方法或函数不访问用户数据。

该方法或函数读取用户数据。

由 和 用来指示用户定义类型 (UDT) 或聚合的序列化格式。

序列化格式使用非常简单的算法，使 SQL Server 能够在磁盘上存储 UDT 的有效表示形式。 标记为 序列化的类型只能将值类型（在 Microsoft Visual C# 中为 struct，在 Microsoft Visual Basic .NET 中为 structure）用作成员。 不支持引用类型（如 Visual C# 和 Visual Basic 中的类）的成员，无论它们是用户定义的成员还是框架中已有的成员（如 ），均是如此。

该序列化格式是未知的。

使用 序列化格式，开发人员可以通过 和 方法完全控制二进制格式。

为用户定义类型 (UDT) 和用户定义聚合的序列化和反序列化提供自定义实现。

从用户定义类型 (UDT) 或用户定义聚合的二进制格式生成用户定义的类型或用户定义的聚合。

从中对对象进行反序列化的 流。

将用户定义的类型 (UDT) 或用户定义的聚合转换为其二进制格式，以便保留。

UDT 或用户定义聚合所序列化到的 流。

在 SQL Server 或 ADO.NET 提供程序检测到无效的用户定义类型 (UDT) 时引发。

对于给定的 ，将所有的 属性流式写入 类。

对象。 对象。

表示调用方上下文的抽象，该上下文提供对 、 和 对象的访问。 此类不能被继承。

指定调用代码是否在 SQL Server 中运行，以及上下文连接是否可访问。

如果上下文连接可用，并且其他 成员可访问，则为 。

获取允许调用方将结果集、消息和命令的执行结果发送回客户端的管道对象。

如果管道可用，则为 的实例；如果在管道不可用的上下文中（如在用户定义的函数中）调用，则为 。

获取触发器上下文，该上下文用于向调用方提供有关导致触发器激发的原因的信息，以及被更新的列的映射。

如果触发器上下文可用，则为 的实例；如果在触发器调用之外调用，则为 。

调用方的 Microsoft Windows 标识。

表示调用方的 Windows 标识的 实例；如果客户端是使用“SQL Server 身份验证”进行身份验证的，则为 。

表示单个数据行及其元数据。 此类不能被继承。

使用基于作为参数传递的 对象数组的架构初始化新的 。

一个 对象的数组，该对象描述 中的每一列。 为 。

获取数据行的列数。 此属性是只读的。

数据行的列数，其形式为整数。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号指定的列的值，其形式为 对象数组。

从零开始的列序号。 开始检索字节的字段值内的偏移量。 要将字节复制到的目标缓冲区。 要将字节开始复制到的缓冲区内的偏移量。 要复制到缓冲区的字节数。 已复制的字节数。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号指定的列的值，其形式为 对象数组。

从零开始的列序号。 开始检索字符的字段值偏移量。 要将字符复制到其中的目标缓冲区。 开始复制字符的缓冲区偏移量。 要复制到缓冲区的字符数。 复制的字符数。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

返回序号参数指定的列的数据类型名称。

从零开始的列序号。 包含列的数据类型的 。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

以 的形式返回指定列的数据。

从零开始的列序号。 以 的形式指定的列的值。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

返回一个 对象，该对象表示映射到 参数指定的列的 SQL Server 类型的公共语言运行时 (CLR) 类型。

从零开始的列序号。 形式为 对象的列类型。 小于 0 或大于列数（即 ）。 此列属于用户定义的类型，不可用于调用应用程序域。 此列属于用户定义的类型，不可用于调用应用程序域。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 指定的列为 null。 类型不匹配。

返回序号参数指定的列的名称。

从零开始的列序号。 一个包含列名称的 。 小于 0 或大于列数（即 ）。 类型不匹配。

返回此列名指定的列序号。

要查找的列的名称。 从零开始的整数列序号。 为 。 无法找到此列名。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

返回 对象，该对象表示映射到 SQL Server 类型列的类型（作为 中定义的 SQL Server 类型）。

从零开始的列序号。 形式为 对象的列类型。 小于 0 或大于列数（即 ）。 此列属于用户定义的类型，不可用于调用应用程序域。 此列属于用户定义的类型，不可用于调用应用程序域。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

返回 对象，它描述由列序号指定的列的元数据。

从零开始的列序号。 列元数据作为 对象。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

返回表示为 SQL Server 类型，由列序号指定的列中存储的数据值。

从零开始的列序号。 表示为 SQL Server 类型的列的值，其形式为 。 小于 0 或大于列数（即 ）。 类型不匹配。

返回记录中所有列的值，这些值在数组中表示为 SQL Server 类型。

要将值列值复制到其中的数组。 指示复制的列数的 。 为 。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

获取序号所指定的列的值，其形式为 。

从零开始的列序号。 形式的列值。 小于 0 或大于列数（即 ）。 类型不匹配。

以 的形式返回指定列的数据。

从零开始的列序号。 以 的形式指定的列的值。

为顺序参数所指定的列，返回公共语言运行时 (CLR) 类型值。

从零开始的列序号。 顺序指定的列的 CLR 类型值。 小于 0 或大于列数（即 ）。 类型不匹配。

返回记录中所有列的值，这些值在数组中表示为公共语言运行时 (CLR) 类型。

要将值列值复制到其中的数组。 指示复制的列数的 。 为 。 类型不匹配。

如果列序号参数所指定的列为 null，则返回 true。

从零开始的列序号。 如果该列为 null，则为 ；否则为 。 小于 0 或大于列数（即 ）。

为列 参数所指定的列，获取公共语言运行时 (CLR) 类型值。

从零开始的列序号。 指定的列的 CLR 类型值。 小于 0 或大于列数（即 ）。

为列 参数所指定的列，获取公共语言运行时 (CLR) 类型值。

列的名称。 指定的列的 CLR 类型值。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值数组。

从零开始的列序号。 字段值中的偏移量，从该位置开始复制字节。 要从其中复制字节的目标缓冲区。 缓冲区中的偏移量，从该位置开始复制字节。 要从缓冲区复制的字节数。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值数组。

从零开始的列序号。 字段值中的偏移量，从该位置开始复制字符。 要从其中复制字符的目标缓冲区。 缓冲区中的偏移量，从该位置开始复制字符。 要从缓冲区复制的字符数。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

设置为 值指定的列的值。

从零开始的列序号。 列的新值。

将指定列中的值设置为 。

从零开始的列序号。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

将存储在列中的数据设置为指定的 值。

从零开始的列序号。 列的新值。 小于 0 或大于列数（即 ）。

设置为 指定的列的值。

从零开始的列序号。 列的新值。 传入的 是负数。 传入的 值的长度大于 24 小时。

为列序号指定的列设置新值，表示为公共语言运行时 (CLR) 类型。

从零开始的列序号。 指定列的新值。 小于 0 或大于列数（即 ）。

设置 中所有列的新值。 这些值表示为公共语言运行时 (CLR) 类型。

实例的新值数组，其表示为装箱为 引用的 CLR 类型。 列值数设置为整数。 为 。 值的大小与 实例中的列数不匹配。

在此版本中不受支持。

从零开始的列序号。 将始终引发异常。 小于 0 或大于列数（即 ）。

使用可用在 Transact-SQL 中的其他信息对用户定义类型 (UDT) 的返回结果进行批注。

用户定义类型 (UDT) 返回类型的可选特性，该特性的用途是借助可以在 Transact-SQL 中使用的其他信息对返回的结果进行批注。

指示用户定义类型的返回类型是否具有固定长度。

如果返回类型具有固定长度，则为 ；否则为 。

指示用户定义类型的返回类型是否可以为 。

如果用户定义类型的返回类型可以为 ，则为 ；否则为 。

用户定义类型的基础字段类型的最大大小（用逻辑单元表示）。

一个 ，它以逻辑单位表示基础字段类型的最大大小。

用户定义类型的返回类型的精度。

表示返回类型的精度的 。

用户定义类型的返回类型的小数位数。

表示返回类型的小数位数的 。

用于将用户定义聚合的方法定义标记为 SQL Server 中的函数。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特征。

用户定义聚合的可选特性，用于指示方法应在 SQL Server 中注册为函数。 还用于设置函数特性的 、、、、、 和 属性。

指示函数是否需要访问存储在 SQL Server 的本地实例中的用户数据。

.： 不访问数据。 .： 仅读取用户数据。

同一类中的方法名称，该类用于填充表值函数返回的表中的一行数据。

一个值，该值表示用于填充表值函数返回表中的数据行的相同类中方法的名称。

指示用户定义的函数是否是确定性的。

如果该函数是确定性的，则为 ；否则为 。

指示函数是否涉及不精确的计算，如浮点运算。

如果函数涉及精确的计算，则为 ；否则为 。

函数在 SQL Server 中注册时所使用的名称。

一个 值，它表示函数在注册时应使用的名称。

指示函数是否需要访问存储在 SQL Server 的系统目录或虚拟系统表中的数据。

.： 不访问系统数据。 .： 仅读取系统数据。

如果方法用作表值函数 (TVF)，则为一个字符串，该字符串表示结果的表定义。

一个 值，它表示结果的表定义。

从 对象的参数和列指定和检索元数据信息。 此类不能被继承。

使用指定的列名称和类型初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 为 。 不允许的 作为 传递给了构造函数。

使用指定的列名称和默认服务器初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型、精度和小数位数初始化 类的新实例。

参数或列的名称。 参数或列的 SQL Server 类型。 参数或列的精度。 参数或列的小数位数。 为 。 不允许的 作为 传递给了构造函数，或者 大于 。

使用指定的列名称、类型、精度、小数位数和服务器默认值初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 参数或列的精度。 参数或列的小数位数。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型和最大长度初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 为 。 不允许的 SqlDbType 作为 传递给了构造函数。

使用指定的列名称、类型、最大长度和服务器默认值初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型、最大长度、精度、小数位数、区域设置 ID、比较选项和用户定义的类型 (UDT) 初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 参数或列的精度。 参数或列的小数位数。 参数或列的区域设置 ID。 参数或列的比较规则。 一个指向该 UDT 的 实例。 为 。 不允许的 作为 传递给了构造函数，或者 指向了未声明 的类型。

使用指定的列名称、类型、最大长度、精度、小数位数、区域设置 ID、比较选项和用户定义的类型 (UDT) 初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 参数或列的精度。 参数或列的小数位数。 参数或列的区域设置 ID。 参数或列的比较规则。 一个指向该 UDT 的 实例。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型、最大长度、区域设置和比较选项初始化 类的新实例。

参数或列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 参数或列的区域设置 ID。 参数或列的比较规则。 为 。 不允许的 SqlDbType 作为 传递给了构造函数。

使用指定的列名称、类型、最大长度、区域设置、比较选项和服务器默认值初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 指定类型的最大长度。 参数或列的区域设置 ID。 参数或列的比较规则。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型、数据库名称、所属架构和对象名称初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 类型化 XML 实例的 XML 架构集合的数据库名称。 类型化 XML 实例的 XML 架构集合的关系架构名称。 类型化 XML 实例的 XML 架构集合的名称。 当 和 不为 时， 为 ，或 为 。 不允许的 SqlDbType 作为 传递给了构造函数。

使用指定的列名称、数据库名称、所属架构、对象名称和默认服务器初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 类型化 XML 实例的 XML 架构集合的数据库名称。 类型化 XML 实例的 XML 架构集合的关系架构名称。 类型化 XML 实例的 XML 架构集合的名称。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

使用指定的列名称、类型和用户定义的类型 (UDT) 初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 一个指向该 UDT 的 实例。 为 。 不允许的 SqlDbType 作为 传递给了构造函数，或者 指向了未声明 的类型。

使用指定的列名称、用户定义的类型 (UDT) 和 SQLServer 类型初始化 类的新实例。

列的名称。 参数或列的 SQL Server 类型。 一个指向该 UDT 的 实例。 的 SQL Server 类型名称。

使用指定的列名称、类型、用户定义的类型、SQL Server 类型和服务器默认值初始化 类的新实例。 这种形式的构造函数通过允许指定表值参数中的列是否唯一、列的排序顺序和列排序的序号，支持表值参数。

列的名称。 参数或列的 SQL Server 类型。 一个指向该 UDT 的 实例。 的 SQL Server 类型名称。 指定此列是否应使用默认服务器值。 指定表值参数中的列是否唯一。 指定列的排序顺序。 指定列排序的序号。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值的数组，并在需要时调整该值。

要根据 实例进行验证的值。 作为 值的数组的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值的数组，并在需要时调整该值。

要根据 实例进行验证的值。 作为 值的数组的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 值的数组的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 的调整后的值。 与 类型不匹配，或者未能调整 。

根据元数据验证指定的 值，并在需要时调整该值。

要根据 实例进行验证的值。 作为 值的数组的调整后的值。 与 类型不匹配，或者未能调整 。

获取用于列或参数的比较规则。

作为 用于列或参数的比较规则。

获取列或参数的数据类型。

作为 的列或参数的数据类型。

从指定的对象推导出元数据，并将它作为 实例返回。

用于从中推导出元数据的对象。 分配给返回的 实例的名称。 作为 实例的推导出的元数据。 为 。

指示表值参数中的列是否唯一。

一个 值。

获取列或参数的区域设置 ID。

作为 的列或参数的区域设置 ID。

获取 、 和 数据类型的长度。

、 和 数据类型的长度。

获取列或参数的最大长度。

作为 的列或参数的最大长度。

获取列或参数的名称。

作为 的列或参数的名称。 构造函数中指定的 的长度超过 128 个字符。

获取列或参数的精度。

作为 的列或参数的精度。

获取列或参数的小数位数。

列或参数的小数位数。

返回列的排序顺序。

一个 对象。

返回列排序的序号。

列排序的序号。

获取列或参数的数据类型。

作为 的列或参数的数据类型。

获取用户定义的类型 (UDT) 的公共语言运行时 (CLR) 类型。

作为 的用户定义的类型的 CLR 类型名称。

获取该实例所表示的用户定义的类型 (UDT) 或 SQL Server 类型的名称，名称由三部分组成。

作为 的 UDT 或 SQL Server 类型的名称。

报告此列是否应使用默认服务器值。

一个 值。

获取此 XML 实例的架构集合所在的数据库的名称。

此 XML 实例的架构集合所在的数据库的 形式的名称。

获取此 XML 实例的架构集合的名称。

此 XML 实例的架构集合的 形式的名称。

获取此 XML 实例的架构集合所在的所属关系架构。

形式的此 XML 实例的架构集合所在的所属关系架构。

指示用户定义类型 (UDT) 的方法或属性的确定性和数据访问性质。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特性。

用户定义类型 (UDT) 的特性，用于指示 UDT 的方法或属性的确定性和数据访问性质。

指示 SQL Server 是否应在 null 实例上调用此方法。

如果 SQL Server 应在 null 实例上调用此方法，则为 ；否则为 。 如果方法不能调用 （由于方法上属性），SQL Server返回。

指示用户定义类型 (UDT) 的方法是否为转变器。

如果该方法是转变器，则为 ；否则为 。

在方法调用中使用 输入参数时指示是否调用用户定义类型 (UDT) 上的方法。

如果 输入参数在方法调用中指定时，调用了该方法，则为 ；如果任意输入参数为 时，该方法返回了 值，则为 。 如果方法不能调用 （由于方法上属性），SQL Server返回。

允许托管存储过程在 SQL Server 数据库上进行进程内运行，以便将结果返回调用方。 此类不能被继承。

执行作为参数传递的命令，并将结果发送到客户端。

要执行的 对象。 为 。 对于绑定到进程外连接的命令，此方法不受支持。

获取一个值，该值指示 是否处于将单个结果集发送回客户端的模式。 此属性是只读的。

如果已调用 方法，并且 处于将单个结果集发送回客户端的模式，则为 ；否则为 。

将单行结果集直接发送到客户端或当前输出使用者。

发送到客户端的单行结果集：一个 对象。 为 。

将多行结果集直接发送到客户端或当前输出使用者。

要发送到客户端的多行结果集：一个 对象。 为 。

将字符串消息直接发送到客户端或当前输出使用者。

要发送到客户端的消息字符串。 大于4,000个字符。 为 。

标记结果集的结尾，并将 实例返回到初始状态。

方法以前未被调用过。

将单行数据发送回客户端。

对象，它具有要发送到客户端的行的列值。 记录的架构必须与传递给 方法的 的元数据所描述的架构相匹配。 为 。 方法以前未被调用过。

标记要发送到客户端的结果集的开始，并使用记录参数构造描述结果集的元数据。

对象，元数据即是从中提取并用来描述结果集的。 为 。 没有列或者还没有初始化。 在 方法之后调用了一个 或 方法之外的方法。

用于将程序集中的方法定义标记为存储过程。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特征。 此类不能被继承。

程序集中的方法定义的特性，用于指示应将给定的方法注册为 SQL Server 中的存储过程。

存储过程的名称。

表示存储过程名称的 。

用于将程序集中的方法定义标记为 SQL Server 中的触发器。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特性。 此类不能被继承。

程序集中的方法定义的特性，用于将方法标记为 SQL Server 中的触发器。

触发器的类型和激活触发器的数据操作语言 (DML) 操作。

一个 值，该值表示触发器类型以及激活该触发器的数据操作语言 (DML) 操作。

触发器的名称。

一个表示触发器名称的 值。

应用触发器的表。

一个表示表名的 值。

提供所激发的触发器的上下文信息。

获取绑定到触发器的数据表所包含的列的数目。 此属性是只读的。

绑定到触发器的数据表所包含的列的数目（整数类型）。

获取特定于激发触发器的操作的事件数据。

如果有更多信息可用，则为特定于激发触发器的操作的事件数据（其形式为 ）；否则为 。

如果列受 INSERT 或 UPDATE 语句的影响，则返回 。

从零开始的列序号。 如果列受 INSERT 或 UPDATE 操作的影响，则为 。 在触发器的上下文中被调用，其中 属性的值不是 或 。

指示激发触发器的操作。

激发触发器的操作，形式为 。

指示类型应注册为用户定义的聚合。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特性。 此类不能被继承。

用户定义的聚合的一个必需特性，用于指示给定的类型为用户定义的聚合，以及用户定义的聚合的存储格式。

值之一，表示聚合的序列化格式。

序列化格式为 的值之一。

表示序列化格式的 。

指示聚合是否与重复值无关。

如果聚合与重复值无关，则为 ；否则为 。

指示聚合是否与空值无关。

如果聚合与空值无关，则为 ；否则为 。

指示聚合是否与顺序无关。

如果聚合与顺序无关，则为 ；否则为 。

指示在没有对任何值进行累积时聚合是否返回 。

如果在没有对任何值进行累积时聚合返回 ，则为 ；否则为 。

聚合实例的最大大小（以字节为单位）。

表示聚合实例的最大大小的 值。

在计算期间存储此聚合实例的状态所需的最大大小（以字节为单位）。

聚合的名称。

表示聚合名称的 值。

用于将程序集中的类型定义标记为 SQL Server 中的用户定义类型 (UDT)。 该特性的属性反映了向 SQL Server 注册该类型时所使用的实体特征。 此类不能被继承。

用户定义类型 (UDT) 的一个必需特性，用于确认给定的类型属于 UDT 并指示 UDT 的存储格式。

值之一，表示类型的序列化格式。

序列化格式为 的值之一。

一个 值，表示序列化格式。

指示用户定义的类型是否根据字节进行排序。

如果用户定义的类型是按字节进行排序的，则为 ；否则为 。

指示此用户定义类型的所有实例是否都具有相同的长度。

如果此类型的所有实例都具有相同的长度，则为 ；否则为 。

实例的最大大小（以字节为单位）。

一个 值，表示实例的最大大小。

用户定义类型的 SQL Server 名称。

一个 值，表示用户定义类型的 SQL Server 名称。

方法的名称，该方法用于验证用户定义类型的实例。

一个 ，表示用于验证用户定义类型的实例的方法名称。

描述用户定义的方法或函数对系统数据的访问类型。

方法或函数不访问系统数据。

方法或函数读取系统数据。

枚举由 类用来指示激发该触发器的操作。

已执行 ALTER APPLICATION ROLE Transact-SQL 语句。

已执行 ALTER ASSEMBLY Transact-SQL 语句。

当事件通知在数据库或服务器实例上创建时，会指定 ALTER_REMOTE_SERVICE_BINDING 事件类型。

已执行 ALTER FUNCTION Transact-SQL 语句。

已执行 ALTER INDEX Transact-SQL 语句。

已执行 ALTER LOGIN Transact-SQL 语句。

已执行 ALTER PARTITION FUNCTION Transact-SQL 语句。

已执行 ALTER PARTITION SCHEME Transact-SQL 语句。

已执行 ALTER PROCEDURE Transact-SQL 语句。

已执行 ALTER QUEUE Transact-SQL 语句。

已执行 ALTER ROLE Transact-SQL 语句。

已执行 ALTER ROUTE Transact-SQL 语句。

已执行 ALTER SCHEMA Transact-SQL 语句。

已执行 ALTER SERVICE Transact-SQL 语句。

已执行 ALTER TABLE Transact-SQL 语句。

已执行 ALTER TRIGGER Transact-SQL 语句。

已执行 ALTER USER Transact-SQL 语句。

已执行 ALTER VIEW Transact-SQL 语句。

已执行 CREATE APPLICATION ROLE Transact-SQL 语句。

已执行 CREATE ASSEMBLY Transact-SQL 语句。

当事件通知在数据库或服务器实例上创建时，会指定 CREATE_REMOTE_SERVICE_BINDING 事件类型。

已执行 CREATE CONTRACT Transact-SQL 语句。

已执行 CREATE EVENT NOTIFICATION Transact-SQL 语句。

已执行 CREATE FUNCTION Transact-SQL 语句。

已执行 CREATE INDEX Transact-SQL 语句。

已执行 CREATE LOGIN Transact-SQL 语句。

已执行 CREATE MESSAGE TYPE Transact-SQL 语句。

已执行 CREATE PARTITION FUNCTION Transact-SQL 语句。

已执行 CREATE PARTITION SCHEME Transact-SQL 语句。

已执行 CREATE PROCEDURE Transact-SQL 语句。

已执行 CREATE QUEUE Transact-SQL 语句。

已执行 CREATE ROLE Transact-SQL 语句。

已执行 CREATE ROUTE Transact-SQL 语句。

已执行 CREATE SCHEMA Transact-SQL 语句。

不可用。

已执行 CREATE SERVICE Transact-SQL 语句。

已执行 CREATE SYNONYM Transact-SQL 语句。

已执行 CREATE TABLE Transact-SQL 语句。

已执行 CREATE TRIGGER Transact-SQL 语句。

已执行 CREATE TYPE Transact-SQL 语句。

已执行 CREATE USER Transact-SQL 语句。

已执行 CREATE VIEW Transact-SQL 语句。

已执行 DELETE Transact-SQL 语句。

已执行 DENY Object Permissions Transact-SQL 语句。

已执行 DENY Transact-SQL 语句。

已执行 DROP APPLICATION ROLE Transact-SQL 语句。

已执行 DROP ASSEMBLY Transact-SQL 语句。

当事件通知在数据库或服务器实例上创建时，会指定 DROP_REMOTE_SERVICE_BINDING 事件类型。

已执行 DROP CONTRACT Transact-SQL 语句。

已执行 DROP EVENT NOTIFICATION Transact-SQL 语句。

已执行 DROP FUNCTION Transact-SQL 语句。

已执行 DROP INDEX Transact-SQL 语句。

已执行 DROP LOGIN Transact-SQL 语句。

已执行 DROP MESSAGE TYPE Transact-SQL 语句。

已执行 DROP PARTITION FUNCTION Transact-SQL 语句。

已执行 DROP PARTITION SCHEME Transact-SQL 语句。

已执行 DROP PROCEDURE Transact-SQL 语句。

已执行 DROP QUEUE Transact-SQL 语句。

已执行 DROP ROLE Transact-SQL 语句。

已执行 DROP ROUTE Transact-SQL 语句。

已执行 DROP SCHEMA Transact-SQL 语句。

不可用。

已执行 DROP SERVICE Transact-SQL 语句。

已执行 DROP SYNONYM Transact-SQL 语句。

已执行 DROP TABLE Transact-SQL 语句。

已执行 DROP TRIGGER Transact-SQL 语句。

已执行 DROP TYPE Transact-SQL 语句。

已执行 DROP USER Transact-SQL 语句。

已执行 DROP VIEW Transact-SQL 语句。

已执行 GRANT OBJECT Transact-SQL 语句。

已执行 GRANT Transact-SQL 语句。

已执行 INSERT Transact-SQL 语句。

出现一个无效触发操作，该操作不向用户公开。

已执行 REVOKE OBJECT Transact-SQL 语句。

已执行 REVOKE Transact-SQL 语句。

已执行 UPDATE Transact-SQL 语句。

确定在带有 的 上调用 或 方法时将发生的操作。

在关系中级联更改。

不发生任何操作（默认）。

提供查询结果及其对数据库的影响的说明。

执行命令时，关闭关联的 对象时，关联的 对象也会关闭。

查询可能返回多个结果集。 执行查询可能会影响数据库状态。 未设置 标志，因此调用 在功能上等效于调用 。

查询返回列和主键信息。

查询仅返回列信息。 使用 时，用于 SQL Server 的 .NET Framework 数据提供程序在要执行的语句前加上 SET FMTONLY ON。

提供一种方法，以便 处理包含带有大型二进制值的列的行。 不是加载整行，而是使 能够以数据流的加载数据。 然后可以使用 或 方法来指定开始读取操作的字节位置，以及正在返回的数据的有限缓冲区大小。

查询返回单个结果集。

查询应返回结果集中的单行。 执行查询可能会影响数据库状态。 某些 .NET Framework 数据提供程序可能（但不要求）使用此信息来优化命令性能。 使用 对象的 方法指定 时，用于 OLE DB 的 .NET Framework 数据提供程序使用 OLE DB 接口（如果可用）执行绑定。 否则，它使用 接口。 如果期望 SQL 语句仅返回一行，则指定 也可提高应用程序性能。 执行应返回多个结果集的查询时，可指定 。 在这种情况下，如果同时指定了多结果集 SQL 查询和单行，返回的结果仅包含第一个结果集的第一行。 不返回查询的其他结果集。

指定如何解释命令字符串。

存储过程的名称。

表的名称。

SQL 文本命令。 （默认。）

指示目录名称在文本命令的限定表名中的位置。

指示目录名称的位置位于文本命令的完全限定表名中的架构部分之后。

指示目录名称的位置位于文本命令的完全限定表名中的架构部分之前。

表示用于填充 和更新数据源的一组 SQL 命令和一个数据库连接。

初始化 类的新实例。

从同一类型的现有对象中初始化 类的新实例。

用于创建新 的 对象。

获取或设置一个值，该值指示在任何 Fill 操作过程中，在将 添加到 之后是否在 上调用它。

如果在 上调用 ，则为 ；否则为 。 默认值为 。

获取或设置在 期间是否调用 。

如果在 期间调用 ，则为 ；否则为 。 默认值为 。

创建此 实例的一个副本。

的克隆实例。

获取或设置一个值，该值指定在行更新过程中遇到错误时是否生成异常。

如果要继续更新而不生成异常，则为 ，否则为 。 默认值为 。

创建一个新的 。

新的表映射集合。

释放由 占用的非托管资源，还可以另外再释放托管资源。

表示释放托管资源和非托管资源； 表示仅释放非托管资源。

在 中添加或刷新行以与数据源中的行匹配。

要用记录和架构（如果必要）填充的 。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在 的指定范围中添加或刷新行以匹配使用 和 名称的数据源中的行。

一个要用记录填充的 。 一个字符串，指示源表的名称。 的一个实例。 起始记录的从零开始的索引。 指示最大记录数的整数。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在 中添加或刷新行以与使用 名称和指定的 的数据源中的行匹配。

一个要用记录填充的 。 的一个实例。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在 对象集合的指定范围中添加或刷新行以与数据源中的行匹配。

要用记录填充的 对象的集合。 的一个实例。 起始记录的从零开始的索引。 指示最大记录数的整数。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在填充操作过程中出现错误时返回。

获取或设置 ，后者确定适配器如何从 中填充 。

一个 值。

将 添加到指定的 中，并根据指定的 配置架构以匹配数据源中的架构。

要用数据源中的架构填充的 。 值之一。 包含从数据源返回的架构信息的 对象。

向指定的 添加一个 。

要从 填充的 。 值之一。 用于表映射的源表的名称。 填充 时要用作数据源的 。 一个引用，指向添加到 的 对象的集合。

向指定的 添加一个 。

要从 填充的 。 值之一。 填充 时要用作数据源的 。 包含从数据源返回的架构信息的 对象。

获取当执行 SQL SELECT 语句时由用户设置的参数。

对象的数组，这些对象包含由用户设置的参数。

指示是否已创建了一个 。

如果已创建 ，则为 ；否则为 。

确定传入数据没有匹配的表或列时需要执行的操作。

值之一。 默认值为 。 设置的值不是 值之一。

确定现有 架构与传入数据不匹配时需要执行的操作。

值之一。 默认值为 。 设置的值不是 值之一。

当 过程中出现错误时调用。

一个 对象。

将 重置为默认状态，并使 接受 。

获取或设置 方法是应当返回提供程序特定的值，还是返回公用的符合 CLS 的值。

如果 方法应返回特定于提供程序的值，则为 ；否则如果返回常用的符合 CLS 的值，则为 。

确定是否应保持 属性。

如果保持 属性，则为 ；否则为 。

确定是否应保持 属性。

如果保持 属性，则为 ；否则为 。

确定一个或多个 对象是否存在，并且它们是否应该是持久的。

如果存在一个或多个 对象，则为 ；否则为 。

指示如何将源表映射到数据集表。

一个集合，它提供返回记录和 之间的主映射。 默认值为空集合。

获取一个集合，它提供源表和 之间的主映射。

一个集合，它提供返回记录和 之间的主映射。 默认值为空集合。

从名为“Table”的 为指定的 中每个已插入、已更新或已删除的行调用相应的 INSERT、UPDATE 或 DELETE 语句。

用于更新数据源的 。 中成功更新的行数。 源表无效。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

包含从 继承的对象的一般列映射。 此类不能被继承。

初始化 类的新实例。

使用指定的源列名称和要映射到的 列名初始化 类的新实例。

数据源中区分大小写的列名。 中要映射到的列名（该名称不区分大小写）。

获取或设置 中要映射到的列的名称。

中要映射到的列的名称。 该名称不区分大小写。

使用 和 属性从给定的 获取 。

从中获取列的 。 数据列的 。 值之一。 数据列。

的静态版本，可以在不实例化 对象的情况下调用。

数据源中区分大小写的列名。 中要映射到的列名（该名称不区分大小写）。 的一个实例。 正被映射的列的数据类型。 确定现有 架构与传入数据不匹配时需要执行的操作。 一个 对象。

获取或设置数据源中从其映射的列的名称。 该名称区分大小写。

数据源中列的区分大小写的名称。

创建作为当前实例副本的新对象。

当前对象的副本。

将当前的 名称转换为字符串。

当前的 名称作为字符串。

包含 对象的集合。

创建一个空的 。

将 对象添加到集合中。

要添加到集合的 对象。 已添加到集合中的 对象的索引。 传入的对象不是 对象。

当给定源列名称和 列名时，将 对象添加到集合中。

要映射到的源列的区分大小写的名称。 要映射到的 列的名称（该名称不区分大小写）。 已添加到集合中的 对象。

将指定的 的元素复制到集合末尾。

要添加到集合中的 。

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

从集合中删除所有 对象。

获取一个值，该值指示集合中是否存在具有给定 的 对象。

是 的 。 如果集合包含指定的 对象，则为 ；否则为 。 传入的对象不是 对象。

获取一个值，该值指示集合中是否存在具有给定源列名称的 对象。

对象的区分大小写的源列名称。 如果集合包含具有指定源列名称的 对象，则为 ；否则为 。

将 的元素复制到指定的数组。

要将 元素复制到其中的 。 数组的起始索引。

将 的元素复制到指定的 数组。

元素要复制到的 数组。 中从零开始的索引，在此处开始复制。

获取集合中 对象的数量。

集合中项的数目。

获取具有指定 列名的 对象。

要查找的 列的名称（该名称不区分大小写）。 具有指定 列名的 对象。

给指定的 、源列名称和 获取一个 。

。 要查找的区分大小写的源列名称。 值之一。 一个 对象。 参数设置为 ，并且未指定任何映射。

一个静态方法，它返回未实例化的 对象的 对象。

。 数据源中区分大小写的列名。 正被映射的列的数据类型。 的一个实例。 值之一。 确定现有 架构与传入数据不匹配时需要执行的操作。 一个 对象。

获取可循环访问集合的枚举数。

可用于循环访问集合的 。

获取指定的 （它是 ）在集合中的位置。

一个 ，它是要查找的 。 指定的 （它是 ）在集合中从零开始的位置。

获取具有指定源列名称的 的位置。

源列的区分大小写的名称。 具有指定的区分大小写的源列名称的 从零开始的位置。

获取具有给定 列名的指定 的位置。

要查找的数据集列的名称（该名称不区分大小写）。 具有给定 列名的指定 的从零开始的位置；或者如果在集合中不存在 对象，则为 -1。

在 中的指定索引处插入一个 对象。

要插入的 对象的从零开始的索引。 对象。

在 中的指定索引处插入一个 对象。

要插入的 对象的从零开始的索引。 对象。

获取或设置位于指定索引处的 对象。

要查找的 对象的从零开始的索引。 指定索引处的 对象。

获取或设置具有指定源列名称的 对象。

源列的区分大小写的名称。 具有指定源列名称的 对象。

从集合中移除指定的 。

要移除的 。

从集合中移除 ，它是一个 。

，它是要移除的 。 指定的对象不是 对象。 指定的对象不在集合中。

从集合中移除具有指定索引的 对象。

要移除的 对象的索引（从零开始）。 没有具有指定索引的 对象。

从集合中移除具有指定源列名称的 对象。

区分大小写的源列名称。 没有具有指定源列名称的 对象。

获取一个值，该值指示对 的访问是否同步（线程安全）。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

获取可用于同步对 的访问的对象。

可用于同步对 的访问的对象。

获取一个值，该值指示 是否具有固定大小。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 是只读的，则为 ；否则为 。

获取或设置指定索引处的元素。

要获取或设置的元素的从零开始的索引。 指定索引处的元素。

使用源列名和 列名将 对象添加到 。

源列的区分大小写的名称。 列的名称。 已添加到集合中的 ColumnMapping 对象。

获取具有指定的 列名的 对象。

要查找的 列的名称（该名称不区分大小写）。 具有指定的 列名的 对象。

获取或设置具有指定 名称的 对象。

元素的索引。 具有指定 名称的 对象。

包含有关源表与 之间映射关系的说明。 填充 时，由 使用该类。

初始化 类的新实例。

给定源表名称和 名称时，使用源初始化 类的新实例。

数据源中区分大小写的源表名称。 中要映射到的表名。

给定源表名称、 名称和 对象数组时，初始化 类的新实例。

数据源中区分大小写的源表名称。 中要映射到的表名。 一个 对象数组。

获取 的 。

一个数据列映射集合。

获取或设置 中的表名。

中的表名称。

使用指定的 值和 的名称从指定的 中获取 。

的名称。 值之一。 数据列。 参数设置为 ，并且未指定任何映射。

为给定的列名返回 对象。

的名称。 的数据类型。 中要映射到的表名。 值之一。 值之一。 一个 对象。

使用指定的 值获取指定 的当前 。

要从其中获取 的 。 值之一。 数据表。

获取或设置数据源中区分大小写的源表名称。

数据源中区分大小写的源表名称。

获取 的派生 。

一个数据列映射集合。

创建作为当前实例副本的新对象。

作为当前实例副本的新对象。

将当前的 名称转换为字符串。

当前的 名称作为字符串。

对象的集合。 此类不能被继承。

初始化 类的新实例。 此新实例为空，即它尚未包含任何 对象。

添加 ，它是集合的表映射。

要添加到集合的 对象。 添加到集合中的 对象的索引。 传入的对象不是 对象。

给定源表名称和 表名时，向集合添加 对象。

要从中映射的源表的区分大小写的名称。 要映射到的 表的名称（该名称不区分大小写）。 已添加到集合中的 对象。

将指定的 的元素复制到集合末尾。

要添加到集合的值的 。

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

从集合中删除所有 对象。

获取一个值，该值指示集合中是否存在给定的 对象。

是 的 。 如果此集合包含指定的 ，则为 ；否则为 。

获取一个值，该值指示集合中是否存在具有指定源表名称的 对象。

包含 对象的区分大小写的源表名称。 如果该集合包含具有此源表名称的 对象，则为 ；否则为 。

将 的元素复制到指定的数组。

要将 元素复制到其中的 。 数组的起始索引。

将 的元素复制到指定的数组。

要将 元素复制到其中的 。 数组的起始索引。

获取集合中 对象的数量。

集合中 对象的数目。

获取具有指定的 表名的 对象。

要查找的 表的名称（该名称不区分大小写）。 具有指定的 表名的 对象。

获取可循环访问集合的枚举数。

可用于循环访问集合的 。

使用给定的 获取具有指定源表名称和 表名称的 对象。

要搜索的 集合。 已映射的区分大小写的源表名称。 已映射的 表的名称（该名称不区分大小写）。 值之一。 一个 对象。 参数设置为 ，并且未指定任何映射。

获取指定的 对象在集合中的位置。

即要查找的 对象。 指定的 对象在集合中从零开始的位置。

获取具有指定源表名称的 对象的位置。

区分大小写的源表名称。 具有指定源表名称的 对象的从零开始的位置。

获取具有指定的 表名称的 对象的位置。

要查找的 表的名称（该名称不区分大小写）。 具有给定 表名称的 对象的从零开始的位置；或者，如果集合中不存在 对象，则为 -1。

在 中的指定索引处插入一个 对象。

要插入的 对象的从零开始的索引。 要插入的 对象。

在 中的指定索引处插入一个 对象。

要插入的 对象的从零开始的索引。 要插入的 对象。

获取或设置位于指定索引处的 对象。

要返回的 对象的从零开始的索引。 指定索引处的 对象。

获取或设置具有指定源表名称的 对象。

区分大小写的源表名称。 具有指定源表名称的 对象。

从集合中移除指定的 对象。

要移除的 对象。

从集合中移除指定的 对象。

要移除的 对象。 指定的对象不是 对象。 指定的对象不在集合中。

从集合中移除位于指定索引处的 对象。

要移除的 对象的索引（从零开始）。 具有指定索引的 对象不存在。

从集合中移除具有指定源表名称的 对象。

要查找的区分大小写的源表名称。 具有指定源表名称的 对象不存在。

获取一个值，该值指示是否同步对 的访问（线程安全）。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

获取可用于同步对 的访问的对象。

可用于同步对 的访问的对象。

获取一个值，该值指示 是否具有固定大小。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 是只读的，则为 ；否则为 。

获取或设置指定索引处的集合中的项。

要获取或设置的项的从零开始的索引。 指定索引处的元素。

向集合添加表映射。

区分大小写的源表名称。 表的名称。 对新映射的 对象的引用。

获取具有指定的 表名的 TableMapping 对象。

集合中表 的名称。 具有指定的 表名的 TableMapping 对象。

获取或设置具有指定 名称的 的实例。

的 名称。 具有指定的 名称的 的实例。

表示数据源中的列。

初始化 类的新实例。

获取可为 null 的布尔值，该值指示此列中是否允许 值，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列中是否允许 值，也可设置为 （在 Visual Studio 中为 ）。

如果此列中允许 值，则返回 ，否则，返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取与数据源关联的目录；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为目录名称或 。

与数据源关联的目录名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取列名称；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为列名称或 。

基列名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取与数据源关联的架构；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为架构名称或 。

与数据源关联的架构名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取与列关联的服务器名称；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为服务器名称或 。

与列关联的服务器名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取架构中的表名称；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为表名称或 。

架构中的表名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取列的名称。 在派生类中重写时，可设置为列名称。

列的名称。

获取数据源行中的列位置（序号）；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为 值（用于指定列位置）或 。

表示列序号的 值；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取列大小；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为 值（用于指定列大小）或 。

值的列大小; 否则，为空引用 (在 Visual Basic 中) 如果未不设置任何值。

获取列中存储的数据的类型。 在派生类中重写时，可设置为表示列中数据类型的 对象。

表示列中包含的数据类型的 对象。

获取数据类型的名称；否则，如果未设置任何值，则为 。 在派生类中重写时，可设置为数据类型名称或 。

数据类型的名称；否则，如果未设置任何值，则为空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否具有别名，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否具有别名，也可设置为 （在 Visual Studio 中为 ）。

如果此列具有别名，则返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列中的值是否自动递增，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列中的值是否自动递增，也可设置为 （在 Visual Studio 中为 ）。

如果此列中的值自动递增，则返回 ，否则，返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否是表达式，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否是表达式，也可设置为 （在 Visual Studio 中为 ）。

如果此列是表达式，将返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否被隐藏，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否被隐藏，也可设置为 （在 Visual Studio 中为 ）。

如果此列被隐藏，则返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否是标识，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否是标识，也可设置为 （在 Visual Studio 中为 ）。

如果此列是标识，将返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否是密钥，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否是密钥，也可以设置为 （在 Visual Studio 中为 ）。

如果此列是密钥，则返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否包含长数据，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否包含长数据，也可设置为 （在 Visual Studio 中为 ）。

如果此列包含长数据，则返回 ；否则，返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示此列是否是只读的，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示此列是否是只读的，也可设置为 （在 Visual Studio 中为 ）。

如果此列为只读，则返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取可为 null 的布尔值，该值指示唯一约束是否适用于此列，或者在未设置任何值时返回 。 在派生类中重写时，可设置为 或 ，指示唯一约束是否适用于此列，也可设置为 （在 Visual Studio 中为 ）。

如果唯一约束适用于此列，返回 ；否则返回 。 如果未设置任何值，则返回空引用（在 Visual Basic 中为 ）。

获取基于列属性名称的对象。

列属性名称。 基于列属性名称的对象。

获取列数据的数值精度，否则在未设置任何值时为 。 在派生类中重写时，可设置为 值（用于指定列数据的数值精度）或 。

值，该值指定列数据的精度，如果数据是数值; 否则为为 null 引用 (在 Visual Basic 中) 如果未不设置任何值。

获取可为 null 的 值，该值将返回 或列数据的数值范围。 在派生类中重写时，可设置为 或 值（用于表示列数据的数值范围）。

如果未设置任何值，则为空引用（在 Visual Basic 中为 ）；否则，在数据是数值时，为指定列数据范围的 值。

获取表示列中数据类型的 对象的程序集限定名称，否则，在未设置任何值时为 。 在派生类中重写时，可设置为程序集限定名称或 。

表示列中数据类型的 对象的程序集限定名称，否则，在未设置任何值时为空引用（在 Visual Basic 中为 ）。

表示要对数据源执行的 SQL 语句或存储过程。 提供表示命令的数据库特定类的基类。

构造 对象的实例。

尝试取消 的执行。

获取或设置对数据源运行的文本命令。

要执行的文本命令。 默认值为空字符串 ("")。

获取或设置在终止尝试执行命令并生成错误之前的等待时间。

等待命令执行所需的时间（以秒为单位）。

指示或指定解释 属性的方式。

值之一。 默认值为 。

获取或设置此 使用的 。

与数据源的连接。

创建 对象的新实例。

一个 对象。

创建 对象的新实例。

一个 对象。

获取或设置此 使用的 。

与数据源的连接。

获取 对象的集合。

SQL 语句或存储过程的参数。

获取或设置将在其中执行此 对象的 。

要在其中执行 .NET Framework 数据提供程序的 Command 对象的事务。 默认值为空引用（在 Visual Basic 中为 ）。

获取或设置一个值，该值指示此命令对象在自定义界面控件中是否可见。

如果该命令对象应在控件中可见，则为 ；否则为 。 默认值为 。

对连接执行命令文本。

的一个实例。 表示该操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

提供程序应执行该方法对 重载提供非默认的实现。 默认实现调用同步 方法并返回已完成任务，以便阻止调用线程。 如果传递到已取消的取消标记，则默认实现将返回已取消的任务。 ExecuteReader 引发的异常将通过返回的任务异常属性传递。 该方法可用于请求操作之前接受取消标记。 实现可能会忽略该请求。

语句执行和数据检索的选项。 要监视取消请求的标记。 表示异步操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

对连接对象执行 SQL 语句。

受影响的行数。

的异步版本，针对一个连接对象执行一个 SQL 声明。 通过 CancellationToken.None 调用 。

表示异步操作的任务。 执行命令文本时出现的一个错误。

这是 的异步版本。 提供程序应使用合适的实现进行重写。 可选择性忽略取消标记。 默认实现调用同步 方法并返回已完成任务，以便阻止调用线程。 如果传递到已取消的取消标记，则默认实现将返回已取消的任务。 引发的异常将通过任务异常属性传递。 在返回的任务完成前，不要调用 对象的其他方法和属性。

要监视取消请求的标记。 表示异步操作的任务。 执行命令文本时出现的一个错误。

针对 执行 ，并返回 。

一个 对象。

针对 执行 ，并使用 值之一返回 。

值之一。 一个 对象。

的异步版本，针对 和 执行 。 通过 CancellationToken.None 调用 。

表示异步操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

的异步版本，针对 和 执行 。 调用 .

值之一。 表示异步操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

调用 .

值之一。 要监视取消请求的标记。 表示异步操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

的异步版本，针对 和 执行 。 此方法传播有关应取消操作的通知。 调用 .

要监视取消请求的标记。 表示异步操作的任务。 执行命令文本时出现的一个错误。 无效的 值。

执行查询，并返回查询所返回的结果集中第一行的第一列。 所有其他的列和行将被忽略。

结果集中第一行的第一列。

的异步版本，执行查询，并将查询返回的结果集中第一行的第一列返回。 所有其他的列和行将被忽略。 通过 CancellationToken.None 调用 。

表示异步操作的任务。 执行命令文本时出现的一个错误。

这是 的异步版本。 提供程序应使用合适的实现进行重写。 可选择性忽略取消标记。 默认实现调用同步 方法并返回已完成任务，以便阻止调用线程。 如果传递到已取消的取消标记，则默认实现将返回已取消的任务。 ExecuteScalar 引发的异常将通过返回的任务异常属性传递。 在返回的任务完成前，不要调用 对象的其他方法和属性。

要监视取消请求的标记。 表示异步操作的任务。 执行命令文本时出现的一个错误。

获取 对象的集合。 有关参数的详细信息，请参阅配置参数和参数数据类型。

SQL 语句或存储过程的参数。

在数据源上创建准备就绪（或已编译）的命令版本。

获取或设置 的此实例使用的 。

与数据源的连接。

创建 对象的新实例。

一个 对象。

对 执行 并生成 。

一个 对象。

对 执行 ，并使用 值之一生成 。

值之一。 一个 对象。

获取 。

SQL 语句或存储过程的参数。

获取或设置将在其中执行此 对象的 。

在其中执行 .NET Framework 数据提供程序的 对象的事务。 默认值为空引用（在 Visual Basic 中为 ）。

获取或设置将在其中执行此 对象的 。

在其中执行 .NET Framework 数据提供程序的 对象的事务。 默认值为空引用（在 Visual Basic 中为 ）。

获取或设置命令结果在由 的 Update 方法使用时如何应用于 。

值之一。 除非自动生成该命令，否则默认值为 。 如果自动生成该命令，默认值为 。

自动生成用于协调 的更改与关联数据库的单表命令。 这是一个只能被继承的抽象类。

初始化从 类继承的类的新实例。

允许 类的提供程序实现处理附加参数属性。

要将附加修改应用到的 。 来自由 提供的架构表的 。 生成的命令的类型；INSERT、UPDATE 或 DELETE。 如果参数是 update 或 delete WHERE 子句的一部分，则为 ；如果是 insert 或 update 值的一部分，则为 。

对于 类的实例，设置或获取 。

一个 对象。

设置或获取一个字符串，该字符串用作 类的实例的目录分隔符。

一个字符串，指示用于 类的实例的目录分隔符。

指定哪个 将由 使用。

返回描述此 行为的 值之一。

获取或设置自动为其生成 Transact-SQL 语句的一个 对象。

一个 对象。

释放由 占用的非托管资源，还可以另外再释放托管资源。

若要释放托管资源和非托管资源，则为 ；若仅释放非托管资源，则为 。

获取在数据源中执行删除操作所需的自动生成的 对象。

自动生成的、执行删除操作所需的 对象。

获取对数据源执行删除操作所必需的自动生成的 对象，可选择使用列作为参数名。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行删除操作所需的 对象。

获取在数据源中执行插入操作所需的自动生成的 对象。

自动生成的、执行插入操作所需的 对象。

获取对数据源执行插入操作所必需的自动生成的 对象，可选择使用列作为参数名。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行插入操作所需的 对象。

以 @p# 格式返回指定参数的名称。 在生成自定义命令生成器时使用。

作为参数名的一部分而包含的数字。 参数名，其中包含作为参数名的一部分而附加的指定数字。

给定部分参数名，返回完整参数名。

参数的部分名称。 对应于所请求的部分参数名的完整参数名。

返回该参数在关联的 SQL 语句中的占位符。

作为参数名的一部分而包含的数字。 附加了指定数字的参数名。

返回 的架构表。

要为其检索对应架构表的 。 表示特定 的架构的 。

获取在数据源中执行更新操作所需的自动生成的 对象。

自动生成的、执行更新所需的 对象。

获取对数据源执行更新操作所必需的自动生成的 对象，可选择使用列作为参数名。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行更新所需的 对象。

重置 上的 、、 和 属性。

由命令生成器用于对应的 insert、update 或 delete 命令的 。 用于每个 insert、update 或 delete 操作的 实例。 传入一个 null 值将允许 方法根据与 关联的 Select 命令创建 对象。

以正确的目录大小写给定一个不带引号的标识符，返回该标识符的带引号的正确形式，包括正确转义该标识符中嵌入的任何引号。

不带引号的原始标识符。 带引号的标识符版本。 该标识符中嵌入的引号已正确转义。

获取或设置指定其名称包含空格或保留标记等字符的数据库对象（例如，表或列）时使用的开始字符。

要使用的起始字符。 默认值为一个空字符串。 当生成 Insert、Update 或 Delete 命令后，不能更改此属性。

获取或设置一个或多个结束字符，供指定其名称中包含空格或保留标记等字符的数据库对象（例如，表或列）时使用。

要使用的结束字符。 默认值为一个空字符串。

清除与此 关联的命令。

添加 事件的事件处理程序。

包含关于该事件的信息的 实例。

获取或设置要用作架构标识符和任何其他标识符之间的分隔符的字符。

要用作架构分隔符的字符。

指定 update 语句中是包含所有列值还是仅包含更改的列值。

如果 生成的 UPDATE 语句包含所有列，则为 ；如果它仅包含更改的列，则为 。

注册 以处理 的 事件。

要用于更新的 。

给定一个带引号的标识符，返回该标识符的不带引号的正确形式，包括正确地取消转义该标识符中嵌入的任何引号。

其嵌入引号将被移除的标识符。 不带引号的标识符，其中嵌入的引号已正确进行取消转义。

表示数据库连接。

初始化 类的新实例。

开始数据库事务。

指定事务的隔离级别。 表示新事务的对象。

开始数据库事务。

表示新事务的对象。

以指定的隔离级别启动数据库事务。

指定事务的隔离级别。 表示新事务的对象。

为打开的连接更改当前数据库。

为要使用的连接指定数据库名称。

关闭与数据库之间的连接。 此方法是关闭任何打开连接的首选方法。

打开连接时出现的连接级别的错误。

获取或设置用于打开连接的字符串。

用来建立初始连接的连接字符串。 该连接字符串的确切内容取决于此连接的特定数据源。 默认值为一个空字符串。

获取在建立连接时终止尝试并生成错误之前所等待的时间。

等待连接打开所需的时间（以秒为单位）。 默认值是由您正在使用的连接的特定类型确定的。

创建并返回与当前连接关联的 对象。

一个 对象。

创建并返回与当前连接关联的 对象。

一个 对象。

在连接打开之后获取当前数据库的名称，或者在连接打开之前获取连接字符串中指定的数据库名。

当前数据库的名称或打开连接后要使用的数据库的名称。 默认值为一个空字符串。

获取要连接的数据库服务器的名称。

要连接的数据库服务器的名称。 默认值为一个空字符串。

获取此 的 。

一组方法的集合，这些方法用于创建提供程序对数据源类的实现的实例。

在指定事务中登记。

对用于登记的现有 的引用。

返回此 的数据源的架构信息。

一个包含架构信息的 。

通过使用架构名称的指定字符串，返回此 的数据源的架构信息。

指定要返回的架构的名称。 一个包含架构信息的 。 将 指定为 null。

通过使用指定字符串作为架构名称，指定字符串数组作为限制值，返回此 的数据源的架构信息。

指定要返回的架构的名称。 为请求的架构指定一组限制值。 一个包含架构信息的 。 将 指定为 null。

引发 事件。

包含事件数据的 。

使用 所指定的设置打开数据库连接。

的异步版本，打开由 指定的设置的数据库连接。 此方法通过 CancellationToken.None 调用虚拟方法 。

表示异步操作的任务。

这是 的异步版本。 提供程序应使用合适的实现进行重写。 可选择性接受取消标记。 默认实现调用同步 调用并返回已完成任务。 如果传递到已取消的取消标记，则默认实现将返回已取消的 cancellationToken。 Open 引发的异常将通过返回的任务异常属性传递。 在返回的任务完成前，不要调用 对象的其他方法和属性。

取消指令。 表示异步操作的任务。

获取表示对象所连接到的服务器的版本的字符串。

数据库的版本。 返回的字符串的格式取决于您正在使用的连接的特定类型。 当返回的任务未完成，且在调用 后未打开连接时，调用了 。

获取描述连接状态的字符串。

连接的状态。 返回的字符串的格式取决于您正在使用的连接的特定类型。

当事件状态更改时发生。

开始一项数据库事务。

一个表示新事务的对象。

以指定的 值开始数据库事务。

值之一。 一个表示新事务的对象。

创建并返回与当前连接关联的 对象。

与连接关联的 对象。

提供强类型化连接字符串生成器的基类。

初始化 类的新实例。

初始化 类的新实例，可以选择使用 ODBC 规则来引用值。

如果使用 {} 来分隔字段，则为 ；如果使用引号，则为 。

将带有指定键和值的条目添加到 中。

要添加到 的键。 指定键的值。 为空引用（在 Visual Basic 中为 ）。 为只读。 或 - 具有固定的大小。

提供了一种有效而安全的方法，用于将键和值附加到现有的 对象中。

要向其中添加键/值对的 。 要添加的键。 提供的键的值。

提供了一种有效而安全的方法，用于将键和值附加到现有的 对象中。

要向其中添加键/值对的 。 要添加的键。 提供的键的值。 如果使用 {} 来分隔字段，则为 ；如果使用引号，则为 。

获取或设置一个值，该值指示 属性是否在 Visual Studio 设计器中可见。

如果连接字符串在设计器中可见，则为 ；否则为 。 默认值为 。

清除 实例的内容。

为只读。

清除关联的 上的 对象集合。

获取或设置与 相关联的连接字符串。

使用 中包含的键/值对创建的当前连接字符串。 默认值为一个空字符串。 提供的连接字符串参数无效。

确定 是否包含特定键。

要在 中定位的键。 如果 包含具有指定键的项，则为 ；否则为 。 为空引用（在 Visual Basic 中为 ）。

获取属性 中包含的键的当前数目。

由 实例维护的连接字符串中包含的键的数目。

将此 对象中的连接信息与提供的对象中的连接信息进行比较。

要与此 对象进行比较的 。 如果两个 对象中的连接信息生成等效的连接字符串，则为 ；否则为 。

使用有关此 的所有属性的信息，填充提供的 。

使用有关此 的信息填充的 。

获取一个值，该值指示 是否具有固定大小。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 为只读，则为 ；否则为 。 默认值为 。

获取或设置与指定的键关联的值。

要获取或设置的项的键。 与指定的键相关联的值。 如果指定键未找到，尝试让其返回空引用（在 Visual Basic 中为 ），并尝试设置为使用指定键创建新的元素。 传递 null 键（在 Visual Basic 中为 ）将引发 。 分配一个删除键/值对的 null 值。 为空引用（在 Visual Basic 中为 ）。 设置了该属性，但 为只读。 或 - 设置了该属性，但 不存在于集合中，且 具有固定的大小。

获取包含 中的键的 。

一个 ，它包含 中的键。

从 实例中移除具有指定的键的项。

要从此 中的连接字符串移除的键/值对中的键。 如果该键存在于连接字符串中并已被移除，则为 ；如果该键不存在，则为 。 为 Null（在 Visual Basic 中为 ） 是只读，或 具有固定的大小。

指示此 实例中是否存在指定的键。

要在 中定位的键。 如果 包含具有指定键的项，则为 ；否则为 。

从特定的 索引处开始，将 的元素复制到一个 中。

一维 ，它是从 复制的元素的目标。 必须具有从零开始的索引。 中从零开始的索引，从此处开始复制。

获取一个值，该值指示是否同步对 的访问（线程安全）。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

获取可用于同步对 的访问的对象。

可用于同步对 的访问的对象。

在 对象中添加一个带有所提供的键和值的元素。

用作要添加的元素的键的 。 用作要添加的元素的键的 。

确定 对象是否包含具有指定键的元素。

要在 对象中查找的键。 如果 包含具有键的元素，则为 ；否则为 。

返回 对象的 对象。

对象的 对象。

获取或设置具有指定键的元素。

要获取或设置的元素的键。 带有指定键的元素。

从 对象中移除具有指定键的元素。

要移除的元素的键。

返回循环访问集合的枚举数。

一个可用于循环访问集合的 对象。

返回此组件实例的自定义属性的集合。

包含此对象的属性的 。

返回此组件实例的类名称。

对象的类名称，如果该类没有名称，则为 。

返回某个组件的此实例的名称。

对象的名称，如果该对象不具有名称，则为 。

返回此组件实例的类型转换器。

作为此对象转换器的 ，或为 （如果此对象不存在任何 ）。

返回某个组件的此实例的默认事件。

表示此对象的默认事件的 ；如果该对象没有事件，则为 。

返回此组件实例的默认属性。

表示此对象的默认属性的 ；如果该对象没有属性，则为 。

返回此组件实例的指定类型的编辑器。

表示该对象的编辑器的 。 表示该对象编辑器的指定类型的 ；如果无法找到编辑器，则为 。

返回此组件实例的事件。

一个 ，表示此组件实例的事件。

使用指定的属性数组作为筛选器，返回此组件实例的事件。

用作筛选器的 类型数组。 表示此组件实例的已筛选事件的 。

返回此组件实例的属性。

表示此组件实例的属性的 。

使用特性数组作为筛选器，返回此组件实例的属性。

用作筛选器的 类型数组。 一个 ，它表示此组件实例的已筛选属性。

返回一个对象，该对象包含指定的属性描述符所描述的属性。

一个 ，表示要查找其所有者的属性。 一个 ，表示指定属性的所有者。

返回与此 关联的连接字符串。

当前 属性。

从此 中检索与提供的键相对应的值。

要检索的项的键。 与 对应的值。 如果在连接字符串中找到 ，则为 ，否则为 。 包含一个 null 值（在 Visual Basic 中为 ）。

获取包含 中的值的 。

一个 ，包含 中的值。

帮助实现 接口。 的继承类实现了一组功能以提供强类型，但是继承了完全实现 DataAdapter 所需的大部分功能。

初始化 DataAdapter 类的新实例。

从同一类型的现有对象中初始化 类的新实例。

用于创建新 的 对象。

向当前批处理添加 。

要添加到批处理的 。 添加 之前批处理中的命令数。 该适配器不支持批处理。

从批处理中移除所有 对象。

该适配器不支持批处理。

初始化 类的新实例。

用于更新数据源的 。 在 过程中执行的 。 该命令是 UPDATE、INSERT、DELETE 语句还是 SELECT 语句。 一个 对象。 类的新实例。

初始化 类的新实例。

更新数据源的 。 要在 过程中执行的 。 该命令是 UPDATE、INSERT、DELETE 语句还是 SELECT 语句。 一个 对象。 类的新实例。

对象用于表映射的默认名称。

获取或设置用于从数据集中删除记录的命令。

过程中使用的 ，它针对数据集中已删除的行删除数据源中的记录。

释放由 占用的非托管资源，还可以另外再释放托管资源。

若要释放托管资源和非托管资源，则为 ；若仅释放非托管资源，则为 。

执行当前批处理。

从批处理中的最后一个命令返回的值。

在 中添加或刷新行。

要用记录和架构（如果必要）填充的 。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在 的指定范围中添加或刷新行以匹配使用 和 名称的数据源中的行。

要用记录和架构（如果必要）填充的 。 从其开始的从零开始的记录号。 要检索的最大记录数。 用于表映射的源表的名称。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。 无效。 源表无效。 或 - 连接无效。 未能找到连接。 参数小于 0。 或 - 参数小于 0。

使用 和源表名称、命令字符串以及命令行为，在 的指定范围中添加或刷新某些行以使它们与数据源中对应的行相一致。

要用记录和架构（如果必要）填充的 。 从其开始的从零开始的记录号。 要检索的最大记录数。 用于表映射的源表的名称。 用于从数据源中检索行的 SQL SELECT 语句。 值之一。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。 源表无效。 参数小于 0。 或 - 参数小于 0。

在 中添加或刷新行以匹配使用 和 名称的数据源中的行。

要用记录和架构（如果必要）填充的 。 用于表映射的源表的名称。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。 源表无效。

在 的指定范围中添加或刷新行，以与使用 名称的数据源中的行匹配。

用于表映射的 的名称。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。 源表无效。

在 中添加或刷新行，以与使用指定的 、 和 的数据源中的行匹配。

要用记录和架构（如果必要）填充的 。 用于从数据源中检索行的 SQL SELECT 语句。 值之一。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

在 的指定范围中添加或刷新行以匹配使用 和 名称的数据源中的行。

要从数据源填充的 对象。 从其开始的从零开始的记录号。 要检索的最大记录数。 执行以填充 对象的 。 值之一。 已在数据表中添加或刷新的行数。 无效。 源表无效。 或 - 连接无效。 未能找到连接。 参数小于 0。 或 - 参数小于 0。

在 中添加或刷新行，以与从指定的记录开始一直检索到指定的最大数目的记录的数据源中的行匹配。

从其开始的从零开始的记录号。 要检索的最大记录数。 要从数据源填充的 对象。 已在 中成功添加或刷新的行数。 此值不包括受不返回行的语句影响的行。

获取或设置用于填充数据适配器的命令的行为。

用于填充数据适配器的命令的 。

将名为“Table”的 添加到指定的 ，并根据指定的 配置架构以匹配数据源中的架构。

要插入架构的 。 值之一，指定如何插入架构。 一个引用，指向添加到 的 对象的集合。

将 添加到指定的 中，并根据指定的 配置架构以匹配数据源中的架构。

要用数据源中的架构填充的 。 值之一。 用于从数据源中检索行的 SQL SELECT 语句。 用于表映射的源表的名称。 值之一。 对象的数组，这些对象包含从数据源返回的架构信息。

将 添加到指定的 中，并根据指定的 和 配置架构以匹配数据源中的架构。

要插入架构的 。 值之一，指定如何插入架构。 用于表映射的源表的名称。 一个引用，指向添加到 的 对象的集合。 找不到从中获取架构的源表。

根据指定的 配置指定 的架构。

要用数据源中的架构填充的 。 值之一。 一个 ，其中包含从数据源返回的架构信息。

根据指定的 、命令字符串以及 值配置指定 的架构。

要用数据源中的架构填充的 。 值之一。 用于从数据源中检索行的 SQL SELECT 语句。 值之一。 包含从数据源返回的架构信息的 对象。

从当前批处理中的其中一个命令返回一个 。

要从中检索参数的命令的索引。 命令内的参数的索引。 指定的 。 该适配器不支持批处理。

返回与较大的批处理更新内的单次更新尝试有关的信息。

该批次内单个命令的从零开始的列序号。 数据存储区中受该批内的指定命令影响的行数。 在执行指定命令期间引发的一个 。 如果未引发任何异常，则返回 （在 Visual Basic 中为 ）。 与较大的批处理更新内的单次更新尝试有关的信息。

获取当执行 SQL SELECT 语句时由用户设置的参数。

对象的数组，这些对象包含由用户设置的参数。

初始化 的批处理。

该适配器不支持批处理。

获取或设置用于将新记录插入到数据源中的命令。

在 过程中使用的 ，它针对数据集中的新行将记录插入到数据源中。

引发 .NET Framework 数据提供程序的 事件。

包含事件数据的 。

引发 .NET Framework 数据提供程序的 事件。

包含事件数据的 。

获取或设置用于在数据源中选择记录的命令。

在 过程中使用的 ，它从数据源中选择记录以便放入数据集中。

获取或设置用于从数据集中删除记录的 SQL 语句。

过程中使用的 ，它针对数据集中已删除的行删除数据源中的记录。

获取或设置用于将新记录插入到数据源中的 SQL 语句。

在 过程中使用的 ，它针对数据集中的新行将记录插入到数据源。

获取或设置用于在数据源中选择记录的 SQL 语句。

在 过程中使用的 ，它从数据源中选择记录以便放入数据集中。

获取或设置用于更新数据源中的记录的 SQL 语句。

在 过程中使用的 ，它针对数据集中已修改的行更新数据源中的记录。

创建作为当前实例副本的新对象。

作为此实例副本的新对象。

结束 的批处理。

该适配器不支持批处理。

通过为 中的指定数组中的每个已插入、已更新或已删除的行执行相应的 INSERT、UPDATE 或 DELETE 语句来更新数据库中的值。

用于更新数据源的 对象的数组。 中成功更新的行数。 无效。 源表无效。 不存在要更新的 。 或 - 不存在要更新的 。 或 - 不存在要用作源的 。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

通过为指定的 对象数组中的每个已插入、已更新或已删除的行执行相应的 INSERT、UPDATE 或 DELETE 语句来更新数据库中的值。

用于更新数据源的 对象的数组。 要使用的 集合。 中成功更新的行数。 无效。 源表无效。 不存在要更新的 。 或 - 不存在要更新的 。 或 - 不存在要用作源的 。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

通过为指定的 中的每个已插入、已更新或已删除的行执行相应的 INSERT、UPDATE 或 DELETE 语句来更新数据库中的值。

用于更新数据源的 。 中成功更新的行数。 源表无效。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

通过为具有指定名称 的 中的每个已插入、已更新或已删除的行执行相应的 INSERT、UPDATE 或 DELETE 语句来更新数据库中的值。

用于更新数据源的 。 用于表映射的源表的名称。 中成功更新的行数。 无效。 源表无效。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

通过为指定的 中的每个已插入、已更新或已删除的行执行相应的 INSERT、UPDATE 或 DELETE 语句来更新数据库中的值。

用于更新数据源的 。 中成功更新的行数。 无效。 源表无效。 不存在要更新的 。 或 - 不存在要更新的 。 或 - 不存在要用作源的 。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

获取或设置一个值，该值启用或禁用批处理支持，并且指定可在一次批处理中执行的命令的数量。

每个批处理要处理的行数。 值为 效果 0 批大小没有限制。 1 禁用批量更新。 > 1 更改是使用 操作的批处理一次性发送的。 当设置为 1 以外的值，与相关联的所有命令必须具有其属性设置为None或OutputParameters。 否则，将引发异常。

获取或设置用于更新数据源中的记录的命令。

在 过程中使用的 ，它针对数据集中已修改的行更新数据源中的记录。

启用一个 .NET Framework 数据提供程序，以帮助确保用户具有足够的安全级别来访问数据。

初始化 类的新实例。

使用现有的 初始化 类的新实例。

用于创建新 的现有 。

用指定的 初始化 类的新实例。

与自定义安全特性相关的安全操作。

使用指定的 值初始化 类的新实例。

值之一。

用指定的 值和指示是否允许空白密码的值初始化 类的新实例。

值之一。 表示允许使用空白密码；否则为 。

将指定连接字符串的访问权限添加到 的现有状态。

允许的连接字符串。 标识允许使用或禁用的连接字符串参数的字符串。 属性之一。

获取一个值，该值指示是否允许使用空白密码。

如果允许使用空白密码，则为 ；否则为 。

移除以前使用 方法添加的所有权限。

创建并返回与当前权限对象相同的副本。

当前权限对象的副本。

创建 类的新实例。

一个新 对象。

通过 XML 编码重新构造具有指定状态的安全对象。

用于重新构造安全对象的 XML 编码。

返回表示当前权限对象和指定权限对象的交集的新权限对象。

与当前的权限对象相交的权限对象。 它必须与当前权限对象的类型相同。 表示当前权限对象和指定权限对象的交集的新权限对象。 如果交集为空，则此新权限对象是一个 null 引用（在 Visual Basic 中为 ）。 参数不是 null 引用（在 Visual Basic 中为 ），并且不是与当前权限对象相同的类的实例。

返回一个值，该值指示当前的权限对象是否为指定权限对象的一个子集。

将用于测试子集关系的权限对象。 该对象必须与当前权限对象的类型相同。 如果当前权限对象是指定权限对象的子集，则为 ；否则为 。 参数是一个与当前权限对象的类型不同的对象。

返回一个值，该值指示在不了解权限语义的情况下是否可以将权限表示为无限制。

如果可以将权限表示为无限制，则为 。

创建安全对象及其当前状态的 XML 编码。

安全对象的 XML 编码，包括任何状态信息。

返回一个新的权限对象，它是当前权限对象和指定权限对象的并集。

要与当前的权限对象合并的权限对象。 它必须与当前权限对象的类型相同。 新权限对象，它表示当前权限对象和指定权限对象的并集。 对象与当前权限对象不属于同一类型。

将某安全操作与自定义安全特性相关联。

初始化 的新实例。

安全操作值之一，它表示可以由声明性安全执行的操作。

获取或设置一个值，该值指示是否允许使用空白密码。

如果允许使用空白密码，则为 ；否则为 。

获取或设置允许的连接字符串。

允许的连接字符串。

标识由 属性标识的连接字符串参数列表是否为所唯一允许的连接字符串参数。

值之一。

获取或设置允许或不允许的连接字符串参数。

允许或不允许的一个和多个连接字符串参数。

标识特性是否应序列化连接字符串。

如果特性应序列化连接字符串，则为 ；否则为 。

标识特性是否应序列化键限制集合。

如果特性应序列化键限制集合，则为 ；否则为 。

从数据源中读取行的只进流。

初始化 类的新实例。

关闭 对象。

获取一个值，该值指示当前行的嵌套深度。

当前行的嵌套深度。

释放 类的当前实例所使用的所有资源。

释放由 使用的托管资源，还可以选择释放非托管资源。

若要释放托管资源和非托管的资源，则为 ；若要仅释放非托管资源，则为 。

获取当前行中的列数。

当前行中的列数。 没有对 SQL Server 实例的当前连接。

以布尔值的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以字节的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

从指定列读取一个字节流（从 指示的位置开始），读到缓冲区中（从 指示的位置开始）。

从零开始的列序号。 行中作为读取操作起始位置的索引。 要将数据复制到的缓冲区。 要将数据复制到的位置的缓冲区索引。 要读取的最大字符数。 读取的实际字节数。 指定的强制转换无效。

以单个字符的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

从指定列读取一个字符流，从 指示的位置开始，读到缓冲区中，从 指示的位置开始。

从零开始的列序号。 行中作为读取操作起始位置的索引。 要将数据复制到的缓冲区。 要将数据复制到的位置的缓冲区索引。 要读取的最大字符数。 读取的实际字符数。

返回被请求的列序号的 对象。

从零开始的列序号。 一个 对象。

获取指定列的数据类型的名称。

从零开始的列序号。 一个字符串，表示数据类型的名称。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

为可用提供程序特定的实现重写的已请求的列序号返回一个 对象。

从零开始的列序号。 一个 对象。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以双精度浮点数字的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

返回一个可用于循环访问数据读取器中的行的 。

一个 ，可用于循环访问数据读取器中的行。

获取指定列的数据类型。

从零开始的列序号。 指定列的数据类型。 指定的强制转换无效。

同步获取作为类型的指定列的值。

要检索的列。 同步获取作为类型的指定列的值。 要检索的列。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 与 SQL Server 返回的类型不匹配或无法进行强制转换。

异步获取作为类型的指定列的值。

要返回的值的类型。 要返回的值的类型。 要返回的值的类型。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 与数据源返回的类型不匹配或无法进行强制转换。

异步获取作为类型的指定列的值。

要返回的值的类型。 取消指示，用于对应该取消操作的通知进行传播。 此构造函数不对取消做保证。 设置为 将此方法等效于 。 返回任务必须标记为已取消。 要返回的值的类型。 要返回的值的类型。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 与数据源返回的类型不匹配或无法进行强制转换。

以单精度浮点数字的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以全局唯一标识符 (GUID) 的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 16 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 32 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 64 位有符号整数的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

在给定从零开始的列序号时获取该列的名称。

从零开始的列序号。 指定列的名称。

在给定列名时获取相应的列序号。

列的名称。 从零开始的列序号。 指定的名称不是有效的列名。

返回指定列的提供程序特定的字段类型。

从零开始的列序号。 描述指定列的数据类型的 对象。

以 实例的形式获取指定列的值。

从零开始的列序号。 指定列的值。

在当前行的集合中获取提供程序特定的所有属性列。

要将属性列复制到的 数组。 数组中的 实例数。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

检索作为 的数据。

检索作为 的数据。 返回的对象。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 返回的类型不属于以下类型之一：二进制、映像、varbinary 或 udt。

以 实例的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

检索作为 的数据。

检索作为 的数据。 返回的对象。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 返回的类型不属于以下类型之一：char、nchar、ntext、nvarchar、文本 或 varchar。

以 实例的形式获取指定列的值。

从零开始的列序号。 指定列的值。

使用当前行的列值来填充对象数组。

要将属性列复制到的 数组。 数组中的 实例数。

获取一个值，该值指示此 是否包含一个或多个行。

如果 包含一行或多行，则为 ；否则为 。

获取一个值，该值指示 是否已关闭。

如果 已关闭，则为 ；否则为 。 已关闭。

获取一个值，该值指示列中是否包含不存在或丢失的值。

从零开始的列序号。 如果指定的列等于 ，则为；否则为 。

的异步版本，其获取指示列是否包含不存在或缺失值的值。

从零开始的要检索的列。 如果指定的列值与 等效，则为 ；否则为 。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。

的异步版本，其获取指示列是否包含不存在或缺失值的值。 可选地，发送操作应取消的注明。

从零开始的要检索的列。 取消指示，用于对应该取消操作的通知进行传播。 此构造函数不对取消做保证。 设置为 将此方法等效于 。 返回任务必须标记为已取消。 如果指定的列值与 等效，则为 ；否则为 。 连接中断或在数据检索期间已关闭。 或 - 数据检索期间， 处于关闭状态。 或 - 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 或 - 按顺序模式尝试读取上一步骤中读取的列。 或 - 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。

以 实例的形式获取指定列的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 的范围。

以 实例的形式获取指定列的值。

列的名称。 指定列的值。 未找到具有指定名称的列。

在读取一批语句的结果时，使读取器前进到下一个结果。

如果存在多个结果集，则为 ；否则为 。

的异步版本，读取批处理语句的结果时，将读取器推进到下一个结果。 通过 CancellationToken.None 调用 。

表示异步操作的任务。 执行命令文本时出现的一个错误。

这是 的异步版本。 提供程序应使用合适的实现进行重写。 可选择性忽略 。 默认实现调用同步 方法并返回已完成任务，以便阻止调用线程。 如果传递到已取消 ，则默认实现将返回已取消的任务。 引发的异常将通过任务异常属性传递。 当返回任务还未完成时， DbDataReader 对象的其他方法和属性不应调用 。

取消指令。 表示异步操作的任务。 执行命令文本时出现的一个错误。

使读取器前进到结果集中的下一条记录。

如果存在更多行，则为 ；否则为 。

的异步版本，将读取器前移到结果集的下一条记录。 此方法通过 CancellationToken.None 调用 。

表示异步操作的任务。 执行命令文本时出现的一个错误。

这是 的异步版本。 提供程序应使用合适的实现进行重写。 可选择性忽略的 cancellationToken。 默认实现调用同步 方法并返回已完成任务，以便阻止调用线程。 如果传递到已取消的取消标记，则默认实现将返回已取消的 cancellationToken。 Read 引发的异常将通过返回的任务异常属性传递。 在返回的任务完成前，不要调用 对象的其他方法和属性。

取消指令。 表示异步操作的任务。 执行命令文本时出现的一个错误。

获取通过执行 SQL 语句更改、插入或删除的行数。

更改、插入或删除的行数。 对于 SELECT 语句为 -1；如果没影响任何行或该语句失败，则为 0。

有关此成员的说明，请参见 。

从零开始的列序号。 字段指向更多远程结构化数据时使用的 实例。

获取 中未隐藏的字段的数目。

未隐藏的字段的数目。

此类包含用于 的列架构扩展方法。

获取一个值，指示 是否可以获取列架构。

要检查其是否支持列架构的 。 如果 可以获取列架构，则为 ；否则为 。

获取 的列架构（ 集合）。

要返回列架构的 。 的列架构（ 集合）。

实现 和 ，并为 提供数据绑定支持。

初始化 类的新实例。

指示当前记录中字段的数目。 此属性是只读的。

当前记录中字段的数目。 未连接到要从中读取的数据源。

以布尔值的形式返回指定列的值。

列序号。 如果布尔值为 则为 ；否则为 。

以字节的形式返回指定列的值。

列序号。 指定列的值。

以字节数组的形式返回指定列的值。

从零开始的列序号。 字段中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 开始读取操作的 的索引。 要读取的字节数。 指定列的值。

以字符的形式返回指定列的值。

列序号。 指定列的值。

以字符数组的形式返回指定列的值。

列序号。 要将数据复制到其中的缓冲区。 复制到缓冲区的最大长度。 从缓冲区中开始的点。 从数据源中开始的点。 指定列的值。

目前尚不支持。

目前尚不支持。 目前尚不支持。

返回后端数据类型的名称。

列序号。 后端数据类型的名称。

以 对象的形式返回指定列的值。

列序号。 指定列的值。

为可用提供程序特定的实现重写的已请求的列序号返回一个 对象。

从零开始的列序号。 一个 对象。

以 对象的形式返回指定列的值。

列序号。 指定列的值。

以双精度浮点数字的形式返回指定列的值。

列序号。 指定列的值。

返回作为对象的数据类型的 。

列序号。 作为对象的数据类型的 。

以单精度浮点数字的形式返回指定列的值。

列序号。 指定列的值。

返回指定字段的 GUID 值。

要返回的字段的索引。 指定字段的 GUID 值。 传递的索引超出了 0 到 的范围。

以 16 位带符号整数的形式返回指定列的值。

列序号。 指定列的值。

以 32 位带符号整数的形式返回指定列的值。

列序号。 指定列的值。

以 64 位带符号整数的形式返回指定列的值。

列序号。 指定列的值。

返回指定列的名称。

列序号。 指定列的名称。

在给定列名时返回列序号。

列的名称。 列序号。

以字符串的形式返回指定列的值。

列序号。 指定列的值。

以本机格式返回位于指定列的值。

列序号。 要返回的值。

使用当前记录的列值填充对象的数组。

要将属性字段复制到其中的 数组。 数组中的 实例数。

用于指示不存在的值。

列序号。 如果指定的列等于 ，则为；否则为 。

在给定列序号的情况下，指示位于指定列中采用本机格式的值。 此属性是只读的。

列序号。 位于指定列中采用本机格式的值。

在给定列名的情况下，指示位于指定列中采用本机格式的值。 此属性是只读的。

列名称。 位于指定列中采用本机格式的值。

返回此组件实例的自定义属性的集合。

一个包含该对象的特性的 。

返回此组件实例的类名称。

对象的类名称，如果该类没有名称，则为 。

返回某个组件的此实例的名称。

对象的名称，如果该对象不具有名称，则为 。

返回此组件实例的类型转换器。

作为此对象转换器的 ，或为 （如果此对象不存在任何 ）。

返回某个组件的此实例的默认事件。

表示此对象的默认事件的 ；如果该对象没有事件，则为 。

返回此组件实例的默认属性。

表示此对象的默认属性的 ；如果该对象没有属性，则为 。

返回此组件实例的指定类型的编辑器。

表示该对象的编辑器的 。 表示该对象编辑器的指定类型的 ；如果无法找到编辑器，则为 。

返回此组件实例的事件。

一个 ，表示此组件实例的事件。

使用指定的属性数组作为筛选器，返回此组件实例的事件。

用作筛选器的 类型数组。 表示此组件实例的已筛选事件的 。

返回此组件实例的属性。

表示此组件实例的属性的 。

使用特性数组作为筛选器，返回此组件实例的属性。

用作筛选器的 类型数组。 一个 ，它表示此组件实例的已筛选属性。

返回一个对象，该对象包含指定的属性描述符所描述的属性。

一个 ，表示要查找其所有者的属性。 一个 ，表示指定属性的所有者。

提供了一种枚举本地网络内的所有可用数据库服务器实例的机制。

创建 类的新实例。

检索一个 ，它包含由该类的强类型实例所表示的服务器的所有可见实例的相关信息。

一个 ，它包含有关联数据源的可见实例的信息。

公开 方法，该方法支持 .NET Framework 数据提供程序对集合进行简单的迭代。

使用给定的数据读取器初始化 类的新实例。

要对其进行循环访问的 DataReader。

使用指定的读取器初始化 类的新实例，并表示在循环访问读取器的数据后是否将其自动关闭。

要对其进行循环访问的 DataReader。 若要在循环访问 DataReader 的数据后将其自动关闭，则为 ；否则为 。

使用指定的 初始化 类的新实例。

要通过其进行循环访问的 。

使用指定的 初始化 类的新实例，并指示在循环访问 的数据后是否将其自动关闭。

要通过其进行循环访问的 。 若要在循环访问 的数据后将其自动关闭，则为 ；否则为 。

获取集合中的当前元素。

集合中的当前元素。 枚举器位于集合中第一个元素之前或最后一个元素之后。

将枚举数推进到集合的下一个元素。

如果枚举数已成功地推进到下一个元素，则为 ；如果枚举数传递到集合的末尾，则为 。 集合在枚举器创建后被修改。

将枚举数设置为其初始位置，该位置位于集合中第一个元素之前。

集合在枚举器创建后被修改。

代表数据源引发的所有异常的基类。

初始化 类的新实例。

用指定的序列化信息和上下文初始化 类的新实例。

包含有关所引发异常的序列化对象数据的 。 ，它包含关于源或目标的上下文信息。

使用指定的错误消息初始化 类的新实例。

为此异常显示的消息。

使用指定的错误消息和对导致此异常的内部异常的引用来初始化 类的新实例。

错误消息字符串。 内部异常引用。

使用指定的错误消息和错误代码初始化 类的新实例。

解释异常原因的错误消息。 异常的错误代码。

提供已知 MetaDataCollections 的常量列表：DataSourceInformation、DataTypes、MetaDataCollections、ReservedWords 和 Restrictions。

与表示 DataSourceInformation 集合的 方法一起使用的常量。

与表示 DataTypes 集合的 方法一起使用的常量。

与表示 MetaDataCollections 集合的 方法一起使用的常量。

与表示 ReservedWords 集合的 方法一起使用的常量。

与表示 Restrictions 集合的 方法一起使用的常量。

提供静态值，这些值用于 中包含的 MetaDataCollection 对象的列名称。 由 GetSchema 方法创建。

由 GetSchema 方法用来创建 DataTypes 集合中的 CollectionName 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 ColumnSize 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 CompositeIdentifierSeparatorPattern 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 CreateFormat 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 CreateParameters 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 DataSourceProductName 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 DataSourceProductVersion 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 DataSourceProductVersionNormalized 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 DataType 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 GroupByBehavior 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 IdentifierCase 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 IdentifierPattern 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsAutoIncrementable 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsBestMatch 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsCaseSensitive 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsConcurrencyType 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsFixedLength 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsFixedPrecisionScale 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsLiteralSupported 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsLong 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsNullable 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsSearchable 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsSearchableWithLike 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 IsUnsigned 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 LiteralPrefix 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 LiteralSuffix 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 MaximumScale 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 MinimumScale 列。

由 GetSchema 方法用来创建 MetaDataCollections 集合中的 NumberOfIdentifierParts 列。

由 GetSchema 方法用来创建 MetaDataCollections 集合中的 NumberOfRestrictions 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 OrderByColumnsInSelect 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 ParameterMarkerFormat 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 ParameterMarkerPattern 列。

由 GetSchema 方法用来创建 DataSourceInformation ParameterNameMaxLength 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 ParameterNamePattern 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 ProviderDbType 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 QuotedIdentifierCase 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 QuotedIdentifierPattern 列。

由 GetSchema 方法用来创建 ReservedWords 集合中的 ReservedWord 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 StatementSeparatorPattern 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 StringLiteralPattern 列。

由 GetSchema 方法用来创建 DataSourceInformation 集合中的 SupportedJoinOperators 列。

由 GetSchema 方法用来创建 DataTypes 集合中的 TypeName 列。

表示 的参数，还可以是它到 列的映射。 有关参数的详细信息，请参阅配置参数和参数数据类型。

初始化 类的新实例。

获取或设置参数的 。

值之一。 默认值为 。 该属性未设置为有效的 。

获取或设置一个值，该值指示参数是只可输入的参数、只可输出的参数、双向参数还是存储过程返回值参数。

值之一。 默认值为 。 该属性未设置为有效的 值之一。

获取或设置一个值，该值指示参数是否接受 null 值。

如果接受 null 值，则为 ；否则为 。 默认值为 。

获取或设置 的名称。

的名称。 默认值为空字符串("")。

获取或设置用于表示 属性的最大位数。

用于表示 属性的最大位数。

将 DbType 属性重置为其原始设置。

获取或设置所解析的 的小数位数。

所解析的 的小数位数。

获取或设置列中的数据的最大大小（以字节为单位）。

列中的数据的最大大小（以字节为单位）。 默认值将根据参数值进行推断。

获取或设置源列的名称，该源列映射到 并用于加载或返回 。

映射到 的源列的名称。 默认值为一个空字符串。

设置或获取一个值，该值指示源列是否可以为 null。 通过此操作， 能够为可以为 null 的列正确地生成 Update 语句。

如果源列可以为 null，则为 ；如果不可以为 null，则为 。

获取或设置在加载 时使用的 。

值之一。 默认值为 。 该属性未设置为 值之一。

指示数值参数的精度。

用于表示数据提供程序 对象的 属性的最大位数。 默认值为 0，指示数据提供程序将设置 的精度。

有关此成员的说明，请参见 。

所解析的 的小数位数。 默认值为 0。

获取或设置参数的值。

充当参数值的 。 默认值为 null。

与 相关的参数集合的基类。

初始化 类的新实例。

将指定的 对象添加到 中。

要添加到集合中的 的 。 集合中的 对象的索引。

将具有指定值的项的数组添加到 。

要添加到集合的 类型的值的数组。

将所有 值从 中移除。

指示集合中是否包含具有指定 的 。

要在集合中查找的 的 。 如果 位于集合中，则为 ；否则为 。

指示具有指定名称的 是否存在于集合中。

要在集合中查找的 的名称。 如果 位于集合中，则为 ；否则为 。

将项的数组复制到从指定索引开始的集合。

要复制到集合的项数组。 要复制项的集合中的索引。

指定集合中项的数目。

集合中项的数目。

公开 方法，该方法支持 .NET Framework 数据提供程序对集合进行简单的迭代。

可用于循环访问集合的 。

返回位于集合中指定索引处的 对象。

集合中 的索引。 集合中指定索引处的 对象。

返回具有指定名称的 对象。

集合中 的名称。 具有指定名称的 对象。

返回指定的 对象的索引。

集合中的 对象。 指定的 对象的索引。

返回具有指定名称的 对象的索引。

集合中 对象的名称。 具有指定名称的 对象的索引。

将具有指定名称的 对象的指定索引插入指定索引处的集合中。

插入 对象的索引位置。 要插入到集合中的 对象。

指定集合是否为固定大小。

如果集合为固定大小，则为 ；否则为 。

指定集合是否为只读。

如果该集合为只读，则为 ；否则为 。

指定是否同步集合。

如果同步集合，则为 ；否则为 。

获取或设置指定索引处的 。

参数的从零开始的索引。 位于指定索引处的 。 指定的索引不存在。

获取或设置具有指定名称的 。

参数的名称。 具有指定名称的 。 指定的索引不存在。

从集合中移除指定的 对象。

要移除的 对象。

从集合中删除位于指定位置的 对象。

对象所在的索引。

从集合中删除具有指定名称的 对象。

要删除的 对象的名称。

将指定索引处的 对象设置为新值。

对象所在的索引。 新的 值。

将具有指定名称的 对象设置为新值。

集合中 对象的名称。 新的 值。

指定将用于同步集合访问的 。

用于同步 访问的 。

获取或设置指定索引处的元素。

要获取或设置的元素的从零开始的索引。 指定索引处的元素。

获取或设置指定索引处的参数。

要检索的参数的名称。 指定索引处的一个 。

任何提供程序都可使用此类以支持特定于提供程序的配置部分。

任何提供程序都可使用此类以支持特定于提供程序的配置部分。

创建一个新的 表达式。

此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 新表达式。

表示一组静态方法，这些方法用于创建 类的一个或多个实例。

返回 的一个实例。

要使用的连接。 指定连接的 实例。

返回 的一个实例。

包含提供程序的配置信息。 指定 的 的一个实例。

返回 的一个实例。

提供程序的固定名称。 指定提供程序名称的 的一个实例。

返回一个 ，其中包含有关实现 的所有已安装提供程序的信息。

一个包含 对象的 ，这些对象具有以下数据： 列序号 列名称 描述 0 Name 数据提供程序的可识别名称。 1 描述 数据提供程序的可识别描述。 2 InvariantName 可以以编程方式用于引用数据提供程序的名称。 3 AssemblyQualifiedName 工厂类的完全限定名，它包含用于实例化该对象的足够的信息。

此类型支持 .NET Framework 基础结构，不能在代码中直接使用。

此类型支持 .NET Framework 基础结构，不能在代码中直接使用。

此类型支持 .NET Framework 基础结构，不能在代码中直接使用。

此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 此类型支持 .NET Framework 基础结构，不能在代码中直接使用。 此类型支持 .NET Framework 基础结构，不能在代码中直接使用。

表示一组方法，这些方法用于创建数据源类的提供程序实现的实例。

初始化 类的新实例。

指定特定的 是否支持 类。

如果 的实例支持 类，则为 ；否则为 。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序类的一个新实例。

的新实例。

返回实现 类的提供程序版本的提供程序类的一个新实例。

值之一。 指定的 的一个 对象。

标识在设置提供程序特定的类型时，使用强类型参数类中的哪个提供程序特定的属性。

初始化 类的新实例。

指定该属性是否是提供程序特定的属性。

指示特性化属性是否为特定于提供程序的类型。

如果此特性所应用的属性是特定于提供程序的类型属性，则为 ；否则为 。

事务的基类。

初始化新的 对象。

提交数据库事务。

指定与该事务关联的 对象。

与事务关联的 对象。

指定与该事务关联的 对象。

与事务关联的 对象。

释放 使用的非托管资源。

释放由 占用的非托管资源，还可以另外再释放托管资源。

如果为 ，此方法将释放由此 引用的任何托管对象所保留的全部资源。

为该事务指定 。

该事务的 。

从挂起状态回滚事务。

获取与事务关联的 对象，或空引用（如果该事务不再有效）。

与事务关联的 对象。

指定 GROUP BY 子句中的列与 SELECT 语句的选择列表中的非聚集列之间的关系。

GROUP BY 子句必须包含选择列表中的所有非聚集列，而且不能包含选择列表中没有的其他列。

GROUP BY 子句必须包含选择列表中的所有非聚集列，而且可以包含选择列表中没有的其他列。

不支持 GROUP BY 子句。

对 GROUP BY 子句的支持是未知的。

GROUP BY 子句中的列和 SELECT 列表中的非聚集列之间不存在关系。 您可以按任何列分组。

生成列架构。

获取列架构（ 集合）。

列架构（ 集合）。

指定在搜索系统目录时，数据源如何处理标识符。

搜索系统目录时，数据源忽略标识符的大小写。 标识符“ab”和“AB”匹配。

搜索系统目录时，数据源区分标识符的大小写。 标识符“ab”和“AB”不匹配。

数据源的标识符大小写规则不明确，无法识别此信息。

为 .NET Framework 数据提供程序的 事件提供数据。

初始化 类的新实例。

通过 发送 。 调用 时执行的 。 所执行的 SQL 语句类型。 通过 发送 。

调用 时执行的 。

调用 时执行的 。

将已修改的行的引用复制到提供的数组中。

要复制到其中的 数组。

将已修改的行的引用复制到提供的数组中。

要复制到其中的 数组。 要在数组中开始粘贴的位置的索引。

获取当 执行时 .NET Framework 数据提供程序生成的任何错误。

当 执行时 .NET Framework 数据提供程序生成的错误。

获取通过执行 SQL 语句更改、插入或删除的行数。

已更改、插入或删除的行数；如果没有受影响的行或语句失败，则为 0；对于 SELECT 语句为 -1。

获取通过 发送的 。

通过 发送 。

获取在一批更新记录中处理的行数。

指定已处理的行数的 。

获取所执行的 SQL 语句的类型。

所执行的 SQL 语句类型。

获取 属性的 。

值之一。 默认值为 。

获取通过 发送的 。

通过 发送 。

为 .NET Framework 数据提供程序的 RowUpdating 事件提供数据。

初始化 类的新实例。

要进行 的 。 当调用 时执行的 。 要执行的 SQL 语句的类型。 要通过 发送的 。

获取或设置此类的实例的 对象。

要在 过程中执行的 。

获取要在 操作过程中执行的 。

要在 过程中执行的 。

获取当 执行时 .NET Framework 数据提供程序生成的任何错误。

当 执行时 .NET Framework 数据提供程序生成的错误。

获取要作为插入、更新或删除操作的一部分发送到服务器的 。

要通过 发送的 。

获取要执行的 SQL 语句的类型。

要执行的 SQL 语句的类型。

获取或设置 属性的 。

值之一。 默认值为 。

获取要通过 发送的 。

要通过 发送的 。

描述数据库表的架构的列元数据。

指定是否允许值 。

指定架构表中的列的名称。

指定架构表中的架构的名称。

指定架构表中的表的名称。

指定架构表中的列的名称。

指定列的序号。

指定列的大小。

指定列中数据的类型。

指定该列是否具有别名。

指定该列是否是一个表达式。

指定该列是否是表的一个键。

指定该列是否包含 long 型数据。

指定是否有唯一的约束应用于此列。

指定该列特定于无版本提供程序的数据类型。

指定列数据的精度（如果是数值数据）。

指定列数据的小数位数（如果是数值数据）。

指定列的提供程序特定的数据类型。

描述数据库表的架构的可选列元数据。

指定新标识列的序列被分配的值。

指定标识列中的值之间的增量。

与最新的查询的结果相关联的目录的名称。

列的命名空间。

列的服务器名。

包含列的表的命名空间。

指定列的映射。

列的默认值。

用于计算该列的表达式。

指定列中的列值是否自动递增。

指定该列是否是隐藏的。

指定该列是否是只读的。

指定该列是否包含行版本信息。

指定列的提供程序特定的数据类型。

指定数据源支持何种类型的 Transact-SQL 联接语句。

数据源支持完全外部联接。

数据源支持内部联接。

数据源支持左外部联接。

数据源不支持联接查询。

数据源支持右外部联接。

指定将如何检测和解决对数据源的相互冲突的更改。

更新和删除语句将在 WHERE 子句中包含表中的所有可搜索列。 这等效于指定 | 。

如果表中存在任何 Timestamp 列，则这些列在 WHERE 子句中用于所有生成的更新语句。 这等效于指定 | 。

所有的更新和删除语句仅在 WHERE 子句中包含 列。 如果未定义 ，则所有可搜索的列都包含在 WHERE 子句中。 这等效于 | 。

描述与数据源连接的当前状态。

与数据源的连接中断。 只有在连接打开之后才可能发生这种情况。 可以关闭处于这种状态的连接，然后重新打开。 （该值是为此产品的未来版本保留的。）

连接已关闭。

连接对象正在与数据源连接。

连接对象正在执行命令。 （该值是为此产品的未来版本保留的。）

连接对象正在检索数据。 （该值是为此产品的未来版本保留的。）

连接处于打开状态。

表示可在一个或多个 对象上强制执行的约束。

初始化 类的新实例。

获取此约束所属的 。

此约束所属的 。

获取此约束所属的 。

中的约束的名称。

的名称。 名称是空值或空字符串。 已经包含同名称的 （比较不区分大小写。）

获取用户定义的约束属性的集合。

自定义信息的 。

设置约束的 。

此约束将属于的 。

获取向其应用约束的 。

向其应用约束的 。

获取 （如果存在）作为字符串。

的字符串值。

表示 的约束集合。

将指定的 对象添加到集合。

要添加的 。 参数为 null。 约束已属于此集合，或属于其他集合。 集合已具有相同名称的约束。 （该比较不区分大小写。）

使用指定名称、 和指示列是否为主键的值构造一个新 ，并将其添加到集合中。

的名称。 向其应用约束的 。 指定列是否应为主键。 如果为 ，则该列将为主键列。 一个新的 。 该约束已属于此集合。 或者 - 该约束属于另一集合。 集合中已存在具有指定名称的约束。 （该比较不区分大小写。）

使用指定名称、父列和子列来构造新 ，并将此约束添加到集合。

的名称。 主键或父级、。 外键或子级、。 一个新的 。

使用指定名称、 对象的数组和指示列是否为主键的值构造一个新 ，并将其添加到集合中。

的名称。 对其应用约束的 对象数组。 指定列是否应为主键。 如果为 ，则该列将为主键列。 一个新的 。 该约束已属于此集合。 或者 - 该约束属于另一集合。 集合中已存在具有指定名称的约束。 （该比较不区分大小写。）

使用指定的父列和子列数组，构造新的 ，并将该约束添加到集合。

的名称。 作为主键列或父列的 对象数组。 作为外键列或子列的 对象数组。 一个新的 。

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

指示是否可移除 。

要对其进行测试以查看是否可从集合删除的 。 如果可从集合中移除 ，则为 ；否则为 。

清除所有 对象的集合。

每当由于添加或移除 对象而更改 时发生。

指示集合中是否存在按名称指定的 对象。

约束的 。 如果集合包含指定的约束，则为 ；否则为 。

从指定的索引处开始，将集合对象复制到一维 实例中。

一维 ，它是从集合所复制值的目标位置。 插入开始处的数组索引。

获取指定 的索引。

要搜索的 。 如果 在集合中，则为其从零开始的索引；否则为 -1。

获取按名称指定的 的索引。

的名称。 如果 在集合中，则为它的索引，否则为 -1。

从集合中获取位于指定索引位置的 。

要返回的约束的索引。 位于指定索引处的 。 索引值大于集合中的项目数。

从具有指定名称的集合中获取 。

要返回的约束的 。 具有指定名称的 ；否则，如果 不存在，则为空值。

从集合中移除指定的 。

要移除的 。 参数为 。 约束不属于该集合。

从集合中移除按名称指定的 对象。

要移除的 的名称。

从集合中移除位于指定索引位置的 对象。

要移除的 的索引。 该集合在此索引位置无约束。

表示在尝试执行违反约束的操作时引发的异常。

初始化 类的新实例。 这是默认构造函数。

用指定的序列化和流上下文初始化 类的新实例。

将对象序列化或反序列化所必需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的字符串和内部异常初始化 类的新实例。

引发异常时显示的字符串。 获取导致当前异常的 实例。

表示 中的列的架构。

将 类的新实例初始化为类型字符串。

使用指定的列名称将 类的新实例初始化为类型字符串。

一个字符串，它表示要创建的列的名称。 如果设置为 或空字符串 ("")，则当添加到列集合中时，将指定一个默认名称。

使用指定列名称和数据类型初始化 类的新实例。

一个字符串，它表示要创建的列的名称。 如果设置为 或空字符串 ("")，则当添加到列集合中时，将指定一个默认名称。 支持的 。 未指定任何 。

使用指定的名称、数据类型和表达式初始化 类的新实例。

一个字符串，它表示要创建的列的名称。 如果设置为 或空字符串 ("")，则当添加到列集合中时，将指定一个默认名称。 支持的 。 用于创建该列的表达式。 有关更多信息，请参见 属性。 未指定任何 。

使用指定名称、数据类型、表达式和确定列是否为特性的值，初始化 类的新实例。

一个字符串，它表示要创建的列的名称。 如果设置为 或空字符串 ("")，则当添加到列集合中时，将指定一个默认名称。 支持的 。 用于创建该列的表达式。 有关更多信息，请参见 属性。 值之一。 未指定任何 。

获取或设置一个值，该值指示对于属于该表的行，此列中是否允许空值。

如果允许空值，则为 ；否则为 。 默认值为 。

获取或设置一个值，该值指示对于添加到该表中的新行，列是否将列的值自动递增。

如果列的值自动递增，则为 ；否则为 。 默认值为 。 该列是计算所得的列。

获取或设置其 属性设置为 的列的起始值。 默认值为 0。

功能的起始值。

获取或设置其 属性设置为 的列使用的增量。

列的值自动递增的数值。 默认值为 1。 设置的值为零。

获取或设置列的标题。

列的标题。 如果没有设置，则返回 的值。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

获取或设置列的 。

值之一。

获取或设置 中的列的名称。

列的名称。 属性设置为 或空字符串，且列属于一个集合。 集合中已经存在同名称的列。 名称比较不区分大小写。

获取或设置存储在列中的数据的类型。

一个 对象，它表示列数据类型。 列已经存储了数据。

获取或设置列的 。

所指定的列的 。

在创建新行时获取或设置列的默认值。

适合于列的 的值。 在添加行时，默认值不是列的数据类型的实例。

获取或设置表达式，用于筛选行、计算列中的值或创建聚合列。

用来计算列的值，或创建聚合列的表达式。 表达式的返回类型由列的 来确定。 将 或 属性设置为 。 在使用 CONVERT 函数时，表达式的计算结果为一个字符串，但该字符串不包含可以转换成类型参数的表示形式。 在使用 CONVERT 函数时，所请求的强制转换不可能完成。 有关可能的强制转换的详细信息，请参见下面一节中的 Conversion 函数。 在使用 SUBSTRING 函数时，起始参数超出范围。 或者 - 在使用 SUBSTRING 函数时，长度参数超出范围。 在使用 LEN 函数或 TRIM 函数时，表达式的计算结果不是字符串。 这包括计算结果为 的表达式。

获取与 相关的自定义用户信息的集合。

自定义信息的 。

获取或设置文本列的最大长度。

列的最大长度（以字符数表示）。 如果列没有最大长度，值为-1 （默认值）。

获取或设置 的命名空间。

的命名空间。 该命名空间已有数据。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

参数引用。

获取列在 集合中的位置（从零开始）。

列的位置。 如果列不是集合的成员，获取 -1。

获取或设置一个 XML 前缀，该前缀是 的命名空间的别名。

命名空间的 XML 前缀。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

参数引用。

获取或设置一个值，该值指示一旦向表中添加了行，列是否还允许更改。

如果列为只读，则为 ；否则为 。 默认值为 。 对于计算所得的列，此属性设置为 。

将 的序号或位置更改为指定的序号或位置。

指定的序号。

获取列所属的 。

所属的 。

获取列的 （如果存在的话）。

如果设置了属性；则为 的值；否则为 的属性。

获取或设置一个值，该值指示列的每一行中的值是否必须是唯一的。

如果值必须是唯一的，则为 ；否则为 。 默认值为 。 列是计算出的列。

为 事件提供数据。

初始化 类的新实例。

带有可变值的列的 。 带有可变值的 。 新值。

获取带有可变值的 。

带有可变值的 。

获取或设置列的建议新值。

建议的值，类型为 。

获取带有可变值的列的 。

带有可变值的列的 。

表示用来处理 事件的方法。

事件源。 包含事件数据的 。

表示 的 对象的集合。

创建 对象并将其添加到 中。

新创建的 。

创建指定的 对象并将其添加到 。

要添加的 。 参数为 。 该列已经属于此集合，或者属于另一个集合。 集合中已存在具有指定名称的列。 （该比较不区分大小写。） 表达式无效。 有关如何创建表达式的更多信息，请参见 属性。

创建一个具有指定名称的 对象，并将其添加到 中。

列的名称。 新创建的 。 集合中已存在具有指定名称的列。 （该比较不区分大小写。）

创建一个具有指定名称和类型的 对象，并将其添加到 中。

要在创建列时使用的 。 新列的 。 新创建的 。 集合中已存在具有指定名称的列。 （该比较不区分大小写。） 表达式无效。 有关如何创建表达式的更多信息，请参见 属性。

创建一个具有指定名称、类型和表达式的 对象，并将其添加到 中。

要在创建列时使用的名称。 新列的 。 要分配给 属性的表达式。 新创建的 。 集合中已存在具有指定名称的列。 （该比较不区分大小写。） 表达式无效。 有关如何创建表达式的更多信息，请参见 属性。

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

检查是否可从集合中移除特定列。

集合中的 。 如果可移除该列，则为 。 ，如果 参数为 。 该列不属于此集合。 该列是关系的一部分。 另一个列的表达式取决于该列。 参数为 null。 该列不属于此集合。 或 - 该列是关系的一部分。 或 - 另一个列的表达式取决于该列。

清除集合中的所有列。

在由于添加或删除列而使列集合发生变化时发生。

检查集合是否包含具有指定名称的列。

要查找的列的 。 如果存在此名称的列，则为 ；否则为 。

将整个集合复制到现有数组中，从该数组内的指定索引处开始复制。

将集合复制到其中的 对象的数组。 从其开始的索引。

获取按名称指定的列的索引。

要返回的列的名称。 如果找到由 指定的列的索引，则为这个索引；否则为 -1。

获取具有特定名称的列的索引（名称不区分大小写）。

要查找的列的名称。 具有指定名称的列的从零开始的索引，或者如果集合中不存在该列，则为 -1。

从集合中获取位于指定索引位置的 。

要返回的列的从零开始的索引。 位于指定索引处的 。 索引值大于集合中的项目数。

从具有指定名称的集合中获取 。

要返回的列的 。 具有指定 的集合中的 ，否则，如果 不存在，则为空值。

从集合中移除指定的 对象。

要移除的 。 参数为 。 该列不属于此集合。 或者 - 该列是关系的一部分。 或者 - 另一个列的表达式取决于该列。

从集合中移除具有指定名称的 对象。

要移除的列的名称。 该集合中没有具有指定名称的列。

从集合中移除指定索引位置的列。

要移除的列的索引。 该集合在指定的索引位置没有列。

表示使用 ADO.NET 组件发生错误时引发的异常。

初始化 类的新实例。 这是默认构造函数。

用指定的序列化信息和上下文初始化 类的新实例。

将对象序列化或反序列化所必需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的字符串和内部异常初始化 类的新实例。

引发异常时显示的字符串。 对内部异常的引用。

表示两个 对象之间的父/子关系。

使用指定的 名称、父级和子级 对象，初始化 类的新实例。

的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 关系中的父级 。 关系中的子级 。 一个或两个 对象包含 。 列具有不同的数据类型 或者 - 表不属于同一个 。

使用指定名称、父级和子级 对象以及指示是否创建约束的值，初始化 类的新实例。

关系的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 关系中的父级 。 关系中的子级 。 一个指示是否创建约束的值。 如果要创建约束，则为 。 否则为 。 一个或两个 对象包含 。 列具有不同的数据类型 或者 - 表不属于同一个 。

使用指定的 名称、父级和子级 对象的匹配数组，初始化 类的新实例。

关系的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 父级 对象的数组。 子级 对象的数组。 一个或两个 对象包含 。 对象具有不同的数据类型 或者 - 一个或两个数组不由同一个表中的不同列构成。 或者 - 表不属于同一个 。

使用指定的名称、父级和子级 对象的匹配数组以及指示是否创建约束的值，初始化 类的新实例。

关系的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 父级 对象的数组。 子级 对象的数组。 一个指示是否创建约束的值。 如果要创建约束，则为 。 否则为 。 一个或两个 对象为 。 列具有不同的数据类型 或者 - 表不属于同一个 。

此构造函数在 Visual Studio 环境中提供设计时支持。

的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 作为关系的父表的 的名称。 父表命名空间的名称。 作为关系的子表的 的名称。 子表命名空间的名称。 关系的父级 中的 对象名称的数组。 关系的子级 中的 对象名称的数组。 一个指示是否嵌套关系的值。

此构造函数在 Visual Studio 环境中提供设计时支持。

关系的名称。 如果为 或空字符串 ("")，则当创建的对象添加到 时，将提供一个默认名称。 作为关系的父表的 的名称。 作为关系的子表的 的名称。 关系的父级 中的 对象名称的数组。 关系的子级 中的 对象名称的数组。 一个指示是否嵌套关系的值。

此方法支持 .NET Framework 基础结构，但不适合直接在代码中使用。

父表和子表属于不同的 对象。 或者 - 一对或多对父级和子级 对象具有不匹配的数据类型。 或者 - 父级和子级 对象相同。

获取此关系的子级 对象。

一个 对象数组。

获取关系的 。

。

获取此关系的子表。

一个 ，它是关系的子表。

获取 所属的 。

所属的 。

获取存储自定义属性的集合。

一个包含自定义属性的 。

获取或设置一个指示是否嵌套 对象的值。

如果 对象嵌套，则为 ；否则为 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

参数引用。

获取作为此 的父列的 对象的数组。

作为此 的父列 对象的数组。

获取 ，它确保 的父列中的值是唯一的。

一个 ，它确保父列中的值是唯一的。

获取此 的父级 。

一个 ，它是此关系的父表。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

参数引用。

获取或设置用于从 中检索 的名称。

的名称。 将 或空字符串 ("") 传入作为 的 。 属于一个集合，该集合已经包含具有相同名称的 。

获取 （如果存在）。

属性的值。

表示此 的 对象的集合。

初始化 类的新实例。

用指定的父列和子列创建 ，并将其添加到集合中。

该关系的父列。 该关系的子列。 创建的关系。

用指定的父列和子列创建 ，并将其添加到集合中。

该关系的父列。 该关系的子列。 创建的关系。 参数为空值。 该关系已经属于此集合，或者它属于另一个集合。 集合中已存在同名关系。 （该比较不区分大小写。） 该关系在创建后进入了无效的状态。

向 中添加一个 。

要添加到集合中的 。 参数为空值。 该关系已经属于此集合，或者它属于另一个集合。 集合中已经存在具有指定名称的关系。 （该比较不区分大小写。） 该关系在创建后进入了无效的状态。

用指定名称以及父列和子列创建 ，并将其添加到集合。

关系的名称。 该关系的父列。 该关系的子列。 创建的关系。

用指定的名称、父列和子列，以及根据 参数的值而定的可选约束创建 ，并将其添加到集合中。

关系的名称。 该关系的父列。 该关系的子列。 如果创建约束，则为 ；否则为 。 （默认值为 ）。 创建的关系。

使用父列和子列数组创建一个具有指定名称的 ，并将其添加到集合中。

要创建的 的名称。 父级 对象的数组。 子级 对象的数组。 创建的 。 该关系名称为空值。 该关系已经属于此集合，或者它属于另一个集合。 集合中已存在同名关系。 （该比较不区分大小写。） 该关系在创建后进入了无效的状态。

用指定的名称、父列和子列的数组以及指定是否创建约束的值，创建 ，并将其添加到集合。

要创建的 的名称。 父级 对象的数组。 子级 对象的数组。 若要创建约束，则为 ；否则为 。 创建的关系。 该关系名称为空值。 该关系已经属于此集合，或者它属于另一个集合。 集合中已存在同名关系。 （该比较不区分大小写。） 该关系在创建后进入了无效的状态。

对表执行验证。

要检查的关系。 关系为空。 该关系已经属于此集合，或者它属于另一个集合。 集合中已存在同名关系。 （该比较不区分大小写。）

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

验证是否可以将指定的 从集合中移除。

要对其执行检查的关系。 如果可以移除 ，则为 ；否则为 。

清除集合的所有关系。

在集合更改后发生。

验证集合中是否存在具有特定名称（不区分大小写）的 。

要查找的关系的名称。 如果存在具有指定名称的关系，则为 ；否则为 。

从指定的索引开始复制 对象的集合。

该集合要复制到的 对象的数组。 从其开始的索引。

此方法支持 .NET Framework 基础结构，但不适合直接在代码中使用。

引用的数据集。

获取指定 对象的索引。

要搜索的关系。 该关系的从 0 开始的索引；或者如果在该集合中找不到该关系，则为 -1。

获取按名称指定的 的索引。

要查找的关系的名称。 具有指定名称的关系的从零开始的索引；或者如果集合中不存在该关系，则为 -1。

获取位于指定索引位置的 对象。

要查找的从零开始的索引。 ，或者如果指定的 不存在，则为空值。 索引值大于集合中的项目数。

获取按名称指定的 对象。

要查找的关系的名称。 命名的 ，或者如果指定的 不存在，则为空值。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

从集合中移除指定的关系。

要移除的关系。 关系为空值。 关系不属于该集合。

从集合中移除具有指定名称的关系。

要移除的关系的名称。 该集合中没有具有指定名称的关系。

从集合中移除指定索引位置的关系。

要移除的关系的索引。 该集合在指定的索引位置没有关系。

对指定 对象执行验证。

要验证的 对象。 该集合在指定的索引位置没有关系。 指定的关系不属于此集合，或者它属于另一个集合。

表示 中的一行数据。

初始化 DataRow 的新实例。 从生成器中构造行。 仅限内部使用。

生成器

提交自上次调用 以来对该行进行的所有更改。

此行不属于该表。

对 对象启动编辑操作。

已在 事件中调用该方法。 对已删除的行调用该方法。

取消当前对该行进行的编辑。

已在 事件中调用该方法。

清除该行的错误。 这包括 和 的错误设置。

删除 。

已删除 。

终止该行的编辑。

已在 事件中调用该方法。 该编辑操作破坏了约束。 此行属于该表，该编辑尝试更改只读列的值。 该编辑操作尝试将 null 值放在 为 False 的列中。

使用指定的 获取此 的子行。

要使用的 。 一个 对象数组，或长度为零的数组。 关系和行不属于同一个表。 关系为 。 此行不属于该表。 该行没有此版本的数据。

使用指定的 和 获取 的子行。

要使用的 。 值之一，指定要获取的数据的版本。 可能值为 、、 和 。 一个 对象数组。 关系和行不属于同一个表。 为 。 此行不属于该表。 该行没有请求的 。

使用 的指定 获取 的子行。

要使用的 的 。 一个 对象数组，或长度为零的数组。 关系和行不属于同一个表。 此行不属于该表。

使用 的指定 和 获取 的子行。

要使用的 的 。 值之一，指定要获取的数据的版本。 可能值为 、、 和 。 一个 对象数组，或长度为零的数组。 关系和行不属于同一个表。 为 。 此行不属于该表。 该行没有请求的 。

获取指定 的错误说明。

。 错误说明的文本。

获取由索引指定的列的错误说明。

列的从零开始的索引。 错误说明的文本。 参数超出范围。

获取由名称指定的列的错误说明。

列的名称。 错误说明的文本。

获取由包含错误的列组成的数组。

包含错误的 对象组成的数组。

使用指定的 获取 的父行。

要使用的 。 当前行的父 。 不属于 。 或 - 该行为 。 子行具有多个父行。 此行不属于 对象的子表。 此行不属于表。

使用指定的 和 获取 的父行。

要使用的 。 值之一，指定要获取的数据的版本。 当前行的父 。 该行为 。 或 - 不属于该表的父关系。 子行具有多个父行。 此关系的子表不是该行所属的表。 此行不属于表。 该行没有此版本的数据。

使用 的指定 获取 的父行。

的 。 当前行的父 。 关系和行不属于同一个表。 子行具有多个父行。 此行不属于该表。

使用 的指定 和 获取 的父行。

的 。 值之一。 当前行的父 。 关系和行不属于同一个表。 为 。 子行具有多个父行。 此行不属于该表。 该行没有请求的 。

使用指定的 获取 的父行。

要使用的 。 一个 对象数组，或长度为零的数组。 不属于此行的 。 该行为 。 此关系的子表不是该行所属的表。 该行不属于 。

使用指定的 和 获取 的父行。

要使用的 。 值之一，指定要获取的数据的版本。 一个 对象数组，或长度为零的数组。 不属于此行的 。 该行为 。 此关系的子表不是该行所属的表。 该行不属于 。 该行没有请求的 。

使用 的指定 获取 的父行。

的 。 一个 对象数组，或长度为零的数组。 关系和行不属于同一个表。 此行不属于该表。

使用 的指定 和 获取 的父行。

的 。 值之一，指定要获取的数据的版本。 可能值为 、、 和 。 一个 对象数组，或长度为零的数组。 关系和行不属于同一个表。 为 。 此行不属于该表。 该行没有请求的 。

获取一个值，该值指示某行是否包含错误。

如果该行包含错误，则为 ；否则，为 。

获取一个值，该值指示指定的版本是否存在。

值之一，用于指定行版本。 如果该版本存在，则为 ；否则为 。

获取一个值，该值指示指定的 是否包含 null 值。

。 如果该列包含 null 值，则为 ；否则为 。

获取一个值，该值指示指定的 和 是否包含 null 值。

。 值之一，用于指定行版本。 可能值为 、、 和 。 如果该列包含 null 值，则为 ；否则为 。

获取一个值，该值指示位于指定索引处的列是否包含 null 值。

列的从零开始的索引。 如果该列包含 null 值，则为 ；否则为 。

获取一个值，该值指示指定的列是否包含 null 值。

列的名称。 如果该列包含 null 值，则为 ；否则为 。

获取或设置指定 中存储的数据。

一个包含数据的 。 包该数据的 。 该列不属于此表。 为 null。 尝试对已删除的行设置值。 值与列的数据类型不匹配。

获取指定 中存储的数据的指定版本。

，包含有关该列的信息。 值之一，用于指定需要的行版本。 可能值为 、、 和 。 包该数据的 。 该列不属于此表。 参数包含 null。 该行没有此版本的数据。

获取或设置由索引指定的列中存储的数据。

列的从零开始的索引。 包该数据的 。 尝试对已删除的行设置值时发生。 参数超出范围。 设置值且新值的 与 不匹配时发生。

获取由索引和要检索的数据版本指定的列中存储的数据。

列的从零开始的索引。 值之一，用于指定需要的行版本。 可能值为 、、 和 。 包该数据的 。 参数超出范围。 值与列的数据类型不匹配。 该行没有此版本的数据。 尝试对已删除的行设置值。

获取或设置由名称指定的列中存储的数据。

列的名称。 包该数据的 。 找不到由 指定的列。 尝试对已删除的行设置值时发生。 设置值且该值的 与 不匹配时发生。 尝试在 设置为 的列中插入 null 值时发生。

获取指定列中存储的数据的指定版本。

列的名称。 值之一，用于指定需要的行版本。 可能值为 、、 和 。 包该数据的 。 找不到由 指定的列。 值与列的数据类型不匹配。 该行没有此版本的数据。 该行已删除。

通过数组获取或设置此行的所有值。

类型的数组。 该数组大于表中的列数。 数组中的值与其相应的 中的 不匹配。 编辑操作破坏了约束。 编辑操作尝试更改只读列的值。 编辑操作尝试将 null 值放在 对象的 为 的列中。 已删除该行。

拒绝自上次调用 以来进行的所有更改。

此行不属于该表。

获取或设置行的自定义错误说明。

描述错误的文本。

获取与该行和 的关系相关的当前状态。

值之一。

将 的 更改为 。

为指定为 的列设置错误说明。

为其设置错误说明的 。 错误说明。

为由索引指定的列设置错误说明。

列的从零开始的索引。 错误说明。 参数超出范围

为由名称指定的列设置错误说明。

列的名称。 错误说明。

将 的 更改为 。

将指定 的值设置为 null 值。

。

使用指定的新父 设置 的父行。

新的父 。

使用指定的新父 和 设置 的父行。

新的父 。 要使用的关系 。 其中一行不属于表 其中一行为 。 该关系不属于 对象的 。 该关系的子级 不是此行所属的表。

获取该行拥有其架构的 。

该行所属的 。

描述对 执行的操作。

该行已添加到表中。

此行已更改。

该行的原始版本和当前版本都已更改。

该行的原始版本已更改。

已提交了对此行的更改。

已从表中删除此行。

此行尚未更改。

对此行的最近更改已回滚。

类型支持 .NET Framework 基础结构，并且不应直接从代码中使用。

为 、、 和 事件提供数据。

初始化 类的新实例。

正针对其进行操作的 。 值之一。

获取针对 进行的操作。

值之一。

获取已针对其进行操作的行。

已针对其发生操作的 。

表示将处理 的 、、 和 事件的方法。

事件源。 包含事件数据的 。

表示 的行的集合。

将指定的 添加到 对象中。

要添加的 。 该行为 null。 此行要么属于另一个表，要么已经属于此表。 添加将使约束无效。 添加尝试将 null 置于 为 false 的 中。

创建使用指定值的行，并将其添加到 中。

用于创建新行的值的数组。 无。 该数组大于表中的列数。 值与其各自的列类型不匹配。 添加行会使约束无效。 尝试将空值放到 为 false 的列中。

清除所有行的集合。

针对 实施 。

获取一个值，该值指示集合中任何行的主键中是否包含指定的值。

要测试的主键的值。 如果集合中包含具有指定主键值的 ，则为 ；否则为 。 该表没有主键。

获取一个值，该值指示集合中任何行的主键列中是否包含在对象数组中指定的值。

要测试的主键值的数组。 如果 中包含具有指定键值的 ，则为 ；否则为 。 该表没有主键。

将该集合中的所有 对象复制到起始位置为给定目标数组索引的给定数组中。

一维数组，它是从 中复制的元素的目标。 该数组的索引必须从零开始。 数组中开始复制的位置的索引（从零开始）。

将该集合中的所有 对象复制到起始位置为给定目标数组索引的给定数组中。

一维数组，它是从 中复制的元素的目标。 该数组的索引必须从零开始。 数组中开始复制的位置的索引（从零开始）。

获取该集合中 对象的总数。

该集合中的 对象的总数。

获取由主键值指定的行。

要查找的 的主键值。 包含指定的主键值的 ；否则为空值（如果 中不存在主键值）。 该表没有主键。

获取包含指定的主键值的行。

要查找的主键值的数组。 数组的类型为 。 包含指定的主键值的 对象；如果 中不存在主键值，则为 Null 值。 任何行都不与该索引值相对应。 该表没有主键。

获取该集合的 。

该集合的 。

获取指定 对象的索引。

要搜索的 。 该行从零开始的索引；如果在集合中未找到该行，则为 -1。

将新行插入到集合中的指定位置。

要添加的 。 您要添加该 的集合的位置（位置从零开始）。 小于 0。

获取指定索引处的行。

要返回的行的从零开始的索引。 指定的 。 索引值大于集合中的项目数。

从集合中移除指定的 。

要移除的 。

从集合中移除指定索引处的行。

要移除的行的索引。

获取 对象的状态。

该行已添加到 中， 尚未调用。

该行已通过 的 方法被删除。

已创建该行，但它不是任何 的一部分。 在以下情况下立即处于此状态：创建之后添加到集合中之前；或从集合中移除之后。

该行已被修改， 尚未调用。

自上一次调用 之后，该行未更改。

介绍 的版本。

包含其当前值的行。

的默认版本。 对于 、 或 的 值，默认的版本是 。 对于 的 值，版本是 。

包含其原始值的行。

包含建议值的行。

表示 的自定义视图。

开始编辑过程。

取消编辑过程。

返回具有指定的子级 的子级 的 。

对象。 子级 的 。

返回具有指定的 及父级的子级 的 。

对象。 父对象。 子级 的 。

返回具有指定的子级 名称的子级 的 。

一个包含 名称的字符串。 子级 的 。

返回具有指定的 及父级的子级 的 。

一个包含 名称的字符串。 父级 子级 的 。

获取该行所属的 。

该行所属的 。

删除行。

提交基础 的更改并结束使用 启动的编辑会话。 使用 放弃对 所做的更改。

获取一个值，该值指示当前的 是否与指定对象相同。

要比较的 。 如果 是 且它返回与当前 相同的行，则为 ；否则为 。

返回 对象的哈希代码。

如果此实例的值不为零，则为 32 位有符号整数哈希代码 1，它表示布尔值 ；否则为整数 0，它表示布尔值 。

指示行是否处于编辑模式。

如果行处于编辑模式，则为 ；否则为 。

指示 是否为新。

如果是新行，则为 ；否则为 。

获取或设置指定列中的值。

指定的列。 列的值。

获取或设置指定列中的值。

包含指定列的字符串。 列的值。

当 属性发生更改时引发的事件。

获取正被查看的 。

正被 查看的 。

获取 的当前版本说明。

值之一。 属性的可能值有：、、 和 。

返回此组件实例的自定义属性的集合。

包含此对象的 AttributeCollection 特性。

返回此组件实例的类名称。

此组件实例的类名。

返回某个组件的此实例的名称。

此组件实例的名称。

返回此组件实例的类型转换器。

此组件实例的类型转换器。

返回某个组件的此实例的默认事件。

此组件实例的默认事件。

返回此组件实例的默认属性。

此组件实例的默认属性。

返回此组件实例的指定类型的编辑器。

表示该对象的编辑器的 。 表示该对象编辑器的指定类型的 ；如果无法找到编辑器，则为 。

返回此组件实例的事件。

此组件实例的事件。

返回具有指定特性的此组件实例的事件。

特性 此组件实例的事件。

返回此组件实例的属性。

此组件实例的属性。

返回具有指定特性的此组件实例的属性。

属性。 此组件实例的属性。

返回一个对象，该对象包含指定的属性描述符所描述的属性。

一个 ，表示要查找其所有者的属性。 一个 ，表示指定属性的所有者。

获取描述该对象的任何验证错误的消息。

对象上的验证错误。

获取具有给定名称的属性的错误信息。

要获取其错误信息的属性的名称。 该属性的错误信息。 默认值为空字符串("")。

表示数据在内存中的缓存。

初始化 类的新实例。

初始化具有给定序列化信息和上下文的 类的新实例。

序列化或反序列化对象所需的数据。 给定序列化流的源和目标。

初始化 类的新实例。

对象。 对象。 布尔值。

用给定名称初始化 类的新实例。

的名称。

提交自加载此 或上次调用 以来对其进行的所有更改。

开始初始化在窗体上使用或由另一个组件使用的 。 初始化发生在运行时。

获取或设置一个值，该值指示 对象中的字符串比较是否区分大小写。

如果字符串比较是区分大小写。否则为。 默认值为 。

通过移除所有表中的所有行来清除任何数据的 。

复制 的结构，包括所有 架构、关系和约束。 不要复制任何数据。

新 ，其架构与当前 的架构相同，但是不包含任何数据。

复制该 的结构和数据。

新的 ，具有与该 相同的结构（表架构、关系和约束）和数据。 如果已创建这些类的子类，则副本也将属于相同的子类。

为每个 返回带有一个结果集的 ，顺序与 集合中表的显示顺序相同。

包含一个或多个结果集的 ，与源 中包含的 实例相对应。

为每个 返回带有一个结果集的 。

一个 DataTable 数组，它提供要在 中返回的结果集的顺序。 包含一个或多个结果集的 ，与源 中包含的 实例相对应。 返回的结果集按 参数所指定的顺序排列。

获取或设置当前 的名称。

的名称。

获取 所包含的数据的自定义视图，以允许使用自定义的 进行筛选、搜索和导航。

对象。

确定 的 。

，在远程处理方案中进行反序列化期间将使用它调用 的受保护构造函数 。 ，在远程处理方案中进行反序列化期间将使用它调用 的受保护构造函数 。 一个 枚举，指示是否已从负载中忽略架构信息。

确定 的 。

在对 进行反序列化期间传递的 实例。 一个 枚举，指示是否已从负载中忽略架构信息。

结束在窗体上使用或由另一个组件使用的 的初始化。 初始化发生在运行时。

获取或设置一个值，该值指示在尝试执行任何更新操作时是否遵循约束规则。

如果强制执行规则;否则为。 默认值为 。 无法实施一个或多个约束。

获取与 相关的自定义用户信息的集合。

包含所有自定义用户信息的 。

获取 的副本，该副本包含自加载以来或自上次调用 以来对该数据集进行的所有更改。

此 中更改的副本，可以对该副本执行操作，然后可以使用 将其合并回去。 如果未找到更改的行，则该方法将返回 。

获取由 筛选的 的副本，该副本包含上次加载以来或调用 以来进行的所有更改。

值之一。 此 的筛选副本，可以对该副本执行操作，然后使用 将其合并回数据集。 如果未找到所需 的行，则该方法返回 。

获取数据集的 的副本。

指定的架构集。 的副本。

使用序列化 时所需的数据填充序列化信息对象。

一个 ，它保存与 关联的序列化数据。 一个 ，它包含与 关联的序列化流的源和目标。 参数为 。

返回一个可序列化的 实例。

实例。

从二进制或 XML 流反序列化表数据。

实例。 流上下文。

返回存储在 中的数据的 XML 表示形式。

表示存储在 中的数据的字符串。

返回存储在 中的数据的 XML 表示形式的 XML 架构。

字符串，它是存储在 中的数据的 XML 表示形式的 XML 架构。

获取一个值，该值指示 是否有更改，包括新增行、已删除的行或已修改的行。

如果 有更改，则返回 ；否则，返回 。

获取一个值，该值指示 是否有 被筛选的更改，包括新增行、已删除的行或已修改的行。

值之一。 如果 有更改，则返回 ；否则，返回 。

获取一个值，指示在此 中的任何 对象中是否存在错误。

如果任何表包含错误;否则为。

将指定 中的 XML 架构应用于 。

将从其中读取该架构的 。 要从架构推理中排除的命名空间统一资源标识符 (URI) 字符串的数组。

将指定 中的 XML 架构应用于 。

将从其中读取该架构的 。 要从架构推理中排除的命名空间统一资源标识符 (URI) 字符串的数组。

将指定文件中的 XML 架构应用于 。

从中读取架构的文件的名称（包括路径）。 要从架构推理中排除的命名空间统一资源标识符 (URI) 字符串的数组。 未设置为 。

将指定 中的 XML 架构应用于 。

将从其中读取该架构的 。 要从架构推理中排除的命名空间统一资源标识符 (URI) 字符串的数组。

初始化 后发生。

从二进制或 XML 流反序列化数据集的所有表数据。

检查 的序列化表示形式的格式。

对象。 对象。 如果指定的 表示以二进制格式序列化的 ，则为 ；否则为 。

获取一个值，该值指示是否已初始化 。

如果为 ，说明组件已完成初始化；否则为 。

使用提供的 以数据源的值填充 ，同时使用 实例的数组提供架构和命名空间信息。

提供一个或多个结果集的 。 一个来自 枚举的值，该值指示 中的 实例内已有的行如何与共享同一主键的传入行进行组合。 实例的数组， 方法从该数组中检索名称和命名空间信息。 其中每个表都必须是此 所包含的 的成员。

使用提供的 以数据源的值填充 ，同时使用 实例的数组提供架构和命名空间信息。

提供一个或多个结果集的 。 一个来自 枚举的值，该值指示 中的 实例内已有的行如何与共享同一主键的传入行进行组合。 加载数据时出现错误的情况下要调用的 委托。 实例的数组， 方法从该数组中检索名称和命名空间信息。

使用所提供的 ，并使用字符串数组为 中的表提供名称，从而用来自数据源的值填充 。

提供一个或多个结果集的 。 一个来自 枚举的值，该值指示 中的 实例内已有的行如何与共享同一主键的传入行进行组合。 字符串数组， 方法将从该数组中检索表名称信息。

获取或设置用于比较表中字符串的区域设置信息。

一个 ，它包含有关用户计算机区域设置的数据。 默认值为 。

将 对象数组合并到当前的 中。

要合并到 中的 对象数组。

将 对象数组合并到当前的 中，在此过程中，将根据给定的参数保留或放弃在 中进行的更改并处理不兼容的架构。

要合并到 中的 对象数组。 要保留 中的更改，则返回 ；否则，返回 。 值之一。

将指定的 及其架构合并到当前 中。

其数据和架构将被合并的 。 无法启用一个或多个约束。 为 。

将指定的 及其架构合并到当前 中，在此过程中，将根据给定的参数保留或放弃在此 中进行的任何更改。

其数据和架构将被合并的 。 要保留当前 中的更改，则返回 ；否则，返回 。

将指定的 及其架构与当前的 合并，在此过程中，将根据给定的参数保留或放弃在当前 中的更改并处理不兼容的架构。

其数据和架构将被合并的 。 要保留当前 中的更改，则返回 ；否则，返回 。 值之一。 为 。

将指定的 及其架构合并到当前 中。

其数据和架构将被合并的 。 为 。

将指定的 及其架构合并到当前的 中，在此过程中，将根据给定的参数保留或放弃在 中进行的更改并处理不兼容的架构。

其数据和架构将被合并的 。 值之一。 要保留 中的更改，则返回 ；否则，返回 。 为 。

当目标和源 的主键值相同且 设置为真时发生。

获取或设置 的命名空间。

的命名空间。 该命名空间已有数据。

引发 事件。

包含事件数据的 。

当从 中移除 对象时发生。

正在移除的 。

当从 中移除 时发生。

正在移除的 。

获取或设置一个 XML 前缀，该前缀是 的命名空间的别名。

命名空间的 XML 前缀。

发送指定的 属性将要更改的通知。

将要更改的属性的名称。

使用指定的 将 XML 架构和数据读入 。

从 派生的对象。 用于读取数据的 。

使用指定的 和 将 XML 架构和数据读入 。

从中读取的 。 值之一。 用于读取数据的 。

使用指定的 将 XML 架构和数据读入 。

从中读取架构和数据的 。 用于读取数据的 。

使用指定的 和 将 XML 架构和数据读入 。

从中读取的 。 值之一。 用于读取数据的 。

使用指定的文件将 XML 架构和数据读入 。

作为读取源的文件名（包括路径）。 用于读取数据的 。 未设置为 。

使用指定的文件和 将 XML 架构和数据读入 。

作为读取源的文件名（包括路径）。 值之一。 用于读取数据的 。 未设置为 。

使用指定的 将 XML 架构和数据读入 。

从中读取的 。 用于读取数据的 。

使用指定的 和 将 XML 架构和数据读入 。

从中读取的 。 值之一。 用于读取数据的 。

从指定的 中将 XML 架构读入 。

从中读取的 。

从指定的 中将 XML 架构读入 。

从中读取的 。

从指定的文件中将 XML 架构读入 。

从中读取的文件的名称（包括路径）。 未设置为 。

从指定的 中将 XML 架构读入 。

从中读取的 。

忽略特性并返回一个空的数据集。

指定的 XML 读取器。

回滚自创建 以来或上次调用 以来对其进行的所有更改。

获取用于将表链接起来并允许从父表浏览到子表的关系的集合。

一个包含 对象集合的 。 如果 对象不存在，将返回空集合。

为远程处理期间使用的 获取或设置 。

一个 对象。

清除所有表并从 中删除所有关系、外部约束和表。 子类应重写 ，以便将 还原到其原始状态。

获取或设置 的 。

的 。

获取一个值，该值指示是否应该保持 属性。

如果已将属性值更改为其默认值之外的值，则为 ；否则为 。

获取一个值，该值指示是否应该保持 属性。

如果已将属性值更改为其默认值之外的值，则为 ；否则为 。

获取或设置 的 。

的一个 。

有关此成员的说明，请参阅 。

有关此成员的说明，请参阅 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参阅 。

有关此成员的说明，请参阅 。

有关此成员的说明，请参见 。

。

有关此成员的说明，请参见 。

。

获取包含在 中的表的集合。

此 包含的 。 如果 对象不存在，将返回空集合。

使用指定的 为 写当前数据。

用于写入文件的 对象。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

用于写入文件的 对象。 值之一。

使用指定的 为 写当前数据。

要进行写入的 对象。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

对象用于写文档。 值之一。

将 的当前数据写入指定的文件。

要向其写入的文件的名称（包括路径）。 未设置为 。

使用指定的 将 的当前数据和架构（可选）写入指定的文件。 若要写入架构，请将 参数的值设置为 。

要向其写入的文件的名称（包括路径）。 值之一。 未设置为 。

将 的当前数据写入指定的 。

用于写入的 。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

用于写入的 。 值之一。

将 结构作为 XML 架构写入指定的 对象。

用于写入文件的 对象。

将 结构作为 XML 架构写入指定的 对象。

要写入到的 对象。 用于将 转换为字符串的委托。

将 结构作为 XML 架构写入指定的 对象。

要进行写入的 对象。

将 结构作为一个 XML 架构写入指定的 。

要写入到的 对象。 用于将 转换为字符串的委托。

将 XML 架构形式的 结构写入文件。

要向其写入的文件的名称（包括路径）。 未设置为 。

将 XML 架构形式的 结构写入文件。

要写入的文件的名称。 用于将 转换为字符串的委托。

将 XML 架构形式的 结构写入 对象。

要向其中进行写入的 。

将 结构作为一个 XML 架构写入指定的 。

要写入到的 对象。 用于将 转换为字符串的委托。

介绍 中 列的序列化格式。

始终存储为 Local 格式。 如果将 或 分配给此模式的列，则首先要将其转换为 Local 格式。 通常以 Local 格式在此模式中执行序列化。 在序列化期间将产生偏移量。

始终存储为 Unspecified 格式。 如果将 或 分配给此模式的列，则首先要将其转换为 格式。 在此模式中的序列化不会产生偏移量。

存储为 Unspecified 格式。 如果将 或 分配给此模式的列，则首先要将其转换为 格式。 在此模式中的序列化将产生偏移量。 此为默认行为，可向后兼容。 应将此选项在存储区中视为 Unspecified 格式，而在序列化期间应用类似于 的偏移量。

存储为协调通用时间 (UTC) 格式。 如果将 或 分配给此模式的列，则首先要将其转换为 格式。 通常以 格式在此模式中执行序列化。 序列化时不会产生偏移量。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

用说明来标记属性、事件或扩展程序。 可视化设计器在引用成员时可显示该说明。

使用指定的说明字符串初始化 类的新实例。

说明字符串。

获取说明的文本。

说明字符串。

表示内存中数据的一个表。

在不使用参数的情况下初始化 类的新实例。

使用 和 初始化 类的新实例。

序列化或反序列化对象所需的数据。 给定序列化流的源和目标。

使用指定的表名初始化 类的新实例。

要向表提供的名称。 如果 为 或是空字符串，则在添加到 中时指定默认名称。

使用指定的表名和命名空间初始化 类的新实例。

要向表提供的名称。 如果 为 或是空字符串，则在添加到 中时指定默认名称。 中所存储数据的 XML 表示形式的命名空间。

提交自上次调用 以来对该表进行的所有更改。

开始初始化在窗体上使用或由另一个组件使用的 。 初始化发生在运行时。

加载数据时，关闭通知、索引维护和约束。

指示表中的字符串比较是否区分大小写。

如果比较区分大小写，则为 ；否则为 。 默认值被设置为父级 对象的 属性；当 的创建独立于 时设置为 。

获取此 的子关系的集合。

一个 ，包含该表的子关系。 如果 对象不存在，将返回空集合。

清除所有数据的 。

克隆 的结构，包括所有 架构和约束。

新的 ，与当前 具有相同架构。

更改 中指定的 值之后发生。

更改 中指定的 值时发生。

获取属于该表的列的集合。

一个 ，包含该表的 对象的集合。 如果 对象不存在，将返回空集合。

计算用来传递筛选条件的当前行上的给定表达式。

要计算的表达式。 用于限制表达式中计算的行的筛选器。 将 设置为计算结果。 如果该表达式计算结果为 null，则返回值为 。

获取由该表维护的约束的集合。

一个 ，包含该表的 对象的集合。 如果 对象不存在，将返回空集合。

复制该 的结构和数据。

新的 ，具有与该 相同的结构（表架构和约束）和数据。 如果已派生这些类，则副本也是相同的派生类。 创建一个新 ，后者与原始 具有相同的结构和数据。 要将结构复制到新的 ，而不是复制到数据，请使用 。

返回与此 内的数据对应的 。

包含一个对应于源 实例的结果集。

创建 的新实例。

新表达式。

获取此表所属的 。

此表所属的 。

获取可能包含筛选视图或游标位置的表的自定义视图。

与 关联的 。

获取或设置一个表达式，该表达式返回的值用于在用户界面中表示此表。 属性用于在用户界面中显示此表名。

显示字符串。

结束在窗体上使用或由另一个组件使用的 的初始化。 初始化发生在运行时。

加载数据后，打开通知、索引维护和约束。

获取自定义用户信息的集合。

包含自定义用户信息的 。

检查是否正在进行初始化。 初始化发生在运行时。

获取 的副本，该副本包含自加载以来或自上次调用 以来进行的所有更改。

此 中的更改的副本，如果未发现更改，则为 。

获取由 筛选的 的副本，该副本包含上次加载以来或调用 以来进行的所有更改。

值之一。 的筛选副本，可以对该副本执行操作，之后可以使用 将其合并回 。 如果未找到所需 的行，则该方法返回 。

该方法返回一个包含 Web Services 描述语言 (WSDL) 的 实例，该语言描述了用于 Web 服务的 。

一个 实例。 实例。

获取包含错误的 对象数组。

包含错误的 对象数组。

使用序列化 时所需的数据填充序列化信息对象。

一个 对象，包含与 关联的序列化数据。 一个 对象，包含与 关联的序列化流的源和目标。 参数为 null 引用（在 Visual Basic 中为 ）。

获取行类型。

的类型。

有关此成员的说明，请参见 。

一个 ，描述由 方法生成并由 方法使用的对象的 XML 表示形式。

获取一个值，该值指示该表所属的 的任何表的任何行中是否有错误。

如果有错误，则为 ；否则为 。

将 复制到 中，保留任何属性设置以及初始值和当前值。

要导入的 。

初始化 后发生。

获取一个值，该值指示是否已初始化 。

表明组件已完成初始化；否则为 。

通过所提供的 ，用某个数据源的值填充 。 如果 已经包含行，则从数据源传入的数据与现有行合并。

提供结果集的 。

通过所提供的 ，用某个数据源的值填充 。 如果 已包含行，则从数据源传入的数据根据 参数的值与现有行合并。

提供一个或多个结果集的 。 枚举的值，指示 中已有的行如何与共享相同主键的传入行合并。

通过所提供的使用错误处理委托的 ，用某个数据源中的值填充 。

提供结果集的 。 枚举的值，指示 中已有的行如何与共享相同主键的传入行合并。 加载数据时出现错误的情况下要调用的 委托。

查找和更新特定行。 如果找不到任何匹配行，则使用给定值创建新行。

用于创建新行的值数组。 如果接受更改，则为 ；否则为 。 新的 。 该数组大于表中的列数。 值与其各自的列类型不匹配。 添加行会使约束无效。 尝试将 null 值放到 为 false 的列中。

查找和更新特定行。 如果找不到任何匹配行，则使用给定值创建新行。

用于创建新行的值数组。 用于确定数组值如何应用于现有行中的对应值。 新的 。

获取或设置用于比较表中字符串的区域设置信息。

一个 ，它包含有关用户计算机区域设置的数据。 默认为 所属的 对象的 （由 属性返回）；如果该表不属于 ，则默认为当前系统的 。

将指定的 与当前 合并。

要与当前 合并的 。

将指定的 与当前 合并，指示是否保留当前 中的更改。

要与当前 合并的 。 如果保留当前 中的更改，则为 ；否则为 。

将指定的 与当前 合并，指示是否保留更改以及如何处理当前 中缺失的架构。

要与当前 合并的 。 如果保留当前 中的更改，则为 ；否则为 。 值之一。

获取或设置该表最初的起始大小。

该表中行的最初起始大小。 默认值为 50。

获取或设置 中所存储数据的 XML 表示形式的命名空间。

的命名空间。

创建与该表具有相同架构的新 。

与 具有相同架构的 。

返回 的数组。

描述数组大小的 值。 新数组。

从现有行创建新行。

一个 对象。 派生类。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

通知 正在移除 。

正在移除的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

引发 事件。

包含事件数据的 。

获取该 的父关系的集合。

一个 ，包含该表的父关系。 如果 对象不存在，将返回空集合。

获取或设置 中所存储数据的 XML 表示形式的命名空间。

的前缀。

获取或设置用作数据表主键的列数组。

一个 对象数组。 该键是外键。

使用指定的 将 XML 架构和数据读入 。

从 派生的对象 用于读取数据的 。

使用指定的 将 XML 架构和数据读入 。

将用于读取数据的 。 用于读取数据的 。

从指定的文件将 XML 架构和数据读入 。

从中读取数据的文件的名称。 用于读取数据的 。

使用指定的 将 XML 架构和数据读入 。

将用于读取数据的 。 用于读取数据的 。

使用指定的流将 XML 架构读入 。

用于读取架构的流。

使用指定的 将 XML 架构读入 。

用于读取架构信息的 。

从指定的文件将 XML 架构读入 。

从中读取架构信息的文件的名称。

使用指定的 将 XML 架构读入 。

用于读取架构信息的 。

从 XML 流中读取。

一个 对象。

回滚自该表加载以来或上次调用 以来对该表进行的所有更改。

获取或设置序列化格式。

指定 或 序列化的 枚举。

将 重置为其初始状态。 重置将移除表的所有数据、索引、关系和列。 如果数据集包含一个数据表，则在重置该表之后，它将仍是数据集的一部分。

在成功更改 后发生。

在更改 时发生。

删除表中的行后发生。

要删除表中的行之前发生。

获取属于该表的行的集合。

包含 对象的 ；否则为 null 值（如果不存在任何 对象）。

获取由所有 对象组成的数组。

一个 对象数组。

获取由与筛选条件匹配的所有 对象组成的数组。

用于筛选行的条件。 有关如何筛选行的示例，请参阅 DataView RowFilter 语法 [C#]。 一个 对象数组。

以指定排序顺序，获取由与筛选条件匹配的所有 对象组成的数组。

用于筛选行的条件。 有关如何筛选行的示例，请参阅 DataView RowFilter 语法 [C#]。 指定列和排序方向的字符串。 由与筛选条件匹配的 对象组成的数组。

以与指定状态匹配的排序顺序，获取由与筛选条件匹配的所有 对象组成的数组。

用于筛选行的条件。 有关如何筛选行的示例，请参阅 DataView RowFilter 语法 [C#]。 指定列和排序方向的字符串。 值之一。 一个 对象数组。

获取或设置 的 。

的一个 。

有关此成员的说明，请参见 。

如果集合是 对象集合，则为 ；否则，为 。

有关此成员的说明，请参见 。

对象中可以绑定到数据源的 。

有关此成员的说明，请参见 。

一个 ，描述由 方法生成并由 方法使用的对象的 XML 表示形式。

有关此成员的说明，请参见 。

XmlReader。

有关此成员的说明，请参见 。

XmlWriter。

清除 后发生。

清除 时发生。

获取或设置 的名称。

的名称。 传入 或空字符串 ("")，此表属于一个集合。 该表属于一个集合，该集合已包含同名的表。 （比较区分大小写）。

插入新的 时发生。

获取 和 （如果有一个用作连接字符串）。

一个由 和 值字符串。

通过指定的 ，按 XML 形式编写 的当前内容。

要向其写入数据的流。

通过指定的 ，按 XML 形式编写 的当前内容。 若要保存该表及其所有子代的数据，请将 参数设置为 。

要向其写入数据的流。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

使用指定的 将 的当前数据和架构（可选）写入指定的文件。 若要写入架构，请将 参数的值设置为 。

要向其写入数据的流。 值之一。

使用指定的 将 的当前数据和架构（可选）写入指定的文件。 若要写入架构，请将 参数的值设置为 。 若要保存该表及其所有子代的数据，请将 参数设置为 。

要向其写入数据的流。 值之一。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

通过指定的 ，按 XML 形式编写 的当前内容。

用于写入内容的 。

通过指定的 ，按 XML 形式编写 的当前内容。 若要保存该表及其所有子代的数据，请将 参数设置为 。

用于写入内容的 。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

用于写入文档的 。 值之一。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。 若要保存该表及其所有子代的数据，请将 参数设置为 。

用于写入文档的 。 值之一。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

使用指定的文件以 XML 形式写入 的当前内容。

要向其写入 XML 数据的文件。

使用指定的文件以 XML 形式写入 的当前内容。 若要保存该表及其所有子代的数据，请将 参数设置为 。

要向其写入 XML 数据的文件。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

使用指定的文件和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

将向其写入数据的文件名称。 值之一。

使用指定的文件和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。 若要保存该表及其所有子代的数据，请将 参数设置为 。

将向其写入数据的文件名称。 值之一。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

通过指定的 ，按 XML 形式编写 的当前内容。

用于写入内容的 。

通过指定的 ，按 XML 形式编写 的当前内容。

用于写入内容的 。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。

用于写入文档的 。 值之一。

使用指定的 和 写入 的当前数据和架构（可选）。 若要写入架构，请将 参数的值设置为 。 若要保存该表及其所有子代的数据，请将 参数设置为 。

用于写入文档的 。 值之一。 如果为 ，则写入当前表及其所有子代的内容。 如果为 （默认值），则只写入当前表的数据。

以 XML 架构的形式将 的当前数据结构写入指定的流。

要向其写入 XML 架构的流。

以 XML 架构的形式将 的当前数据结构写入指定的流。 若要保存该表及其所有子代的架构，请将 参数设置为 。

要向其写入 XML 架构的流。 如果为 ，则写入当前表及其所有子代的架构。 如果为 （默认值），则只写入当前表的架构。

使用指定的 以 XML 架构的形式写入 的当前数据结构。

用于写入的 。

使用指定的 以 XML 架构的形式写入 的当前数据结构。 若要保存该表及其所有子代的架构，请将 参数设置为 。

用于写入的 。 如果为 ，则写入当前表及其所有子代的架构。 如果为 （默认值），则只写入当前表的架构。

以 XML 架构的形式将 的当前数据结构写入指定的文件。

要使用的文件的名称。

以 XML 架构的形式将 的当前数据结构写入指定的文件。 若要保存该表及其所有子代的架构，请将 参数设置为 。

要使用的文件的名称。 如果为 ，则写入当前表及其所有子代的架构。 如果为 （默认值），则只写入当前表的架构。

使用指定的 以 XML 架构的形式写入 的当前数据结构。

要使用的 。

使用指定的 以 XML 架构的形式写入 的当前数据结构。 若要保存该表及其所有子代的架构，请将 参数设置为 。

用于写入文档的 。 如果为 ，则写入当前表及其所有子代的架构。 如果为 （默认值），则只写入当前表的架构。

为 方法提供数据。

初始化 类的新实例。

，它的行正在被清除。

获取正在清除其中的行的表。

，它的行正在被清除。

获取正在清除其中的行的表的名称。

一个 ，指示表的名称。

获取其中的行正在被清除的表的命名空间。

一个 ，指示命名空间名称。

表示处理 方法的方法。

事件源。 包含事件数据的 。

表示 的表的集合。

使用默认名称创建一个新的 对象，并将其添加到集合中。

新创建的 。

将指定的 添加到集合。

要添加的 对象。 为该表指定的值为 。 该表已经属于此集合，或者属于另一个集合。 集合中的某个表具有相同的名称。 该比较不区分大小写。

使用指定名称创建一个 对象，并将其添加到集合中。

要赋予已创建的 的名称。 新创建的 。 集合中的某个表具有相同的名称。 （该比较不区分大小写。）

使用指定名称创建一个 对象，并将其添加到集合中。

要赋予已创建的 的名称。 要为已创建的 提供的命名空间。 新创建的 。 集合中的某个表具有相同的名称。 （该比较不区分大小写。）

将指定的 数组的元素复制到集合末尾。

要添加到集合中的 对象的数组。

验证是否可以将指定的 对象从集合中移除。

集合中要对其执行检查的 。 如果该表可被移除，则为 ；否则为 。

清除所有 对象的集合。

由于添加或移除 对象而更改 之后发生。

由于添加或移除 对象而更改 时发生。

获取一个值，该值指示集合中是否存在具有指定名称的 对象。

要查找的 的名称。 如果存在指定的表，则为 ；否则为 。

获取一个值，该值指示集合中是否存在具有指定名称和表命名空间的 对象。

要查找的 的名称。 作为查找范围的 命名空间的名称。 如果存在指定的表，则为 ；否则为 。

将当前 的所有元素复制到一维 ，从指定目标数组索引处开始。

要将当前 对象的元素复制到其中的一维 。 从其所在位置开始复制对象的目标 索引。

获取指定 对象的索引。

要搜索的 。 表从零开始的索引，如果在集合中未找到该表，则为 -1。

获取具有指定名称的 对象的集合中的索引。

要查找的 对象的名称。 具有指定名称的 的从零开始的索引；或者如果集合中不存在该表，则为 –1。 当两个或两个以上的表同名，但是命名空间不同时，返回 -1。 如果在将表名只匹配到一个表时存在任何二义性，则该调用不会成功。

获取指定 对象的集合中的索引。

要查找的 对象的名称。 作为查找范围的 命名空间的名称。 具有指定名称的 的从零开始的索引；或者如果集合中不存在该表，则为 –1。

获取位于指定索引位置的 对象。

要查找的 的从零开始的索引。 一个具有指定的索引; 否则为如果不存在。 索引值大于集合中的项目数。

获取具有指定名称的 对象。

要查找的 的名称。 具有指定名称的 ；否则，如果 不存在，则为 。

获取指定命名空间中具有指定名称的 对象。

要查找的 的名称。 作为查找范围的 命名空间的名称。 具有指定名称的 ；否则，如果 不存在，则为 。

从集合中移除指定的 对象。

要移除的 。 为该表指定的值为 。 该表不属于此集合。 或 该表是关系的一部分。

从集合中删除具有指定名称的 对象。

要删除的 对象的名称。 该集合不包含具有指定名称的表。

从集合中删除具有指定名称的 对象。

要删除的 对象的名称。 作为查找范围的 命名空间的名称。 该集合不包含具有指定名称的表。

从集合中移除位于指定索引位置的 对象。

要移除的 的索引。 该集合在指定的索引位置没有表。

为 方法提供数据。

初始化 的新实例。

正被添加的 。

获取正被添加的行。

正被添加的 。

表示处理 方法的方法。

事件源。 包含事件数据的 。

以一个或多个只读、只进结果集的形式获取一个或多个 对象的内容。

通过使用提供的 中的数据初始化 类的新实例。

新的 从中获取其结果集的 。

使用提供的 对象的数组初始化 类的新实例。

用于为新的 对象提供结果的 对象数组。

关闭当前的 。

的当前行的嵌套深度。

当前行的嵌套深度；始终为零。

返回当前行中的列数。

如果未定位在有效的结果集中，则为 0；否则为当前行中的列数。 尝试在关闭的 中检索字段计数。

获取指定列的 形式的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含 。

以字节的形式获取指定列的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含字节。

将从指定列偏移量开始的字节流作为从指定缓冲区偏移量开始的数组读入缓冲区中。

从零开始的列序号。 字段中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 缓冲区中的索引，从该索引处开始放置数据。 复制到缓冲区中的最大长度。 读取的实际字节数。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含字节数组。

获取指定列的字符形式的值。

从零开始的列序号。 列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的字段不包含字符。

以字符数组的形式返回指定列的值。

从零开始的列序号。 字段中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 缓冲区中的索引，从该索引处开始放置数据。 复制到缓冲区中的最大长度。 读取的实际字符数。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含字符数组。

获取一个表示指定列的数据类型的字符串。

从零开始的列序号。 一个表示列的数据类型的字符串。 传递的索引超出了 0 到 -1 的范围。 尝试读取或访问已关闭的 中的列。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含 DateTime 值。

获取指定列的 形式的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含 值。

获取双精度浮点数形式的列值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含双精度浮点数。

返回一个可用于循环访问项集合的枚举数。

一个 对象，它代表项集合。 尝试读取或访问已关闭的 中的列。

获取作为对象的数据类型的 。

从零开始的列序号。 作为对象的数据类型的 。 传递的索引超出了 0 到 -1 的范围。 尝试读取或访问已关闭 中的列。

以单精度浮点数字的形式获取指定列的值。

从零开始的列序号。 列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含单精度浮点数。

以全局唯一标识符 (GUID) 的形式获取指定列的值。

从零开始的列序号。 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含 GUID。

获取指定列的 16 位带符号整数形式的值。

从零开始的列序号 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含 16 位带符号整数。

获取指定列的 32 位带符号整数形式的值。

从零开始的列序号 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭 中的列。 指定的列不包含 32 位带符号整数值。

以 64 位有符号整数的形式获取指定列的值。

从零开始的列序号 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭 中的列。 指定的列不包含 64 位带符号整数值。

获取指定列的 形式的值。

从零开始的列序号 指定列的名称。 传递的索引超出了 0 到 -1 的范围。 尝试读取或访问已关闭的 中的列。

在给定列名时获取相应的列序号。

列的名称。 从零开始的列序号。 尝试读取或访问已关闭的 中的列。 指定的名称不是有效的列名。

获取指定列特定于提供程序的格式的类型。

从零开始的列序号。 作为对象的数据类型的 。 传递的索引超出了 0 到 -1 的范围。 尝试读取或访问已关闭的 中的列。

获取指定列特定于提供程序的格式的值。

值被检索的列的从零开始的编号。 指定列特定于提供程序的格式的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭 中的列

使用 中所有列的特定于提供程序的类型信息填充提供的数组。

要使用 中列的类型信息填充的对象数组。 复制到数组中的列值个数。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

获取指定列的字符串形式的值。

从零开始的列序号 指定列的值。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。 指定的列不包含字符串。

获取指定列以本机格式表示的值。

从零开始的列序号 指定列的值。 此方法为 null 列返回 。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问关闭的 中的列。

使用当前行的列值来填充对象数组。

要将 中的列值复制到其中的 数组。 复制到数组中的列值个数。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭 中的列。

获取一个值，该值指示 是否包含一行还是多行。

如果 包含一行或多行，则为 ；否则为 。 尝试检索有关已关闭的 的信息。

获取一个值，该值指示 是否已关闭。

如果 已关闭，则为 ；否则为 。

获取一个值，该值指示列中是否包含不存在的或缺少的值。

从零开始的列序号 如果指定的列值与 等效，则为 ；否则为 。 传递的索引超出了 0 到 -1 的范围。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭 中的列。

在给定列序号的情况下，获取指定列的以本机格式表示的值。

从零开始的列序号。 指定列的以本机格式表示的值。 传递的索引超出了 0 到 -1 的范围。

在给定列名称的情况下，获取指定列的以本机格式表示的值。

列的名称。 指定列的以本机格式表示的值。 指定的名称不是有效的列名。 尝试从已删除的行中检索数据。 尝试读取或访问已关闭的 中的列。

使 前进到下一个结果集（如果有）。

如果有另一个结果集，则为 ；否则为 。 尝试在已关闭的 中进行导航。

让 前进到下一条记录。

如果有另一行要读取，则为 ；否则为 。 尝试读取或访问已关闭 中的列。

通过执行 SQL 语句获取插入、更改或删除的行数。

不支持此属性，并且始终返回 0。

代表 的可绑定数据的自定义视图，它用于排序、筛选、搜索、编辑和导航。 不存储数据，而改为表示对应的 的连接视图。 更改 的数据会影响 。 更改 的数据将影响与之关联的所有 。

初始化 类的新实例。

使用指定的 初始化 类的新实例。

要添加到 中的 。

使用指定的 、、 和 初始化 类的新实例。

要添加到 中的 。 要应用于 的 。 要应用于 的 。 要应用于 的 。

在 中添加新行。

一个新 对象。

设置或获取一个值，该值指示是否允许删除。

如果允许删除，则为 ；否则为 。

获取或设置一个值，该值指示是否允许编辑。

如果允许编辑，则为 ；否则为 。

获取或设置一个值，该值指示是否可以通过使用 方法添加新行。

如果可以添加新行，则为 ；否则为 。

获取或设置一个值，该值指示是否使用默认排序。 默认排序是通过 指定的所有主键进行排序（升序）。

如果使用默认排序，则为 ；否则为 。

开始初始化在窗体上使用或由另一个组件使用的 。 此初始化在运行时发生。

关闭 。

在成功更改 后发生。

事件源。 包含事件数据的 。

将项复制到数组中。 仅适用于 Web 窗体界面。

要复制到的数组。 从其开始的索引。

在应用 和 之后，获取 中的记录数。

中的记录数。

获取与此视图关联的 。

创建了此视图的 。 如果这是 的默认 ，那么 属性将返回 的默认 。 否则，如果在没有 的情况下创建了 ，那么此属性为 。

删除指定索引处的行。

要删除行的索引。

释放由 对象使用的资源（内存除外）。

若要释放托管资源和非托管资源，则为 ；若仅释放非托管资源，则为 。

结束在窗体上使用或由另一个组件使用的 的初始化。 此初始化在运行时发生。

确定指定的 实例是否可视为相等的实例。

要比较的 。 如果这两个 实例相等，则为 ；否则为 。

根据指定的排序键值在 中查找行。

要搜索的对象。 包含指定排序关键字值的 中的行的索引；否则为 -1（如果不存在排序关键字值）。

根据指定的排序键值在 中查找行。

类型为 的值的数组。 中与指定的排序键值匹配的第一个行的位置索引；如果没有匹配的排序键值，则为 -1。

返回其列与指定的排序键值匹配的 对象数组。

要搜索的列值，为 类型。 对象数组，其列与指定的排序键值匹配；或者，如果任何行都不包含指定的排序键值，则为空的 数组。

返回其列与指定的排序键值匹配的 对象数组。

要搜索的列值数组，其类型为 。 对象数组，其列与指定的排序键值匹配；或者，如果任何行都不包含指定的排序键值，则为空的 数组。

获取此 的枚举器。

用于浏览列表的 。

在成功更改 后发生。

事件源。 包含事件数据的 。

的初始化完成时发生。

获取一个值，该值指示组件是否已初始化。

如果为 ，说明组件已完成初始化；否则为 。

获取一个值，该值指示数据源当前是否打开并投影 上的数据视图。

如果源打开，则为 ；否则为 。

从指定的表中获取数据行。

中的记录的索引。 所需的行的 。

更改由 管理的列表时发生。

引发 事件。

包含事件数据的 。

打开 。

保留以仅供内部使用。

获取或设置用于筛选在 中查看哪些行的表达式。

用于指定行的筛选方式的字符串。

获取或设置用于 中的行状态筛选器。

值之一。

获取或设置 的一个或多个排序列和排序顺序。

一个字符串，该字符串包含后跟“ASC”（升序）或"DESC"（降序）的列名。 默认情况下，列按升序排序。 可以用逗号分隔多个列。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。 有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。 有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。 有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。 要插入的 值。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。 有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 值。

有关此成员的说明，请参见 。

一个 值。

有关此成员的说明，请参见 。

一个 对象。

有关此成员的说明，请参见 。

添加到列表的项。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 对象。 一个 对象。

有关此成员的说明，请参见 。

一个 对象。 一个 值。 有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 对象。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

一个 对象。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

要在组合中查找的可绑定的 对象的数组。 它可以是 。

有关此成员的说明，请参见 。

一个 对象数组。 有关此成员的说明，请参见 。

获取或设置源 。

为此视图提供数据的 。

基于现有的 中的行，创建并返回一个新的 。

一个新 实例，其中包含请求的行和列。

基于现有的 中的行，创建并返回一个新的 。

如果为 ，则返回的 包含具有与其所有列不同的值的行。 默认值为 。 一个字符串数组，其中的一个列名称列表将包括在返回的 中。 包含指定的列，这些列按其在该数组中显示的顺序排列。 一个新 实例，其中包含请求的行和列。

基于现有的 中的行，创建并返回一个新的 。

返回的 的名称。 一个新 实例，其中包含请求的行和列。

基于现有的 中的行，创建并返回一个新的 。

返回的 的名称。 如果为 ，则返回的 包含具有与其所有列不同的值的行。 默认值为 。 一个字符串数组，其中的一个列名称列表将包括在返回的 中。 包含指定的列，这些列按其在该数组中显示的顺序排列。 一个新 实例，其中包含请求的行和列。

保留以仅供内部使用。

保留以仅供内部使用。

保留以仅供内部使用。

在 中包含每个 的默认 。

初始化 类的新实例。

为指定的 初始化 类的新实例。

要使用的 的名称。

为指定的 创建 。

要在 中使用的 的名称。 一个 对象。

获取或设置要与 一起使用的 。

要使用的 。

获取或设置用于代码持久性的值。

一个用于代码持久性的值。

获取 中每个 的 。

每个 的 。

在将行添加到 或从中删除行之后发生。

引发 事件。

包含事件数据的 。

在 中添加或移除 时引发 事件。

事件源。 包含事件数据的 。

从特定的 索引处开始，将 的元素复制到一个 中。

一维 ，它是从 复制的元素的目标。 必须具有从零开始的索引。 中从零开始的索引，从此处开始复制。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

有关此成员的说明，请参见 。

可用于同步对 的访问的对象。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

将某项添加到 中。

要添加到 的 。 新元素的插入位置。

有关此成员的说明，请参见 。

确定 是否包含特定值。

要在 中定位的 。 如果在 中找到了 ，则为 ；否则为 。

确定 中特定项的索引。

要在 中定位的 。 如果在列表中找到，则为 的索引；否则为 -1。

在 中的指定索引处插入一个项。

应插入 的从零开始的索引。 要插入到 的 。

有关此成员的说明，请参见 。

如果 具有固定大小，则为 ；否则为 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

获取或设置指定索引处的元素。

要获取或设置的元素的从零开始的索引。 指定索引处的元素。

从 中移除特定对象的第一个匹配项。

要从 移除的 。

移除位于指定索引处的 项。

要移除的项的从零开始的索引。

将 添加到用于搜索的索引。

将 添加到用于搜索的索引。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

根据 和 对列表进行排序。

以其为根据进行排序的 。 值之一。

返回具有给定 的行的索引。

要对其进行搜索的 。 要搜索的属性参数的值。 具有给定 的行的索引。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

将 从用于搜索的索引中移除。

要从用于搜索的索引中移除的 。

使用 移除任何已应用的排序。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

有关此成员的说明，请参见 。

返回 ，其表示每一项上用于绑定数据的属性。

要在组合中查找的可绑定的 对象的数组。 它可以是 。 ，其表示每一项上用于绑定数据的属性。

返回列表名称。

为其返回列表名称的 对象的数组。 它可以是 。 列表名称。

在 中添加或移除 时引发 事件。

事件源。 包含事件数据的 。

描述 中的数据版本。

新行。

当前行包括未更改的行、新行和已修改的行。 默认情况下， 设置为 CurrentRows。

已删除的行。

已修改的原始数据的当前版本（请参阅 ）。

已修改数据的原始版本。 （尽管已修改此数据，它仍作为 可用）。

无。

原始行包括未更改的行和已删除的行。

未更改的行。

表示从 创建的 DataView 的 、、、、 和 的默认设置。

获取或设置一个值，该值指示是否使用默认排序。

如果使用默认排序方式，则为 ；否则为 。

获取包含此 的 。

对象。

获取或设置应用于 中的筛选器。 有关使用 RowFilter 的代码示例，请参见 。

包含要应用的筛选器的字符串。

获取或设置一个值，该值指示在 中是显示 Current、Deleted、Modified Current、ModifiedOriginal、New、Original、Unchanged 还是不显示任何行。

一个指示要显示哪些行的值。

获取或设置一个值，该值指示要应用于 中的排序。

要应用于 中的排序。

获取要应用 属性的 。

对象。

包含 中每个 的 对象的只读集合。

从指定的索引处开始，将集合对象复制到一维 实例中。

一维 ，它是从集合所复制值的目标位置。 插入开始处的数组索引。

从指定的索引处开始，将集合对象复制到一维 实例中。

一维 ，它是从集合所复制值的目标位置。 插入开始处的数组索引。

获取 中的 对象数。

集合中 对象的数目。

获取集合的 。

一个 对象。

获取一个值，该值指示 是否为只读。

始终返回以指示该集合是只读的。

获取一个值，该值指示是否同步对 的访问（线程安全）。

如果不被派生类重写，该属性总是为 。

获取集合中指定 的 对象。

要查找的 。 对象的集合。

获取 的 对象（由其索引指定）。

要查找的 的从零开始的索引。 对象的集合。

获取 的 （由其名称指定）。

要查找的 的名称。 对象的集合。

获取可用于同步对 的访问的对象。

可用于同步对 的访问的对象。

在插入、更新或删除操作过程中当受影响的行数等于零时由 引发的异常。

初始化 类的新实例。

初始化 类的新实例。

文本字符串，它描述有关异常的详细信息。

初始化 类的新实例。

文本字符串，它描述有关异常的详细信息。 对内部异常的引用。

初始化 类的新实例。

说明发生此异常的原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。 一个数组，其中包含因更新失败而导致生成此异常的 对象。

将因更新失败而导致生成此异常的 对象复制到指定的 对象数组。

要向其中复制 对象的一维的 对象数组。

将因更新失败而导致生成此异常的 对象复制到指定的 对象数组（从指定的目标数组索引开始）。

要向其中复制 对象的一维的 对象数组。 从其所在位置开始复制对象的目标数组索引。

使用序列化 所需的数据填充指定的序列化信息对象。

一个 ，它保存与 关联的序列化数据。 一个 ，它包含与 关联的序列化流的源和目标。 参数为 null 引用（在 Visual Basic 中为 ）。

获取或设置生成 的 的值。

的值。

获取更新失败（因而生成此异常）的行数。

一个整数，其中包含表示更新失败的行数的计数。

指定 .NET Framework 数据提供程序的字段、属性或 对象的数据类型。

非 Unicode 字符的可变长度流，范围在 1 到 8,000 个字符之间。

非 Unicode 字符的固定长度流。

二进制数据的可变长度流，范围在 1 到 8,000 个字节之间。

简单类型，表示 或 的布尔值。

一个 8 位无符号整数，范围在 0 到 255 之间。

货币值，范围在 2 63（即 -922,337,203,685,477.5808）到 2 63 -1（即 +922,337,203,685,477.5807）之间，精度为千分之十个货币单位。

表示日期值的类型。

表示一个日期和时间值的类型。

日期和时间数据。 日期值范围从公元 1 年 1 月 1 日到公元 9999 年 12 月 31 日。 时间值范围从 00:00:00 到 23:59:59.9999999，精度为 100 毫微秒。

显示时区的日期和时间数据。 日期值范围从公元 1 年 1 月 1 日到公元 9999 年 12 月 31 日。 时间值范围从 00:00:00 到 23:59:59.9999999，精度为 100 毫微秒。 时区值范围从 -14:00 到 +14:00。

简单类型，表示从 1.0 x 10 -28 到大约 7.9 x 10 28 且有效位数为 28 到 29 位的值。

浮点型，表示从大约 5.0 x 10 -324 到 1.7 x 10 308 且精度为 15 到 16 位的值。

全局唯一标识符（或 GUID）。

整型，表示值介于 -32768 到 32767 之间的有符号 16 位整数。

整型，表示值介于 -2147483648 到 2147483647 之间的 32 位有符号整数。

整型，表示值介于-9223372036854775808 和 9223372036854775807 之间的 64 位有符号整数。

常规类型，表示任何没有由其他 值显式表示的引用或值类型。

整型，表示值介于 -128 到 127 之间的 8 位有符号整数。

浮点型，表示从大约 1.5 x 10 -45 到 3.4 x 10 38 且精度为 7 位的值。

表示 Unicode 字符串的类型。

Unicode 字符的定长串。

一个表示 SQL Server 值的类型。 如果要使用 SQL Server 值，请使用 。

整型，表示值介于 0 到 65535 之间的 16 位无符号整数。

整型，表示值介于 0 到 4294967295 之间的 32 位无符号整数。

整型，表示值介于 0 到 18446744073709551615 之间的 64 位无符号整数。

变长数值。

XML 文档或片段的分析表示。

表示尝试在已删除的 上执行操作时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

表示在 — 相关对象添加操作的过程中，遇到重复的数据库对象名称时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的字符串和异常初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

表示无法计算 的 属性时引发的异常。

初始化 类的新实例。

使用 和 初始化 类的新实例。

序列化或反序列化对象所需的数据。 特定序列化流的源和目标。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

为 的 事件提供数据。

初始化 类的新实例。

正在更新的 。 正在更新的行的值。

获取或设置一个值，指示是否继续执行填充操作而不考虑该错误。

如果应该继续执行填充操作，则 ；否则为 。

获取发生错误时正在更新的 。

正在更新的 。

获取正在处理的错误。

正在处理的错误。

获取发生错误时正在更新的行的值。

正在更新的行的值。

表示用来处理 事件的方法。

事件源。 包含事件数据的 。

表示删除或更新某个值或行时，对主键/外键关系中一组列强制进行的操作限制。

使用指定的父级和子级 对象初始化 类的新实例。

约束中的父级 。 约束中的子级 。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

使用指定的父级和子级 对象的数组，初始化 类的新实例。

约束中的父级 的数组。 约束中的子级 的数组。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

使用指定的名称、父级和子级 对象初始化 类的新实例。

约束的名称。 约束中的父级 。 约束中的子级 。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

使用指定的名称、父级和子级 对象的数组初始化 类的新实例。

的名称。 当添加到约束集合中时，如果是 或空字符串，则给出默认名称。 约束中的父级 的数组。 约束中的子级 的数组。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

此构造函数在 Visual Studio 环境中提供设计时支持。 因此，使用此构造函数创建的 对象必须通过 添加到集合中。 当调用该方法时，必须存在具有指定名称的表和列，或者如果在调用该构造函数之前已经调用了 ，则在调用 时，必须存在具有指定名称的表和列。

约束的名称。 在约束中包含父级 对象的父级 的名称。 的名称。 约束中父级 对象名称的数组。 约束中子级 对象名称的数组。 值之一。 可能的值包括 、 和 。 当删除某行时要使用 值之一。 默认值为 。 可能的值包括：、、、 和 。 当某一行被更新时，要使用 值之一。 默认值为 。 可能的值包括：、、、 和 。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

此构造函数在 Visual Studio 环境中提供设计时支持。 因此，使用此构造函数创建的 对象必须通过 添加到集合中。 当调用该方法时，必须存在具有指定名称的表和列，或者如果在调用该构造函数之前已经调用了 ，则在调用 时，必须存在具有指定名称的表和列。

约束的名称。 在约束中包含父级 对象的父级 的名称。 约束中父级 对象名称的数组。 约束中子级 对象名称的数组。 值之一。 可能的值包括 、 和 。 当删除某行时要使用 值之一。 默认值为 。 可能的值包括：、、、 和 。 当某一行被更新时，要使用 值之一。 默认值为 。 可能的值包括：、、、 和 。 其中一列是或两列都是 。 列具有不同的数据类型。 或 - 表不属于同一 。

指示调用 时，通过该约束应发生的操作。

值之一。 可能的值包括 和 。 默认值为 。

获取该约束的子列。

作为约束子列的 对象的数组。

获取或设置当删除某一行时通过该约束发生的操作。

值之一。 默认值为 。

获取一个值，该值指示当前的 是否与指定对象相同。

此 将与之比较的对象。 如果两个 约束相同的列，则它们相等。 如果对象相同，则为 ；否则为 。

获取 对象的此实例的哈希代码。

32 位有符号整数哈希代码。

该约束的父列。

作为约束父列的 对象的数组。

获取该约束的父表。

该约束的父级 。

获取该约束的子表。

作为该约束中子表的 。

获取或设置当更新某一行时通过该约束发生的操作。

值之一。 默认值为 。

将数据源列与 列关联起来，并由 类实现，这是 .NET Framework 数据提供程序通常使用的方法。

获取或设置 中要映射到的列的名称。

中要映射到的列的名称。 该名称不区分大小写。

获取或设置数据源中从其映射的列的名称。 该名称区分大小写。

数据源中列的区分大小写的名称。

包含一个 DataColumnMapping 对象的集合，并由 实现，这是由 .NET Framework 数据提供程序通常使用的方法。

使用源列和 列名，将 ColumnMapping 对象添加到 ColumnMapping 集合中。

源列的区分大小写的名称。 列的名称。 已添加到集合中的 ColumnMapping 对象。

获取一个值，该值指示 是否包含具有指定源列名称的 对象。

源列的区分大小写的名称。 如果具有指定源列名称的 对象存在，则为 ；否则为 。

获取具有指定 列名的 ColumnMapping 对象。

集合中 列的名称。 具有指定 列名的 ColumnMapping 对象。

获取具有指定源列名称的 对象的位置。 该名称区分大小写。

源列的区分大小写的名称。 具有指定源列名称的 对象的从零开始的位置。

获取或设置具有指定 名称的 对象。

要查找的 对象的 名称。 具有指定 名称的 对象。

从集合中移除具有指定 名称的 对象。

区分大小写的 名称。 带有指定的 名称的 对象不存在

允许对象实现 DataAdapter，并且表示一组用于填充和更新 及数据源的方法以及与映射操作有关的属性。 实例针对作为（或类似于）具有文字命令（如 Transact-SQL）的关系数据库的数据源，而 实例可使用任何类型的数据源。

添加或更新 中的行以匹配使用 名称的数据源中的行，并创建一个名为“Table”的 。

要用记录和架构（如果必要）填充的 。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。

将名为“Table”的 添加到指定的 ，并根据指定的 配置架构以匹配数据源中的架构。

要用数据源中的架构填充的 。 值之一。 对象的数组，这些对象包含从数据源返回的架构信息。

获取当执行 SQL SELECT 语句时由用户设置的参数。

对象的数组，这些对象包含由用户设置的参数。

指示或指定是否将未映射的源表或列与其源名一起传递以便筛选或引发错误。

值之一。 默认值为 。 设置的值不是 值之一。

指示或指定是否将丢失的源表、列及其关系添加到数据集架构中，是否忽略它们或者它们是否会引发错误。

值之一。 默认值为 。 设置的值不是 值之一。

指示如何将源表映射到数据集表。

一个集合，它提供返回记录和 之间的主映射。 默认值为空集合。

从名为“Table”的 为指定的 中每个已插入、已更新或已删除的行调用相应的 INSERT、UPDATE 或 DELETE 语句。

用于更新数据源的 。 中成功更新的行数。 尝试执行 INSERT、UPDATE 或 DELETE 语句，但没有记录受到影响。

表示 Command 对象的参数，也可以表示其到 列的映射；并由访问数据源的 .NET Framework 数据提供程序实现。

获取或设置参数的 。

值之一。 默认值为 。 该属性未设置为有效的 。

获取或设置一个值，该值指示参数是只可输入的参数、只可输出的参数、双向参数还是存储过程返回值参数。

值之一。 默认值为 。 属性未设置为有效的 值之一。

获取一个值，该值指示参数是否接受 null 值。

如果接受 null 值，则为 ；否则为 。 默认值为 。

获取或设置 的名称。

的名称。 默认值为一个空字符串。

获取或设置映射到 并且用于加载或返回 的源列的名称。

映射到 的源列的名称。 默认值为一个空字符串。

获取或设置要在加载 时使用的 。

值之一。 默认值为 。 属性未设置为 值之一。

获取或设置参数的值。

充当参数值的 。 默认值为 null。

收集与 Command 对象相关的所有参数以及这些参数到 列的映射，并由访问数据源的 .NET Framework 数据提供程序实现。

获取一个值，该值指示集合中的参数是否具有指定的名称。

参数的名称。 如果集合包含该参数，则为 ；否则为 。

在集合中获取 的位置。

参数的名称。 集合中 从零开始的位置。

获取或设置指定索引处的参数。

要检索的参数的名称。 指定索引处的一个 。

从集合中移除 。

参数的名称。

提供一种读取结果集（通过对数据源执行命令获取）的一个或多个只进流的方法，并由访问关系数据库的.NET Framework 数据提供程序实现。

关闭 对象。

获取一个值，该值指示当前行的嵌套深度。

嵌套的级别。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

获取一个值，该值指示数据读取器是否已关闭。

如果数据读取器已关闭，则为 ；否则为 。

在读取一批 SQL 语句的结果时，使数据读取器前进到下一个结果。

如果存在更多行，则为 ；否则为 。

让 前进到下一条记录。

如果存在更多行，则为 ；否则为 。

获取通过执行 SQL 语句更改、插入或删除的行数。

已更改、插入或删除的行数；如果没有受影响的行或语句失败，则为 0；对于 SELECT 语句为 -1。

为 提供对每行中的列值的访问权限，并由访问关系数据库的.NET Framework 数据提供程序实现。

获取当前行中的列数。

如果未位于有效的记录集中，则为 0；否则为当前记录中的列数。 默认值为 -1。

以布尔值的形式获取指定列的值。

从零开始的列序号。 列的值。 传递的索引超出了 0 到 的范围。

获取指定列的 8 位无符号整数值。

从零开始的列序号。 指定列的 8 位无符号整数值。 传递的索引超出了 0 到 的范围。

将字节流从指定列偏移量读入到缓冲区中，将其作为从给定缓冲区偏移量开始的数组。

从零开始的列序号。 字段中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 开始读取操作的 的索引。 要读取的字节数。 读取的实际字节数。 传递的索引超出了 0 到 的范围。

获取指定列的字符值。

从零开始的列序号。 指定列的字符值。 传递的索引超出了 0 到 的范围。

将字符流从指定列偏移量读入到缓冲区中，将其作为从给定缓冲区偏移量开始的数组。

从零开始的列序号。 行中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 开始读取操作的 的索引。 要读取的字节数。 读取的实际字符数。 传递的索引超出了 0 到 的范围。

返回指定列序号的 。

要查找的字段的索引。 指定列序号的 。 传递的索引超出了 0 到 的范围。

获取指定字段的数据类型信息。

要查找的字段的索引。 指定字段的数据类型信息。 传递的索引超出了 0 到 的范围。

获取指定字段的日期和时间数据值。

要查找的字段的索引。 指定字段的日期和时间数据值。 传递的索引超出了 0 到 的范围。

获取指定字段的固定位置数值。

要查找的字段的索引。 指定字段的固定位置数值。 传递的索引超出了 0 到 的范围。

获取指定字段的双精度浮点数。

要查找的字段的索引。 指定字段的双精度浮点数。 传递的索引超出了 0 到 的范围。

获取对应于会从 返回的 类型的 信息。

要查找的字段的索引。 对应于会从 返回的 类型的 信息。 传递的索引超出了 0 到 的范围。

获取指定字段的单精度浮点数。

要查找的字段的索引。 指定字段的单精度浮点数。 传递的索引超出了 0 到 的范围。

返回指定字段的 GUID 值。

要查找的字段的索引。 指定字段的 GUID 值。 传递的索引超出了 0 到 的范围。

获取指定字段的 16 位带符号整数值。

要查找的字段的索引。 指定字段的 16 位带符号整数值。 传递的索引超出了 0 到 的范围。

获取指定字段的 32 位带符号整数值。

要查找的字段的索引。 指定字段的 32 位带符号整数值。 传递的索引超出了 0 到 的范围。

获取指定字段的 64 位带符号整数值。

要查找的字段的索引。 指定字段的 64 位带符号整数值。 传递的索引超出了 0 到 的范围。

获取要查找的字段的名称。

要查找的字段的索引。 字段的名称，如果没有要返回的值，则为空字符串 ("")。 传递的索引超出了 0 到 的范围。

返回已命名字段的索引。

要查找的字段的名称。 已命名字段的索引。

获取指定字段的字符串值。

要查找的字段的索引。 指定字段的字符串值。 传递的索引超出了 0 到 的范围。

返回指定字段的值。

要查找的字段的索引。 返回时将包含字段值的 。 传递的索引超出了 0 到 的范围。

使用当前记录的列值填充对象的数组。

要将属性字段复制到其中的 数组。 数组中的 实例数。

返回指定字段是否设置为 null。

要查找的字段的索引。 如果指定的字段设置为 null，则为 ；否则为 。 传递的索引超出了 0 到 的范围。

获取位于指定索引处的列。

要获取的列的从零开始的索引。 位于作为 指定索引处的列。 传递的索引超出了 0 到 的范围。

获取具有指定名称的列。

要查找的列的名称。 具有指定名称、作为 的列。 未找到具有指定名称的列。

表示连接到数据源时执行的 SQL 语句，并由访问关系数据库的 .NET Framework 数据提供程序实现。

尝试取消执行 。

获取或设置对数据源运行的文本命令。

要执行的文本命令。 默认值为空字符串 ("")。

获取或设置在终止尝试执行命令并生成错误之前的等待时间。

等待命令执行所需的时间（以秒为单位）。 默认值为 30 秒。 分配的属性值小于 0。

指示或指定解释 属性的方式。

值之一。 默认值为 。

获取或设置 的此实例使用的 。

与数据源的连接。

创建 对象的新实例。

一个 对象。

对 .NET Framework 数据提供程序的 对象执行 SQL 语句，并返回受影响的行数。

受影响的行数。 连接不存在。 或 连接未打开。

对 执行 并生成 。

一个 对象。

对 执行 ，并使用 值之一生成 。

值之一。 一个 对象。

执行查询，并返回由查询返回的结果集中第一行的第一列。 忽略其他列或行。

结果集中第一行的第一列。

获取 。

SQL 语句或存储过程的参数。

在数据源上创建准备就绪（或已编译）的命令版本。

未设置 。 或 不为 。

获取或设置要在其中执行 .NET Framework 数据提供程序的 对象的事务。

.NET Framework 数据提供程序的 对象执行。 默认值为 。

获取或设置命令结果在由 的 方法使用时应用于 的方式。

值之一。 除非自动生成该命令，否则默认值为 。 如果自动生成该命令，默认值为 。 输入的值不是 值之一。

表示一个与数据源的开放连接，并由访问关系数据库的 .NET Framework 数据提供程序实现。

开始一项数据库事务。

表示新事务的对象。

以指定的 值开始数据库事务。

值之一。 表示新事务的对象。

更改已打开的 对象的当前数据库。

要代替当前数据库使用的数据库名称。

关闭与数据库之间的连接。

获取或设置用于打数据库的字符串。

包含连接设置的字符串。

获取终止尝试并生成错误之前在尝试建立连接时所等待的时间。

等待连接打开所需的时间（以秒为单位）。 默认值为 15 秒。

创建并返回一个与连接关联的命令对象。

与连接关联的命令对象。

获取当前数据库的名称或打开连接后要使用的数据库的名称。

当前数据库的名称或打开连接后要使用的数据库的名称。 默认值为一个空字符串。

打开具有指定设置（由特定于提供程序的 Connection 对象的 属性所指定）的数据库连接。

获取连接的当前状态。

值之一。

表示一组与命令有关的属性，用于填充 和更新数据源，由访问关系数据库的 .NET Framework 数据提供程序实现。

获取或设置用于从数据集中删除记录的 SQL 语句。

过程中使用的 ，它针对数据集中已删除的行删除数据源中的记录。

获取或设置用于将新记录插入到数据源中的 SQL 语句。

在 过程中使用的 ，它针对数据集中的新行将记录插入到数据源。

获取或设置用于在数据源中选择记录的 SQL 语句。

在 过程中使用的 ，它从数据源中选择记录以便放入数据集中。

获取或设置用于更新数据源中的记录的 SQL 语句。

在 过程中使用的 ，它针对数据集中已修改的行更新数据源中的记录。

由 Visual Basic.NET 数据设计器使用，用于表示命令对象的参数和（可选）该参数到 列的映射。

指示数值参数的精度。

用于表示数据提供程序 Parameter 对象的 Value 属性的最大位数。 默认值为 0，指示数据提供程序将设置 Value 的精度。

指示数值参数的比例。

所解析的 的小数位数。 默认值为 0。

参数的大小。

列中的数据的最大大小（以字节为单位）。 默认值将根据参数值进行推断。

表示要在数据源上执行的事务，并由访问关系数据库的 .NET Framework 数据提供程序实现。

提交数据库事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

指定要与事务关联的 Connection 对象。

要与事务关联的 Connection 对象。

为该事务指定 。

该事务的 。 默认值为 。

从挂起状态回滚事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

表示在 事件中调用 方法时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

提供用于创建集合的基本功能。

初始化 类的新实例。

将当前 的所有元素复制到一维 ，从指定的 索引开始。

要将当前 对象的元素复制到其中的一维 。 从其所在位置开始复制对象的目标 索引。

获取集合中的元素总数。

集合中的元素的总数。

获取集合的 。

集合的 。

获取一个值，该值指示 是否为只读。

如果该集合为只读，则为 ；否则为 。 默认值为 。

获取一个值，该值指示 是否同步。

如果集合是同步的，则为 ；否则为 。 默认值为 。

获取作为列表的集合的项。

包含集合的 。

获取可用于同步集合的对象。

用于同步集合的 。

表示在不正确地尝试创建或访问关系时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

表示在尝试将包含无效 的 添加到 中时引发的异常。

初始化 类的新实例。

使用 和 初始化 类的新实例。

序列化或反序列化对象所需的数据。 给定序列化流的源和目标。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

指定连接的事务锁定行为。

无法覆盖隔离级别更高的事务中的挂起的更改。

在正在读取数据时保持共享锁，以避免脏读，但是在事务结束之前可以更改数据，从而导致不可重复的读取或幻像数据。

可以进行脏读，意思是说，不发布共享锁，也不接受独占锁。

在查询中使用的所有数据上放置锁，以防止其他用户更新这些数据。 防止不可重复的读取，但是仍可以有幻像行。

在 上放置范围锁，以防止在事务完成之前由其他用户更新行或向数据集中插入行。

通过在一个应用程序正在修改数据时存储另一个应用程序可以读取的相同数据版本来减少阻止。 表示您无法从一个事务中看到在其他事务中进行的更改，即便重新查询也是如此。

正在使用与指定隔离级别不同的隔离级别，但是无法确定该级别。

将源表与 中的表关联，并由 类实现，该类由 .NET Framework 数据提供程序共同使用。

获取 的派生 。

数据列映射集合。

获取或设置 中不区分大小写的表名。

内的表的不区分大小写的名称。

获取或设置区分大小写的源表名称。

区分大小写的源表名称。

包含 TableMapping 对象的集合，并由 （通常由 .NET Framework 数据提供程序共同使用）实现。

向集合添加表映射。

区分大小写的源表名称。 表的名称。 对新映射的 对象的引用。

获取一个值，该值指示集合是否包含具有指定源表名称的表映射。

区分大小写的源表名称。 如果存在具有指定源表名称的表映射，则为 ；否则为 。

获取具有指定的 表名的 TableMapping 对象。

集合中表 的名称。 具有指定的 表名的 TableMapping 对象。

获取 对象在集合内的位置。

区分大小写的源表名称。 集合中 对象的从零开始的位置。

获取或设置具有指定 名称的 的实例。

的 名称。 具有指定的 名称的 的实例。

从集合中移除具有指定 名称的 对象。

区分大小写的 名称。

标识由 属性标识的连接字符串参数的列表，这些参数或者是被允许的，或者是不被允许的。

默认。 标识唯一允许的其他连接字符串参数。

标识不允许的其他连接字符串参数。

当使用 或 方法时控制数据源中的值如何应用至现有行。

传入此行的值将同时写入每列数据的当前值和原始值版本。

传入此行的值将写入每列数据的原始值版本。 每列数据的当前版本不变化。 这是默认设置。

传入此行的值将写入每列数据的当前版本。 每列数据的原始版本不变化。

指定如何映射 。

将列映射到 XML 特性。

将列映射到 XML 元素。

将列映射到内部结构。

将列映射到 节点。

在目标和源 具有相同的主键值，且将 属性设置为“真”时发生。

使用 和合并冲突说明来初始化 类的新实例。

对象。 合并冲突的说明。

返回合并冲突的说明。

合并冲突的说明。

返回 对象。

对象。

表示用来处理 事件的方法。

事件源。 事件的数据。

确定源表或源列中缺少映射时发生的操作。

如果缺少指定的列映射，则生成 。

忽略没有映射的列或表。 返回 。

创建源列或源表，并使用其原始名称将其添加到 。

表示在尝试访问没有主键的表中的行时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定序列化流的源和目的地的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

指定在将数据添加到 而缺少要求的 或 时要采取的操作。

添加必需的列以完成架构。

添加必需的列和主键信息以完成架构。 有关如何将主键信息添加到 的更多信息，请参见 。为与用于 OLE DB 的 .NET Framework 数据提供程序一起正确运行， 要求本机 OLE DB 提供程序通过设置 DBPROP_UNIQUEROWS 属性获得必需的主键信息，然后通过检查 IColumnsRowset 中的 DBCOLUMN_KEYCOLUMN 确定哪些列是主键列。 作为一种备选方法，用户可以在每个 上显式设置主键约束。 这将确保对与现有记录匹配的传入记录进行更新，而不是追加。 当使用 时，用于 SQL Server 的 .NET Framework 数据提供程序将 FOR BROWSE 子句追加到正在执行的语句。 用户应该注意潜在的副作用，例如对 SET FMTONLY ON 语句的使用产生的干扰。 有关详细信息，请参阅 SET FMTONLY (Transact-SQL)。

如果缺少指定的列映射，则生成 。

忽略额外列。

表示在尝试将 NULL 值插入 设置为 的列中时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

表示要对数据源执行的 SQL 语句或存储过程。 此类不能被继承。

初始化 类的新实例。

使用查询的文本初始化 类的新实例。

查询的文本。

用查询文本和 对象初始化 类的新实例。

查询的文本。 表示数据源连接的 对象。

使用查询文本、 对象以及 初始化 类的新实例。

查询的文本。 表示数据源连接的 对象。 在其中执行的事务。

尝试取消执行 。

获取或设置要对数据源执行的 SQL 语句或存储过程。

要执行的 SQL 语句或存储过程。 默认值为空字符串 ("")。

获取或设置在终止对执行命令的尝试并生成错误之前的等待时间。

等待命令执行所需的时间（以秒为单位）。 默认值为 30 秒。

获取或设置一个值，该值指示如何解释 属性。

值之一。 默认值为 。 该值不是有效的 。

获取或设置 的此实例使用的 。

到数据源的连接。 默认值为 null 。 属性在事务执行过程中发生了更改。

创建 对象的新实例。

一个 对象。

获取或设置一个值，指示该命令对象在自定义界面控件中是否应可见。

如果命令对象应在控件; 中可见否则为。 默认值为 。

针对 执行 SQL 语句并返回受影响的行数。

对于 UPDATE、INSERT 和 DELETE 语句，返回值为该命令所影响的行数。 对于其他所有类型的语句，返回值为 -1。 连接不存在。 或 - 连接未打开。

将 发送到 并生成一个 。

一个 对象。

将 发送到 ，并使用 值之一构造 。

值之一。 一个 对象。

执行查询，并返回由查询返回的结果集中的第一行的第一列。 其他列或行将被忽略。

结果集中第一行的第一列或 null 引用（如果结果集为空）。

获取 。

SQL 语句或存储过程的参数。 默认值为空集合。

在数据源上创建准备就绪（或已编译）的命令版本。

未设置 。 或 - 不为 。

将 属性重置为默认值。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

获取或设置要在其中执行 的 。

一个 。 默认值为 null 。

获取或设置一个值，该值指定 “Update” 方法应如何将命令结果应用于“DataRow”。

值之一。

自动生成用于协调对 的更改与关联的数据源的单表命令。 此类不能被继承。

初始化 类的新实例。

使用关联的 对象初始化 类的新实例。

与此 关联的 对象。

获取或设置此 对象将为其生成 SQL 语句的 对象。

与此 关联的 对象。

从在 中指定的存储过程中检索参数信息并填充指定的 对象的 集合。

引用将从其中导出参数信息的存储过程的 。 将派生参数添加到 的 集合中。 基础 ODBC 驱动程序不支持返回存储过程参数信息，或者命令文本不是有效的存储过程名称，或者指定的 不是 。

获取在数据源中执行删除操作所需的自动生成的 对象。

自动生成的、执行删除操作所需的 对象。

获取在数据源中执行删除操作所需的自动生成的 对象。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行删除操作所需的 对象。

获取在数据源中执行插入操作所需的自动生成的 对象。

自动生成的、执行插入操作所需的 对象。

获取在数据源中执行插入操作所需的自动生成的 对象。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行插入操作所需的 对象。

获取在数据源中执行更新操作所需的自动生成的 对象。

自动生成的、执行更新所需的 对象。

获取在数据源中执行更新操作所需的自动生成的 对象。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行更新所需的 对象。

给定了具有正确的目录大小写设置且不带引号的标识符时，返回该标识符的正确的带引号形式。 这包括正确地转义该标识符中的任何嵌入引号。

不带引号的原始标识符。 带引号的标识符版本。 标识符内的嵌入引号被正确地转义。

给定了具有正确的目录大小写设置且不带引号的标识符时，返回该标识符的正确的带引号形式。 这包括正确地转义该标识符中的任何嵌入引号。

不带引号的原始标识符。 当连接是通过时，会导致托管包装从获取 ODBC 驱动程序的引号字符，调用 SQLGetInfo （SQL_IDENTIFIER_QUOTE_CHAR）。 如果连接未通过时，使用从 和 的值中引用该字符串。 带引号的标识符版本。 标识符内的嵌入引号被正确地转义。

给定了带引号的标识符时，返回该标识符的正确的不带引号形式，包括正确地非转义该标识符中的任何嵌入引号。

其嵌入引号将被移除的标识符。 不带引号的标识符，带有已正确进行非转义的嵌入引号。

给定了带引号的标识符时，返回该标识符的正确的不带引号形式，包括正确地非转义该标识符中的任何嵌入引号。

其嵌入引号将被移除的标识符。 。 不带引号的标识符，带有已正确进行非转义的嵌入引号。

表示到数据源的连接是打开的。

初始化 类的新实例。

使用指定的连接字符串初始化 类的新实例。

用于打开数据源的连接。

在数据源中开始事务。

表示新事务的对象。 事务当前是活动的。 不支持并行事务。

在数据源中用指定的 值开始事务。

该连接的事务隔离级别。 若未指定隔离级别，将使用驱动程序的默认隔离级别。 表示新事务的对象。 事务当前是活动的。 不支持并行事务。

更改与打开的 关联的当前数据库。

数据库名称。 数据库名称无效。 连接未打开。 不能更改数据库。

关闭到数据源的连接。

获取或设置用于打开数据源的字符串。

包括一些需要建立初始连接的设置（例如，数据源名称）的 ODBC 驱动程序连接字符串。 默认值为空字符串 ("")。 最大长度是 1024 个字符。

获取或设置在尝试建立连接时终止尝试并生成错误之前所等待的时间。

等待连接打开的时间（以秒为单位）。 默认值为 15 秒。 设置的值小于 0。

创建并返回一个与该 关联的 对象。

一个 对象。

获取当前数据库的名称或打开连接后要使用的数据库的名称。

当前数据库的名称。 在打开连接前，默认值一直为空字符串 ("")。

获取数据源的服务器名或文件名。

数据源的服务器名或文件名。 在打开连接前，默认值一直为空字符串 ("")。

获取为当前连接指定的 ODBC 驱动程序名称。

ODBC 驱动程序的名称。 它通常是 DLL 名称（例如 Sqlsrv32.dll）。 在打开连接前，默认值一直为空字符串 ("")。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

返回此 的数据源的架构信息。

一个包含架构信息的 。

使用架构名称的指定名称，返回此 的数据源的架构信息。

指定要返回的架构的名称。 一个包含架构信息的 。

通过使用指定字符串作为架构名称，指定字符串数组作为限制值，返回此 的数据源的架构信息。

指定要返回的架构的名称。 为请求的架构指定一组限制值。 一个包含架构信息的 。

在 ODBC 驱动程序发送警告或信息性消息时发生。

使用 指定的属性设置打开到数据源的连接。

此方法的功能在基类中不受支持，并且必须改为在派生类中实现。

指示当释放最后的基础连接时可以释放 ODBC 驱动程序管理器环境句柄。

获取一个包含客户端所连接到的服务器的版本的字符串。

连接的服务器的版本。 连接已关闭。

获取连接的当前状态。

值的按位组合。 默认值为 。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

为创建和管理由 类使用的连接字符串的内容提供了一种简单方法。

初始化 类的新实例。

初始化 类的新实例。 所提供的连接字符串为实例的内部连接信息提供数据。

对象内部连接信息的基础。 分析为键/值对。 连接字符串的格式错误（可能是键/值对中缺少必需的“=”）。

清除 实例的内容。

确定 是否包含特定键。

要在 中定位的键。 如果 包含具有指定键的元素，则为 ；否则为 。 为 null（在 Visual Basic 中为 ）。

获取或设置与连接关联的 ODBC 驱动程序的名称。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置与连接关联的数据源名称 (DSN) 的名称。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置与指定的键关联的值。 在 C# 中，此属性为索引器。

要获取或设置的项的键。 与指定的键相关联的值。 连接字符串的格式错误（可能是键/值对中缺少必需的“=”）。 为空引用（在 Visual Basic 中为 ）。

获取包含 中的键的 。

一个 ，它包含 中的键。

从 实例中移除具有指定的键的项。

要从此 中的连接字符串移除的键/值对中的键。 如果该键存在于连接字符串中并已被移除，则为 ；如果该键不存在，则为 。 为 null（在 Visual Basic 中为 ）。

从此 中检索与提供的键相对应的值。

要检索的项的键。 与 对应的值。 如果在连接字符串中找到 ，则为 ；否则为 。

表示用于填充 和更新数据源的一组数据命令和一个数据源连接。 此类不能被继承。

初始化 类的新实例。

用指定的 SQL SELECT 语句初始化 类的新实例。

，它是一个 SQL SELECT 语句或存储过程，被设置为 的 属性。

用一个 SQL SELECT 语句和一个 初始化 类的新实例。

一个字符串，表示将由 的 属性使用的 SQL SELECT 语句或存储过程。 表示连接的 。

使用 SQL SELECT 语句和连接字符串初始化 类的新实例。

一个字符串，表示将由 的 属性使用的 SQL SELECT 语句或存储过程。 连接字符串。

获取或设置 SQL 语句或存储过程，用于删除数据源中的记录。

在更新操作期间使用的 ，它用来删除数据源中与 中已删除的行相对应的记录。

获取或设置 SQL 语句或用于将新记录插入数据源的存储过程。

在更新操作期间用于在对应于 中新行的数据源中插入记录的 。

在针对数据源执行命令之后的更新操作期间发生。

在对数据源执行命令前的 过程中发生。

获取或设置 SQL 语句或存储过程，用于选择数据源中的记录。

，在填充操作过程中用于从数据源选择记录以放置在 中。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于针对数据集中删除的行删除数据源中的记录。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于插入数据源中的记录，以便放入数据集中。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于选择数据源中的记录，以便放入数据集中。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于针对数据集中修改的行更新数据源中的记录。

有关此成员的说明，请参阅 。

新的 对象，是此实例的副本。

获取或设置 SQL 语句或用于在数据源中更新记录的存储过程。

，用于在更新操作期间在对应于 中被修改行的数据源中更新记录。

提供从数据源读取数据行的只进流的方法。 此类不能被继承。

关闭 对象。

获取一个值，用于指示当前行的嵌套深度。

当前行的嵌套深度。

获取当前行中的列数。

如果不是位于有效的记录集中，则为 0；否则为当前记录的列数。 默认值为 -1。 没有到数据源的当前连接。

以布尔值的形式获取指定列的值。

从零开始的列序号。 一个表示列值的布尔值。 指定的强制转换无效。

以字节的形式获取指定列的值。

从零开始的列序号。 指定列的字节形式的值。 指定的强制转换无效。

从指定的列偏移量将字节流作为数组从特定的缓冲区偏移量开始读入缓冲区。

从零开始的列序号。 字段中读取操作开始位置的索引。 要读入字节流的缓冲区。 中写入操作开始位置的索引。 要读取的字节数。 读取的实际字节数。

获取指定列的字符形式的值。

从零开始的列序号。 指定列的字符形式的值。 指定的强制转换无效。

从指定的列偏移量将字符流作为数组从特定的缓冲区偏移量开始读入缓冲区。

从零开始的列序号。 行中读取操作开始位置的索引。 要向其中复制数据的缓冲区。 中写入操作开始位置的索引。 要读取的字符数。 读取的实际字符数。

获取源数据类型的名称。

从零开始的列序号。 源数据类型的名称。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的 对象形式的值。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的 对象形式的值。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的 对象形式的值。 指定的强制转换无效。

获取指定列的双精度浮点数形式的值。

从零开始的列序号。 指定列的双精度浮点数形式的值。 指定的强制转换无效。

返回一个可用于循环访问数据读取器中的行的 。

一个 ，可用于循环访问数据读取器中的行。

获取作为对象的数据类型的 。

从零开始的列序号。 作为对象的数据类型的 。

获取指定列的单精度浮点数形式的值。

从零开始的列序号。 指定列的单精度浮点数形式的值。 指定的强制转换无效。

获取指定列的值作为全局唯一标识符 (GUID)。

从零开始的列序号。 指定列的 GUID 形式的值。 指定的强制转换无效。

获取指定列的 16 位带符号整数形式的值。

从零开始的列序号。 指定列的 16 位有符号整数形式的值。 指定的强制转换无效。

获取指定列的 32 位带符号整数形式的值。

从零开始的列序号。 指定列的 32 位有符号整数形式的值。 指定的强制转换无效。

以 64 位有符号整数的形式获取指定列的值。

从零开始的列序号。 指定列的 64 位有符号整数形式的值。 指定的强制转换无效。

获取指定列的名称。

从零开始的列序号。 指定列的名称的字符串。

在给定列名时获取相应的列序号。

列的名称。 从零开始的列序号。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

获取指定列的 形式的值。

从零开始的列序号。 以 的形式指定的列的值。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的 对象形式的值。

获取以本机格式表示的指定序号处的列的值。

从零开始的列序号。 要返回的值。

使用当前行的列值来填充对象数组。

将特性列复制到的 类型的数组。 数组中的 实例数。

获取一个值，该值指示 是否包含一行还是多行。

如果 包含一行或多行，则为 ；否则为 。

指示 是否关闭。

如果 已关闭，则为 ；否则为 。

获取一个值，该值指示列中是否包含不存在或丢失的值。

从零开始的列序号。 如果指定的列值与 等效，则为 ；否则为 。

在给定列序号的情况下，获取指定列的以本机格式表示的值。

列序号。 指定列的以本机格式表示的值。 传递的索引超出了 0 到 的范围。

在给定列名称的情况下，获取指定列的以本机格式表示的值。

列名称。 指定列的以本机格式表示的值。 未找到具有指定名称的列。

读取批处理 SQL 语句的结果时，使 前进到下一个结果。

如果存在多个结果集，则为 ；否则为 。

让 前进到下一条记录。

如果存在更多行，则为 ；否则为 。

获取通过执行 SQL 语句更改、插入或删除的行数。

更改、插入或删除的行数。 对于 SELECT 语句为 -1；如果没影响任何行或该语句失败，则为 0。

收集与数据源返回的警告或错误有关的信息。

获取错误的简短说明。

错误说明。

获取数据源特定的错误信息。

数据源特定的错误信息。

获取生成错误的驱动程序的名称。

生成错误的驱动程序的名称。

获取符合数据库的 ANSI SQL 标准的五字符错误代码。

五个字符的错误代码，它确定错误的来源（如果错误可能来自不止一个地方）。

获取错误信息的完整文本。

错误信息的完整文本。

收集 生成的所有错误。 此类不能被继承。

从数组中指定的索引位置开始，将 的元素复制到数组。

要将元素复制到其中的数组。 的起始索引。 和 中元素的数量之和大于该数组的长度。 为 。 对于 无效。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

获取集合中错误的数目。

集合中的错误总数。

返回实现 接口并可循环访问 中的 对象的对象。

实现 接口并可循环访问 中的 对象的对象。

获取位于指定索引处的错误。

要检索的错误的从零开始的索引。 ，其中包含指定索引处的错误。

有关此成员的说明，请参见 。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

有关此成员的说明，请参见 。

可用于同步对 的访问的对象。

ODBC 数据源返回警告或错误时生成的异常。 此类不能被继承。

获取一个或多个 对象的集合，这些对象提供有关用于 ODBC 的 .NET Framework 数据提供程序生成的异常的详细信息。

类的收集的实例。

此成员重写 。

包含有关所引发异常的序列化对象数据的 。 ，它包含关于源或目标的上下文信息。 参数为 null 引用（在 Visual Basic 中为 ）。

获取生成错误的 ODBC 驱动程序的名称。

生成错误的 ODBC 驱动程序名称。

表示一组方法，这些方法用于创建 ODBC 提供程序实现数据源类的实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

枚举的一个成员。 新的强类型 实例。

获取一个 实例，该实例可用于检索强类型的数据对象。

为 事件提供数据。

获取从数据源发送的警告的集合。

从数据源发送的警告的集合。

获取从数据库发送的全文本错误。

错误的完整文本。

检索 事件的字符串表示形式。

表示 事件的字符串。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 对象。

提供一个常数列表，该列表与 GetSchema 方法一起使用以检索元数据集合。

用于 GetSchema 方法的常数，表示 Columns 集合。

用于 GetSchema 方法的常数，表示 Indexes 集合。

用于 GetSchema 方法的常数，表示 ProcedureColumns 集合。

用于 GetSchema 方法的常数，表示 ProcedureParameters 集合。

用于 GetSchema 方法的常数，表示 Procedures 集合。

用于 GetSchema 方法的常数，表示 Tables 集合。

用于 GetSchema 方法的常数，表示 Views 集合。

提供静态值，这些值用于 中包含的 对象的列名称。 由 GetSchema 方法创建。

由 GetSchema 方法用于创建 BooleanFalseLiteral 列。

由 GetSchema 方法用于创建 BooleanTrueLiteral 列。

供 GetSchema 方法使用，用于创建 SQLType 列。

表示 的参数，还可以表示它到 的映射。 此类不能被继承。

初始化 类的新实例。

初始化使用参数名称和数据类型的 类的新实例。

参数的名称。 值之一。 参数 中提供的值不是有效的后端数据类型。

初始化使用参数名称、数据类型和长度的 类的新实例。

参数的名称。 值之一。 参数的长度。 参数 中提供的值不是有效的后端数据类型。

初始化 类的新实例，该类使用参数名称、数据类型、长度、源列名、参数方向、数值精度和其他属性。

参数的名称。 值之一。 参数的长度。 值之一。 如果字段的值可以为 null，则为 ；否则为 。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列的名称。 值之一。 作为 的值的 。 参数 中提供的值不是有效的后端数据类型。

初始化 类的新实例，该类使用参数名称、数据类型、长度、源列名、参数方向、数值精度和其他属性。

参数的名称。 值之一。 参数的长度。 值之一。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列的名称。 值之一。 如果对应的源列可为 null，则为 ；否则为 。 作为 的值的 。 参数 中提供的值不是有效的后端数据类型。

初始化使用参数名称、数据类型、长度和源列名称的 类的新实例。

参数的名称。 值之一。 参数的长度。 源列的名称。 参数 中提供的值不是有效的后端数据类型。

初始化使用参数名称和 对象的 类的新实例。

参数的名称。 一个 对象。

获取或设置参数的 。

值之一。 默认值为 。 该属性未设置为有效的 。

获取或设置一个值，该值指示参数是只可输入的参数、只可输出的参数、双向参数还是存储过程返回值参数。

值之一。 默认值为 。 属性未设置为有效的 值之一。

获取或设置一个值，该值指示参数是否接受 null 值。

如果接受 null 值，则为 ；否则为 。 默认值为 。

获取或设置参数的 。

值，它是该参数的 。 默认值为 。

获取或设置 的名称。

的名称。 默认值为空字符串("")。

获取或设置用来表示 属性的最大位数。

用于表示 属性的最大位数。 默认值为 0，它表示数据提供程序设置 的精度。

重置与此 关联的类型。

重置与此 关联的类型。

获取或设置所解析的 的小数位数。

所解析的 的小数位数。 默认值为 0。

获取或设置列内数据的最大大小。

列内数据的最大大小。 默认值将根据参数值进行推断。

获取或设置源列的名称，该源列映射到 并用于加载或返回 。

将用于设置此参数值的源列的名称。 默认值为空字符串("")。

设置或获取一个值，该值指示源列是否可以为 null。 这使 能够正确地为可为 null 的列生成 Update 语句。

如果源列可以为 null，则为 ；如果不可以为 null，则为 。

获取或设置在加载 时使用的 。

值之一。 默认值为 Current。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

获取一个包含 的字符串。

一个包含 的字符串。

获取或设置参数的值。

充当参数值的 。 默认值为 null。

表示与 相关的参数的集合以及各个参数到 中列的映射。 此类不能被继承。

将指定的 添加到 。

要添加到集合中的 。 新的 对象的索引。 在 参数中指定的 已经添加到这个或其他 中。 参数为 null。

将指定的 对象添加到 中。

。 集合中新的 对象的索引。

在给定参数名称和数据类型的情况下，将 添加到 中。

参数的名称。 值之一。 新的 对象的索引。

在给定参数名称、数据类型和列长的情况下，将 添加到 中。

参数的名称。 值之一。 列的长度。 新的 对象的索引。

在给定参数名称、数据类型、列长和源列名称的情况下，将 添加到 中。

参数的名称。 值之一。 列的长度。 源列的名称。 新的 对象的索引。

在给定参数名称和参数值的情况下，将 添加到 中。

参数的名称。 要添加到集合中的 的 。 新的 对象的索引。 参数不是一个 。

向 的末尾添加一个值数组。

要添加的 值。

向 的末尾添加一个 值数组。

要添加到集合中的 对象的数组。

向 的末尾添加一个值。

参数的名称。 要添加的值。 一个 对象。

从 中移除所有 对象。

确定指定的 是否在此 中。

值。 如果 位于集合中，则为 ；否则为 。

确定指定的 是否在此 中。

值。 如果 包含此值，则返回 ；否则，返回 。

获取一个值，该值指示集合中是否存在具有指定参数名称的 对象。

要查找的 对象的名称。 如果集合包含该参数，则为 ；否则为 。

将当前 的所有元素复制到指定的一维 中，并以指定的目标 索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的一维 。 一个 32 位整数，表示 中开始复制的位置的索引。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

返回一个整数，包含 中的元素数。 只读。

以整数形式表示的 中的元素数。

返回循环访问 的枚举数。

的一个 。

获取指定的 在集合中的位置。

要在集合中查找的 。 指定的 在集合中从零开始的位置。

获取指定的 在集合中的位置。

要查找的 。 指定的 （它是 ）在集合中从零开始的位置。

获取具有指定名称的指定 的位置。

要查找的 的名称（区分大小写）。 具有指定名称（区分大小写）的指定 的位置（从零开始）。

在 中的指定索引处插入一个 对象。

从零开始的索引，应在该位置插入对象。 要插入到 中的 对象。

将 插入到 中的指定索引位置处。

从零开始的索引，应在该位置插入对象。 要插入 中的 。

获取一个值，该值指示 是否具有固定大小。 只读。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 为只读，则为 ；否则为 。

获取一个值，该值指示 是否已同步。 只读。

如果 已同步，则为 ；否则为 。

获取或设置指定索引处的 。

要检索的参数的索引（从零开始）。 位于指定索引处的 。 指定的索引不存在。

获取或设置具有指定名称的 。

要检索的参数的名称。 具有指定名称的 。 指定的名称不存在。

从 中移除 。

要从集合中移除的 对象。 该参数不是 。 集合中不存在该参数。

从 中移除 对象。

要从 中移除的 。

从 的指定索引处移除 。

要移除的 对象的索引（从零开始）。

从 中移除具有指定参数名的 。

要删除的 对象的名称。

获取可用于同步对 的访问的对象。 只读。

可用于同步对 的访问的对象。

启用用于 ODBC 的 .NET Framework 数据提供程序，以帮助确保用户具有足够的安全级别来访问 ODBC 数据源。 此类不能被继承。

初始化 类的新实例。

使用其中一个 值初始化 类的新实例。

值之一。

初始化 类的新实例。

值之一。 指示是否允许空白密码。

将指定连接字符串的访问权限添加到现有权限状态。

允许的连接字符串。 标识允许使用或禁用的连接字符串参数的字符串。 值之一。

以 形式返回 。

当前权限对象的副本。

将某安全操作与自定义安全特性相关联。

使用其中一个 值初始化 类的新实例。

一个 值，其表示可使用声明性安全执行的操作。

返回一个根据特性属性配置的 对象。

一个 对象。

为 事件提供数据。

初始化 类的新实例。

通过更新操作发送的 。 调用 时执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送的 。

调用 时执行的 。

调用 时执行的 。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 。

为 事件提供数据。

初始化 类的新实例。

要更新的 。 在更新操作期间执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送的 。

获取或设置当调用 时执行的 。

当调用 时执行的 。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 。

表示要在数据源进行的 SQL 事务。 此类不能被继承。

提交数据库事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

获取与该事务关联的 对象，或者如果该事务不再有效，则为 。

与事务关联的 对象。

为该事务指定 。

该事务的 。 默认值取决于基础 ODBC 驱动程序。

从挂起状态回滚事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

指定 中使用的字段、属性的数据类型。

精度为 19（有符号）或 20（无符号）且小数位数为 0 的精确数值（有符号：-2[63] <= n <= 2[63] - 1，无符号：0 <= n <= 2[64] - 1）(SQL_BIGINT)。 它映射到 。

二进制数据流 (SQL_BINARY)。 它映射到 类型的 。

只有一位的二进制数据 (SQL_BIT)。 它映射到 。

固定长度字符串 (SQL_CHAR)。 它映射到 。

格式为 yyyymmdd 的日期数据 (SQL_TYPE_DATE)。 它映射到 。

格式为 yyyymmddhhmmss 的日期数据 (SQL_TYPE_TIMESTAMP)。 它映射到 。

精度至少为 p 且小数位数为 s 的有符号精确数值，其中 1 <= p <= 15 且 s <= p。 最大精度因驱动程序而定 (SQL_DECIMAL)。 它映射到 。

有符号的近似数值，其二进制精度为 53 （零或绝对值为 10[-308] 到 10[308]） (SQL_DOUBLE)。 它映射到 。

变长二进制数据。 最大长度因数据源而定 (SQL_LONGVARBINARY)。 它映射到 类型的 。

精度为 10 且小数位数为 0 的精确数值（有符号：-2[31] <= n <= 2[31] - 1，无符号：0 <= n <= 2[32] - 1）(SQL_INTEGER)。 它映射到 。

固定长度的 Unicode 字符串 (SQL_WCHAR)。 它映射到 。

Unicode 变长字符数据。 最大长度因数据源而定。 (SQL_WLONGVARCHAR)。 它映射到 。

精度为 p 且小数位数为 s 的有符号的精确数值，其中 1 <= p <= 15 且 s <= p (SQL_NUMERIC)。 它映射到 。

Unicode 字符的变长流 (SQL_WVARCHAR)。 它映射到 。

有符号的近似数值，其二进制精度为 24 （零或绝对值为 10[-38] 到 10[38]）。(SQL_REAL)。 它映射到 。

格式为 yyyymmddhhmmss 的数据和时间数据 (SQL_TYPE_TIMESTAMP)。 它映射到 。

精度为 5 且小数位数为 0 的精确数值（有符号：-32,768 <= n <= 32,767，无符号：0 <= n <= 65,535) (SQL_SMALLINT)。 它映射到 。

变长字符数据。 最大长度因数据源而定 (SQL_LONGVARCHAR)。 它映射到 。

格式为 hhmmss 的日期数据 (SQL_TYPE_TIMES)。 它映射到 。

二进制数据流 (SQL_BINARY)。 它映射到 类型的 。

精度为 3 且小数位数为 0 的精确数值（有符号：-128 <= n <= 127，无符号：0 <= n <= 255）(SQL_TINYINT)。 它映射到 。

固定长度的 GUID (SQL_GUID)。 它映射到 。

变长二进制。 由用户设置该最大值 (SQL_VARBINARY)。 它映射到 类型的 。

变长流字符串 (SQL_CHAR)。 它映射到 。

表示要对数据源执行的 SQL 语句或存储过程。

初始化 类的新实例。

使用查询的文本初始化 类的新实例。

查询的文本。

使用查询的文本和 初始化 类的新实例。

查询的文本。 表示到数据源的连接的 。

使用查询文本、 以及 初始化 类的新实例。

查询的文本。 表示到数据源的连接的 。 在其中执行的事务。

尝试取消执行 。

创建属于当前实例的副本的新 对象。

属于此实例副本的新 对象。

获取或设置要对数据源执行的 SQL 语句或存储过程。

要执行的 SQL 语句或存储过程。 默认值为一个空字符串。

获取或设置在终止对执行命令的尝试并生成错误之前的等待时间。

等待命令执行所需的时间（以秒为单位）。 默认值为 30 秒。

获取或设置一个值，该值指示如何解释 属性。

值之一。 默认值为 Text。 该值不是有效的 。

获取或设置 的此实例使用的 。

到数据源的连接。 默认值为 。 属性在事务执行过程中发生了更改。

创建 对象的新实例。

一个 对象。

获取或设置一个值，该值指示命令对象在自定义的 Windows 窗体设计器控件中是否应可见。

一个指示命令对象在控件中是否应该可见的值。 默认值为 。

针对 执行 SQL 语句并返回受影响的行数。

受影响的行数。 连接不存在。 或 - 连接未打开。 或 - 不能在连接最初在其中登记的上下文之外的事务上下文中执行命令。

将 发送到 并生成一个 。

一个 对象。 不能在连接最初在其中登记的上下文之外的事务上下文中执行命令。

将 发送到 ，并使用 值之一构造 。

值之一。 一个 对象。 不能在连接最初在其中登记的上下文之外的事务上下文中执行命令。

执行查询，并返回由查询返回的结果集中的第一行的第一列。 其他列或行将被忽略。

结果集中第一行的第一列或 null 引用（如果结果集为空）。 不能在连接最初在其中登记的上下文之外的事务上下文中执行命令。

获取 。

SQL 语句或存储过程的参数。 默认值为空集合。

在数据源上创建准备就绪（或已编译）的命令版本。

未设置 。 或 - 未打开。

将 属性重置为默认值。

有关此成员的说明，请参见 。

一个 对象。

对 执行 ，并使用 值之一生成 。

值之一。 使用某一个 值的 生成。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

获取或设置要在其中执行 的 。

。 默认值为 。

获取或设置命令结果在由 的 方法使用时如何应用于 。

值之一。 输入的值不是 值之一。

自动生成用于协调对 的更改与关联数据库的单表命令。 此类不能被继承。

初始化 类的新实例。

使用关联的 对象初始化 类的新实例。

。

获取或设置为其自动生成 SQL 语句的 对象。

一个 对象。

从在 中指定的存储过程中检索参数信息并填充指定的 对象的 集合。

引用将从其中导出参数信息的存储过程的 。 将派生参数添加到 的 集合中。 基础 OLE DB 提供程序不支持返回存储过程参数信息，命令文本不是有效的存储过程名称，或者指定的 不是 。

获取在数据源中执行删除操作所需的自动生成的 对象。

自动生成的、执行删除操作所需的 对象。

获取在数据源中执行删除操作所需的自动生成的 对象。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行删除操作所需的 对象。

获取在数据源中执行插入操作所需的自动生成的 对象。

自动生成的、执行插入操作所需的 对象。

获取在数据源中执行插入操作所需的自动生成的 对象。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行插入操作所需的 对象。

获取在数据源中执行更新操作所需的自动生成的 对象。

自动生成的、执行更新所需的 对象。

获取对数据源执行更新操作所必需的自动生成的 对象，可选择使用列作为参数名。

如果为 ，则如有可能，将生成与列名相匹配的参数名称。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行更新所需的 对象。

给定了具有正确的目录大小写设置且不带引号的标识符时，返回该标识符的正确的带引号形式。 这包括正确地转义该标识符中的任何嵌入引号。

不带引号的原始标识符。 带引号的标识符版本。 标识符内的嵌入引号被正确地转义。

给定了具有正确的目录大小写设置且不带引号的标识符时，返回该标识符的正确的带引号形式。 这包括正确地转义该标识符中的任何嵌入引号。

要以带引号的形式返回的不带引号的标识符。 当连接是通过时，会导致托管包装从获取 OLE DB 提供程序的引号字符，调用 SQLGetInfo 、、（SQL_IDENTIFIER_QUOTE_CHAR）。 如果连接未通过时，使用从 和 的值中引用该字符串。 带引号的标识符版本。 标识符内的嵌入引号被正确地转义。

给定了带引号的标识符时，返回该标识符的正确的不带引号的形式。 这包括正确地取消转义该标识符中的任何嵌入引号。

其嵌入引号将被移除的标识符。 不带引号的标识符，其嵌入引号被正确地取消转义。

给定了带引号的标识符时，返回该标识符的正确的不带引号的形式。 这包括正确地取消转义该标识符中的任何嵌入引号。

其嵌入引号将被移除的标识符。 。 不带引号的标识符，其嵌入引号被正确地取消转义。

表示到数据源的连接是打开的。

初始化 类的新实例。

使用指定的连接字符串初始化 类的新实例。

用于打开数据库的连接。

以当前的 值开始数据库事务。

表示新事务的对象。 不支持并行事务。

以指定的隔离级别启动数据库事务。

事务应在其下运行的隔离级别。 表示新事务的对象。 不支持并行事务。

更改已打开的 的当前数据库。

数据库名称。 数据库名称无效。 连接未打开。 不能更改数据库。

关闭到数据源的连接。

获取或设置用于打数据库的字符串。

OLE DB 提供程序连接字符串，它包括建立初始连接所必需的数据源名称和其他参数。 默认值为一个空字符串。 提供了无效的连接字符串参数或未提供所需的连接字符串参数。

获取终止尝试并生成错误之前在尝试建立连接时所等待的时间。

等待连接打开的时间（以秒为单位）。 默认值为 15 秒。 设置的值小于 0。

创建并返回一个与该 关联的 对象。

一个 对象。

获取当前数据库的名称或打开连接后要使用的数据库的名称。

当前数据库的名称或打开连接后要使用的数据库的名称。 默认值为一个空字符串。

获取数据源的服务器名或文件名。

数据源的服务器名或文件名。 默认值为一个空字符串。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

应用了指定的限制之后，按照 GUID 的指示从数据源返回架构信息。

的值之一，它指定要返回的架构表。 限制值的 数组。 这些值按照限制列的顺序来应用。 即，第一个限制值应用于第一个限制列，第二个限制值应用于第二个限制列，依此类推。 一个包含所请求的架构信息的 。 指定的限制集无效。 已关闭。 OLE DB 提供程序不支持指定的架构行集合。 或 - 参数包含 的值， 参数包含一条或多条限制。

返回此 的数据源的架构信息。

一个包含架构信息的 。

通过使用架构名称的指定字符串，返回此 的数据源的架构信息。

指定要返回的架构的名称。 一个包含架构信息的 。

通过使用指定字符串作为架构名称，指定字符串数组作为限制值，返回此 的数据源的架构信息。

指定要返回的架构的名称。 为请求的架构指定一组限制值。 一个包含架构信息的 。

在提供程序发送警告或信息性消息时发生。

使用由 指定的属性设置打开一个数据库连接。

连接已打开。 打开连接时出现的连接级别错误。

获取在连接字符串的“Provider = ”子句中指定的 OLE DB 提供程序的名称。

在连接字符串的“Provider= ”子句中指定的提供程序的名称。 默认值为一个空字符串。

指示可在释放最后一个基础连接时释放 对象池。

更新 对象的 属性。

获取一个包含客户端所连接到的服务器的版本的字符串。

连接的服务器的版本。 连接已关闭。

获取连接的当前状态。

值的按位组合。 默认值为 Closed。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

为创建和管理由 类使用的连接字符串的内容提供了一种简单方法。

初始化 类的新实例。

初始化 类的新实例。 所提供的连接字符串为实例的内部连接信息提供数据。

对象内部连接信息的基础。 分析为键/值对。 连接字符串的格式错误（可能是键/值对中缺少必需的“=”）。

清除 实例的内容。

确定 是否包含特定键。

要在 中定位的键。 如果 包含具有指定键的元素，则为 ；否则为 。 为 null（在 Visual Basic 中为 ）。

获取或设置要连接到的数据源的名称。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置用于连接到数据源的通用数据链接 (UDL) 文件的名称。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置与指定的键关联的值。 在 C# 中，此属性为索引器。

要获取或设置的项的键。 与指定的键相关联的值。 连接字符串的格式错误（可能是键/值对中缺少必需的“=”）。 为空引用（在 Visual Basic 中为 ）。

获取包含 中的键的 。

一个 ，它包含 中的键。

获取或设置要为连接字符串内的 OLE DB Services 键传递的值。

与连接字符串内的 OLE DB Services 键对应的值。 默认情况下，该值为 -13。

获取或设置一个布尔值，该值指示如果连接是打开的或者一直处于打开状态，那么安全敏感信息（如密码）是否作为连接的一部分返回。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置一个字符串，该字符串包含与内部连接字符串关联的数据提供程序的名称。

为 属性的值，或者，如果未提供任何值，则为 。

从 实例中移除具有指定的键的项。

要从此 中的连接字符串移除的键/值对中的键。 如果该键原本存在于连接字符串中但被移除，则为 ；如果连接字符串中不存在该键，则为 。 为 null（在 Visual Basic 中为 ）。

从 实例中检索与所提供的键对应的值。

要检索的项的键。 与 对应的值。 如果在连接字符串中找到 ，则为 ；否则为 。 包含一个 null 值（在 Visual Basic 中为 ）。

表示用于填充 和更新数据源的一组数据命令和一个数据库连接。

初始化 类的新实例。

初始化 类的新实例，用指定的 作为 的属性。

，它是 SELECT 语句或存储过程，被设置为 的 属性。

用 初始化 类的新实例。

一个字符串，它是 SQL SELECT 语句或将由 的 属性使用的存储过程。 表示连接的 。

用 初始化 类的新实例。

一个字符串，它是 SQL SELECT 语句或将由 的 属性使用的存储过程。 连接字符串。

获取或设置 SQL 语句或存储过程，用于从数据集中删除记录。

在 过程中使用的 ，用以删除数据源中与 中已删除的行相对应的记录。

使用指定的 、ADO 对象和源表名称，添加或刷新 中的行，使之与 ADO 或 对象中的行相匹配。

要用记录和架构（如果需要）填充的一个 。 一个 ADO 或 对象。 用于表映射的源表。 已在 中成功添加或刷新的行数。 这不包括受不返回行的语句影响的行。 源表无效。

使用指定的 和 ADO 对象，在 中添加或刷新行，以便与 ADO 或 对象中的行相匹配。

要用记录和架构（如果需要）填充的一个 。 一个 ADO 或 对象。 已对 成功刷新的行数。 这不包括受不返回行的语句影响的行。

获取或设置 SQL 语句或用于将新记录插入数据源的存储过程。

在 过程中使用的 ，用于将与 中的新行相对应的记录插入到数据源中。

在对数据源执行命令后的 过程中发生。 尝试进行更新。 因此，事件发生。

在对数据源执行命令前的 过程中发生。 尝试进行更新。 因此，事件发生。

获取或设置 SQL 语句或存储过程，用于选择数据源中的记录。

在 过程中使用的 ，用于从数据源中选择要放在 中的记录。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于针对数据集中删除的行删除数据源中的记录。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于插入数据源中的记录，以便放入数据集中。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于选择数据源中的记录，以便放入数据集中。

有关此成员的说明，请参阅 。

一个 ，在更新过程中，用于针对数据集中修改的行更新数据源中的记录。

有关此成员的说明，请参阅 。

新的 对象，是此实例的副本。

获取或设置 SQL 语句或用于在数据源中更新记录的存储过程。

在 期间用于在对应于 中的修改行的数据源中更新记录的 。

提供从数据源读取数据行的只进流的方法。 此类不能被继承。

关闭 对象。

获取一个值，用于指示当前行的嵌套深度。

当前行的嵌套深度。

获取当前行中的列数。

如果未放在有效的记录集中，则为 0；否则为当前记录的列数。 默认值为 -1。 没有到数据源的当前连接。

以布尔值的形式获取指定列的值。

从零开始的列序号。 列的值。 指定的强制转换无效。

以字节的形式获取指定列的值。

从零开始的列序号。 指定列的字节形式的值。 指定的强制转换无效。

从按指定的列偏移量将字节流作为数组从给定的缓冲区偏移量开始读入缓冲区。

从零开始的列序号。 字段中作为读取操作起始位置的索引。 要读入字节流的缓冲区。 中写入操作开始位置的索引。 复制到缓冲区中的最大长度。 读取的实际字节数。

获取指定列的字符形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

从指定的列偏移量将字符流作为数组从给定的缓冲区偏移量开始读入缓冲区。

从零开始的列序号。 行中作为读取操作起始位置的索引。 要向其中复制数据的缓冲区。 中写入操作开始位置的索引。 要读取的字符数。 读取的实际字符数。

返回请求的列序号的 对象。

从零开始的列序号。 一个 对象。

获取源数据类型的名称。

从零开始的列序号。 后端数据类型的名称。 有关详细信息，请参阅 SQL Server 数据类型或访问数据类型。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的双精度浮点数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

返回一个可用于循环访问数据读取器中的行的 。

一个 ，可用于循环访问数据读取器中的行。

获取作为对象的数据类型的 。

从零开始的列序号。 作为对象的数据类型的 。

获取指定列的单精度浮点数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的值作为全局唯一标识符 (GUID)。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 16 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 32 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 64 位有符号整数的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的名称。

从零开始的列序号。 指定列的名称。

在给定列名时获取相应的列序号。

列的名称。 从零开始的列序号。 指定的名称不是有效的列名。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

获取指定列的字符串形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取以本机格式表示的指定序号处的列的值。

从零开始的列序号。 要返回的值。

使用当前行的列值来填充对象数组。

要将属性列复制到的 数组。 数组中的 实例数。

获取一个值，该值指示 是否包含一行还是多行。

如果 包含一行或多行，则为 ；否则为 。

指示是否可关闭数据读取器。

如果 已关闭，则为 ；否则为 。

获取一个值，该值指示列中是否包含不存在或丢失的值。

从零开始的列序号。 如果指定的列值与 等效，则为 ；否则为 。

在给定列序号的情况下，获取指定列的以本机格式表示的值。

列序号。 指定列的以本机格式表示的值。 传递的索引超出了 0 到 的范围。

在给定列名称的情况下，获取指定列的以本机格式表示的值。

列名称。 指定列的以本机格式表示的值。 未找到具有指定名称的列。

在读取一批 SQL 语句的结果时，使数据读取器前进到下一个结果。

如果存在多个结果集，则为 ；否则为 。

让 前进到下一条记录。

如果存在更多行，则为 ；否则为 。

获取通过执行 SQL 语句更改、插入或删除的行数。

已更改、插入或删除的行数；如果没有受影响的行或语句失败，则为 0；对于 SELECT 语句为 -1。

获取 中未隐藏的字段的数目。

未隐藏的字段的数目。

提供用于枚举本地网络中所有可用 OLE DB 提供程序的机制。

创建 类的实例。

检索一个 ，该数据表包含所有可见 OLE DB 提供程序的信息。

一个 ，其中包含可见 OLE DB 提供程序的信息。 提供程序不支持 ISourcesRowset。 基础提供程序中发生了异常。

使用特定的 OLE DB 枚举数，无需 类的实例即可返回 ，该读取器包含有关当前安装的 OLE DB 提供程序的信息。

。 一个 ，该数据表使用指定的 OLE DB 枚举器包含有关请求的 OLE DB 提供程序的信息。 提供程序不支持 ISourcesRowset。 基础提供程序中出现了异常。

无需 类的实例，即可返回一个 ，该读取器包含当前安装的 OLE DB 提供程序的信息。

一个 ，其中包含可见 OLE DB 提供程序的信息。 提供程序不支持 ISourcesRowset。 基础提供程序中发生了异常。

收集与数据源返回的警告或错误有关的信息。

获取错误的简短说明。

错误的简短说明。

获取数据库特定的错误信息。

数据库特定的错误信息。

获取生成错误的提供程序的名称。

生成错误的提供程序的名称。

获取符合数据库 ANSI SQL 标准的 5 字符错误代码。

5 个字符的错误代码，它确定错误的来源（如果错误可能来自不止一个地方）。

获取错误信息的完整文本。

错误信息的完整文本。

收集 OLE DB .NET Framework 数据提供程序生成的所有错误。 此类不能被继承。

将 的元素复制到 中，从 中的指定索引处开始。

要将元素复制到其中的 。 的起始索引。 和 中元素的数量之和大于 的长度。 为 。 对于 无效。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

获取集合中错误的数目。

集合中错误的总数。

公开 方法，该方法支持 .NET Framework 数据提供程序对集合进行简单的迭代。

可用于循环访问集合的 。

获取位于指定索引处的错误。

要检索的错误的从零开始的索引。 包含在指定索引位置的错误的 。

有关此成员的说明，请参阅 。

如果对集合的访问是同步的（线程安全），则为 ；否则为 。 默认值为 。

有关此成员的说明，请参阅 。

可用于同步集合访问的 。

在基础提供程序返回 OLE DB 数据源的警告或错误时引发的异常。 此类不能被继承。

获取错误的 HRESULT。

错误的 HRESULT。

获取一个或多个 对象集合，这些对象提供有关用于 OLE DB 的 .NET Framework 数据提供程序生成的异常的详细信息。

类的收集的实例。

此成员重写 。

包含有关所引发异常的序列化对象数据的 。 ，它包含关于源或目标的上下文信息。 参数为 null 引用（在 Visual Basic 中为 ）。

表示一组方法，这些方法用于创建 OLEDB 提供程序实现数据源类的实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

新的强类型 实例。

返回强类型 实例。

枚举的一个成员。 强类型的 实例。

获取 的实例。 它可用于检索强类型的数据对象。

为 事件提供数据。 此类不能被继承。

获取符合数据库 ANSI SQL 标准的 HRESULT。

HRESULT，如果错误可能源自不止一个地方，则它识别错误的来源。

获取从数据源发送的警告的集合。

从数据源发送的警告的集合。

获取从数据源发送的错误的完整文本。

错误的完整文本。

获取生成错误的对象的名称。

生成错误的对象的名称。

检索 事件的字符串表示形式。

表示 事件的字符串。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 对象。

返回有关文本命令、数据值和数据库对象中使用的文本的信息。

文本命令中的二进制文本。 映射到 DBLITERAL_BINARY_LITERAL。

文本命令中的目录名。 映射到 DBLITERAL_CATALOG_NAME。

文本命令中将目录名与标识符的其余部分隔开的字符。 映射到 DBLITERAL_CATALOG_SEPARATOR。

文本命令中的字符文本。 映射到 DBLITERAL_CHAR_LITERAL。

文本命令中的列别名。 映射到 DBLITERAL_COLUMN_ALIAS。

用于文本命令或数据定义接口中的列名。 映射到 DBLITERAL_COLUMN_NAME。

文本命令中的相关名称（表别名）。 映射到 DBLITERAL_CORRELATION_NAME。

架构（如果提供程序不支持架构，则为目录）中多维数据集的名称。

文本命令中的游标名。 映射到 DBLITERAL_CURSOR_NAME。

维的名称。 如果维是不止一个多维数据集是一部分，则针对每个多维数据集/维的组合都有一行。

LIKE 子句中使用的字符，用于转义为 DBLITERAL_LIKE_PERCENT 文本返回的字符。 例如，如果百分号 (%) 用于匹配零个或更多个字符，而且这是一个反斜杠 (\)，则字符“abc\%%”与所有以“abc%”开头的字符值都匹配。 某些 SQL 方言支持可用于重写此值的子句（ESCAPE 子句）。 映射到 DBLITERAL_ESCAPE_PERCENT_PREFIX。

转义符（如果有的话），用于为 DBLITERAL_LIKE_PERCENT 文本返回的字符添加后缀。 例如，如果百分号 (%) 用于匹配零个或多个字符，而且百分号通过括在左右方括号中进行转义，则 DBLITERAL_ESCAPE_PERCENT_PREFIX 就是“[”，DBLITERAL_ESCAPE_PERCENT_SUFFIX 就是“]”，而字符“abc[%]%”就匹配所有以“abc%”开头的字符值。 不使用后缀字符来转义 DBLITERAL_ESCAPE_PERCENT 字符的提供程序不会返回此文本值，它们可以在需要时将 DBLITERAL 结构的 lt 成员设置为 DBLITERAL_INVALID。 映射到 DBLITERAL_ESCAPE_PERCENT_SUFFIX。

LIKE 子句中使用的字符，用于转义为 DBLITERAL_LIKE_UNDERSCORE 文本返回的字符。 例如，如果下划线 () 用于正好匹配一个字符，并且这是一个反斜杠 (\)，则字符“abc\\ ”与长度为 5 个字符并以“abc\”开头的所有字符值相匹配。 某些 SQL 方言支持可用于重写此值的子句（ESCAPE 子句）。 映射到 DBLITERAL_ESCAPE_UNDERSCORE_PREFIX。

LIKE 子句中使用的字符，用于转义为 DBLITERAL_LIKE_UNDERSCORE 文本返回的字符。 例如，如果下划线 () 用于正好匹配一个字符，并且这是一个反斜杠 (\)，则字符“abc\\ ”与长度为 5 个字符并以“abc\”开头的所有字符值相匹配。 某些 SQL 方言支持可用于重写此值的子句（ESCAPE 子句）。 映射到 DBLITERAL_ESCAPE_UNDERSCORE_SUFFIX。

层次结构的名称。 如果该维不包含层次结构或者只有一个层次结构，则当前列包含空值。

用于文本命令或数据定义接口中的索引名称。 映射到 DBLITERAL_INDEX_NAME。

一个无效值。 映射到 DBLITERAL_INVALID。

当前级别所属的多维数据集的名称。

在 LIKE 子句中用以匹配零个或多个字符的字符。 例如，如果这是一个百分号 (%)，则字符“abc%”就与所有以“abc”开头的字符值相匹配。 映射到 DBLITERAL_LIKE_PERCENT。

在 LIKE 子句中用以只匹配一个字符的字符。 例如，如果这是一个下划线 ()，则字符“abc\”与所有长度为 4 个字符并以“abc”开头的所有字符值相匹配。 映射到 DBLITERAL_LIKE_UNDERSCORE。

成员名。

文本命令中的过程名。 映射到 DBLITERAL_PROCEDURE_NAME。

属性的名称。

用在文本命令中的字符，作为将包含特殊字符的标识符引起来的左引号。 映射到 DBLITERAL_QUOTE_PREFIX。

用在文本命令中的字符，作为将包含特殊字符的标识符引起来的右引号。 用相同字符作为前缀和后缀的 1.x 提供程序可能不返回此文本值，它们在有需要时可将 DBLITERAL 结构的成员设置为 DBLITERAL_INVALID。 映射到 DBLITERAL_QUOTE_SUFFIX。

文本命令中的架构名。 映射到 DBLITERAL_SCHEMA_NAME。

文本命令中将架构名与标识符的其余部分隔开的字符。 映射到 DBLITERAL_SCHEMA_SEPARATOR。

在文本命令或数据定义接口中使用的表名。 映射到 DBLITERAL_TABLE_NAME。

文本命令，例如 SQL 语句。 映射到 DBLITERAL_TEXT_COMMAND。

文本命令中的用户名。 映射到 DBLITERAL_USER_NAME。

文本命令中的视图名。 映射到 DBLITERAL_VIEW_NAME。

提供一个常数列表，该列表与 GetSchema 方法一起使用以检索元数据集合。

用于 GetSchema 方法的常数，表示 Catalogs 集合。

用于 GetSchema 方法的常数，表示 Collations 集合。

用于 GetSchema 方法的常数，表示 Columns 集合。

用于 GetSchema 方法的常数，表示 Indexes 集合。

用于 GetSchema 方法的常数，表示 ProcedureColumns 集合。

用于 GetSchema 方法的常数，表示 ProcedureParameters 集合。

用于 GetSchema 方法的常数，表示 Procedures 集合。

用于 GetSchema 方法的常数，表示 Tables 集合。

用于 GetSchema 方法的常数，表示 Views 集合。

提供静态值，这些值用于 中包含的 对象的列名称。 由 GetSchema 方法创建。

由 GetSchema 方法用于创建 BooleanFalseLiteral 列。

由 GetSchema 方法用于创建 BooleanTrueLiteral 列。

由 GetSchema 方法用于创建 DateTimeDigits 列。

由 GetSchema 方法用于创建 NativeDataType 列。

表示 的参数，还可以是参数到 列的映射。 此类不能被继承。

初始化 类的新实例。

初始化使用参数名称和数据类型的 类的新实例。

要映射的参数的名称。 值之一。 参数 中提供的值不是有效的后端数据类型。

初始化使用参数名称、数据类型和长度的 类的新实例。

要映射的参数的名称。 值之一。 参数的长度。 参数 中提供的值不是有效的后端数据类型。

初始化 类的新实例，该类使用参数名称、数据类型、长度、源列名、参数方向、数值精度和其他属性。

参数的名称。 值之一。 参数的长度。 值之一。 如果字段的值可以为 null，则为 ；否则为 。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列的名称。 值之一。 作为 的值的 。 参数 中提供的值不是有效的后端数据类型。

初始化 类的新实例，该类使用参数名称、数据类型、长度、源列名、参数方向、数值精度和其他属性。

参数的名称。 值之一。 参数的长度。 值之一。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列的名称。 值之一。 如果源列可以为 null，则为 ；如果不可以为 null，则为 。 作为 的值的 。 参数 中提供的值不是有效的后端数据类型。

初始化使用参数名称、数据类型、长度和源列名称的 类的新实例。

要映射的参数的名称。 值之一。 参数的长度。 源列的名称。 参数 中提供的值不是有效的后端数据类型。

初始化使用新 的参数名称和值的 类的新实例。

要映射的参数的名称。 新 对象的值。

获取或设置参数的 。

值之一。 默认值为 。 该属性未设置为有效的 。

获取或设置一个值，该值指示参数是只可输入、只可输出、双向还是存储过程返回值参数。

值之一。 默认值为 。 属性未设置为有效的 值之一。

获取或设置一个值，该值指示参数是否接受 null 值。

如果接受 null 值，则为 ；否则为 。 默认值为 。

获取或设置参数的 。

参数的 。 默认值为 。

获取或设置 的名称。

的名称。 默认值为空字符串("")。

获取或设置用于表示 属性的最大位数。

用于表示 属性的最大位数。 默认值为 0，它表示数据提供程序设置 的精度。

重置与此 关联的类型。

重置与此 关联的类型。

获取或设置所解析的 的小数位数。

所解析的 的小数位数。 默认值为 0。

获取或设置列中的数据的最大大小（以字节为单位）。

列中的数据的最大大小（以字节为单位）。 默认值将根据参数值进行推断。

获取或设置源列的名称，该源列映射到 并用于加载或返回 。

映射到 的源列的名称。 默认值为一个空字符串。

设置或获取一个值，该值指示源列是否可以为 null。 通过此操作， 能够为可以为 null 的列正确地生成 Update 语句。

如果源列可以为 null，则为 ；如果不可以为 null，则为 。

获取或设置在加载 时使用的 。

值之一。 默认值为 。 该属性未设置为 值之一。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

获取一个包含 的字符串。

一个包含 的字符串。

获取或设置参数的值。

充当参数值的 。 默认值为 null。

表示与 相关的参数集合及其各自到 中列的映射。

将指定的 添加到 。

要添加到集合中的 。 新的 对象的索引。 在 参数中指定的 已经添加到这个或其他 中。 参数为 null。

将指定的 对象添加到 中。

。 集合中新的 对象的索引。

在给定参数名称和数据类型的情况下，将 添加到 中。

参数的名称。 值之一。 新的 对象的索引。

在给定参数名称、数据类型和列长的情况下，将 添加到 中。

参数的名称。 值之一。 列的长度。 新的 对象的索引。

在给定参数名称、数据类型、列长和源列名称的情况下，将 添加到 中。

参数的名称。 值之一。 列的长度。 源列的名称。 新的 对象的索引。

在给定参数名称和参数值的情况下，将 添加到 中。

参数的名称。 要添加到集合中的 的 。 新的 对象的索引。 参数不是一个 。

向 的末尾添加一个值数组。

要添加的 值。

向 的末尾添加一个 值数组。

要添加的 值。

向 的末尾添加一个值。

参数的名称。 要添加的值。 一个 对象。

从 中移除所有 对象。

确定指定的 是否在此 中。

值。 如果 位于集合中，则为 ；否则为 。

确定指定的 是否在此 中。

值。 如果 包含 ，则为 ；否则为 。

确定指定的 是否在此 中。

值。 如果 包含该值，则为 ；否则为 。

将当前 的所有元素复制到指定的一维 中，并以指定的目标 索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的一维 。 一个 32 位整数，表示 中开始复制的位置的索引。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

返回一个整数，此整数包含 中的元素数。 只读。

用整数表示的 中的元素数。

返回循环访问 的枚举数。

的一个 。

获取指定的 在集合中的位置。

要在集合中查找的 。 指定的 （它是 ）在集合中从零开始的位置。

集合中指定 的位置。

要查找的 。 指定的 （它是 ）在集合中从零开始的位置。

获取具有指定名称的指定 的位置。

要查找的 的名称（区分大小写）。 具有指定名称（区分大小写）的指定 的位置（从零开始）。

在 中的指定索引处插入一个 对象。

应将值插入到的位置的索引（从零开始）。 要插入到 中的 对象。

将 插入到 中的指定索引位置处。

应将值插入到的位置的索引（从零开始）。 要插入 中的 。

获取一个值，该值指示 是否具有固定大小。 只读。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 为只读，则为 ；否则为 。

获取一个值，该值指示 是否已同步。 只读。

如果 同步，则为 ；否则为 。

获取或设置指定索引处的 。

要检索的参数的索引（从零开始）。 位于指定索引处的 。 指定的索引不存在。

获取或设置具有指定名称的 。

要检索的参数的名称。 具有指定名称的 。 指定的名称不存在。

从 中移除 。

要从集合中移除的 对象。 该参数不是 。 集合中不存在该参数。

从 中移除 对象。

要从 中除移的 。

从 的指定索引处移除 。

要移除的 对象的索引（从零开始）。

从 中移除具有指定参数名称的 。

要删除的 对象的名称。

获取可用于同步对 的访问的对象。 只读。

可用于同步对 的访问的对象。

启用用于 OLE DB 的 .NET Framework 数据提供程序，以帮助确保用户具有足够的安全级别来访问 OLE DB 数据源。

初始化 类的新实例。

初始化 类的新实例。

值之一。

初始化 类的新实例。

值之一。 指示是否允许空白密码。

以 形式返回 。

当前权限对象的副本。

此属性已被标记为过时。 设置此属性将不会产生任何作用。

此属性已被标记为过时。 设置此属性将不会产生任何作用。

将某安全操作与自定义安全特性相关联。

初始化 类的新实例。

一个 值，其表示可使用声明性安全执行的操作。

返回一个根据特性属性配置的 对象。

一个 对象。

获取或设置包含受支持的提供程序的列表的逗号分隔字符串。

该安全策略所允许的提供程序的逗号分隔列表。

为 事件提供数据。

初始化 类的新实例。

通过 发送 。 调用 时执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送 。

调用 时执行的 。

调用 时执行的 。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 。

为 事件提供数据。

初始化 类的新实例。

要进行 的 。 要在 过程中执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送 。

获取或设置进行 时执行的 。

进行 时要执行的 。

表示将要处理 的 事件的方法。

事件源。 包含事件数据的 。

返回由 方法指定的架构表类型。

初始化 类的新实例。

返回在目录中定义的给定用户拥有的断言。

返回与可从数据源访问的目录有关的物理特性。 返回在目录中定义的给定用户拥有的断言。

返回在目录中定义的字符集，给定用户可以访问它们。

返回在目录中定义的给定用户拥有的 CHECK 约束。

返回在目录中定义的给定用户拥有的 CHECK 约束。

返回在目录中定义的字符排序规则，给定用户可以访问它们。

返回在目录中定义、依赖于在目录中定义的域并由给定用户拥有的列。

返回在目录中定义、给定用户可使用或负责授予的对表中列的特权。

返回在目录中定义的表（包括视图）的列，给定用户可以访问这些列。

返回由引用约束、唯一约束、CHECK 约束和断言使用的、在目录中定义并由给定用户拥有的列。

返回由引用约束、唯一约束、CHECK 约束和在目录中定义并由给定用户拥有的断言使用的表。

返回提供程序特定的关键字的列表。

返回在文本命令使用的提供程序特定的文本的列表。

返回由给定用户在目录中定义的外键列。

返回在目录中定义的由给定用户拥有的索引。

返回在目录中定义的列，给定用户将这些列约束为键。

返回在目录中由给定用户定义的主键列。

返回有关由过程返回的行集合的列的信息。

返回有关过程的参数和返回代码的信息。

返回在目录中定义的由给定用户拥有的过程。

返回用于 OLE DB 的 .NET Framework 数据提供程序支持的基本数据类型。

返回在目录中定义的由给定用户拥有的引用约束。

返回架构行集合的列表，该架构行集合是由它们的 GUID 和一个指向限制列的说明的指针标识的。

返回给定用户拥有的架构对象。

返回在目录中定义的 SQL 实现处理数据所支持的一致性级别、选项和语言。

返回在目录中定义的由给定用户拥有的统计。

返回在目录中定义的由给定用户拥有的表约束。

返回在目录中定义、给定用户可使用或负责授予的对表的特权。

描述提供程序中表的可用统计集合。

返回在目录中定义的表（包括视图），给定用户可以访问它们。

返回给定用户可访问的表（包括视图）。

返回在目录中定义的字符转换，给定用户可以访问这些字符转换。

标识在数据源中定义的受信者。

返回在目录中定义、给定用户可使用或负责授予的对对象的 USAGE 特权。

返回已查看的表所依赖、在目录中定义并由给定用户拥有的列。

返回已查看的表所依赖、在目录中定义并由给定用户拥有的表。

返回在目录中定义的视图，给定用户可以访问这些视图。

表示要在数据源进行的 SQL 事务。 此类不能被继承。

启动嵌套的数据库事务。

嵌套的数据库事务。 不支持嵌套的事务。

启动嵌套的数据库事务，并为新事务指定要使用的隔离级别。

要用于该事务的隔离级别。 嵌套的数据库事务。 不支持嵌套的事务。

提交数据库事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

获取与该事务关联的 对象，或者如果该事务不再有效，则为 。

与事务关联的 对象。

为该事务指定 。

该事务的 。 默认值为 。

从挂起状态回滚事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

指定字段的数据类型、属性，以便在 中使用。

64 位带符号的整数 (DBTYPE_I8)。 它映射到 。

二进制数据流 (DBTYPE_BYTES)。 它映射到 类型的 。

布尔值 (DBTYPE_BOOL)。 它映射到 。

以 null 终止的 Unicode 字符串 (DBTYPE_BSTR)。 它映射到 。

字符串 (DBTYPE_STR)。 它映射到 。

一个货币值，范围在 -2 63（或 -922,337,203,685,477.5808）到 2 63 -1（或 +922,337,203,685,477.5807）之间，精度为千分之十个货币单位 (DBTYPE_CY)。 它映射到 。

日期数据，存储为双精度型 (DBTYPE_DATE)。 整数部分是自 1899 年 12 月 30 日以来的天数，而小数部分是不足一天的部分。 它映射到 。

格式为 yyyymmdd 的日期数据 (DBTYPE_DBDATE)。 它映射到 。

格式为 hhmmss 的时间数据 (DBTYPE_DBTIME)。 它映射到 。

格式为 yyyymmddhhmmss 的日期和时间数据 (DBTYPE_DBTIMESTAMP)。 它映射到 。

定点精度和小数位数数值，范围在 -10 38 -1 和 10 38 -1 之间 (DBTYPE_DECIMAL)。 它映射到 。

浮点数字，范围在 -1.79E +308 到 1.79E +308 之间 (DBTYPE_R8)。 它映射到 。

无任何值 (DBTYPE_EMPTY)。

32 位错误代码 (DBTYPE_ERROR)。 它映射到 。

64 位无符号整数，表示自 1601 年 1 月 1 日以来 100 个纳秒间隔的数字 (DBTYPE_FILETIME)。 它映射到 。

全局唯一标识符（或 GUID） (DBTYPE_GUID)。 它映射到 。

指向 接口的指针 (DBTYPE_IDISPATCH)。 它映射到 。

32 位带符号的整数 (DBTYPE_I4)。 它映射到 。

指向 接口的指针 (DBTYPE_UNKNOWN)。 它映射到 。

长的二进制值（只限 ）。 它映射到 类型的 。

长的字符串值（只限 ）。 它映射到 。

长的以 null 终止的 Unicode 字符串值（只限 ）。 它映射到 。

具有定点精度和小数位数的精确数值 (DBTYPE_NUMERIC)。 它映射到 。

自动化 PROPVARIANT (DBTYPE_PROP_VARIANT)。 它映射到 。

浮点数字，范围在 -3.40E +38 到 3.40E +38 之间 (DBTYPE_R4)。 它映射到 。

16 位带符号的整数 (DBTYPE_I2)。 它映射到 。

8 位带符号的整数 (DBTYPE_I1)。 它映射到 。

64 位无符号整数 (DBTYPE_UI8)。 它映射到 。

32 位无符号整数 (DBTYPE_UI4)。 它映射到 。

16 位无符号整数 (DBTYPE_UI2)。 它映射到 。

8 位无符号整数 (DBTYPE_UI1)。 它映射到 。

二进制数据的变长流（只限 ）。 它映射到 类型的 。

非 Unicode 字符的变长流（只限 ）。 它映射到 。

可包含数字、字符串、二进制或日期数据以及特殊值 Empty 和 Null 的特殊数据类型 (DBTYPE_VARIANT)。 如果未指定任何其他类型，则假定为该类型。 它映射到 。

变长数值（只限 ）。 它映射到 。

长可变、以 null 终止的 Unicode 字符流（只限 ）。 它映射到 。

以 null 终止的 Unicode 字符流 (DBTYPE_WSTR)。 它映射到 。

当用户中止正在执行的某操作时，将引发此异常。

指定查询内的有关 的参数的类型。

该参数为输入参数。

参数既能输入，也能输出。

该参数为输出参数。

该参数表示从某操作（如存储过程、内置函数或用户定义的函数）返回的值。

指定属性的特性。

提供程序不支持该属性。

在初始化数据源之前，用户不必为此属性指定值。

用户可以读取该属性。

在初始化数据源之前，用户必须为此属性指定值。

用户可以写入该属性。

表示可以添加到 、 或 的属性集合。

初始化 类的新实例。

初始化 类的新实例。

序列化或反序列化对象所需的数据。 给定序列化流的源和目标。

创建 对象的浅表副本。

返回 ，它是 对象的浅表副本。

表示在尝试更改只读列的值时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

表示尝试在不位于 中的 上执行操作时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

指示强制执行 时发生的操作。

删除或更新相关的行。 这是默认设置。

不对相关的行采取任何操作。

将相关的行中的值设置为 属性中包含的值。

将相关的行中的值设置为 。

指示类型化 的架构序列化模式。

跳过类型化 的架构序列化。

包括类型化 的架构序列化。 默认值。

指定在执行 操作时如何处理现有的架构映射。

将任何现有的表映射应用到传入架构。 用转换的架构配置 。

忽略 DataAdapter 上的任何表映射。 使用传入架构配置 ，而不应用任何转换。

确定 的序列化格式。

作为二进制内容序列化。 仅可在 ADO.NET 2.0 中使用。

作为 XML 内容序列化。 默认值。

提供了一种枚举本地网络内的所有可用 SQL Server 实例的机制。

检索包含有关所有可见 SQL Server 2000 或 SQL Server 2005 实例的信息的 。

一个 ，包含有关可见 SQL Server 实例的信息。

获取 的实例，该实例可用于检索有关可用 SQL Server 实例的信息。

一个 实例，该实例可用于检索有关可用 SQL Server 实例的信息。

表示对给定命令的通知的请求。

使用默认值创建 类的新实例。

使用用户定义的字符串创建 类的新实例，该字符串标识特定的通知请求、预定义的 SQL Server 2005 Service Broker 服务名以及（以秒来计算）超时时间。

一个字符串，它包含此通知的应用程序特定的标识符。 通知基础结构并不使用它，但是可以使用它将通知与应用程序状态相关联。 此参数中指示的值包含在 Service Broker 队列消息中。 一个字符串，它包含发送通知消息的 Service Broker 服务名，并且必须包括一个数据库名称或 Service Broker 实例 GUID（用来将服务名查找的范围限制为一个特定的数据库）。 有关 参数的格式的更多信息，请参阅 。 等待通知消息的时间（以秒为单位）。 参数的值为 NULL。 或 参数大于 ，或者 参数中的值小于零。

获取或设置发送通知消息的 SQL Server Service Broker 服务名。

，包含发送通知消息的 SQL Server 2005 Service Broker 服务名，以及用于限制服务器名查找范围的数据库或服务中间装置实例 GUID。 该值为 NULL。 该值比 长。

获取或设置一个值，该值指定在操作超时之前，SQL Server 等待发生更改的时间。

带符号的整数值，指定在操作超时之前，SQL Server 等待发生更改的时间（以秒为单位）。 值小于零。

获取或设置此通知的应用程序特定的标识符。

此通知的应用程序特定的标识符的 值。 该值比 长。

指定 的值。 可能的值为 和 。

连接到服务器时的应用程序工作负荷类型是只读的。

连接到服务器时的应用程序工作负荷类型是可读写的。

处理当收到与 对象相关联的任何命令的通知时激发的 事件。

事件源。 包含事件数据的 对象。

为 属性指定一个值。

对所有 SQL 服务器（包括 Azure SQL 服务器）启用暂停时段。

对 Azure SQL 服务器禁用暂停时段，但对所有其他 SQL 服务器启用。

对所有 SQL 服务器（包括 Azure SQL 服务器）禁用暂停时段。

指定数据行排序方式。

按升序排序各行。

按降序排序各行。

默认值。 不指定排序顺序。

定义可以在 app.config 文件中注册的身份验证初始化表达式的核心行为，并为派生类提供基类。

从派生类的构造函数中调用，用于初始化 类。

在派生类中重写时，初始化身份验证初始化表达式。 在启动过程中， 构造函数调用此方法。

介绍可供连接到 Azure SQL 数据库的客户端使用的不同 SQL 身份验证方法。 有关详细信息，请参阅使用 Azure Active Directory 身份验证连接到 SQL 数据库。

身份验证方法使用 Active Directory Integrated。 使用 Active Directory Integrated 连接到使用集成 Windows 身份验证的 SQL 数据库。

身份验证方法使用 Active Directory Interactive。 自.NET Framework 4.7.2 之后可用。

身份验证方法使用 Active Directory 密码。 使用 Active Directory 密码连接到使用 Azure AD 主体名称和密码的 SQL 数据库。

未指定身份验证方法。

身份验证方法为 SQL 密码。

表示由驱动程序传递给验证提供程序的 AD 验证参数。

初始化 类的新实例，使用指定的身份验证方法、服务器名称、数据库名称、资源 URI、颁发机构 URI、用户登录名称/ID、用户密码和连接 ID。

用于指定身份验证方法的枚举值之一。 服务器名称。 数据库名称。 资源 URI。 颁发机构 URI。 用户登录名/ID。 用户密码。 连接 ID。

获取身份验证方法。

身份验证方法。

获取颁发机构 URI。

颁发机构 URI。

获取连接 ID。

连接 ID。

获取数据库名称。

数据库名称。

获取用户密码。

用户密码。

获取资源 URI。

资源 URI。

获取服务器名称。

服务器名称。

获取用户登录名/ID。

用户登录名/ID。

定义验证提供程序的核心行为，并为派生类提供基类。

从派生类中的构造函数中调用，用于初始化 类。

从颁发机构获取安全令牌。

Active Directory 身份验证参数由驱动程序传递给身份验证提供程序。 表示返回 AD 身份验证令牌的异步操作。

调用此方法后立即在 SQL 驱动程序注册表中添加提供程序。

身份验证方法。

调用此方法后立即从 SQL 驱动程序注册表中删除提供程序。

身份验证方法。

按方法获取验证提供程序。

身份验证方法。 验证提供程序或 （若未找到）。

指示是否支持指定的身份验证方法。

身份验证方法。 如果支持指定的身份验证方法，则为 ；否则为 。

按方法设置验证提供程序。

身份验证方法。 验证提供程序。 如果操作成功，则为 ；否则为 （例如，现有提供程序不允许重写）。

表示 AD 身份验证令牌。

初始化 类的新实例。

访问令牌。 令牌的过期时间。 参数为 或为空。

获取标记字符串。

标记字符串。

获取令牌的过期时间。

令牌的过期时间。

允许你使用其他源的数据有效地批量加载 SQL Server 表。

使用 的指定打开实例初始化 类的新实例。

将用于执行批量复制操作的已经打开的 实例。 如果连接字符串不使用 ，则可以使用 来传递用户 ID 和密码，这比将用户 ID 和密码指定为连接字符串中的文本更安全。

使用提供的 的现有打开实例初始化 类的新实例。 实例的行为取决于 参数中提供的选项。 如果提供非空 ，则复制操作将在该事务中执行。

将用于执行批量复制操作的已经打开的 实例。 如果连接字符串不使用 ，则可以使用 来传递用户 ID 和密码，这比将用户 ID 和密码指定为连接字符串中的文本更安全。 枚举中的值的组合，可确定将哪些数据源行复制到目标表中。 现有的 实例，批量复制操作将在该实例下进行。

基于提供的 初始化并打开 的新实例。 该构造函数使用 来初始化 类的新实例。

定义将打开供 实例使用的连接的字符串。 如果该连接字符串不使用 ，则可以使用 或 和 来传递用户 ID 和密码，这比将用户 ID 和密码指定为连接字符串中的文本更安全。

基于提供的 初始化并打开 的新实例。 构造函数使用该 来初始化 类的新实例。 实例的行为取决于 参数中提供的选项。

定义将打开供 实例使用的连接的字符串。 如果该连接字符串不使用 ，则可以使用 或 和 来传递用户 ID 和密码，这比将用户 ID 和密码指定为连接字符串中的文本更安全。 枚举中的值的组合，可确定将哪些数据源行复制到目标表中。

每个批处理中的行数。 在每个批处理结束时，批处理中的行将发送到服务器。

属性的整数值；如果未设置任何值，则为零。

超时之前可用于完成操作的秒数。

属性的整数值。 默认值为 30 秒。 值为 0 表示无限制，大容量复制将无限期等待。

关闭 实例。

返回 项的集合。 列映射定义数据源中的列和目标中的列之间的关系。

列映射集合。 默认情况下为空集合。

服务器上的目标表的名称。

属性的字符串值，如果未提供任何值，则为 null。

启用或禁用 对象，以流式传输 对象中的数据

如果 对象可以流式传输 对象中的数据，则为 ；否则为 false。 默认值为 。

定义生成通知事件之前要处理的行数。

属性的整数值，如果未设置任何属性，则为零。

每当 属性指定的行数被处理后会发生。

释放 类的当前实例所使用的所有资源。

将所有行从提供的 数组复制到 对象的 属性指定的目标表中。

一个 ，其行将复制到目标表。

将所有行从提供的 数组复制到 对象的 属性指定的目标表中。

将复制到目标表的 对象数组。

将所有行从提供的 复制到 对象的 属性指定的目标表中。

一个 ，其行将复制到目标表。

仅将与提供的 中提供的行状态匹配的行复制到 对象的 属性指定的目标表。

一个 ，其行将复制到目标表。 枚举中的一个值。 只有与行状态匹配的行才会复制到目标中。

将所有行从提供的 复制到 对象的 属性指定的目标表中。

一个 ，其行将复制到目标表。

的异步版本，它将所有行从提供的 数组复制到 对象的 属性指定的目标表。

一个 ，其行将复制到目标表。 表示异步操作的任务。

的异步版本，它将所有行从提供的 数组复制到 对象的 属性指定的目标表。

一个 ，其行将复制到目标表。 取消指令。 此参数中的 值将使此方法等效于 。 返回 。

的异步版本，它将所有行从提供的 数组复制到 对象的 属性指定的目标表。

将复制到目标表的 对象数组。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它将所有行从提供的 数组复制到 对象的 属性指定的目标表。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

将复制到目标表的 对象数组。 取消指令。 此参数中的 值将使此方法等效于 。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它将提供的 中的所有行复制到 对象的 属性指定的目标表。

一个 ，其行将复制到目标表。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它只将匹配所提供 中所提供行状态的行复制到 对象的 属性指定的目标表中。

一个 ，其行将复制到目标表。 枚举中的一个值。 只有与行状态匹配的行才会复制到目标中。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它只将匹配所提供 中所提供行状态的行复制到 对象的 属性指定的目标表中。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

一个 ，其行将复制到目标表。 枚举中的一个值。 只有与行状态匹配的行才会复制到目标中。 取消指令。 此参数中的 值将使此方法等效于 。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它将提供的 中的所有行复制到 对象的 属性指定的目标表。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

一个 ，其行将复制到目标表。 取消指令。 此参数中的 值将使此方法等效于 。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它将提供的 中的所有行复制到 对象的 属性指定的目标表。

一个 ，其行将复制到目标表。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在完成的 返回之前， 已关闭。 在完成的 返回之前，与 相关的连接已关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

的异步版本，它将提供的 中的所有行复制到 对象的 属性指定的目标表。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

一个 ，其行将复制到目标表。 取消指令。 此参数中的 值将使此方法等效于 。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在完成任务前，为同一个实例调用 和 。 在执行 期间连接断开或关闭。 在任务对象中返回的 对象在执行方法时关闭。 在任务对象中返回后存在连接池超时。 在任务对象中返回的 对象在执行方法前关闭。 在完成的 返回之前， 已关闭。 在完成的 返回之前，与 相关的连接已关闭。 在连接字符串中指定 。 由 SQL Server 在任务对象中返回的任意错误，这些错误是打开连接时出现的。

定义 实例的数据源中的列与该实例的目标表中的列之间的映射。

用于初始化新的 对象的默认构造函数。

创建新的列映射，并使用列序号引用源列和目标列。

数据源中源列的序号位置。 目标表中目标列的序号位置。

创建新的列映射，并使用列序号引用源列和目标列的列名称。

数据源中源列的序号位置。 目标表中目标列的名称。

创建新的列映射，并使用列名称引用源列和目标列的列序号。

数据源中源列的名称。 目标表中目标列的序号位置。

创建新的列映射，并使用列名称引用源列和目标列。

数据源中源列的名称。 目标表中目标列的名称。

正在目标数据库表中映射的列的名称。

属性的字符串值。

目标表中目标列的序号值。

属性的整数值，或者如果尚未设置该属性，则为 -1。

正在数据源中映射的列的名称。

属性的字符串值。

数据源中源列的序号位置。

属性的整数值。

从 继承的 对象的集合。

将指定的映射添加到 中。

描述要添加到集合中的映射的 对象。 一个 对象。

通过使用序号指定源列和目标列，创建一个新的 并将其添加到集合中。

数据源中源列的序号位置。 目标表中目标列的序号位置。 列映射。

通过对源列使用序号和对目标列使用字符串，创建一个新的 并将其添加到集合中。

数据源中源列的序号位置。 目标表中目标列的名称。 列映射。

通过使用列名称描述源列，同时使用序号指定目标列，从而创建一个新的 并将其添加到集合中。

数据源中源列的名称。 目标表中目标列的序号位置。 列映射。

通过使用列名称指定源列和目标列，创建一个新的 并将其添加到集合中。

数据源中源列的名称。 目标表中目标列的名称。 列映射。

清除集合的内容。

获取一个值，该值指示集合中是否存在指定的 对象。

有效的 对象。 如果集合中存在指定映射，则为 ；否则为 。

从特定索引处开始，将 的元素复制到 项的数组。

作为从 复制的元素的目标位置的一维 数组。 该数组的索引必须从零开始。 中从零开始的索引，从此处开始复制。

获取指定 对象的索引。

要搜索的 对象。 列映射的从零开始的索引；如果在集合中未找到该列映射，则为 -1。

在指定索引处插入一个新 。

中要插入新 的位置的整数值。 要插入集合中的 对象。

获取位于指定索引位置的 对象。

要查找的 的从零开始的索引。 一个 对象。

从 中移除指定的 元素。

要从集合中移除的 对象。

从集合中移除指定索引处的映射。

要从集合中移除的 对象的从零开始的索引。

按位标志，指定要与 的实例一起使用的一个或多个选项。

如果指定，AllowEncryptedValueModifications 可启用表或数据库之间加密数据的大容量复制，无需对数据解密。 通常情况下，应用程序会从一个表的加密列中选择数据并且不对数据解密（该应用程序会连接到列加密设置关键字设置为已禁用的数据库），然后使用此选项大容量插入数据（仍然为加密状态）。 有关详细信息，请参阅始终加密。 指定 AllowEncryptedValueModifications 时要格外小心，因为这可能导致数据库损坏，原因是驱动程序不会检查数据是否确实已加密，或者是否使用与目标列相同的加密类型、算法和密钥进行了正确加密。

插入数据时检查约束。 默认情况下，不检查约束。

使用所有选项的默认值。

如果指定，则使服务器激发插入触发器，从而使行插入数据库。

保留源标识值。 未指定标识值时，该值由目标指派。

在目标表中保留 null 值，而不考虑默认值的设置。 如果未指定，由默认值替换 null 值（适用时）。

获取批量复制操作持续时间的批量更新锁定。 如果未指定，则使用行锁定。

如果指定，批量复制操作的每一批都将在事务内发生。 如果指示该选项，并且还向构造函数提供 对象，则发生 。

表示一组方法，这些方法用于创建 提供程序对数据源类的实现的实例。

获取一个指示是否可创建 的值。

如果可创建; 否则为。

返回强类型的 实例。

的新强类型实例。

返回强类型的 实例。

的新强类型实例。

返回强类型的 实例。

的新强类型实例。

返回强类型的 实例。

的新强类型实例。

返回强类型的 实例。

的新强类型实例。

返回一个新的 。

新的数据源枚举器。

返回强类型的 实例。

的新强类型实例。

返回一个新的 。

枚举的一个成员。 的强类型实例。

获取 的实例。 此操作可用于检索强类型数据对象。

有关此成员的说明，请参见 。

一个对象，它指定要获取的服务对象的类型。 服务对象。

表示 SQL 客户端记录器。

初始化 类的新实例。

获取一个值，该值指示是否启用 bid 跟踪。

如果启用 bid 跟踪，则为 ；否则为 。

如果 为 ，则记录指定的消息。

若要记录消息，则为 ；否则为 。 要记录的类型。 记录方法。 要记录的消息。 如果未记录消息，则为 ；否则为 。

通过当前实例类型的指定方法记录错误。

要记录的类型。 记录方法。 要记录的消息。

通过当前实例类型指定的方法记录信息。

要记录的类型。 记录方法。 要记录的消息。

提供一个常数列表，该列表与 GetSchema 方法一起使用以检索元数据集合。

用于 GetSchema 方法的常数，表示 Columns 集合。

用于 GetSchema 方法的常数，表示 Databases 集合。

用于 GetSchema 方法的常数，表示 ForeignKeys 集合。

用于 GetSchema 方法的常数，表示 IndexColumns 集合。

用于 GetSchema 方法的常数，表示 Indexes 集合。

用于 GetSchema 方法的常数，表示 Parameters 集合。

用于 GetSchema 方法的常数，表示 ProcedureColumns 集合。

用于 GetSchema 方法的常数，表示 Procedures 集合。

用于 GetSchema 方法的常数，表示 Tables 集合。

用于 GetSchema 方法的常数，表示 UserDefinedTypes 集合。

用于 GetSchema 方法的常数，表示 Users 集合。

用于 GetSchema 方法的常数，表示 ViewColumns 集合。

用于 GetSchema 方法的常数，表示 Views 集合。

启用用于 SQL Server 的 .NET Framework 数据提供程序，帮助确保用户具有足够的安全级别来访问数据源。

初始化 类的新实例。

初始化 类的新实例。

值之一。

初始化 类的新实例。

值之一。 指示是否允许空白密码。

向 对象添加新的连接字符串和一组限制性关键字。

连接字符串。 关键限制。 枚举之一。

以 形式返回 。

当前权限对象的副本。

将某安全操作与自定义安全特性相关联。

初始化 类的新实例。

一个 值，其表示可使用声明性安全执行的操作。

返回一个 对象，该对象是根据特性属性配置的。

一个 对象。

Windows 证书存储的密钥存储提供程序的实现。 借助此类，可将 Windows 证书存储中存储的证书用作列的主密钥。 有关详细信息，请参阅 Always Encrypted。

Windows 证书存储的密钥存储提供程序。

对列加密密钥的指定加密值进行解密。 加密值预期应使用具有指定密钥路径的证书和指定的算法进行加密。 密钥路径的格式应为“Local Machine/My/<certificate_thumbrint>" or "Current User/My/<certificate_thumbprint>”。

主密钥路径。 加密算法。 当前，唯一有效的值是：RSA_OAEP 加密的列加密密钥。 返回 。已解密的列加密密钥。

使用具有指定密钥路径的证书和使用指定的算法对列加密密钥进行加密。 密钥路径的格式应为“Local Machine/My/<certificate_thumbrint>" or "Current User/My/<certificate_thumbprint>”。

主密钥路径。 加密算法。 当前，唯一有效的值是：RSA_OAEP 加密的列加密密钥。 返回 。加密的列加密密钥。

提供程序名称。

使用 参数引用的列主密钥对列主密钥元数据进行数字签名。

列主密钥路径。 若要指示列主密钥支持 enclave 计算，则为 ；否则为 。 列主密钥元数据的签名。

此函数必须由相应的密钥存储提供程序实现。 此函数应使用由密钥路径标识的非对称密钥，并对由 (masterKeyPath, allowEnclaveComputations, providerName) 组成的主密钥元数据进行验证。

非对称密钥的完整路径。 路径格式专门用于密钥存储提供程序。 一个布尔值，它指示是否可将此密钥发送至受信任的 enclave。 主密钥元数据签名。 一个布尔值，它指示是否能基于提供的签名验证主密钥元数据。

用于将 Microsoft API 下一代加密技术 (CNG) 与 Always Encrypted 结合使用的 CMK 存储提供程序实现。

初始化 类的新实例。

使用由密钥路径和指定算法指定的非对称密钥对给定的加密值进行解密。 密钥路径将采用格式 [ProviderName]/KeyIdentifier，并且应当为存储在指定 CNG 密钥存储提供程序中的非对称密钥。 用于加密/解密 CEK 的有效算法是“RSA_OAEP”。

主密钥路径。 加密算法。 加密的列加密密钥。 已解密的列加密密钥。

通过使用由密钥路径和指定算法所指定的非对称密钥，对给定的纯文本列加密密钥进行加密。 密钥路径将采用格式 [ProviderName]/KeyIdentifier，并且应当为存储在指定 CNG 密钥存储提供程序中的非对称密钥。 用于加密/解密 CEK 的有效算法是“RSA_OAEP”。

主密钥路径。 加密算法。 加密的列加密密钥。 加密的列加密密钥。

提供程序名称“MSSQL_CNG_STORE”的常量字符串。

在所有情况下都会引发 异常。

列主密钥路径。 路径格式专门用于密钥存储提供程序。 若要指示列主密钥支持 enclave 计算，则为 ；否则为 。 列主密钥元数据的签名。 在所有情况下。

此函数必须由相应的密钥存储提供程序实现。 此函数应使用由密钥路径标识的非对称密钥，并对由 (masterKeyPath, allowEnclaveComputations, providerName) 组成的主密钥元数据进行验证。

非对称密钥的完整路径。 路径格式专门用于密钥存储提供程序。 一个布尔值，它指示是否可将此密钥发送至受信任的 enclave。 主密钥元数据签名。 一个布尔值，它指示是否能基于提供的签名验证主密钥元数据。

用于将基于 Microsoft CAPI 的加密服务提供程序 (CSP) 与 Always Encrypted 结合使用的 CMK 存储提供程序实现。

初始化 类的新实例。

使用由密钥路径和算法指定的非对称密钥对给定的加密值进行解密。 密钥路径将采用格式 [ProviderName]/ KeyIdentifier，并且应为存储在指定 CSP 提供程序中的非对称密钥。 用于加密/解密 CEK 的有效算法是“RSA_OAEP”。

主密钥路径。 加密算法。 加密的列加密密钥。 已解密的列加密密钥。

通过使用由密钥路径和指定算法所指定的非对称密钥，对给定的纯文本列加密密钥进行加密。 密钥路径将采用格式 [ProviderName]/ KeyIdentifier，并且应为存储在指定 CSP 提供程序中的非对称密钥。 用于加密/解密 CEK 的有效算法是“RSA_OAEP”。

主密钥路径。 加密算法。 加密的列加密密钥。 加密的列加密密钥。

提供程序名称“MSSQL_CSP_PROVIDER”的常量字符串。

在所有情况下都会引发 异常。

列主密钥路径。 路径格式专门用于密钥存储提供程序。 若要指示列主密钥支持 enclave 计算，则为 ；否则为 。 列主密钥元数据的签名。 在所有情况下。

此函数必须由相应的密钥存储提供程序实现。 此函数应使用由密钥路径标识的非对称密钥，并对由 (masterKeyPath, allowEnclaveComputations, providerName) 组成的主密钥元数据进行签名。

非对称密钥的完整路径。 路径格式专门用于密钥存储提供程序。 一个布尔值，它指示是否可将此密钥发送至受信任的 enclave。 主密钥元数据签名。 一个布尔值，它指示是否能基于提供的签名验证主密钥元数据。

为 Always Encrypted 的 enclave 提供程序定义接口的基类。

初始化 类的新实例。

在派生类中重写后，将执行 enclave 证明、为会话生成对称密钥、创建 enclave 会话，并在缓存中存储会话信息。

提供程序用以证明 enclave 并为会话生成对称密钥的信息。 此信息的格式专门用于 enclave 证明协议。 封装客户端密钥对的 Diffie-Hellman 算法对象。 用于证明 enclave 的证明服务的终结点。 包含 enclave 的 SQL Server 实例的名称。 返回请求的 enclave 会话；如果提供程序未执行会话缓存，则返回 。 SqlClient 每次从缓存中检索会话时 enclave 提供程序预期递增的计数器。 此字段的用途是预防重播攻击。

获取 SqlClient 随后用于启动证明 enclave 的进程和建立具有 enclave 的安全会话的信息。

SqlClient 随后用于启动证明 enclave 的进程和建立具有 enclave 的安全会话的信息。

在派生类中重写后，将查找 enclave 会话缓存中的现有 enclave 会话信息。 如果 enclave 提供程序未执行 enclave 会话缓存，此方法应在 参数中返回 。

包含 enclave 的 SQL Server 实例的名称。 用于证明 enclave 的证明服务 SqlClient 联系人的终结点。 此方法将返回请求的 enclave 会话；如果提供程序未执行会话缓存，则返回 。 该参数未经初始化即被处理。 SqlClient 每次从缓存中检索会话时 enclave 提供程序预期递增的计数器。 此字段的用途是预防重播攻击。

在派生类中重写后，如果提供程序实现会话缓存，将从 enclave 会话缓存中查找并逐出 enclave 会话。

包含 enclave 的 SQL Server 实例的名称。 用于证明 enclave 的证明服务 SqlClient 联系人的终结点。 要令其失效的会话。

所有密钥存储提供程序的基类。 自定义提供程序必须从此类中派生而来并重写其成员函数，然后使用 SqlConnection.RegisterColumnEncryptionKeyStoreProviders() 对其进行注册。 有关详细信息，请参阅 Always Encrypted。

初始化 SqlColumnEncryptionKeyStoreProviderClass 的新实例。

对列加密密钥的指定加密值进行解密。 加密值预期应使用具有指定密钥路径的列主密钥和使用指定的算法进行加密。

主密钥路径。 加密算法。 加密的列加密密钥。 返回 。已解密的列加密密钥。

使用具有指定密钥路径的列主密钥和使用指定的算法对列加密密钥进行加密。

主密钥路径。 加密算法。 加密的列加密密钥。 返回 。加密的列加密密钥。

在派生类中实现时，使用 参数引用的列主密钥对列主密钥元数据进行数字签名。 用于生成签名的输入值应为 和 参数的指定值。

列主密钥路径。 若要指示列主密钥支持 enclave 计算，则为 ；否则为 。 列主密钥元数据的签名。 在所有情况下。

在派生类中实现时，此方法应验证指定签名对于具有指定密钥路径和指定 enclave 行为的列主密钥是否有效。 默认实现会引发 NotImplementedException。

列主密钥路径。 指示列主密钥是否支持 enclave 计算。 列主密钥元数据的签名。 在派生类中实现时，如果指定签名有效，此方法应返回 true；如果指定签名无效，则返回 false。 默认实现会引发 NotImplementedException。

表示要对 SQL Server 数据库执行的一个 Transact-SQL 语句或存储过程。 此类不能被继承。

初始化 类的新实例。

使用查询的文本初始化 类的新实例。

查询的文本。

使用查询的文本和 初始化 类的新实例。

查询的文本。 表示到 SQL Server 实例的连接的 。

使用查询文本、 以及 初始化 类的新实例。

查询的文本。 表示到 SQL Server 实例的连接的 。 其中执行 的 。

使用指定的命令文本、连接、事务和加密设置初始化 类的新实例。

查询的文本。 表示到 SQL Server 实例的连接的 。 其中执行 的 。 加密设置。 有关详细信息，请参阅始终加密。

启动此 描述的 Transact-SQL 语句或存储过程的异步执行。

可用于轮询和/或等待结果的 ；当调用可返回受影响的行数的 时，也需要该值。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

在给定回调过程和状态信息的情况下，启动此 描述的 Transact-SQL 语句或存储过程的异步执行。

命令执行完成时调用的 委托。 传递 （在 Microsoft Visual Basic 中为 ）以指示不需要回调。 传递到回调过程的用户定义的状态对象。 使用 属性从回调过程内检索此对象。 可用于轮询和/或等待结果的 ；当调用可返回受影响的行数的 时，也需要该值。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

启动此 描述的 Transact-SQL 语句或存储过程的异步执行，并从服务器中检索一个或多个结果集。

可用于轮询和/或等待结果的 ；在调用 时，也需要该值。该调用会返回一个可用于检索返回行的 实例。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

在给定回调过程和状态信息的情况下，启动此 描述的 Transact-SQL 语句或存储过程的异步执行，并从服务器中检索一个或多个结果集。

命令执行完成时调用的 委托。 传递 （在 Microsoft Visual Basic 中为 ）以指示不需要回调。 传递到回调过程的用户定义的状态对象。 使用 属性从回调过程内检索此对象。 可用于轮询和/或等待结果的 ；当调用会返回可用于检索返回行的 实例的 时，也需要该值。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

在给定回调过程和状态信息的情况下，通过使用 值之一并从服务器中检索一个或多个结果集，启动由此 描述的 Transact-SQL 语句或存储过程的异步执行。

命令执行完成时调用的 委托。 传递 （在 Microsoft Visual Basic 中为 ）以指示不需要回调。 传递到回调过程的用户定义的状态对象。 使用 属性从回调过程内检索此对象。 值之一，指示用于语句执行和数据检索的选项。 可用于轮询和/或等待结果的 ；在调用 时，也需要该值。该调用会返回一个可用于检索返回行的 实例。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

通过使用 值之一，启动此 描述的 Transact-SQL 语句或存储过程的异步执行。

值之一，指示用于语句执行和数据检索的选项。 可用于轮询和/或等待结果的 ；当调用会返回一个可用于检索返回行的 实例的 时，也需要该值。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

启动此 描述的 Transact-SQL 语句或存储过程的异步执行，并将结果作为 对象返回。

可用于轮询和/或等待结果的 ；当调用会返回单个 XML 值的 时，也需要该值。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

通过使用回调过程，启动此 描述的 Transact-SQL 语句或存储过程的异步执行，并将结果作为 对象返回。

命令执行完成时调用的 委托。 传递 （在 Microsoft Visual Basic 中为 ）以指示不需要回调。 传递到回调过程的用户定义的状态对象。 使用 属性从回调过程内检索此对象。 可用于轮询和/或等待结果的 ；当调用 时，也需要该值，用于将命令的结果作为 XML 返回。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 执行命令文本时出现的任何错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 名称/值对“Asynchronous Processing=true”未包含在为此 定义连接的连接字符串中。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

尝试取消 的执行。

创建属于当前实例的副本的新 对象。

属于此实例副本的新 对象。

获取或设置此命令的列加密设置。

此命令的列加密设置。

获取或设置要在数据源中执行的 Transact-SQL 语句、表名或存储过程。

要执行的 Transact-SQL 语句或存储过程。 默认值为一个空字符串。

获取或设置在终止尝试执行命令并生成错误之前的等待时间。

等待命令执行所需的时间（以秒为单位）。 默认值为 30 秒。

获取或设置一个值，该值指示解释 属性的方式。

值之一。 默认值为 。 该值不是有效的 。

获取或设置 的此实例使用的 。

到数据源的连接。 默认值为 。 命令在事务中登记时 属性被更改。

创建 对象的新实例。

一个 对象。

获取或设置一个值，该值指示命令对象是否应在 Windows 窗体设计器控件中可见。

一个指示命令对象是否应在控件中可见的值。 默认值为 。

完成 Transact-SQL 语句的异步执行。

通过调用 返回的 。 受影响的行数（与 相同的行为）。 参数为 null（在 Microsoft Visual Basic 中为 ） 不止一次为单个命令执行调用了 ，或该方法不匹配其执行方法（例如，代码调用了 以完成对 调用的执行。 中指定的时间已过，并且使用 指定的异步操作不完整。 在某些情况下， 可能不正确地设置为 。 如果发生这种情况并且调用 ，则 EndExecuteNonQuery 可能引发 SqlException 错误（如果 中指定的时间已过，并且使用 指定的异步操作不完整）。 若要更正这种情况，应增加 CommandTimeout 的值或减少正由异步操作完成的工作。

完成 Transact-SQL 语句的异步执行，从而返回请求的 。

通过调用 返回的 。 可用于检索请求行的 对象。 参数为 null（在 Microsoft Visual Basic 中为 ） 不止一次为单个命令执行调用了 ，或该方法不匹配其执行方法（例如，代码调用了 以完成对 调用的执行。

完成 Transact-SQL 语句的异步执行，从而将请求的数据以 XML 形式返回。

通过调用 返回的 。 可用于获取生成的 XML 数据的 对象。 参数为 null（在 Microsoft Visual Basic 中为 ） 不止一次为单个命令执行调用了 ，或该方法不匹配其执行方法（例如，代码调用了 以完成对 调用的执行。

对连接执行 Transact-SQL 语句并返回受影响的行数。

受影响的行数。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 对锁定的行执行命令时出现异常。 当使用 Microsoft .NET Framework 1.0 版时不生成此异常。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，它对连接执行 Transact-SQL 语句并返回受影响的行数。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

将 发送到 ，并生成 。

一个 对象。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 对锁定的行执行命令时出现异常。 当使用 Microsoft .NET Framework 1.0 版时不生成此异常。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 连接的当前状态已关闭。 需要打开 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

将 发送到 ，并使用 值之一生成 。

值之一。 一个 对象。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，它可以将 发送到 ，并生成 。 将通过返回的任务对象报告异常。

表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 无效的 值。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，用于将 发送到 ，并生成一个 。 将通过返回的任务对象报告异常。

语句执行和数据检索的选项。 当设置为 时， 将在返回完整任务前读取整行。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 无效的 值。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，它可以将 发送到 ，并生成 。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

语句执行和数据检索的选项。 当设置为 时， 将在返回完整任务前读取整行。 取消指令。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 无效的 值。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，它可以将 发送到 ，并生成 。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 无效的 值。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

执行查询，并返回由查询返回的结果集中的第一行的第一列。 其他列或行将被忽略。

为结果集中的第一行的第一列，或者，如果结果集为空，则为 null 引用（在 Visual Basic 中为 ）。 返回的最大字符数为 2033 个字符。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 对锁定的行执行命令时出现异常。 当使用 Microsoft .NET Framework 1.0 版时不生成此异常。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，该版本异步执行查询，并返回由查询返回的结果集中的第一行的第一列。 其他列或行将被忽略。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

将 发送到 ，并生成一个 对象。

一个 对象。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 对锁定的行执行命令时出现异常。 当使用 Microsoft .NET Framework 1.0 版时不生成此异常。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，可以将 发送到 ，并生成 对象。 将通过返回的任务对象报告异常。

表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

的异步版本，可以将 发送到 ，并生成 对象。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 将 设置为 时，使用的是 而不是 Binary 或 VarBinary。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 将 设置为 时，使用的是 而不是 Char、NChar、NVarChar、VarChar 或 Xml。 将 设置为 时，使用的是 而不是 Xml。 在完成任务前，为同一个实例多次调用 。 流式处理操作期间关闭或删除了 。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。 流式处理操作期间发生了超时。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间在 、 或 对象中出现了错误。 有关流式处理的详细信息，请参阅 SqlClient 流支持。 流式处理操作期间关闭了 、 或 对象。 有关流式处理的详细信息，请参阅 SqlClient 流支持。

获取或设置一个指定绑定到此命令的 对象的值。

如果设置为 null（默认值），则不应请求任何通知。

获取或设置一个值，该值指示应用程序是否应自动接收来自通用 对象的查询通知。

如果应用程序应自动接收查询通知;否则为。 默认值为 。

获取 。

Transact-SQL 语句或存储过程的参数。 默认值为空集合。

在 SQL Server 的实例上创建命令的一个准备版本。

将 属性重置为其默认值。

当 Transact-SQL 语句执行完成时发生。

创建属于当前实例的副本的新 对象。

属于此实例副本的新 对象。

获取或设置要在其中执行 的 。

。 默认值为 。

获取或设置命令结果在由 的 Update 方法使用时应用于 的方式。

值之一。

自动生成用于协调通过关联的 SQL Server 数据库对 所做更改的单表命令。 此类不能被继承。

初始化 类的新实例。

使用关联的 对象初始化 类的新实例。

的名称。

对于 类的实例，设置或获取 。

一个 对象。

设置或获取一个字符串，该字符串用作 类的实例的目录分隔符。

指示要用于 类的目录分隔符的字符串。

获取或设置自动为其生成 Transact-SQL 语句的一个 对象。

一个 对象。

从在 中指定的存储过程中检索参数信息并填充指定的 对象的 集合。

引用将从其中导出参数信息的存储过程的 。 将派生参数添加到 的 集合中。 此命令文本不是一个有效的存储过程名。

获取自动生成的、对数据库执行删除操作所需的 对象。

自动生成的、执行删除操作所需的 对象。

获取自动生成的、对数据库执行删除操作所需的 对象。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行删除操作所需的 对象。

获取自动生成的、对数据库执行插入操作所需的 对象。

自动生成的、执行插入操作所需的 对象。

获取自动生成的、对数据库执行插入操作所需的 对象。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行插入操作所需的 对象。

获取自动生成的、对数据库执行更新操作所需的 对象。

自动生成的、执行更新所需的 对象。

获取自动生成的、对数据库执行更新操作所需的 对象。

如果为 ，则生成与列名匹配的参数名（如果可能）。 如果为 ，则生成 @p1、@p2，以此类推。 自动生成的、执行更新所需的 对象。

给定了具有正确的目录大小写设置且不带引号的标识符时，返回该标识符的正确的带引号形式。 这包括正确地转义该标识符中的任何嵌入引号。

不带引号的原始标识符。 带引号的标识符版本。 标识符内的嵌入引号被正确地转义。

获取或设置在指定其名称中包含空格或保留标记等字符的 SQL Server 数据库对象（如表或列）时使用的一个或多个起始字符。

要使用的一个或多个起始字符。 默认值为一个空字符串。 在生成 INSERT、UPDATE 或 DELETE 命令后，不能更改此属性。

获取或设置在指定其名称中包含空格或保留标记等字符的 SQL Server 数据库对象（如表或列）时使用的一个或多个结束字符。

要使用的结束字符。 默认值为一个空字符串。 当生成 Insert、Update 或 Delete 命令后，不能更改此属性。

获取或设置要用作架构标识符和任何其他标识符之间的分隔符的字符。

要用作架构分隔符的字符。

给定了带引号的标识符时，返回该标识符的正确的不带引号的形式。 这包括正确地非转义该标识符的所有嵌入的引号。

其嵌入引号将被移除的标识符。 未加引号的标识符，其嵌入的引号已正确进行非转义。

指定读取和写入加密列时将如何发送及接收数据。 根据特定的查询，正当使用非加密列时跳过 Always Encrypted 驱动程序的处理可能会降低性能影响。 请注意这些设置不能用于绕过加密以及获取纯文本数据的访问权限。 有关详细信息，请参阅 Always Encrypted（数据库引擎）。

对查询禁用 Always Encrypted。

为查询启用 Always Encrypted。

指定驱动程序中 Always Encrypted 例程应只能处理命令的结果。 当命令不具有需要加密的任何参数时使用此值。

指定该命令应默认为连接字符串中的 Always Encrypted 设置。

表示到 SQL Server 数据库的连接。 此类不能被继承。

初始化 类的新实例。

如果给定包含连接字符串的字符串，则初始化 类的新实例。

用于打开 SQL Server 数据库的连接。

在给定连接字符串的情况下，初始化 类的新实例，该连接字符串不使用 和包含用户 ID 和密码的 对象。

不使用 或以下任何连接字符串关键字的连接字符串：、 或 。 一个 对象。 如果 为 null，则 在功能上等效于 。

获取或设置用于连接的访问令牌。

用于连接的访问令牌。

开始数据库事务。

表示新事务的对象。 使用多个活动结果集 (MARS) 时，不允许并行事务。 不支持并行事务。

以指定的隔离级别启动数据库事务。

事务应在其下运行的隔离级别。 表示新事务的对象。 使用多个活动结果集 (MARS) 时，不允许并行事务。 不支持并行事务。

以指定的隔离级别和事务名称启动数据库事务。

事务应在其下运行的隔离级别。 事务名称。 表示新事务的对象。 使用多个活动结果集 (MARS) 时，不允许并行事务。 不支持并行事务。

以指定的事务名称启动数据库事务。

事务名称。 表示新事务的对象。 使用多个活动结果集 (MARS) 时，不允许并行事务。 不支持并行事务。

更改已打开的 的当前数据库。

要代替当前数据库加以使用的数据库的名称。 数据库名称无效。 连接未打开。 不能更改数据库。

更改 对象中指示的用户的 SQL Server 密码。

包含连接至服务器的足够信息的连接字符串。 连接字符串不应使用以下任何一个连接字符串关键字：、 或 ；或 。 一个 对象。 新密码 必须为只读。 该密码也必须符合服务器上设置的任何密码安全策略（例如：最小长度、特定字符要求）。 连接字符串包含 、 或 的任意组合。 或 - 连接字符串包含 。 或 - （或 ）的长度超过 128 个字符。 或 - （或 ）不是只读的。 或 - （或 ）是一个空字符串。 其中一个参数（、 或 ）为 null。

将连接字符串中指示的用户的 SQL Server 密码更改为提供的新密码。

包含连接至所需服务器的足够信息的连接字符串。 连接字符串必须包含用户 ID 和当前密码。 要设置的新密码。 此密码必须符合服务器上设置的任何密码安全策略，包括最小长度、特定字符要求等等。 连接字符串包括将使用集成安全性的选项。 Or 超过了 128 个字符。 或 参数为 null。

清空连接池。

清空与指定连接关联的连接池。

要从池中清除的 。

最近连接尝试连接的 ID，无论该尝试是成功还是失败。

最近连接尝试的连接 ID。

关闭与数据库之间的连接。 此方法是关闭任何打开连接的首选方法。

打开连接时出现的连接级别的错误。

在用于 Always Encrypted 功能的列加密密钥缓存中，获取或设置列加密密钥项的生存时间。 默认值为 2 小时。 0 表示无缓存。

时间间隔。

获取或设置一个值，该值指示对参数化查询（针对已启用 Always Encrypted 的数据库运行）已启用 (True) 还是未启用 (False) 查询元数据缓存。 默认值为 true。

如果启用查询元数据缓存，则返回 True；否则返回 False。 默认为 True。

允许你设置数据库服务器的受信任密钥路径列表。 如果在处理应用程序查询时驱动程序接收到不位于列表中的密钥路径，则查询会失败。 此属性针对安全攻击提供附加保护，这些安全攻击涉及提供伪造密钥路径的受威胁的 SQL Server，可能导致密钥存储凭据泄露。

适用于列加密的受信任主密钥路径的列表。

获取或设置用于打开 SQL Server 数据库的字符串。

连接字符串，其中包含源数据库名称和建立初始连接所需的其他参数。 默认值为一个空字符串。 提供了一个无效的连接字符串参数，或者未提供所需的连接字符串参数。

获取终止尝试并生成错误之前在尝试建立连接时所等待的时间。

等待连接打开所需的时间（以秒为单位）。 默认值为 15 秒。 设置的值小于 0。

创建并返回与 关联的 对象。

一个 对象。

获取或设置此连接的 对象。

此连接的 对象。

获取当前数据库的名称或打开连接后要使用的数据库的名称。

当前数据库的名称或打开连接后要使用的数据库的名称。 默认值为一个空字符串。

获取要连接的 SQL Server 的实例的名称。

要连接到 SQL Server 实例的名称。 默认值为一个空字符串。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

在指定的事务中登记为分布式事务。

对用于登记的现有 的引用。

获取或设置 属性。

如果已设置了 属性，则为 ；否则为 。

返回此 的数据源的架构信息。 有关架构的详细信息，请参阅 SQL Server 架构集合。

一个包含架构信息的 。

通过使用架构名称的指定字符串，返回此 的数据源的架构信息。

指定要返回的架构的名称。 一个包含架构信息的 。 将 指定为 null。

通过使用指定字符串作为架构名称，指定字符串数组作为限制值，返回此 的数据源的架构信息。

指定要返回的架构的名称。 请求的架构的一组限制值。 一个包含架构信息的 。 将 指定为 null。

当 SQL Server 返回一个警告或信息性消息时发生。

使用由 指定的属性设置打开一个数据库连接。

如果不指定数据源或服务器，则无法打开连接。 或 连接已打开。 打开连接时出现的连接级别错误。 如果 属性包含值 18487 或 18488，这表明指定的密码已过期或必须重置。 有关更多信息，请参阅 方法。 App.config 文件中的 标记具有无效或未知元素。 部分中有两个具有相同名称的条目。

的异步版本，打开 指定的属性设置的数据库连接。 取消标记可用于请求在连接超时超过前放弃操作。 异常将通过返回的任务传播。 如果在未成功连接的情况下连接超时时间已过，则返回的任务将被标记为“附带异常出错”。 实现返回一个不带有用于共用和非共用连接的锁定调用线程的“任务”。

取消指令。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在连接字符串中指定 。 在经过连接超时时间之前从连接池中的连接不可用。 打开连接时出现的任何由 SQL Server 返回的错误。

获取用于与 SQL Server 的实例进行通信的网络数据包的大小（以字节为单位）。

网络数据包的大小（以字节为单位）。 默认值为 8000。

注册列加密密钥存储提供程序。

自定义提供程序

如果启用了统计信息收集，所有值都将重置为零。

调用此方法时，将返回统计信息的名称值对集合。

返回 项的 类型的引用。

获取一个字符串，其中包含客户端所连接到的 SQL Server 的实例的版本。

SQL Server 实例的版本。 连接已关闭。 当返回的任务未完成，且在调用 后未打开连接时，调用了 。

最近在连接上执行网络操作时表示 的状态。

一个 枚举。

如果设置为 ，则对当前连接启用统计信息收集。

如果启用了统计信息收集，则返回 ；否则返回 。 默认为 。

创建作为当前实例副本的新对象。

作为此实例副本的新对象。

获取一个标识数据库客户端的字符串。

一个标识数据库客户端的字符串。 如果未指定，则为客户端计算机的名称。 如果两个都没有指定，则值为空字符串。

指定在连接中启用“始终加密”功能。 请注意这些设置不能用于绕过加密以及获取纯文本数据的访问权限。 有关详细信息，请参阅 Always Encrypted（数据库引擎）。

指定连接不使用“始终加密”功能。 如果未通过该连接发送访问加密列的查询，则应使用此设置。

启用连接的“始终加密”功能。 将以透明方式加密与加密列对应的查询参数和加密列的查询结果。

为创建和管理由 类使用的连接字符串的内容提供了一种简单方法。

初始化 类的新实例。

初始化 类的新实例。 所提供的连接字符串为实例的内部连接信息提供数据。

对象内部连接信息的基础。 分析为名称/值对。 无效的键名会引发 。 连接字符串中包含无效的键名。 连接字符串中包含无效的值（具体而言，需要使用布尔值或数值，但字符串中并未提供）。 所提供的 无效。

连接到 SQL Server 可用性组中的数据库时声明应用程序工作负荷类型。 您可以使用 设置此属性的值。 有关对 Always On 可用性组的 SqlClient 支持的详细信息，请参阅对高可用性、灾难恢复的 SqlClient 支持。

返回该属性的当前值（类型 的值）。

获取或设置与连接字符串关联的应用程序的名称。

应用程序的名称；或者，如果未提供名称，则为“.NET SqlClient Data Provider”。 若要将值设置为 null，请使用 。

获取或设置一个布尔值，该值指定使用此连接字符串创建的连接是否允许异步处理。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置包含主数据文件名称的字符串。 该字符串包括可附加数据库的完整路径名。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取连接字符串的身份验证。

连接字符串的身份验证。

清除 实例的内容。

获取或设置连接字符串生成器的列加密设置。

连接字符串生成器的列加密设置。

已过时。 获取或设置一个布尔值，该值指示在从连接池中提取连接时是否重置连接。

属性的值；如果未提供任何值，则为 true。

在确定有一个空闲的连接失败之后尝试重新连接的次数。 该值必须是介于 0 和 255 之间的整数。 默认值为 1。 设置为 0 将禁止在空闲连接失败时重新连接。 如果设置的值超过允许的范围，则将引发 。

在确定有一个空闲的连接失败之后尝试重新连接的次数。

标识空闲连接失败之后每次重新连接尝试之间的时间量（以秒为单位）。 此值必须是介于 1 和 60 之间的整数。 默认值为 10 秒。 如果设置的值超过允许的范围，则将引发 。

标识空闲连接失败之后每次重新连接尝试之间的时间量（以秒为单位）。

获取或设置在终止尝试并产生错误之前，等待与服务器连接的时间长度（以秒为单位）。

属性的值；如果未提供任何值，则为 15 秒。

确定 是否包含特定键。

要在 中定位的键。 如果 包含具有指定键的元素，则为 true；否则为 false。 为 Null（在 Visual Basic 中为 ）

获取或设置一个值，该值指示应建立与 SQL Server 的客户端/服务器连接还是进程内连接。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置 SQL Server 语言记录名称。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置要连接到的 SQL Server 实例的名称或网络地址。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置要与基于 enclave 的 Always Encrypted 搭配使用的 enclave 证明 URL。

enclave 证明 URL。

获取或设置一个布尔值，该值指示在服务器安装了证书的情况下，SQL Server 是否为客户端和服务器之间发送的所有数据使用 SSL 加密。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置一个布尔值，该值指示 SQL Server 连接池程序是否在创建线程的当前事务上下文中自动登记连接。

为 属性的值，或者，如果未提供任何值，则为 。

获取或设置在主服务器停机时要连接到的伙伴服务器的名称或地址。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置与该连接关联的数据库的名称。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置一个布尔值，该值指示是否在连接中指定用户 ID 和密码（值为 时），或者是否使用当前的 Windows 帐户凭据进行身份验证（值为 时）。

为 属性的值，或者，如果未提供任何值，则为 。

获取一个值，该值指示 是否具有固定大小。

任何情况下都为 ，因为 提供固定大小的键/值对集合。

获取或设置与指定的键关联的值。 在 C# 中，此属性为索引器。

要获取或设置的项的键。 与指定的键相关联的值。 为空引用（在 Visual Basic 中为 ）。 尝试添加的键不存在于可用键内。 连接字符串中包含无效的值（具体而言，需要使用布尔值或数值，但字符串中并未提供）。

获取包含 中的键的 。

一个 ，它包含 中的键。

获取或设置连接被销毁前在连接池中存活的最短时间（以秒为单位）。

属性的值，如果未提供任何值，则为 0。

获取或设置针对此特定连接字符串连接池中所允许的最大连接数。

属性的值；如果未提供任何值，则为 100。

获取或设置针对此特定连接字符串连接池中所允许的最小连接数。

属性的值，如果未提供任何值，则为 0。

如果为 true，则应用程序可以维护多个活动结果集 (MARS)。 如果为 false，则应用程序必须先处理或取消某一批中的所有结果集，才可以在该连接上执行任何其他批次。 有关详细信息，请参阅多个活动结果集 (MARS)。

为 属性的值，或者，如果未提供任何值，则为 。

如果您的应用程序要连接到不同子网上的 AlwaysOn 可用性组 (AG)，则设置 MultiSubnetFailover=true 会加快检测（当前）活动服务器以及与服务器的连接。 有关对 Always On 可用性组的 SqlClient 支持的详细信息，请参阅对高可用性、灾难恢复的 SqlClient 支持。

返回 ，这指示属性的当前值。

获取或设置一个字符串，该字符串包含用于建立与 SQL Server 的连接的网络库的名称。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置用来与 SQL Server 的实例通信的网络数据包的大小（以字节为单位）。

属性的值；如果未提供任何值，则为 8000。

获取或设置 SQL Server 帐户的密码。

为 属性的值，或者，如果未提供任何值，则为 。 密码错误地设置为 null。 请参阅下面的代码示例。

获取或设置一个布尔值，该值指示如果连接是打开的或者一直处于打开状态，那么安全敏感信息（如密码）是否将不作为连接的一部分返回。

为 属性的值，或者，如果未提供任何值，则为 。

连接池的暂停时段行为。

可用的暂停时段设置。

获取或设置一个布尔值，该值指示每次请求连接时该连接是汇入连接池还是显式打开。

为 属性的值，或者，如果未提供任何值，则为 。

从 实例中移除具有指定的键的项。

要从此 中的连接字符串移除的键/值对中的键。 如果该键存在于连接字符串中并已被移除，则为 ；如果该键不存在，则为 。 为 Null（在 Visual Basic 中为 ）

获取或设置一个布尔值，该值指示是否使用连接来支持复制。

属性的值；如果未提供任何值，则为 false。

指示此 实例中是否存在指定的键。

要在 中定位的键。 如果 包含具有指定键的项，则为 ；否则为 。

获取或设置一个字符串值，该值表示连接如何保持与登记的 事务的关联。

为 属性的值，或者，如果未提供任何值，则为 。

将该键的值设置为 时，需要应用程序检索特定 DNS 条目的所有 IP 地址并尝试连接到列表中的第一个地址。 如果未在 0.5 秒内建立连接，应用程序将尝试并行连接到所有其他地址。 第一个地址响应后，应用程序将与响应的 IP 地址建立连接。

一个布尔值。

获取或设置一个值，该值指示在跳过用于验证信任的证书链遍历时是否加密信道。

。 已识别的值为 、、 和 。

从此 中检索与提供的键相对应的值。

要检索的项的键。 与 对应的值。 如果在连接字符串中找到 ，则为 ；否则为 。 包含一个 null 值（在 Visual Basic 中为 ）。

获取或设置一个字符串值，该值指示应用程序所需的类型系统。

下表列出了 属性的可能值： 值 描述 SQL Server 2005 使用 SQL Server 2005 类型系统。 未对当前版本的 ADO.NET 执行转换。 SQL Server 2008 使用 SQL Server 2008 类型系统。 最新 使用此客户端/服务器对能够处理的最新版本。 这个最新版本将随着客户端和服务器组件的升级自动更新。

获取或设置连接到 SQL Server 时要使用的用户 ID。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取或设置一个值，该值指示是否将连接从默认的 SQL Server Express 实例重定向到在调用方帐户之下运行并且在运行时启动的实例。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

获取包含 中的值的 。

一个 ，包含 中的值。

获取或设置连接到 SQL Server 的工作站的名称。

为 属性的值，或者，如果未提供任何值，则为 。 若要将值设置为 null，请使用 。

提供了更安全的方式来指定使用 SQL Server 身份验证尝试登录的密码。 由用户 ID 和将用于 SQL Server 身份验证的密码构成。 对象中的密码是 类型。 无法继承 。 Windows 身份验证 () 仍是登录到 SQL Server 数据库的最安全的方式。

创建 类型的对象。

用户 ID。 密码；标记为只读的 值。 通过一个读/写 参数将引发 。

获取 对象的密码组件。

密码组件对象。

获取 对象的用户 ID 组件。

用户 ID 组件对象。

表示用于填充 和更新 SQL Server 数据库的一组数据命令和一个数据库连接。 此类不能被继承。

初始化 类的新实例。

初始化 类的新实例，用指定的 作为 的属性。

一个 （可以是 Transact-SQL SELECT 语句或存储过程），已设置为 的 属性。

使用 和 对象初始化 类的一个新实例。

一个 ，它是将要由 的 属性使用的 Transact-SQL SELECT 语句或存储过程。 表示该连接的 。 如果连接字符串不使用 ，则可以使用 来传递用户 ID 和密码，这比将用户 ID 和密码指定为连接字符串中的文本更安全。

用 和一个连接字符串初始化 类的一个新实例。

一个 ，它是将要由 的 属性使用的 Transact-SQL SELECT 语句或存储过程。 连接字符串。 如果连接字符串不使用 ，可以使用 和 来通过用户 ID 和密码比在连接字符串的文本中指定用户 ID 和密码更安全。

获取或设置一个 Transact-SQL 语句或存储过程，以从数据集删除记录。

在 过程中使用 ，以在数据库中删除对应于 中已删除行的记录。

获取或设置一个 Transact-SQL 语句或存储过程，以在数据源中插入新记录。

在 过程中使用 ，以在数据库中插入对应于 中的新行的记录。

在对数据源执行命令后的 过程中发生。 尝试进行更新，因此激发了该事件。

在对数据源执行命令前的 过程中发生。 尝试进行更新，因此激发了该事件。

获取或设置一个 Transact-SQL 语句或存储过程，用于在数据源中选择记录。

在 过程中使用的 ，用来从数据库中为 中的位置选择记录。

有关此成员的说明，请参见 。

期间使用的 ，用于为数据集中已删除行删除数据源中的记录。

有关此成员的说明，请参见 。

在 过程中使用的 ，它针对数据集中的新行将记录插入到数据源。

有关此成员的说明，请参见 。

在 过程中使用的 ，它从数据源中选择记录以便放入数据集中。

有关此成员的说明，请参见 。

在 过程中使用的 ，它针对数据集中已修改的行更新数据源中的记录。

有关此成员的说明，请参见 。

作为当前实例副本的新对象。

获取或设置每次到服务器的往返过程中处理的行数。

每一批处理的行数。 值为 效果 0 批大小没有限制。 1 禁用批量更新。 >1 更改是使用 操作的批处理一次性发送的。 当设置为 1 以外的值，与相关联的所有命令必须具有其UpdatedRowSource属性设置为或。 否则将引发异常。

获取或设置一个 Transact-SQL 语句或存储过程，用于更新数据源中的记录。

在 过程中使用的 ，用于在数据库中更新对应于 中已修改行的记录。

提供一种从 SQL Server 数据库中读取只进的行流的方式。 此类不能被继承。

关闭 对象。

获取与 关联的 。

与 关联的 。

获取一个值，用于指示当前行的嵌套深度。

当前行的嵌套深度。

获取当前行中的列数。

如果未放在有效的记录集中，则为 0；否则为当前行中的列数。 默认值为 -1。 没有对 SQL Server 实例的当前连接。

以布尔值的形式获取指定列的值。

从零开始的列序号。 列的值。 指定的强制转换无效。

以字节的形式获取指定列的值。

从零开始的列序号。 指定列的字节形式的值。 指定的强制转换无效。

从指定的列偏移量将字节流读入缓冲区，并将其作为从给定的缓冲区偏移量开始的数组。

从零开始的列序号。 字段中的索引，从其开始读取操作。 要读入字节流的缓冲区。 中写入操作开始位置的索引。 复制到缓冲区中的最大长度。 读取的实际字节数。

以单个字符的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

从指定的列偏移量将字符流作为数组从给定的缓冲区偏移量开始读入缓冲区。

从零开始的列序号。 字段中的索引，从其开始读取操作。 要读入字节流的缓冲区。 中写入操作开始位置的索引。 复制到缓冲区中的最大长度。 读取的实际字符数。

获取一个表示指定列的数据类型的字符串。

要查找的列的从零开始的序号位置。 表示指定列的数据类型的字符串。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

检索指定列的 对象形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 对象的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以双精度浮点数字的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

返回循环访问 的 。

的一个 。

获取作为对象的数据类型的 。

从零开始的列序号。 作为对象的数据类型的 。 在用户定义的类型 (UDT) 从数据库中返回的情况下，如果客户端上不存在该类型，则 GetFieldType 返回 null。

同步获取作为类型的指定列的值。 是此方法的异步版本。

要检索的列。 要返回的值的类型。 返回的类型对象。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 该列中的值为 null ( == )，检索非 SQL 类型。 与 SQL Server 返回的类型不匹配或无法进行强制转换。

异步获取作为类型的指定列的值。 是此方法的同步版本。

要检索的列。 取消指示，用于对应该取消操作的通知进行传播。 此构造函数不对取消做保证。 设置为 将此方法等效于 。 返回任务必须标记为已取消。 要返回的值的类型。 返回的类型对象。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 在连接字符串中指定 。 尝试读取不存在的列。 该列中的值为 null ( == )，检索非 SQL 类型。 与 SQL Server 返回的类型不匹配或无法进行强制转换。

以单精度浮点数字的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的值作为全局唯一标识符 (GUID)。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 16 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的 32 位带符号整数形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

以 64 位有符号整数的形式获取指定列的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列的名称。

从零开始的列序号。 指定列的名称。

在给定列名时获取相应的列序号。

列的名称。 从零开始的列序号。 指定的名称不是有效的列名。

获取一个 ，它表示基础提供程序特定的字段类型。

表示列序号的 。 获取一个 ，它表示基础提供程序特定的字段类型。

获取一个表示基础提供程序特定值的 。

表示列序号的 。 一个 ，它表示基础提供程序特定值。

获取表示基础提供程序特定值的对象的数组。

要将列值复制到其中的 数组。 对象数组，它表示基础提供程序特定的值。

返回一个描述 的列元数据的 。

一个描述列元数据的 。 已关闭。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 列的值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

获取指定列的 形式的值。

从零开始的列序号。 表示为 的列值。

返回指定列中 SQL Server 类型的数据值。

从零开始的列序号。 表示为 的列值。

填充包含记录中所有列的值的 数组，这些值表示为 SQL Server 类型。

要将值复制到其中的 数组。 这些列值表示为 SQL Server 类型。 表示复制的列数的整数。 为 null。

获取指定列的 XML 值形式的值。

从零开始的列序号。 包含相应字段中存储的 XML 的 值。 传递的索引在 0 至 -1 的范围之外。 已尝试读取或访问关闭的 中的列。 检索的数据与 类型不兼容。

检索作为 的二进制、图像、varbinary、UDT 和变量数据类型。

从零开始的列序号。 一个流对象。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 返回的类型不属于以下类型之一： binary image varbinary udt

获取指定列的字符串形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

检索作为 的 Char、 NChar、 NText、 NVarChar、 text、 varChar 和 Variant data types。

要检索的列。 返回的对象。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 返回的类型不属于以下类型之一： char nchar ntext nvarchar text varchar

检索指定列的 对象形式的值。

从零开始的列序号。 指定列的值。 指定的强制转换无效。

获取指定列以本机格式表示的值。

从零开始的列序号。 对于 null 数据库列，此方法返回 。

使用当前行的列值来填充对象数组。

要将属性列复制到的 数组。 数组中的 实例数。

检索作为 的类型 XML 数据。

指定列的值。 返回的对象。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 尝试读取不存在的列。 返回的类不是 xml。

获取一个值，该值指示 是否包含一行还是多行。

如果 包含一行或多行，则为 ；否则为 。

检索一个布尔值，该值指示是否已关闭指定的 实例。

如果指定的 实例已关闭，则为 ；否则为 。

确定指定的 是否与 的对应项匹配。

枚举。 如果指定的 为 true，则为 ；否则为 。

获取一个值，该值指示列中是否包含不存在的或缺少的值。

从零开始的列序号。 如果指定的列值与 等效，则为 ；否则为 。

的异步版本，其获取指示列是否包含不存在或缺失值的值。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

从零开始的要检索的列。 取消指示，用于对应该取消操作的通知进行传播。 此构造函数不对取消做保证。 设置为 将此方法等效于 。 返回任务必须标记为已取消。 如果指定的列值与 等效，则为 ；否则为 。 连接中断或在数据检索期间已关闭。 数据检索期间， 处于关闭状态。 没有要读取的就绪数据 (例如，第一个 未被调用或返回错误)。 按顺序模式尝试读取上一步骤中读取的列。 没有正在进行的异步操作。 以顺序模式运行时，这适用于所有 Get* 方法，读取流时也可对其进行调用。 在连接字符串中指定 。 尝试读取不存在的列。

在给定列序号的情况下，获取指定列的以本机格式表示的值。

从零开始的列序号。 指定列的以本机格式表示的值。 传递的索引超出了 0 到 的范围。

在给定列名称的情况下，获取指定列的以本机格式表示的值。

列名称。 指定列的以本机格式表示的值。 未找到具有指定名称的列。

当读取批处理 Transact-SQL 语句的结果时，使数据读取器前进到下一个结果。

如果存在多个结果集，则为 ；否则为 。

的异步版本，读取批处理 Transact-SQL 语句的结果时，将数据读取器推进到下一个结果。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。

让 前进到下一条记录。

如果存在更多行，则为 ；否则为 。 执行命令文本时，SQL Server 返回了一个错误。

的异步版本，将 前移到下一条记录。 取消标记可用于请求在命令超时超过前放弃操作。 将通过返回的任务对象报告异常。

取消指令。 表示异步操作的任务。 在完成任务前，为同一个实例多次调用 。 在连接字符串中指定 。 执行命令文本时，SQL Server 返回了一个错误。

获取执行 Transact-SQL 语句所更改、插入或删除的行数。

已更改、插入或删除的行数；如果没有受影响的行或语句失败，则为 0；对于 SELECT 语句为 -1。

返回指定列序号的 。

列序号。 指定列序号的 实例。

获取 中未隐藏的字段的数目。

未隐藏的字段的数目。

包含在内以支持调试应用程序。 不适合直接使用。

包含在内以支持调试应用程序。 不适合直接使用。

对象表示应用程序和 SQL Server 实例间的查询通知依赖关系。 应用程序可以创建一个 对象并进行注册以通过 事件处理程序接收通知。

用默认设置创建 类的新实例。

创建 类的新实例，并将其与 参数关联。

要与此 对象关联的 对象。 该构造函数将设置 对象，并将其绑定到此命令。 参数为 NULL。 已将一个 对象赋值给了 对象的 属性，且该 未与此依赖项关联。

创建 类的一个新实例，将其与 参数关联，并指定通知选项和超时值。

要与此 对象关联的 对象。 该构造函数将设置 对象，并将其绑定到此命令。 此依赖项要使用的通知请求选项。 如果使用默认服务，则为 。 此通知的超时时间（以秒为单位）。 默认值为 0，指示应当使用服务器的超时。 参数为 NULL。 超时值小于零。 已将一个 对象赋值给了 对象的 属性，且该 未与此依赖项关联。 进行了从 SQLCLR 内创建一个 SqlDependency 实例的尝试。

将 对象与此 实例关联。

一个 对象，包含一个对通知有效的语句。 参数为 null。 已将一个 对象赋值给了 对象的 属性，且该 未与此依赖项关联。

获取一个值，该值指示与依赖项关联的结果集之一是否已经更改。

一个布尔值，指示结果集之一是否已经更改。

获取一个值，该值唯一标识 类的此实例。

GUID 的字符串表示，为 类的每个实例都生成。

当收到与此 对象关联的任意命令的通知时发生。

启动用于接收依赖项更改通知的侦听器，该通知来自由连接字符串指定的 SQL Server 实例。

SQL Server 实例（从中获取更改通知）的连接字符串。 如果侦听器初始化成功，则为 ；如果已存在兼容的侦听器，则为 。 参数为 NULL。 与上次调用此方法相比， 参数相同，但其他参数不同。 此方法是从 CLR 内部调用的。 调用方没有所必需的 代码访问安全性 (CAS) 权限。 随后调用了该方法，调用使用等效的 参数和不同的用户，或者不是同一架构的默认用户的用户。 还有所有基础 SqlClient 异常。

启动用于接收依赖项更改通知的侦听器，该侦听器使用指定的 SQL Server Service Broker 队列从由连接字符串指定的 SQL Server 实例接收。

SQL Server 实例（从中获取更改通知）的连接字符串。 要使用的现有 SQL Server Service Broker 队列。 如果为 ，则使用默认队列。 如果侦听器初始化成功，则为 ；如果已存在兼容的侦听器，则为 。 参数为 NULL。 与上次调用此方法相比， 参数相同，但其他参数不同。 此方法是从 CLR 内部调用的。 调用方没有所必需的 代码访问安全性 (CAS) 权限。 已经随后调用了该方法，调用使用等效的 参数和不同的用户，或者不是同一架构的默认用户的用户。 还有所有基础 SqlClient 异常。

停止在上一次 调用中指定的连接的侦听器。

SQL Server 实例的连接字符串，在上一次 调用中使用。 如果侦听器完全停止，则为 ；如果 从侦听器解除绑定，但至少还有另一个 使用同一侦听器，则为 。 参数为 NULL。 此方法是从 SQLCLR 内部调用的。 调用方没有所必需的 代码访问安全性 (CAS) 权限。 发生基础 SqlClient 异常。

停止在上一次 调用中指定的连接的侦听器。

SQL Server 实例的连接字符串，在上一次 调用中使用。 在上一次 调用中使用的 SQL Server Service Broker 队列。 如果侦听器完全停止，则为 ；如果 从侦听器解除绑定，但至少还有另一个 使用同一侦听器，则为 。 参数为 NULL。 此方法是从 SQLCLR 内部调用的。 调用方没有所必需的 代码访问安全性 (CAS) 权限。 发生基础 SqlClient 异常。

封装 SqlClient 向 SQL Server 发送的信息，以便启动证明过程并使用 enclave 创建安全会话，SQL Server 使用此会话计算使用 Always Encrypted 保护的加密列。

初始化 类的新实例。

enclave 证明协议。 enclave 证明协议的输入。 封装客户端密钥对的 Diffie-Hellman 算法。 为 。

获取 Diffie-Hellman 算法，该算法封装 SqlClient 用于建立与 enclave 的安全会话的密钥对。

Diffie-Hellman 算法。

获取用于启动 enclave 证明进程的信息。 此信息的格式和内容专门用于证明协议。

SQL Server 执行由 EnclaveAttestationProtocols 标识的证明协议时所需的信息。

获取 enclave 证明协议标识符。

enclave 证明协议标识符。

封装 SqlClient 和 SQL Server 内部的 enclave 之间的安全会话状态，可用于计算使用 Always Encrypted 保护的加密列。

实例化 类的新实例。

对称密钥，用于对通过会话发送的所有信息加密。 会话 ID。 为 。 的长度为零。

获取对称密钥，SqlClient 使用该密钥对通过会话发送至 enclave 的所有信息进行加密。

对称密钥。

获取会话 ID。

会话 ID。

收集与 SQL Server 返回的警告或错误有关的信息。

获取从 SQL Server 返回的错误的严重级别。

一个 1 至 25 的值，它指示错误的严重级别。 默认值为 0。

从包含错误的 Transact-SQL 批命令或存储过程中获取行号。

Transact-SQL 批命令或存储过程内包含错误的行号。

获取对错误进行描述的文本。

对错误进行描述的文本。 生成的 SQL Server 错误的详细信息，请参阅数据库引擎错事件和错误。

获取一个标识错误类型的数字。

标识错误类型的数字。

获取生成错误的存储过程或远程过程调用 (RPC) 的名称。

存储过程或 RPC 的名称。 生成的 SQL Server 错误的详细信息，请参阅数据库引擎错事件和错误。

获取生成错误的 SQL Server 实例的名称。

SQL Server 实例的名称。

获取生成错误的提供程序的名称。

生成错误的提供程序的名称。

某些错误消息可能在数据库引擎的代码中多次引发。 例如，几种不同的情况下可引发 1105 错误。 引发错误的每种特定情况将分配一个唯一状态代码。

状态代码。

获取错误信息的完整文本。

错误信息的完整文本。

收集用于 SQL Server 的 .NET Framework 数据提供程序生成的所有错误。 此类不能被继承。

将 集合的元素复制到 中，从指定索引开始。

向其中复制元素的 。 从该处开始复制到 参数中的索引。 与 集合中的元素数之和大于 的 。 为 。 对于 无效。

将 集合的元素复制到 中，从指定索引开始。

向其中复制元素的 。 从该处开始复制到 参数中的索引。 与 集合中的元素数之和大于 的长度。 为 。 对于 无效。

获取集合中错误的数目。

集合中错误的总数。

返回循环访问 的枚举数。

的一个 。

获取位于指定索引处的错误。

要检索的错误的从零开始的索引。 一个 ，包含指定索引位置的错误。 索引参数超出数组界限。

有关此成员的说明，请参阅 。

如果对 的访问是同步的（线程安全），则为 ；否则为 。

有关此成员的说明，请参阅 。

可用于同步对 的访问的对象。

SQL Server 返回警告或错误时引发的异常。 此类不能被继承。

获取从 SQL Server .NET Framework 数据提供程序返回的错误的严重级别。

一个 1 至 25 的值，它指示错误的严重级别。

表示客户端连接 ID。 有关详细信息，请参阅 ADO.NET 中的数据跟踪。

客户端连接 id。

获取由一个或多个 对象组成的集合，这些对象提供有关 SQL Server .NET Framework 数据提供程序所生成的异常的详细信息。

类的收集的实例。

使用关于异常的信息设置 。

包含有关所引发异常的序列化对象数据的 。 ，它包含关于源或目标的上下文信息。 参数为 null 引用（在 Visual Basic 中为 ）。

获取生成错误的 Transact-SQL 批命令或存储过程内的行号。

生成错误的 Transact-SQL 批命令或存储过程内的行号。

获取一个标识错误类型的数字。

标识错误类型的数字。

获取生成错误的存储过程或远程过程调用 (RPC) 的名称。

存储过程或 RPC 的名称。

获取正在运行生成错误的 SQL Server 实例的计算机的名称。

运行 SQL Server 实例的计算机的名称。

获取生成错误的提供程序的名称。

生成错误的提供程序的名称。

从 SQL Server 中获取一个数值错误代码，它表示错误、警告或“未找到数据”消息。 有关如何将这些值解码的更多信息，请参阅数据库引擎事件和错误。

表示错误代码的数字。

返回表示当前 对象的字符串，并包括客户端连接 ID（有关更多信息，请参见 ）。

一个字符串，表示当前的 object.。

为 事件提供数据。

获取从服务器发送来的警告的集合。

从服务器发送来的警告的集合。

获取从数据库发送的全文本错误。

错误的完整文本。

获取生成错误的对象的名称。

生成错误的对象的名称。

检索 事件的字符串表示形式。

表示 事件的字符串。

表示将用来处理 的 事件的方法。

事件源。 包含事件数据的 对象。

表示传递给通知事件处理程序的参数集。

创建 对象的新实例。

值，指示此通知是由于实际更改生成的还是通过订阅生成的。 指示通知事件的原因的 值。 发生的原因可能是：实际更改了存储区中的数据，或者通知变为无效（例如，它已超时）。 值，指示生成通知的源。

获取指示通知事件的原因（如数据库中的某个行已被修改或某个表已被截断）的值。

通知事件原因。

获取指示生成通知（如查询数据或数据库状态已更改）的源的值。

通知的源。

获取一个值，该值指示此通知是由于实际更改生成的还是通过订阅生成的。

指示通知是否由更改或订阅生成的值。

此枚举提供有关不同通知的其他信息，这些信息可由依赖项事件处理程序接收。

对象已激发，无法向该对象添加新命令。

与已修改的查询相关的基础服务器对象。

数据已由 DELETE 语句更改。

与已丢弃的查询相关的基础对象。

发生内部服务器错误。

对象已过期。

数据已由 INSERT 语句更改。

提供了无法通知的语句（例如，UPDATE 语句）。

在无效的隔离模式下执行该语句（例如，快照）。

用于查明触发查询通知的服务器端原因。

订阅时没有正确设置 SET 选项。

上一语句导致在当前事务下激发了查询通知。

不能通知或已提供的 SELECT 语句。

因服务器资源压力而激发。

服务器已重新启动（重新启动期间发送通知）。

订阅查询导致某一目标表上的模板数量超过允许的最大限制。

一个或多个表已截断。

在客户端无法识别出服务器所发送的信息选项时使用。

数据已由 UPDATE 语句更改。

指示依赖项事件处理程序所接收的通知的源。

发生了客户端启动的通知（如由于发生客户端超时，或尝试向已激发的依赖项添加命令）。

数据已更改；例如，发生了插入、更新、删除或截断操作。

数据库状态已更改；例如，与查询相关的数据库已被删除或分离。

运行时环境与通知不兼容；例如，隔离级别设置为快照，或一个或多个 SET 选项不兼容。

执行的过程中发生运行时错误。

某数据库对象已更改；例如，与查询相关的某基础对象已被删除或修改。

仅限内部；不应在代码中使用。

Transact-SQL 语句对通知无效；例如，未能通知 SELECT 语句或执行了非 SELECT 语句。

发生了系统相关的事件。 例如，存在内部错误、服务器被重新启动或资源压力导致失效。

订阅超时已过期。

当客户端无法识别服务器发送的源选项时使用。

描述 事件处理程序可通过 参数接收的不同通知类型。

被监视的服务器中的数据已更改。 使用 项确定更改的详细信息。

创建通知订阅时发生错误。 使用 对象的 项来确定发生错误的原因。

当客户端未识别由服务器发送的类型选项时使用。

表示 的参数，或者其与 列的映射。 此类不能被继承。 有关参数的详细信息，请参阅配置参数和参数数据类型。

初始化 类的新实例。

使用提供的参数名称和数据类型初始化 类的新实例。

要映射的参数的名称。 值之一。 参数 中提供的值不是有效的后端数据类型。

使用参数名称、 和大小初始化 类的新实例。

要映射的参数的名称。 值之一。 参数的长度。 参数 中提供的值不是有效的后端数据类型。

使用提供的参数名称、参数类型、参数大小、、参数精度、参数小数位数、源列、要使用的 以及参数值初始化 类的新实例。

要映射的参数的名称。 值之一。 参数的长度。 值之一。 如果字段的值可以为 null，则返回 ；否则，返回 。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列名 ()（如果在调用 中使用了此 ）。 值之一。 作为 的值的 。 参数 中提供的值不是有效的后端数据类型。

使用以下信息初始化 类的新实例：参数名、参数类型、参数长度、参数传递方向、参数精度、参数的范围、源列名、 的一个值、源列映射的布尔值、 的值、此 XML 实例的架构集所在的数据库名称、此 XML 实例的架构集所在的关系型架构，以及此参数的架构集的名称。

要映射的参数的名称。 值之一。 参数的长度。 值之一。 所解析的 的小数点左右两侧的总位数。 所解析的 的总小数位数。 源列名 ()（如果在调用 中使用了此 ）。 值之一。 如果源列可以为 null，则为 ；如果不可以为 null，则为 。 作为 的值的 。 此 XML 实例的架构集合所在的数据库的名称。 此 XML 实例的架构集合所在的所属关系架构。 此参数的架构集的名称。

使用提供的参数名称、、大小和源列名初始化 类的新实例。

要映射的参数的名称。 值之一。 参数的长度。 源列名 ()（如果在调用 中使用了此 ）。 参数 中提供的值不是有效的后端数据类型。

初始化 类的新实例，该类使用参数名称和新 的值。

要映射的参数的名称。 作为 的值的 。

获取或设置 对象，它定义应如何对此参数执行字符串比较。

对象，它定义此参数的字符串比较。

获取或设置参数的 。

值之一。 默认值为 。

获取或设置一个值，该值指示参数是只可输入的参数、只可输出的参数、双向参数还是存储过程返回值参数。

值之一。 默认值为 。 属性未设置为有效的 值之一。

当使用 Always Encrypted 时强制执行参数的加密。 如果 SQL Server 通知驱动程序参数不需要进行加密，则使用该参数的查询会失败。 此属性针对安全攻击提供附加保护，这些安全攻击涉及向客户端提供不正确的加密元数据的受威胁的 SQL Server，可能导致数据泄露。

如果参数具有强制列加密，则为 ；否则为 。

获取或设置一个值，该值指示参数是否接受 null 值。 不用于验证参数的值，并且在执行命令时不会阻止发送或接收 null 值。

如果接受 null 值，则为 ；否则为 。 默认值为 。

获取或设置确定某一特定区域的约定和语言设置的区域设置标识符。

与参数关联的区域设置标识符。

获取或设置 属性的偏移量。

的偏移量。 默认值为 0。

获取或设置 的名称。

的名称。 默认值为一个空字符串。

获取或设置用于表示 属性的最大位数。

用于表示 属性的最大位数。 默认值为 0。 这指示数据提供程序将设置 的精度。

重置与此 关联的类型。

重置与此 关联的类型。

获取或设置所解析的 的小数位数。

所解析的 的小数位数。 默认值为 0。

获取或设置列中的数据的最大大小（以字节为单位）。

列中的数据的最大大小（以字节为单位）。 默认值将根据参数值进行推断。

获取或设置映射到 并且用于加载或返回 的源列的名称

映射到 的源列的名称。 默认值为一个空字符串。

设置或获取一个值，该值指示源列是否可以为 null。 通过此操作， 能够为可以为 null 的列正确地生成 Update 语句。

如果源列可以为 null，则为 ；如果不可以为 null，则为 。

获取或设置要在加载 时使用的 。

值之一。 默认值为 。

获取或设置参数的 。

值之一。 默认值为 。

获取或设置作为 SQL 类型的参数的值。

对象，是使用 SQL 类型的参数的值。 默认值为 null。

有关此成员的说明，请参见 。

新的 对象，是此实例的副本。

获取一个包含 的字符串。

一个包含 的字符串。

获取或设置表值参数的类型名称。

指定的表值参数的类型名称。

获取或设置作为参数的表示用户定义类型的 。

表示数据库中用户定义类型的完全限定名称的 。

获取或设置参数的值。

充当参数值的 。 默认值为 null。

获取此 XML 实例的架构集合所在的数据库的名称。

此 XML 实例的架构集合所在的数据库的名称。

获取此 XML 实例的架构集合的名称。

此 XML 实例的架构集合的名称。

此 XML 实例的架构集合所在的所属关系架构。

此 XML 实例的所属关系架构。

表示与 关联的参数的集合以及各个参数到 中列的映射。 此类不能被继承。

将指定的 对象添加到 中。

要添加到集合中的 。 一个新 对象。 在 参数中指定的 已经添加到这个或其他 中。 传递的参数不是 。 参数为 null。

将指定的 对象添加到 中。

一个 。 新的 对象的索引。

在给定参数名称和数据类型时向 中添加一个 。

参数的名称。 值之一。 一个新 对象。

将 添加到 中（给定了指定的参数名、 和大小）。

参数的名称。 要添加到集合中的 的 。 的大小。 一个新 对象。

使用给定的参数名称、数据类型和列长度向 中添加一个 。

参数的名称。 值之一。 列的长度。 源列名 ()（如果在调用 中使用了此 ）。 一个新 对象。

将指定的 对象添加到 中。

要添加到集合的 的名称。 。 一个新 对象。 使用 方法的重载来指定整数参数值时，请务必谨慎。 因为此重载接受 类型的 ，所以当此值为零时，必须将整数值转换为 类型，如下面的 C# 示例所示。 parameters.Add("@pname", Convert.ToInt32(0)); 如果不执行此转换，编译器将假定您正尝试调用 (，) 重载。 在 参数中指定的 已经添加到这个或其他 中。 参数为 null。

向 的末尾添加一个值数组。

要添加的 值。

向 的末尾添加一个 值数组。

要添加的 值。

向 的末尾添加一个值。

参数的名称。 要添加的值。 使用 （而不是 null）指示空值。 对象。

从 中移除所有的 对象。

确定指定的 是否在此 中。

值。 如果 包含此值，则返回 ；否则，返回 。

确定指定的 是否在此 中。

值。 如果 包含此值，则返回 ；否则，返回 。

确定指定的参数名是否在。

值。 如果 包含此值，则返回 ；否则，返回 。

将当前 的所有元素复制到指定的一维 中，并以指定的目标 索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的一维 。 一个 32 位整数，表示 中开始复制的位置的索引。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

返回一个整数，包含 中的元素数。 只读。

以整数形式表示的 中的元素数。

返回循环访问 的枚举数。

的一个 。

获取指定的 在集合中的位置。

要查找的 。 指定的 （它是 ）在集合中从零开始的位置。 如果 中不存在该对象，则返回 -1。

获取指定的 在集合中的位置。

要查找的 。 指定的 （它是 ）在集合中从零开始的位置。 如果 中不存在该对象，则返回 -1。

获取具有指定名称的指定 的位置。

要查找的 的名称（区分大小写）。 具有指定名称（区分大小写）的指定 的位置（从零开始）。 如果 中不存在该对象，则返回 -1。

在 中的指定索引处插入一个 对象。

应将值插入到的位置的索引（从零开始）。 要插入到 中的 对象。

在 中的指定索引处插入一个 。

应将值插入到的位置的索引（从零开始）。 要插入到 中的 。

获取一个值，该值指示 是否具有固定大小。

如果 具有固定大小，则为 ；否则为 。

获取一个值，该值指示 是否为只读。

如果 是只读的，则为 ；否则为 。

获取一个值，该值指示 是否已同步。

如果 已同步，则为 ；否则为 。

获取位于指定索引处的 。

要检索的参数的索引（从零开始）。 位于指定索引处的 。 指定的索引不存在。

获取具有指定名称的 。

要检索的参数的名称。 具有指定名称的 。 指定的 无效。

从集合中移除指定的 。

要从集合中移除的 对象。 该参数不是 。 集合中不存在该参数。

从集合中移除指定的 。

要从集合中移除的对象。

从 的指定索引处移除 。

要移除的 对象的索引（从零开始）。

从 中移除具有指定参数名称的 。

要移除的 的名称。

获取可用于同步对 的访问的对象。

可用于同步对 的访问的对象。

表示传递给 的参数集。

创建 对象的新实例。

一个 ，指示在当前的批量复制操作过程中复制的行数。

获取或设置指示是否应中止批量复制操作的值。

如果应中止批量复制操作，则为 ；否则为 。

获取一个值，该值返回在当前批量复制操作期间复制的行数。

，返回复制的行数。

表示处理 的 事件的方法。

事件源。 包含事件数据的 对象。

为 事件提供数据。

初始化 类的新实例。

通过 发送 。 调用 时执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送 。

获取或设置当调用 时执行的 。

调用 时执行的 。

表示将用来处理 的 事件的方法。

事件源。 包含事件数据的 。

为 事件提供数据。

初始化 类的新实例。

要进行 的 。 要在 过程中执行的 。 值之一，该值指定所执行的查询的类型。 通过 发送 。

获取或设置进行 时执行的 。

进行 时要执行的 。

表示将用来处理 的 事件的方法。

事件源。 包含事件数据的 。

表示将在 SQL Server 数据库中进行的 Transact-SQL 事务。 此类不能被继承。

提交数据库事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

获取与该事务关联的 对象，或者如果该事务不再有效，则为 。

与事务关联的 对象。

为该事务指定 。

该事务的 。 默认值为 。

从挂起状态回滚事务。

在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

从挂起状态回滚事务，并指定事务或保存点名称。

要回滚的事务的名称，或要回滚到的保存点的名称。 未指定事务名称。 已提交或回滚事务。 或 连接已断开。

在事务中创建保存点（它可用于回滚事务的一部分），并指定保存点名称。

保存点的名称。 在尝试提交事务时出错。 已提交或回滚事务。 或 连接已断开。

指定要用于 中的字段和属性的 SQL Server 特定的数据类型。

。 64 位带符号整数。

类型。 二进制数据的固定长度流，范围在 1 到 8,000 个字节之间。

。 无符号数值，可为 0、1 或 。

。 非 Unicode 字符的固定长度流，范围在 1 到 8,000 个字符之间。

日期数据，值范围从公元 1 年 1 月 1 日到公元 9999 年 12 月 31 日。

。 日期和时间数据，值范围从 1753 年 1 月 1 日到 9999 年 12 月 31 日，精度为 3.33 毫秒。

日期和时间数据。 日期值范围从公元 1 年 1 月 1 日到公元 9999 年 12 月 31 日。 时间值范围从 00:00:00 到 23:59:59.9999999，精度为 100 毫微秒。

显示时区的日期和时间数据。 日期值范围从公元 1 年 1 月 1 日到公元 9999 年 12 月 31 日。 时间值范围从 00:00:00 到 23:59:59.9999999，精度为 100 毫微秒。 时区值范围从 -14:00 到 +14:00。

。 固定精度和小数位数数值，在 -10 38 -1 和 10 38 -1 之间。

。 浮点数在 -1.79E +308 到 1.79E +308 的范围内。

类型。 二进制数据的可变长度流，范围在 0 到 2 31 -1（即 2,147,483,647）字节之间。

。 32 位带符号整数。

。 货币值，范围在 -2 63（即 -922,337,203,685,477.5808）到 2 63 -1（即 +922,337,203,685,477.5807）之间，精度为千分之十个货币单位。

。 Unicode 字符的固定长度流，范围在 1 到 4,000 个字符之间。

。 Unicode 数据的可变长度流，最大长度为 2 30 - 1（即 1,073,741,823）个字符。

。 Unicode 字符的可变长度流，范围在 1 到 4,000 个字符之间。 如果字符串大于 4,000 个字符，则隐式转换将失败。 使用长度超过 4,000 个字符的字符串时，请显式设置对象。 当数据库列为 时，使用 。

。 -3.40E +38 到 3.40E +38 范围内的浮点数。

。 日期和时间数据，值范围从 1900 年 1 月 1 日到 2079 年 6 月 6 日，精度为 1 分钟。

。 16 位带符号整数。

。 货币值，范围在 -214,748.3648 到 +214,748.3647 之间，精度为千分之十个货币单位。

一种特殊数据类型，用于指定表值参数中包含的构造数据。

。 非 Unicode 数据的可变长度流，最大长度为 2 31 -1（即 2,147,483,647）个字符。

基于 24 小时制的时间数据。 时间值范围从 00:00:00 到 23:59:59.9999999，精度为 100 毫微秒。 对应于 SQL Server 值。

类型。 自动生成的二进制数字，保证在数据库中是唯一的。 通常将 用作版本标记表行的机制。 存储大小为 8 个字节。

。 8 位无符号整数。

SQL Server 用户定义类型 (UDT)。

。 全局唯一标识符（或 GUID）。

类型。 二进制数据的可变长度流，范围在 1 到 8,000 个字节之间。 如果字节数组大于 8,000 个字节，则隐式转换将失败。 使用大于 8000 个字节的字节数组时，请显式设置对象。

。 非 Unicode 字符的可变长度流，范围在 1 到 8,000 个字符之间。 当数据库列为 时，使用 。

。 特殊数据类型，可以包含数值、字符串、二进制或日期数据，以及 SQL Server 值 Empty 和 Null，后两个值在未声明其他类型的情况下采用。

XML 值。 使用 方法或 属性获取字符串形式的 XML，或通过调用 方法获取 形式的 XML。

所有 对象和结构均实现 接口。

指示结构是否为 null。 此属性是只读的。

如果此对象的值为 null。 否则为 。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

初始化 类的新实例。

引发异常时显示的字符串。

初始化 类的新实例。

引发异常时显示的字符串。 对内部异常的引用。

表示要存储在数据库中或从数据库中检索的二进制数据的可变长度流。

初始化 结构的新实例，将 属性设置为已提供的字节数组的内容。

要存储或检索的字节数组。

串联两个指定的 值以创建一个新的 结构。

。 。 一个 ，为 x 和 y 的串联值。

将此 对象与所提供的 对象进行比较，并返回其相对值的指示值。

要与此 对象进行比较的 对象。 有符号的数，指示此 结构和对象的相对值。 返回值 条件 小于零 此 对象的值小于该对象。 零 此 对象与对象相同。 大于零 此 对象大于对象。 或 对象为 null 引用。

将此 对象与所提供的对象进行比较，并返回其相对值的指示值。

要与此 结构比较的对象。 有符号的数，指示此 结构和对象的相对值。 返回值 条件 小于零 此 对象的值小于该对象。 零 此 对象与对象相同。 大于零 此 对象大于对象。 - 或 - 对象为 null 引用。

串联两个 结构以创建一个新 结构。

结构。 结构。 和 参数的串联值。

比较两个 结构以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此 结构的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 一个指示指定的 的 XSD 的 。

对两个 结构进行比较，以确定第一个结构是否大于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。 此属性是只读的。

如果是 ，则为 ；否则为 。

从 属性获取单字节，该属性位于整数参数 指示的位置。 如果 指示位置位于字节数组的结尾以外，将引发 。 此属性是只读的。

要检索的字节的位置。 位于整数参数指示的位置的字节。 当 属性包含 时，读取该属性。 或 - 参数指示超过字节数组长度（由 属性指示）的位置。

获取 属性的长度（以字节为单位）。 此属性是只读的。

属性中的二进制数据的长度。 当 属性包含 时，读取 属性。

对两个 结构进行比较，以确定第一个结构是否小于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否小于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

比较两个 结构以确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

串连两个 参数以创建一个新 结构。

一个 对象。 一个 对象。 和 参数的串联值。

比较两个 结构以确定它们是否相等。

一个 对象。 对象。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

将 结构转换为 数组。

要转换的 结构。 数组。

将 结构转换为 结构。

要转换的 结构。 要转换的 结构。

对两个 结构进行比较，以确定第一个结构是否大于第二个结构。

一个 对象。 一个 对象。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

一个 对象。 一个 对象。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将字节数组转换为 结构。

要转换的字节数组。 一个 结构，它表示已转换的字节数组。

比较两个 结构以确定它们是否不相等。

一个 对象。 一个 对象。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否小于第二个结构。

对象。 一个 对象。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否小于或等于第二个结构。

对象。 对象。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

有关此成员的说明，请参阅 。

一个 实例。

有关此成员的说明，请参见 。

。

有关此成员的说明，请参见 。

。

将 的此实例转换为 。

结构。

将此 对象转换为字符串。

一个包含 的 的字符串。 如果 为 null，字符串将包含“null”。

获取 结构的值。 此属性是只读的。

结构的值。 当属性包含 时，读取 属性。

表示要存储在数据库中或者从数据库中检索的整数值，为 1 或 0。

使用提供的布尔值初始化 结构的新实例。

新 结构的值，为 或 。

使用指定的整数值初始化 结构的新实例。

其值用于新 结构的整数。

对两个指定的 结构执行按位 AND 运算。

结构。 结构。 逻辑 AND 运算的结果。

获取 结构的以字节表示的值。

表示 结构的值的字节。

将此 对象与所提供的 对象进行比较，并返回其相对值的指示值。

要比较的 对象，或空引用（在 Visual Basic 中为 ）。 有符号数，指示实例和值的相对值。 值 描述 负整数 此实例小于 。 零 此实例等于 。 正整数 此实例大于 。 - 或 - 为空引用（在 Visual Basic 中为 ）。

将此 结构与指定对象进行比较，并返回它们的相对值指示。

要比较的对象，或 null 引用（在 Visual Basic 中为 ）。 有符号数，指示实例和值的相对值。 值 描述 负整数 此实例小于 。 零 此实例等于 。 正整数 此实例大于 。 - 或 - 为空引用（在 Visual Basic 中为 ）。

比较两个 结构以确定它们是否相等。

结构。 结构。 如果两个实例相等，则返回 ；如果两个实例不相等，则返回 。 如果 的任一实例为空，则 的 将为 。

将提供的对象参数与 比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

表示可分配给 结构实例的 属性的“假”值。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 如果第一个实例大于第二个实例，则返回 ；否则，返回 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 如果第一个实例大于或等于第二个实例，则返回 ；否则，返回 。

指示当前 是否为 。

如果 为 ，则为 ；否则为 。

指示此 结构是否为 null。

如果结构为 null; 否则为。

获取一个值，该值指示当前 是否为 。

如果 为 ，则为 ；否则为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 如果第一个实例小于第二个实例，则返回 ；否则，返回 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 如果第一个实例小于或等于第二个实例，则返回 ；否则，返回 。

比较 的两个实例是否相等。

结构。 结构。 如果两个实例不相等，则返回 ；如果两个实例相等，则返回 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

表示可分配给 结构的 属性的 1 值。

对提供的 结构执行 1 的求补运算。

结构。 所提供的 的 one 的补码。

对两个指定的 结构执行按位 AND 运算。

结构。 结构。 逻辑 AND 运算的结果。

对其操作数执行按位“或”运算。

结构。 结构。 逻辑 OR 运算的结果。

比较 的两个实例是否相等。

。 。 如果两个实例相等，则返回 ；如果两个实例不相等，则返回 。 如果 的任一实例为空，则 的 将为 。

对提供的参数执行按位“异或”(XOR) 运算。

结构。 结构。 逻辑 XOR 运算的结果。

将 转换为布尔值。

要转换的 。 设置为 的 的布尔值。

将 参数转换为 结构。

要转换为 结构的 。 一个新 结构，它的值等于 参数的 。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

将 参数转换为 结构。

要转换为 结构的 。 新的 结构，它的值等于 参数的 属性。

可以使用“假”运算符来测试 的 以确定它是否为“假”。

要测试的 结构。 如果所提供的参数 为 ，则返回 ；否则，返回 。

对两个 结构进行比较，以确定第一个结构是否大于第二个结构。

一个 对象。 一个 对象。 如果第一个实例大于第二个实例，则返回 ；否则，返回 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 如果第一个实例大于或等于第二个实例，则返回 ；否则，返回 。

将提供的字节值转换为 。

要转换为 的字节值。 包含 0 或 1 的 值。

对 的两个实例进行比较，以确定它们是否不相等。

。 。 如果两个实例不相等，则返回 ；如果两个实例相等，则返回 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 如果第一个实例小于第二个实例，则返回 ；否则，返回 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 如果第一个实例小于或等于第二个实例，则返回 ；否则，返回 。

对 执行 NOT 运算。

将要对其执行 NOT 运算的 。 一个 ，如果参数为 true，则其 为 ；如果参数为 NULL，则为 ；其他情况为 。

对提供的 结构执行 1 的求补运算。

结构。 所提供的 的 one 的补码。

可以使用“真”运算符来测试 的 以确定它是否为真。

要测试的 结构。 如果所提供的参数 为 ，则返回 ；否则，返回 。

对两个指定的 结构执行按位“或”运算。

结构。 结构。 新的 结构，其“值”是按位“或”运算的结果。

将逻辑值的指定 表示形式转换为它的等效 。

要转换的 。 一个 结构，包含已分析的值。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，则新 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值为 ，则新 值为 1。 如果 结构的值等于 ，则新 值为 0。 如果 结构的值既不是 1 也不是 0，则新的 值为 。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 true，则新的 结构的值为 1；否则新的 结构的值为 0。

将此 结构转换为 。

新的 结构，其值为 1 或 0。 如果 结构的值等于 ，那么 结构的值为 1。 否则，新的 结构的值为 0。

将此 结构转换为字符串。

一个字符串，它包含 的值。 如果值为 null，字符串将包含“null”。

表示可分配给 结构实例的 属性的“真”值。

获取 结构的值。 此属性是只读的。

如果 为 ，则为 ；否则为 。 该属性设置为 null。

对提供的参数执行按位“异或”运算。

结构。 结构。 逻辑 XOR 运算的结果。

表示可分配给 结构实例的 属性的零值。

表示要存储在数据库中或从数据库中检索的 8 位无符号整数，此整数在 0 到 255 范围内。

使用指定的字节值初始化 结构的新实例。

要存储在新 结构的 属性中的字节值。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，它的 属性包含加法运算的结果。

对其 操作数执行按位 AND 运算。

结构。 结构。 按位 AND 运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 按位“或”运算的结果。

将此实例与所提供的 对象进行比较，并返回其相对值的指示值。

要比较的 对象。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将此实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将其第一个 操作数除以其第二个操作数。

结构。 结构。 新的 结构，它的 属性包含除法运算的结果。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的 参数与 对象的 属性进行比较。

要比较的 。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

获取一个布尔值，该值指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，它表示 的最大可能值。

一个常数，它表示 的最小可能值。

计算将其第一个 操作数除以第二个操作数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

将两个 值相除，并返回余数。

。 。 对 和 执行除法运算后得到的余数。

计算两个 操作数的乘积。

结构。 结构。 一个新的 结构，它的 属性包含该乘法运算的乘积。

对 的两个实例进行比较，以确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

二进制反码运算符对其 操作数执行按位二进制反码运算。

结构。 一个 结构，它的 属性包含 参数的二进制反码。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，它的 属性包含两个操作数的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 按位 AND 运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 按位“或”运算的结果。

将其第一个 操作数除以其第二个操作数。

结构。 结构。 新的 结构，它的 属性包含除法运算的结果。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

对提供的参数执行按位“异或”运算。

结构。 结构。 按位“异或”运算的结果。

将 参数转换为 。

要转换为 的 参数。 一个 ，它的 属性等于提供的 参数的 。

将提供的 结构转换为字节。

要转换为字节的 结构。 一个字节，其值等于 参数的 属性。

将提供的 转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将提供的 转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将 参数转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将提供的 转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将提供的 转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将 参数转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将提供的 结构转换为 。

结构。 一个 结构，它的 属性等于 参数的 。

将提供的 转换为 。

类的实例。 一个 结构，其 属性等于 表示的数值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的字节值转换为 。

要转换为 的字节值。 一个 结构，其 属性等于提供的参数。

对 的两个实例进行比较，以确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

计算将其第一个 操作数除以第二个操作数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

计算两个 操作数的乘积。

结构。 结构。 一个新的 结构，它的 属性包含该乘法运算的乘积。

二进制反码运算符对其 操作数执行按位二进制反码运算。

结构。 一个 结构，它的 属性包含 参数的二进制反码。

从第一个 操作数中减去第二个操作数。

结构。 结构。 从第一个 操作数中减去第二个操作数所得的结果。

将数字的 表示形式转换为它的等效 8 位无符号整数。

要分析的 。 一个 结构，包含 参数表示的 8 位数字。

从第一个 操作数中减去第二个操作数。

结构。 结构。 从第一个 操作数中减去第二个操作数所得的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。

将此 结构转换为 。

与此 具有相同值的 结构。

将此 结构转换为 。

与此 具有相同值的 结构。

将此 转换为 。

与此 具有相同值的 结构。

将此 结构转换为 。

一个 结构，它的 等于此 结构的 。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。

将此 结构转换为 。

一个 结构，它与此 结构具有相同的 。

将 的此实例转换为 。

一个 ，包含 结构的 的字符串表示形式。

将此 结构转换为 。

一个包含 的 的字符串。 如果 为空， 将为空字符串。

获取 结构的值。 此属性为只读。

结构的值。

对提供的参数执行按位“异或”运算。

结构。 结构。 该 XOR 运算的结果。

表示可分配给 结构实例的 属性的零值。

表示包装 或 的可变引用类型。

初始化 类的新实例。

根据指定的字节数组初始化 类的新实例。

无符号字节的数组。

根据指定的 值初始化 类的新实例。

一个 值。

根据指定的 值初始化 类的新实例。

。

返回一个对内部缓冲区的引用。

对内部缓冲区的引用。 对于在非托管指针上创建的 实例，将返回内部缓冲区的托管副本。

返回指定的 的 XML 架构定义语言 (XSD)。

。 一个指示指定的 的 XSD 的 。

获取一个布尔值，该值指示此 是否为 null。

如果 为 null，则为 ；否则为 。

获取或设置指定索引处的 实例。

一个 值。 一个 值。

获取 实例中包含的值的长度。

一个 值，表示 实例中包含的值的长度。 如果没有可由实例使用的缓冲区，或者如果该值为 null，则返回 -1。 返回流包装实例的 。

获取此 的内部缓冲区的值的最大长度。

一个长值，表示内部缓冲区的值的最大长度。 对于流包装的 ，将返回 -1。

获取此 的 null 实例。

实例的属性返回。

将 结构转换为 结构。

要转换的 结构。 结构。

将 结构转换为 结构。

要转换的 结构。 结构。

将此 实例中的字节复制到传入缓冲区中并返回复制的字节数。

实例中包含的值的 长值偏移量。 要在其中执行“复制到”操作的字节数组缓冲区。 缓冲区中的一个 整数偏移量，以启动“复制到”操作。 一个 整数，表示要复制的字节数。 一个 长值，表示已复制的字节数。

设置此 实例的长度。

表示长度的 长值。

将此 实例设置为 null。

返回有关此 实例的存储状态的信息。

枚举。

将此 的数据作为流进行获取或设置。

包含 SqlBytes 数据的流。

获取序列化信息以及包含重新实例化此 实例所需的所有数据。

用序列化信息填充的对象。 序列化的目标上下文。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

从此 实例构造和返回一个 。

来自此实例的 。

返回此 保存的值的托管副本。

此 的值，为字节数组。

将传入缓冲区中的字节复制到此 实例中。

实例中包含的值的 长值偏移量。 要在其中执行“复制到”操作的字节数组缓冲区。 缓冲区中的一个 整数偏移量，以启动“复制到”操作。 一个 整数，表示要复制的字节数。

是一个可变引用类型，可包装 数组或 实例。

初始化 类的新实例。

根据指定的字符数组初始化 类的新实例。

数组。

根据指定的 值初始化 类的新实例。

。

返回一个对内部缓冲区的引用。

对内部缓冲区的引用。 对于在非托管指针上创建的 实例，将返回内部缓冲区的托管副本。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

获取一个布尔值，该值指示此 是否为 null。

如果 为 null，则返回 。 否则为 。

获取或设置指定索引处的 实例。

一个 值。 一个 值。

获取 实例中包含的值的长度。

一个 值，指示 实例中包含的值的长度（以字符为单位）。 如果没有可由该实例使用的缓冲区，或者该值为 null，则返回 -1。 返回流包装实例的 。

获取内部缓冲区可保存的值的最大长度（以双字节字符为单位）。

一个 值，表示内部缓冲区的值的最大长度（以双字节为单位）。 对于流包装的 ，将返回 -1。

返回此 的 null 实例。

实例的属性返回。 有关详细信息，请参阅Handling Null Values。

将 结构转换为 结构。

要转换的 结构。 结构。

将 结构转换为 结构。

要转换的 结构。 结构。

将此 实例中的字符复制到传入缓冲区中，并返回复制的字符数。

实例中所含值的 值偏移量。 向其复制的字符数组缓冲区。 缓冲区中的一个 整数偏移量，以启动“复制到”操作。 一个 整数值，表示要复制的字符数。 表示已复制字节数的 值。

设置此 实例的长度。

表示长度的 值。

将此 实例设置为 null。

返回有关此 实例的存储状态的信息。

枚举。

获取序列化信息以及包含重新实例化此 实例所需的所有数据。

用序列化信息填充的对象。 序列化的目标上下文。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 实例转换为其等效的 表示形式。

此类的 表示形式。

返回此 保存的值的托管副本。

此 的值，为字符数组。

将传入缓冲区中的字符复制到此 实例中。

实例中所含值的 值偏移量。 向其复制的字符数组缓冲区。 缓冲区中的一个 整数偏移量，以启动“复制到”操作。 一个 整数，表示要复制的字符数。

为 结构指定比较选项值。

指定排序应基于字符数值（而非其字母值）。

执行二进制排序。

指定 比较必须忽略大小写。

指定 比较必须忽略假名类型。 假名类型是指日语平假名和片假名字符，它们表示日语中的语音。 平假名用于表示日语自有的短语和字词，而片假名用于表示从其他语言借用的字词，如“computer”或“Internet”。 语音既可以用平假名也可以用片假名表示。 如果选择该值，则认为一个语音的平假名字符等于同一语音的片假名字符。

指定 比较必须忽略非空格组合字符，比如音调符号。 Unicode 标准将组合字符定义为与基字符组合起来产生新字符的字符。 非空格组合字符在呈现时本身不占用字符空间。 有关非空格组合字符的更多信息，请参阅 https://www.unicode.org 上的 Unicode 标准。

指定 比较必须忽略字符宽度。 例如，日语片假名字符可以写为全角或半角形式；如果选择该值，则认为写为全角形式的片假名字符等于写为半角形式的同一字符。

为 比较指定默认选项设置。

表示要存储在数据库中或从数据库中检索的日期和时间数据，值范围介于 1753 年 1 月 1 日到 9999 年 12 月 31 日之间，精度为 3.33 毫秒。 结构具有与其相应的 .NET Framework 类型 不同的基础数据类型，该结构可以表示 12:00:00 AM 1/1/0001 和 11:59:59 PM 12/31/9999 之间的任何时间，精度可达到 100 毫微秒。 实际上存储的是相对于 00:00:00 AM 1/1/1900 的差值。 因此，将“00:00:00 AM 1/1/1900”转换为整数将返回 0。

使用指定的 值初始化 结构的新实例。

结构。

使用提供的参数初始化 结构的新实例。

将日期表示为刻度数的整数值。 将时间表示为刻度数的整数值。

通过使用提供的参数初始化年、月、日，来初始化 结构的新实例。

一个整数，它表示新 结构的年份值。 一个整数值，它表示新 结构的月份值。 一个整数值，它表示新 结构的日值。

通过使用所提供的参数初始化新结构的年、月、日、小时、分钟和秒，来初始化 结构的新实例。

一个整数值，它表示新 结构的年份值。 一个整数值，它表示新 结构的月份值。 一个整数值，它表示新 结构中月份的第几天的值。 一个整数值，它表示新 结构的小时值。 一个整数值，它表示新 结构的分钟值。 一个整数值，它表示新 结构的秒钟值。

通过使用所提供的参数初始化新结构的年、月、日、小时、分钟、秒和毫秒，来初始化 结构的新实例。

一个整数值，它表示新 结构的年份值。 一个整数值，它表示新 结构的月份值。 一个整数值，它表示新 结构中月份的第几天的值。 一个整数值，它表示新 结构的小时值。 一个整数值，它表示新 结构的分钟值。 一个整数值，它表示新 结构的秒钟值。 一个双精度型值，表示新 结构的毫秒值。

通过使用所提供的参数初始化新结构的年、月、日、小时、分钟、秒和毫秒，来初始化 结构的新实例。

一个整数值，它表示新 结构的年份值。 一个整数值，它表示新 结构的月份值。 一个整数值，它表示新 结构的日值。 一个整数值，它表示新 结构的小时值。 一个整数值，它表示新 结构的分钟值。 一个整数值，它表示新 结构的秒钟值。 一个整数值，它表示新 结构的毫秒（千分之一毫秒）。

向指定的 添加一个 。

一个 值。 一个 值。 一个 值。

将此 结构与提供的 结构进行比较，并返回其相对值的指示值。

要比较的 结构。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于 。 零 此实例与 相同。 大于零 此实例大于 。 - 或 - 为空引用（在 Visual Basic 中为 ）

将此 结构与提供的 进行比较，并返回其相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是 null 引用（在 Visual Basic 中为 ）。

获取刻度数，它表示此 结构的日期。

刻度数，表示此 结构的 属性中包含的日期。 当 结构的 属性设置为 null 时所引发的异常。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

获取此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

表示 结构的最大有效日期值。

表示 结构的最小有效日期值。

对 的两个实例执行逻辑比较，确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

将提供的 参数 指示的一段时间添加到提供的 结构中。

结构。 结构。 一个新的 。 如果任一参数为 ，则新的 将是 。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。

将 结构转换为 结构。

结构。 一个 对象，其 和 属性与提供的 结构的 属性包含相同的日期和时间值。

将 参数转换为 。

。 一个 结构，其 等于 参数表示的日期和时间。 如果 为 null，则新创建的 结构的 将为 Null。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将 结构转换为 结构。

结构。 一个 结构，其 等于提供的 结构的 和 属性的组合。

对 的两个实例执行逻辑比较，确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

从提供的 结构中减去提供的 结构 。

结构。 结构。 一个 结构，它表示该减法运算的结果。

将日期和时间的指定的 表示形式转换为其等效的 形式。

要分析的 。 一个 结构，它等于指定的 表示的日期和时间。

值为等效于 1 小时的刻度数的常数。

值为等效于 1 分钟的刻度数的常数。

值为等效于 1 秒的刻度数的常数。

从此 实例中减去指定的 。

一个 值。 一个 值。 一个 值。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

获取表示此 结构的时间的刻度数。

表示此 结构的时间的刻度数。

将此 结构转换为 。

一个 结构，其值是表示此 结构中包含的日期和时间的字符串。

将此 结构转换为 。

一个 ，它表示此 结构的 属性。

获取 结构的值。 此属性是只读的。

此 结构的值。 当 结构的 属性设置为 null 时所引发的异常。

表示具有固定精度和小数位数的数值，该数值介于 - 10^38 +1 和 10^38 - 1 之间。

使用提供的参数初始化 结构的新实例。

可用来表示新 结构的 属性的最大位数。 新 结构的 属性将解析为的小数位数。 一个布尔值，它指示新的 结构是表示正数还是负数。 一个 32 位无符号整数，它将与 data2、data3 和 data4 结合，以组成一个 128 位无符号整数，该整数表示新 结构值。 一个 32 位无符号整数，它将与 data1、data3 和 data4 结合，以组成一个 128 位无符号整数，该整数表示新 结构值。 一个 32 位无符号整数，它将与 data1、data2 和 data4 结合，以组成一个 128 位无符号整数，该整数表示新 结构值。 一个 32 位无符号整数，它将与 data1、data2 和 data3 结合，以组成一个 128 位无符号整数，该整数表示新 结构值。

使用提供的参数初始化 结构的新实例。

可用来表示新 结构的 属性的最大位数。 新 结构的 属性将解析为的小数位数。 一个布尔值，它指示新的 结构是表示正数还是负数。 128 位无符号整数，提供新 的值。

使用提供的 值初始化 结构的新实例。

要作为 结构存储的 值。

使用提供的 double 类型的参数初始化 结构的新实例。

一个双精度型值，它表示新 结构的值。

使用提供的整数值初始化 结构的新实例。

提供的整数值，它将用作新 结构的值。

使用提供的长整数值初始化 结构的新实例。

提供的长整型值，它将用作新 结构的值。

Abs 方法获取 参数的绝对值。

结构。 一个 结构，其 属性包含表示 参数的绝对值的无符号数字。

计算两个 操作数的和。

结构。 结构。 一个新的 结构，它的 属性包含该和。

将 操作数的小数位数调整为位数参数指示的位数。 取决于 fRound 参数的值，该值将舍入到适当的位数或者截断。

要调整的 结构。 已调整的结构的位数。 如果此参数是 ，将舍入新值，如果为 ，将截断该值。 一个新的 结构，它的 属性包含调整后的数字。

以字节数组形式获取此 结构的值的二进制表示形式。

一个字节数组，其中包含 结构的值的二进制表示形式。

返回大于或等于指定 结构的最小整数。

结构，将要计算其最大值。 一个 ，表示大于或等于指定的 结构的最小整数。

将此 实例与所提供的 对象进行比较，并返回其相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）

将 操作数的值调整为指定精度和小数位数。

将要调整其值的 结构。 新 结构的精度。 新 结构的小数位数。 一个新 结构，其值已经调整为参数中指定的精度和小数位数。

以整数数组形式获取此 结构的二进制表示形式。

一个整数数组，其中包含此 结构的二进制表示形式。

该除法运算符计算将第一个 操作数除以第二个操作数所得的结果。

结构。 结构。 新的 结构，它的 属性包含除法运算的结果。

对两个 操作数执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 的值将为 null。

将提供的 参数与 实例的 属性进行比较。

要比较的 。 如果对象是 的实例并且两者相等，则为 。 否则为 。

将指定 数字舍入为下一个较小的整数。

结构，将要计算其最小值。 一个 结构，其中包含此 结构的整数部分。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对两个 结构执行逻辑比较，以确定第一个结构是否大于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。

如果此 结构为 null，则为 。 否则为 。

指示此 结构的 是否大于零。

如果将 Null 赋给了 ，则为 。 否则为 。

对两个 结构执行逻辑比较，以确定第一个结构是否小于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，它表示 属性的可能的最大值。

一个常数，它表示 属性的最大值。

一个常数，它表示 结构的最大值。

一个常数，它表示 结构的最小值。

该乘法运算符计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 属性包含该乘法运算的乘积。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 类的此实例的 。

计算两个 操作数的和。

结构。 结构。 一个新的 结构，它的 属性包含该和。

该除法运算符计算将第一个 操作数除以第二个操作数所得的结果。

结构。 结构。 新的 结构，它的 属性包含除法运算的结果。

对两个 操作数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将 参数转换为 。

要转换的 结构。 一个新 结构，它的值等于 参数的 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

将提供的 参数转换为 。

要转换的 对象。 一个新的 结构，其 等于 参数表示的值。

将 参数转换为 。

要转换的 结构。 一个新 结构，它的值等于 参数的值。

对两个 结构执行逻辑比较，以确定第一个结构是否大于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 SqlDecimal。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将 操作数转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将 值转换为 。

要转换的 值。 新的 结构，它的 属性等于 参数的值。

将提供的 结构转换为 。

要转换的 结构。 新的 结构，它的 属性等于 参数的值。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构执行逻辑比较，以确定第一个结构是否小于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

该乘法运算符计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 属性包含该乘法运算的乘积。

计算从第一个 操作数中减去第二个操作数所得的结果。

结构。 结构。 一个新的 结构，它的“值”属性包含该减法运算的结果。

一元负运算符对 参数求反。

需求反的 结构。 一个新的 结构，其值包含求反的结果。

将数字的 表示形式转换为其等效的 形式。

要分析的 。 一个 ，它与指定的 中包含的值等效。

将指定的 结构的值乘到指定的幂。

要乘幂的 结构。 一个 double 类型值，指示数字应乘到的幂。 一个包含结果的 结构。

获取用于表示 属性的最大位数。

用于表示此 结构的 的最大位数。

以指定精度获取与指定 结构的值最接近的数字。

要舍入的 结构。 返回值中的有效小数位数（精度）。 一个 结构，其中包含该舍入运算的结果。

获取 解析为的小数位数。

属性解析后的小数位数。

获取一个值，该值指示 结构的 属性的符号。

要计算其符号的 结构。 一个指示 结构的符号的数字。

计算从第一个 操作数中减去第二个操作数所得的结果。

结构。 结构。 一个新的 结构，它的“值”属性包含该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

返回等于此实例的 属性的内容的双精度型值。

属性的小数表示形式。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。 如果 结构的值为 ，则 结构的 将为 1。 否则， 结构的 将为 0。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，其值与此 实例的值相同。

将此 结构转换为 。

一个 结构，它的值是一个表示此 结构中包含的值的字符串。

将此 结构转换为 。

一个新的 对象，其中包含 结构的 属性的字符串表示形式。

将指定 结构的值截断到希望的位置。

要截断的 结构。 数字将要截断到的小数位置。 为 参数提供一个负值，以便将该值截断到小数点左侧对应的位置。

获取 结构的值。 此属性是只读的。

介于 -79,228,162,514,264,337,593,543,950,335 到 79,228,162,514,162,514,264,337,593,543,950,335 之间的数字。

表示要存储在数据库中或从数据库中检索的浮点数字，该数字介于 -1.79E+308 到 1.79E+308 的范围内。

通过使用提供的双精度型参数设置新 结构的 属性，从而初始化 结构的新实例。

一个双精度型值，其值用于新 。

该加法运算符计算两个 操作数的和。

结构。 结构。 两个 操作数的和。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）。

该除法运算符将第一个 操作数除以第二个操作数。

结构。 结构。 一个 结构，它包含该除法运算的结果。

对 的两个实例执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果两个值相等，则为 。 否则为 。

返回此 结构的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

返回一个布尔值，该值指示此 实例是否为 null。

如果 为 null，则为 。 否则为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，表示 结构的最大值。

表示 的最小可能值的常数。

该乘法运算符计算两个 操作数的乘积。

结构。 结构。 两个 操作数的乘积。

对 的两个实例进行比较，以确定它们是否不等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

该加法运算符计算两个 操作数的和。

结构。 结构。 两个 操作数的和。

该除法运算符将第一个 操作数除以第二个操作数。

结构。 结构。 一个 结构，它包含该除法运算的结果。

对 的两个实例执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。

将提供的 参数转换为 。

要转换的 。 一个新 结构，其 为 0 或 1，取决于 参数的 属性。 如果 为 ，则 结构将为 。

将提供的 结构转换为双精度型值。

结构。 等效于指定的 结构的值的双精度型值。

将提供的 参数转换为 。

对象。 一个新的 ，其 等于 表示的数值。 如果 为 ，则 结构将为 。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 参数转换为 。

结构。 一个 结构，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 结构，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 结构，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 ，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 ，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 ，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的 参数转换为 。

结构。 一个新的 结构，它的 等于 参数的 。 如果 为 ，则 结构将为 。

将提供的字节值转换为 。

要转换的双精度型值。 与指定双精度型参数具有相同值的 。

对 的两个实例进行比较，以确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

该乘法运算符计算两个 操作数的乘积。

结构。 结构。 两个 操作数的乘积。

该减法运算符从第一个 操作数中减去第二个操作数。

结构。 结构。 该减法运算的结果。

返回指定 结构的求反值。

结构。 一个 结构，包含求反的值。

将数字的 表示形式转换为它的等效双精度浮点数字。

要分析的 。 一个 ，包含 所表示的值。

该减法运算符从第一个 操作数中减去第二个操作数。

结构。 结构。 该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

.NET 框架所使用的 XML 架构。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

。

将此 结构转换为 。

一个 结构，如果 结构的 为非零，其 将是 ；如果 为零，则为 ；如果 结构为 ，则为 。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。

将此 结构转换为 。

一个新的 结构，其转换后的值等于此 的舍入值。

将此 结构转换为 。

一个新的 结构，其 等于 结构值的整数部分。

将此 结构转换为 。

一个新的 结构，其 等于 结构值的整数部分。

将此 结构转换为 。

一个新的 结构，其 等于 结构值的整数部分。

将此 结构转换为 。

一个新的 结构，其 等于此 的值。

将此 结构转换为 。

一个新的 结构，其 等于此 的 。

将此 结构转换为 。

一个 ，表示此 的 。

将此 结构转换为字符串。

表示此 的 的字符串。

获取 结构的值。 此属性是只读的。

结构的值。

表示可分配给 结构实例的 属性的零值。

公开与作为字节序列的 FILESTREAM 列属性存储的 SQL Server 数据。

初始化 类的新实例。

文件的逻辑路径。 可以通过使用表中基础 FILESTREAM 列中的 Transact-SQL Pathname 函数检索路径。 对象的事务上下文。 应用程序应返回通过调用 GET_FILESTREAM_TRANSACTION_CONTEXT 方法返回的字节数组。 打开文件时要使用的访问模式。 支持的 枚举值为 、 和 。 当使用 时， 对象可以用于读取所有现有数据。 当使用 时， 指向零字节文件。 当关闭对象并提交事务时，会覆盖现有数据。 当使用 时， 指向其中包含所有现有数据的文件。 句柄位于文件的开头。 可以使用 方法之一在文件内移动句柄位置，以写入或追加新数据。 为 null 引用，或者， 为 null。 是一个空字符串 ("")，仅包含空格，或者包含一个或多个无效字符。 以“\\.\”开头，例如“\\\PHYSICALDRIVE0”。 通过调用 NTCreateFile 返回的句柄不属于类型 FILE_TYPE_DISK。 包含不支持的值。 无法找到该文件。 出现 I/O 错误。 调用方没有所要求的权限。 指定的 无效，例如在非映射驱动器上。 指定的路径所对应的操作系统不允许请求的访问。 当指定 Write 或 ReadWrite 访问时发生这种情况，并且文件或目录设置为只读访问。 NtCreateFile 失败，并且错误代码设置为 ERROR_SHARING_VIOLATION。

初始化 类的新实例。

文件的逻辑路径。 可以通过使用表中基础 FILESTREAM 列中的 Transact-SQL Pathname 函数检索路径。 对象的事务上下文。 当设置为 null 时，隐式事务将用于 对象。 应用程序应返回通过调用 GET_FILESTREAM_TRANSACTION_CONTEXT 方法返回的字节数组。 打开文件时要使用的访问模式。 支持的 枚举值为 、 和 。 当使用 时， 对象可以用于读取所有现有数据。 当使用 时， 指向零字节文件。 当关闭对象并提交事务时，会覆盖现有数据。 当使用 时， 指向其中包含所有现有数据的文件。 句柄位于文件的开头。 可以使用 方法之一在文件内移动句柄位置，以写入或追加新数据。 指定打开文件时要使用的选项。 支持的 值为 、、 和 。 创建文件时要使用的分配大小。 如果设置为 0，则使用默认值。 为 null 引用，或者， 为 null。 是一个空字符串 ("")，仅包含空格，或者包含一个或多个无效字符。 以“\\.\”开头，例如“\\\PHYSICALDRIVE0”。 通过调用 NTCreateFile 返回的句柄不属于类型 FILE_TYPE_DISK。 包含不支持的值。 无法找到该文件。 出现 I/O 错误。 调用方没有所要求的权限。 指定的 无效，例如在非映射驱动器上。 指定的路径所对应的操作系统不允许请求的访问。 当指定 Write 或 ReadWrite 访问时发生这种情况，并且文件或目录设置为只读访问。 NtCreateFile 失败，并且错误代码设置为 ERROR_SHARING_VIOLATION。

开始异步读操作。

数据读入的缓冲区。 中的字节偏移量，从该偏移量开始写入从流中读取的数据。 最多读取的字节数。 可选的异步回调，在完成读取时调用。 一个用户提供的对象，它将此特定的异步读取请求与其他请求区别开来 表示异步读取的 （可能仍处于挂起状态）。 不支持在流上读取数据。

开始异步写操作。

从中写入数据的缓冲区。 中的字节偏移量，从此处开始写入。 最多写入的字节数。 可选的异步回调，在完成写入时调用。 一个用户提供的对象，它将该特定的异步写入请求与其他请求区别开来。 表示异步写入的 （可能仍处于挂起状态）。 该流不支持写入数据。

获取一个值，该值指示当前流是否支持读取。

如果当前流支持读取，则为 ；否则为 。

获取一个值，该值指示当前流是否支持查找。

如果当前流支持查找，则为 ；否则为 。

获取指示当前流是否可以超时的值。

如果当前流可以超时，则为 ；否则为 。

获取一个值，该值指示当前流是否支持写入。

如果当前流支持写入，则为 ；否则为 。

等待挂起的异步读取完成。

对要完成的挂起异步请求的引用。 从流中读取的字节数，介于零 (0) 和所请求的字节数之间。 流仅在流结尾返回零 (0)，否则在至少有 1 个字节可用之前应一直进行阻止。 对象并非来自相应的 方法。

结束异步写操作。

对未完成的异步 I/O 请求的引用。 对象并非来自相应的 方法。

确保垃圾回收器回收 时释放资源并执行其他清理操作。

清除此流的所有缓冲区并导致所有缓冲数据都写入基础设备中。

获取一个指示当前流的长度的值（以字节为单位）。

一个指示当前流的长度的 （以字节为单位）。

获取传递给构造函数的 的逻辑路径。

一个指示 的名称的字符串值。

获取或设置当前流中的位置。

中的当前位置。

从当前流读取字节序列，并将流中的位置向前移动读取的字节数。

字节数组。 此方法返回时，该缓冲区包含指定的字节数组，该数组的偏移量和（偏移量 + 计数 - 1）之间的值由从当前源中读取的字节替换。 缓冲区中从零开始的字节偏移量，从此处开始存储从当前流中读取的数据。 要从当前流中最多读取的字节数。 读入缓冲区中的总字节数。 如果很多字节当前不可用，则总字节数可能小于请求的字节数；如果已到达流结尾，则为零 (0)。 对象不支持数据读取。

从流中读取一个字节，并将流内的位置向前提升一个字节，或者如果已到达流结尾，则返回 -1。

强制转换为 的无符号字节，如果到达流的末尾，则为 -1。 对象不支持数据读取。

获取或设置一个值（以毫秒为单位），该值确定流在超时前将尝试读取的时间。

一个值（以毫秒为单位），该值确定流在超时前将尝试读取的时间。

设置当前流中的位置。

相对于 参数的字节偏移量 类型的值，指示用于获取新位置的参考点 当前流中的新位置。

设置当前流的长度。

所需的当前流的长度（以字节表示）。 对象不支持数据读取。

获取或设置此 对象的事务上下文。

传递到此 对象的构造函数的 数组。

将字节序列写入当前流，并按写入的字节数向前调整流的当前位置。

字节数组。 此方法将 个字节从 复制到当前流。 中的从零开始的字节偏移量，从此处开始将字节复制到当前流。 要写入当前流的字节数。 对象不支持数据写入。

将一个字节写入流内的当前位置，并将流内的位置向前提升一个字节。

要写入流中的字节。 对象不支持数据写入。

获取或设置一个值（以毫秒为单位），该值确定流在超时前将尝试写入多长时间。

一个确定流在超时前将尝试写入多长时间的值（以毫秒为单位）。

表示要存储在数据库中或要从数据库中检索的 GUID。

使用提供的字节数组参数初始化 结构的新实例。

字节数组。

使用指定的 参数初始化 结构的新实例。

一个

使用指定的值初始化 结构的新实例。

的开头四个字节。 的下两个字节。 的下两个字节。 的下一个字节。 的下一个字节。 的下一个字节。 的下一个字节。 的下一个字节。 的下一个字节。 的下一个字节。 的下一个字节。

使用指定的 参数初始化 结构的新实例。

对象。

将此 结构与提供的 进行比较，并返回其相对值的指示值。 不仅仅是比较最后 6 个字节，但会将最后 6 个字节视为比较中最重要的字节。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于对象。 零 此实例等于对象。 大于零 此实例大于对象 - 或 - 对象是 null 引用 ()。

将此 结构与所提供的对象进行比较，并返回其相对值的指示。 不仅仅是比较最后 6 个字节，但会将最后 6 个字节视为比较中最重要的字节。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于对象。 零 此实例等于对象。 大于零 此实例大于对象 - 或 - 对象是 null 引用 ()

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此 结构的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

获取一个布尔值，该值指示此 结构是否为 null。

如果 ，则为 。 否则为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

将 参数转换为 。

一个 对象。 一个新的 ，它的 等于 参数的 。

将提供的 参数转换为 。

结构。 一个新 ，它等于 的 。

将指定的 结构转换为 。

对象。 一个 ，其 等于 参数表示的值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否大于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 参数转换为 。

。 一个新 ，其 等于 参数。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于或等于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将指定的 结构转换为 。

要分析的 。 一个 ，它与指定的 中包含的值等效。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为字节数组。

一个字节数组，表示此 结构的 。

将此 结构转换为 。

一个 结构，包含 结构中的字节。

将此 结构转换为 。

一个 结构，包含 结构的字符串表示形式。

将此 结构转换为 。

一个 结构，包含 结构的字符串表示形式。

获取 结构的值。 此属性是只读的。

结构。

表示要在数据库中存储或检索的 16 位有符号整数。

使用提供的短整型参数初始化 结构的新实例。

短整型。

计算两个 操作数的和。

结构。 结构。 一个 结构，它的 属性包含两个 操作数的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它的 属性包含按位 AND 运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 一个 结构，它的 属性包含按位“或”运算的结果。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 对象为 null 引用（在 Visual Basic 中为 ）

将第一个 操作数除以第二个操作数。

结构。 结构。 一个 ，它的 属性包含该除法运算的结果。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将指定对象与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 指示指定的 的 XSD 的 值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。 有关详细信息，请参阅Handling Null Values。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否小于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，它表示 的最大可能值。

一个常数，它表示 的最小可能值。

计算将其第一个 操作数除以第二个操作数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

将两个 值相除，并返回余数。

一个 值。 一个 值。 对 和 执行除法运算后得到的余数。

计算两个 参数的乘积。

结构。 结构。 一个 结构，它的 包含两个参数的乘积。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

~ 运算符对它的 操作数执行按位二进制反码运算。

结构。 一个 结构，它的 属性包含指定 结构的二进制反码。

计算两个 操作数的和。

结构。 结构。 一个 结构，它的 属性包含两个 操作数的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它的 属性包含按位 AND 运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 一个 结构，它的 属性包含按位“或”运算的结果。

将第一个 操作数除以第二个操作数。

结构。 结构。 一个 ，它的 属性包含该除法运算的结果。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

对提供的参数执行按位“异或”运算。

结构。 结构。 一个 结构，它的 属性包含按位“异或”运算的结果。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

结构。 一个新的 结构，其 属性等于 参数的整数部分。

将提供的 结构转换为短整型。

结构。 短整型，其值等于 参数的值。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于提供的 参数的 。

将提供的 结构转换为 。

结构。 新的 结构，它的 属性等于 参数的 。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

结构。 一个新的 结构，其 属性等于 参数的整数部分。

将提供的 对象转换为 。

对象。 一个新的 结构，它的 属性等于 对象参数表示的值。

对 的两个实例进行比较，以确定第一个实例是否大于第二个实例。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的短整型转换为 。

短整型值。 与指定的短整型具有相同值的 结构。

对两个 结构执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对 的两个实例进行比较，以确定第一个实例是否小于第二个实例。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构进行比较，以确定第一个结构是否小于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

计算将其第一个 操作数除以第二个操作数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

计算两个 参数的乘积。

结构。 结构。 一个 结构，它的 包含两个参数的乘积。

~ 运算符对它的 操作数执行按位二进制反码运算。

结构。 一个 结构，它的 属性包含指定 结构的二进制反码。

从第一个 参数中减去第二个参数。

结构。 结构。 一个 结构，它的 属性包含该减法运算的结果。

一元负运算符对 操作数的 求反。

结构。 一个 结构，包含求反的值。

将数字的 表示形式转换为它的等效 16 位有符号整数。

要分析的 。 一个 16 位有符号整数，它等效于指定的 中包含的值。

从第一个 参数中减去第二个参数。

结构。 结构。 一个 结构，它的 属性包含该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

.NET 框架所使用的 XML 架构。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。 如果 的值小于 0 或大于 255，则将发生 。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

一个新 结构，其 等于此 结构的值。

将此 结构转换为 。

表示 的此实例的 。

将 结构转换为 。

一个 对象，它表示 的此实例的 。

获取 结构的此实例的值。 此属性是只读的。

表示此 结构的值的短整型。

对提供的参数执行按位“异或”运算。

结构。 结构。 一个 结构，它包含该“异或”运算的结果。

表示可分配给 结构实例的 属性的零值。

表示要在数据库中存储或检索的 32 位有符号整数。

使用提供的整数值初始化 结构的新实例。

要转换的整数。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，它的 属性包含指定 结构的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它包含按位“与”运算的结果。

对指定的 结构执行按位“或”运算。

结构。 结构。 一个 结构，它包含按位“或”运算的结果。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）。

将第一个 参数除以第二个参数。

结构。 结构。 一个 ，它的 属性包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 指示指定的 的 XSD 的 值。

对两个 参数进行比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数进行比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。

如果 为 Null，则此属性为 。 否则为 。

对两个 参数进行比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数进行比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，它表示 的最大可能值。

一个常数，它表示 的最小可能值。

计算将第一个 参数除以第二个参数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

将两个 值相除，并返回余数。

一个 值。 一个 值。 对 和 执行除法运算后得到的余数。

计算两个 参数的乘积。

结构。 结构。 一个 结构，它的 包含两个参数的乘积。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 类的此实例的 。

对指定的 结构执行按位二进制反码运算。

结构。 一个 结构，它包含二进制求补运算的结果。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，它的 属性包含指定 结构的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它包含按位“与”运算的结果。

对指定的 结构执行按位“或”运算。

结构。 结构。 一个 结构，它包含按位“或”运算的结果。

将第一个 参数除以第二个参数。

结构。 结构。 一个 ，它的 属性包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

对指定的 结构执行按位“异或”运算。

结构。 结构。 一个 结构，它包含按位“异或”运算的结果。

将提供的 转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 转换为 。

结构。 一个新的 结构，它的 属性等于 参数的整数部分。

将提供的 结构转换为整数。

结构。 已转换的整数值。

将提供的 转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 结构转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 转换为 。

结构。 一个新的 结构，它的 属性等于 参数的整数部分。

将提供的 对象转换为 。

对象。 一个新的 结构，它的 属性等于 参数表示的值。

对两个 参数进行比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数进行比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 属性转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 转换为 。

结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 转换为整数。

一个整数值。 一个新的 结构，其 Value 属性等于整数参数。

对两个 参数执行逻辑比较，以确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数进行比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数进行比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

计算将第一个 参数除以第二个参数后所得的余数。

结构。 结构。 一个 结构，它的 包含该余数。

计算两个 参数的乘积。

结构。 结构。 一个 结构，它的 包含两个参数的乘积。

对指定的 结构执行按位二进制反码运算。

结构。 一个 结构，它包含二进制求补运算的结果。

从第一个 参数中减去第二个参数。

结构。 结构。 一个 结构，它的 属性包含该减法运算的结果。

对 操作数的 求反。

结构。 一个 结构，包含求反的值。

将数字的 表示形式转换为它的等效 32 位有符号整数。

要分析的 。 一个 32 位有符号整数，它等效于指定的 中包含的值。

从第一个 参数中减去第二个参数。

结构。 结构。 一个 结构，它的 属性包含该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。 如果 的值小于 0 或大于 255，则将发生 。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将此 结构转换为 。

新的 结构等于此 的值。

将 结构转换为 。

结构等于此 的值。

获取此 结构的值。 此属性是只读的。

表示此 结构的值的整数。 此属性包含 。

对指定的 结构执行按位“异或”运算。

结构。 结构。 一个 结构，它包含按位“异或”运算的结果。

表示可分配给 结构实例的 属性的零值。

表示要在数据库中存储或检索的 64 位有符号整数。

使用提供的长整型初始化 结构的新实例。

长整型。

计算两个 参数的和。

结构。 结构。 一个新的 结构，它的 等于两个 参数的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它包含按位“与”运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 一个 结构，它包含按位“或”运算的结果。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）。

将第一个 参数除以第二个参数。

结构。 结构。 一个新的 结构，它的 属性包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 ；否则为 。

返回此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 一个指示指定的 的 XSD 的 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

获取一个布尔值，该值指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个常数，表示 结构的可能的最大值。

一个常数，表示 结构的可能的最小值。

计算将第一个 参数除以第二个参数后所得的余数。

结构。 结构。 一个新的 结构，它的 属性包含该余数。

将两个 值相除，并返回余数。

一个 值。 一个 值。 对 和 执行除法运算后得到的余数。

计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 等于两个 参数的乘积。

对两个 SqlInt64 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

对它的 操作数执行按位二进制反码运算。

结构。 新的 结构，它的 等于 参数的二进制反码。

计算两个 参数的和。

结构。 结构。 一个新的 结构，它的 等于两个 参数的和。

对其 操作数执行按位 AND 运算。

结构。 结构。 一个 结构，它包含按位“与”运算的结果。

对其两个 操作数执行按位“或”计算。

结构。 结构。 一个 结构，它包含按位“或”运算的结果。

将第一个 参数除以第二个参数。

结构。 结构。 一个新的 结构，它的 属性包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

对提供的参数执行按位“异或”运算。

结构。 结构。 一个 结构，它包含按位“异或”运算的结果。

将提供的 参数转换为 。

要转换的 结构。 新的 结构，它的 属性等于 参数的 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，其 等于 参数的整数部分。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的整数部分。

将 参数转换为长值。

结构。 一个新长值，它等于 的 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的整数部分。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，其 属性包含 参数的整数部分。

将提供的 参数转换为 。

要转换的 对象。 一个新的 ，它的 等于 参数表示的值。

对两个 参数执行逻辑比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

将长参数转换为 。

长整型值。 一个新的 结构，它的 等于长参数的值。

对两个 SqlInt64 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

计算将第一个 参数除以第二个参数后所得的余数。

结构。 结构。 一个新的 结构，它的 属性包含该余数。

计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 等于两个 参数的乘积。

对它的 操作数执行按位二进制反码运算。

结构。 新的 结构，它的 等于 参数的二进制反码。

从第一个 参数中减去第二个参数。

结构。 结构。 一个新的 结构，它的 属性等于该减法运算的结果。

一元负运算符对 操作数的 求反。

结构。 一个 结构，它的 等于 参数的求反 。

将数字的 表示形式转换为它的等效 64 位有符号整数。

要分析的 。 一个 64 位有符号整数，它等效于指定的 中包含的值。

从第一个 参数中减去第二个参数。

结构。 结构。 一个新的 结构，它的 属性等于该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

一个 ，表示此 的值。

将 的此实例转换为 。

一个 ，表示此 的值。

获取此 结构的值。 此属性是只读的。

一个长整型，表示此 结构的值。

对提供的参数执行按位“异或”运算。

结构。 结构。 一个 结构，它包含按位“异或”运算的结果。

表示可分配给 结构实例的 属性的零值。

表示要存储在数据库中或要从数据库中检索的货币值，范围介于 -2 63 （或 -922,337,203,685,477.5808） to 2 63 -1 （或 +922,337,203,685,477.5807）之间，精度为千分之十货币单位。

使用指定的 值初始化 类的新实例。

要初始化的货币值。

使用指定的双精度型值初始化 类的新实例。

要初始化的货币值。

用指定的整数值初始化 类的新实例。

要初始化的货币值。

使用指定的长整型值初始化 类的新实例。

要初始化的货币值。

计算两个 参数的和。

结构。 结构。 一个新的 结构，它的 包含两个 参数的和。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）

除法运算符将第一个 参数除以第二个参数。

结构。 结构。 一个新的 结构，它的 包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则返回 ；否则，返回 。

获取此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 一个指示指定的 的 XSD 的 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

返回一个布尔值，该值指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

表示可分配给 类实例的 属性的最大值。

表示可分配给 类实例的 属性的最小值。

乘法运算符计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 包含该乘法运算的结果。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 类的此实例的 。

计算两个 参数的和。

结构。 结构。 一个新的 结构，它的 包含两个 参数的和。

除法运算符将第一个 参数除以第二个参数。

结构。 结构。 一个新的 结构，它的 包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

此运算符将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

此运算符将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

将指定的 结构转换为 。

结构。 一个新 结构，它的值等于 参数的 。

此运算符将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

此运算符将 参数转换为 。

要转换的 对象。 一个新的 结构，它的 属性等于 参数表示的值。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 属性。

对两个 参数执行逻辑比较，以确定第一个参数是否大于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否大于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 新的 结构，它的 属性等于 参数的 。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 属性等于 参数的 。

将 参数转换为 。

要转换的 值。 一个新的 结构，它的 等于 参数的值。

此隐式运算符可将所提供的 参数转换为 。

要转换的 结构。 新的 结构，它的 属性等于 参数的值。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

乘法运算符计算两个 参数的乘积。

结构。 结构。 一个新的 结构，它的 包含该乘法运算的结果。

该减法运算符从第一个 参数中减去第二个参数。

结构。 结构。 一个新的 结构，它包含该减法运算的结果。

一元负运算符对 参数求反。

需求反的 结构。 一个 结构，它的 包含求反的结果。

将数字的 表示形式转换为其等效的 形式。

要分析的 。 一个 ，它与指定的 中包含的值等效。

该减法运算符从第一个 参数中减去第二个参数。

结构。 结构。 一个新的 结构，它包含该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将 的此实例的值转换为 结构。

一个 结构，它的值等于此 结构的 属性。

将此 结构转换为 。

一个双精度型，它的值等于此 结构。

将此 结构转换为 。

一个 32 位整数，其值等于此 结构的整数部分。

将此 结构的值转换为 。

一个 64 位整数，其值等于此 结构的整数部分。

将此 结构转换为 。

结构。 如果 结构的值为零，则 结构的值将为 。 否则为 。

将此 结构转换为 。

等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

一个 结构，它的值是一个表示此 的值的字符串。

将 的此实例转换为字符串。

一个字符串，它的值是此 的值的字符串表示形式。

获取 结构的实例的货币值。 此属性是只读的。

结构的实例的货币值。 该属性设置为 null。

表示可分配给 类实例的 属性的零值。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

初始化 类的新实例。

引发异常时显示的字符串。

初始化 类的新实例。

引发异常时显示的字符串。 对内部异常的引用。

当 结构的 属性设置为 null 时所引发的异常。

使用由系统提供的用于描述错误的消息初始化 类的新实例。

使用指定的描述错误的消息初始化 类的新实例。

描述该异常的消息。 此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

描述该异常的消息。 此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 导致当前异常的异常。 如果 innerException 参数不为 ，则当前异常会在处理内部异常的 块中引发。

表示要存储在数据库中或从数据库中检索的浮点数，范围在 -3.40E+38 到 3.40E+38 之间。

使用提供的 double 类型的参数初始化 结构的新实例。

一个双精度型值，它将用作新 结构的 。

初始化 结构的新实例。

一个浮点数，它将用作新 结构的 。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，包含两个指定 结构的和。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 或 该对象是空引用（在 Visual Basic 中为 ）

将第一个 结构除以第二个结构。

结构。 结构。 一个 结构，包含该除法运算的结果。

对两个 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则为 。 否则为 。

获取此实例的哈希代码。

32 位有符号整数哈希代码。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于第二个操作数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构执行逻辑比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指示此 结构是否为 null。

如果为 null，则返回 。 否则为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

表示可分配给 类实例的 属性的最大值。

表示可分配给 类实例的 属性的最小值。

计算两个指定 结构的乘积。

结构。 结构。 一个 结构，包含该乘法运算的乘积。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

计算两个指定的 结构的和。

结构。 结构。 一个 结构，包含两个指定 结构的和。

将第一个 结构除以第二个结构。

结构。 结构。 一个 结构，包含该除法运算的结果。

对两个 SqlSingle 参数执行逻辑比较，以确定它们是否相等。

结构。 结构。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

此隐式运算符将提供的 转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 参数转换为 。

要转换的 参数。 一个新的 结构，它的 等于 参数的 。

将指定的 结构转换为浮点型。

要转换为浮点型的 值。 一个 float 类型值，包含 结构的值。

将提供的 参数转换为 。

要转换的 对象。 一个新的 结构，它的 等于 参数表示的值。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于第二个操作数。

结构。 结构。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 结构执行逻辑比较，以确定第一个结构是否大于或等于第二个结构。

结构。 结构。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

此隐式运算符将 参数转换为 。

要转换的 。 一个新的 结构，它的 属性等于 参数的 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 参数转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将提供的 结构转换为 。

要转换的 结构。 一个新的 结构，它的 等于 参数的 。

将指定的浮点值转换为 。

要转换为 的浮点值。 一个 结构，包含指定浮点型的值。

对两个 参数执行逻辑比较，确定它们是否不相等。

结构。 结构。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 参数执行逻辑比较，以确定第一个参数是否小于或等于第二个参数。

结构。 结构。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

计算两个指定 结构的乘积。

结构。 结构。 一个 结构，包含该乘法运算的乘积。

从第一个 结构中减去第二个结构。

结构。 结构。 一个 结构，包含该减法运算的结果。

对指定 结构的 求反。

结构。 一个 结构，包含求反的值。

将指定 转换为 结构。

要分析的 。 一个 ，它与指定的 中包含的值等效。

从第一个 结构中减去第二个结构。

结构。 结构。 一个 结构，包含该减法运算的结果。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个 结构，其 等于此 结构的 。 如果 结构的值为 ，则 结构的 将为 1。 否则， 结构的 将为 0。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

新的 等于此 的值。

将此 结构转换为 。

等于此 的值。

将此 结构转换为 。

一个 ，表示此 的值。

将此 结构转换为 。

一个表示此 的值的 对象。

获取此 结构的值。 此属性是只读的。

一个浮点值，介于 -3.40E+38 到 3.40E+38 的范围内。

表示可分配给 类实例的 属性的零值。

表示要存储在数据库中或从数据库中检索的字符的可变长度流。 具有与其相应的 .NET Framework 数据类型不同的基础数据结构。

使用指定的区域设置 ID、比较选项和数据，初始化 结构的新实例。

指定新 结构的地理区域设置和语言。 指定新 结构的比较选项。 要存储的数据数组。

初始化 类的新实例。

指定新 结构的地理区域设置和语言。 指定新 结构的比较选项。 要存储的数据数组。 如果是 Unicode 编码，则为 。 否则为 。

初始化 类的新实例。

指定新 结构的地理区域设置和语言。 指定新 结构的比较选项。 要存储的数据数组。 数组中的起始索引。 要从索引复制的字符数。

初始化 类的新实例。

指定新 结构的地理区域设置和语言。 指定新 结构的比较选项。 要存储的数据数组。 数组中的起始索引。 要从索引复制的字符数。 如果是 Unicode 编码，则为 。 否则为 。

使用指定的字符串初始化 结构的新实例。

要存储的字符串。

使用指定的字符串和区域设置 ID 值，初始化 结构的新实例。

要存储的字符串。 指定新 结构的地理区域设置和语言。

使用指定字符串、区域设置 ID 和比较选项值，初始化 结构的新实例。

要存储的字符串。 指定新 结构的地理区域设置和语言。 指定新 结构的比较选项。

串联两个指定的 值以创建一个新的 结构。

。 。 一个 ，它是 与 的串联值。

指定排序应基于字符数值（而非其字母值）。

指定排序应基于字符数值（而非其字母值）。

创建此 对象的一个副本。

一个新的 对象，其中所有的属性值都与原始值相同。

获取 对象，该对象定义如何对此 结构执行字符串比较。

一个 对象，该对象定义此 结构的字符串比较。

获取与指定 值等效的 枚举。

一个 值，该值描述此 结构的比较选项。 一个 值，该值对应于此 结构的 。

将此 实例与所提供的 进行比较，并返回二者相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）。

将此 对象与所提供的 进行比较，并返回其相对值的指示值。

要比较的 。 一个有符号的数字，它指示该实例和对象的相对值。 返回值 条件 小于零 此实例小于该对象。 零 此实例等于该对象。 大于零 此实例大于该对象 - 或 - 该对象是空引用（在 Visual Basic 中为 ）

串连两个指定的 结构。

。 。 一个 ，它包含表示两个 参数内容的新串联的值。

获取 结构，它表示有关此 对象的区域性信息。

一个 结构，描述有关此 SqlString 结构的区域性的信息，包括区域性的名称、书写体系和使用的日历，还包括对特定于区域性对象的访问，这些对象提供常规运算的方法，例如格式化日期和排序字符串。

对两个 操作数执行逻辑比较，以确定它们是否相等。

。 。 如果两个值相等，则为 。 否则为 。 如果任一实例为 null，则 将为 null。

将提供的对象参数与 对象的 属性进行比较。

要比较的对象。 如果对象是 的实例并且两者相等，则返回 ；否则，返回 。

获取此实例的哈希代码。

32 位有符号整数哈希代码。

获取字节的数组，其中包含 ANSI 格式的内容。

一个字节数组，包含 ANSI 格式的内容。

获取字节的数组，其中包含 Unicode 格式的内容。

一个字节数组，包含 Unicode 格式的内容。

返回指定的 的 XML 架构定义语言 (XSD)。

。 指示指定的 的 XSD 的 值。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于第二个操作数。

。 。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于或等于第二个操作数。

。 。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

指定 比较应忽略大小写。

指定字符串比较必须忽略假名类型。

指定字符串比较必须忽略非空格组合字符，比如音调符号。

指定字符串比较必须忽略字符宽度。

指示此 结构是否为 null。

如果 为 ，则返回 。 否则为 。

指定 结构的地理区域设置和语言。

存储在 属性中的字符串的区域设置 ID。

对两个 操作数执行逻辑比较，以确定第一个操作数是否小于第二个操作数。

。 。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定第一个操作数是否小于或等于第二个操作数。

。 。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定它们是否不相等。

。 。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

表示可指派给 结构的此实例的 。

串连两个指定的 结构。

。 。 一个 ，它包含表示两个 参数内容的新串联的值。

对两个 操作数执行逻辑比较，以确定它们是否相等。

。 。 一个 ，它在两个实例相等时为 ，在两个实例不等时为 。 如果 的任一实例为空，则 的 将为 。

将指定的 结构转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将指定的 结构转换为 。

要转换的 结构。 一个新的 对象，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个 ，它的值是指定的 的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 对象，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 SqlInt32 结构。 一个新的 对象，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 对象，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将指定的 参数转换为 。

要转换的 结构。 一个新的 ，包含 参数的字符串表示形式。

将 转换为 。

要转换的 。 一个 ，它的内容与 参数的 属性相同。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于第二个操作数。

。 。 一个 ，如果第一个实例大于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定第一个操作数是否大于或等于第二个操作数。

。 。 一个 ，如果第一个实例大于或等于第二个实例，则为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

将 参数转换为 。

要转换的 。 一个 ，包含指定的 的值。

对两个 操作数执行逻辑比较，以确定它们是否不相等。

。 。 一个 ，它在两个实例不等时为 ，在两个实例相等时为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定第一个操作数是否小于第二个操作数。

。 。 一个 ，如果第一个实例小于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

对两个 操作数执行逻辑比较，以确定第一个操作数是否小于或等于第二个操作数。

。 。 一个 ，如果第一个实例小于或等于第二个实例，则它为 。 否则为 。 如果 的任一实例为空，则 的 将为 。

一个或多个 枚举值的组合，它们表示此 与其他 结构的比较方式。

一个值，它指定如何将此 与其他 结构进行比较。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

一个 。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

此成员支持 .NET Framework 结构，不能在代码中直接使用。

将此 结构转换为 。

如果 不是零，则为 ；如果为零，则为 ；否则为 Null。

将此 结构转换为 。

一个新的 结构，它的 等于此 结构所表示的数字。

将此 结构转换为 。

一个新的 结构，其中包含此 所表示的日期值。

将此 结构转换为 。

一个新的 ，其中包含此 的值。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将此 结构转换为 。

一个新的 结构，其 是此 结构所表示的 。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将此 结构转换为 。

一个新的 ，它等于此 的数值。

将 对象转换为 。

与此 结构具有相同值的 。

获取存储在此 结构中的字符串。 此属性是只读的。

存储的字符串。 字符串的值是 。

在将值设置到 结构中会截断该值时引发的异常。

初始化 类的新实例。

用指定的错误消息初始化 类的新实例。

解释异常原因的错误消息。

使用指定的错误消息和对 的引用来初始化 类的新实例。

解释异常原因的错误消息。 对内部 的引用。

的基异常类。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

承载序列化对象数据的对象。 关于来源和目标的上下文信息

用指定的错误消息初始化 类的新实例。

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

描述该异常的消息。 此构造函数的调用方需要确保此字符串已针对当前系统区域性进行了本地化。 导致当前异常的异常。 如果 innerException 参数不为 ，则当前异常会在处理内部异常的 块中引发。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

字符串形式的名称。 字符串形式的目标类型。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

字符串形式的名称。 字符串形式的目标类型。 一个布尔值。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

字符串形式的名称。 目标命名空间。 引用的字符串数组。 CodeNamespaceImport 对象数组。 字符串形式的目标类型。 表示定向的布尔值。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

表示存储在服务器中的或从服务器中检索的 XML 数据。

创建一个新的 实例。

创建一个新的 实例，以提供来自所提供的 派生实例中的 XML 值。

一个 派生实例（如 ），要从该实例加载 实例的 XML 内容。

创建一个新的 实例，并将其与提供的 的内容关联起来。

一个要用作新 实例的值的 派生类实例。

作为 来获取此 的 XML 内容的值。

一个包含 XML 内容的 派生实例。 根据信息的内部表示方式，服务器上的实际类型会有所不同（例如，返回值可能为 ）。 曾尝试访问 的 null 实例上的此属性。

返回指定的 的 XML 架构定义语言 (XSD)。

一个 。 一个指示指定的 的 XSD 的字符串。

指示此实例是否表示一个 null 值。

如果 为 null，则为 。 否则为 。

表示 类型的 null 实例。

一个 类型的 null 实例。

有关此成员的说明，请参阅 。

一个 ，描述由 方法生成并由 方法使用的对象的 XML 表示形式。

有关此成员的说明，请参阅 。

XmlReader。

有关此成员的说明，请参阅 。

一个 XmlWriter

获取此 实例的 XML 内容的字符串表示形式。

XML 内容的字符串表示形式。

枚举不用作独立组件，而是用作其他类从中派生标准功能的枚举。

缓冲区大小。

流。

非托管的缓冲区。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

TypeSmallDateTimeSchemaImporterExtension 类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 TypeSmallDateTimeSchemaImporterExtension 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

类不用作独立组件，而是用作其他类从中派生标准功能的类。

初始化 类的新实例。

提供 .NET Framework 数据提供程序的状态更改事件数据。

在给定对象的原始状态和当前状态的情况下，初始化 类的新实例。

值之一。 值之一。

获取连接的新状态。 在激发该事件时，连接对象将处于新状态。

值之一。

获取连接的原始状态。

值之一。

表示用来处理 事件的方法。

事件源。 包含事件数据的 。

为 事件提供附加信息。

创建 类的新实例。

指示受导致 事件发生的语句影响的行数。

指示受导致 事件发生的语句影响的行数。

受影响的行数。

事件的事件处理程序的委托类型。

事件源。 事件的数据。

指定由 、、 或 类使用的 SQL 查询的类型。

SQL 查询，它是批处理语句。

SQL 查询，它是 DELETE 语句。

SQL 查询，它是 INSERT 语句。

SQL 查询，它是 SELECT 语句。

SQL 查询，它是 UPDATE 语句。

在用户访问 值时，强类型 引发的异常。

初始化 类的新实例。

使用指定的序列化信息和流上下文初始化 类的新实例。

对象。 结构。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的字符串和内部异常初始化 类的新实例。

引发异常时显示的字符串。 对内部异常的引用。

表示当 的 属性包含语法错误时引发的异常。

初始化 类的新实例。

使用 和 初始化 类的新实例。

序列化或反序列化对象所需的数据。 特定序列化流的源和目标。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

用于创建强类型 。

初始化 类的新实例。

生成强类型 。

源 ，它为类型化 指定元数据。 为类型化 提供目标命名空间的命名空间。 用于创建类型化 的生成器。

转换有效类型化 名称中的字符串。

要转换为有效类型化 名称的源名称。 用于执行转换的生成器。 一个字符串，它是转换后的名称。

当生成强类型 的过程中发生名称冲突时引发的异常。

初始化 类的新实例。

初始化 类的新实例。

对象，包含动态的异常列表。

使用指定的序列化信息和流上下文初始化 类的新实例。

对象。 结构。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的字符串和内部异常初始化 类的新实例。

引发异常时显示的字符串。 对内部异常的引用。

获取生成的错误的动态列表。

对象。

实现 接口并返回序列化 对象所需的数据。

对象。 结构。

表示对一组列的限制，列中的所有值必须是唯一的。

使用指定的 初始化 类的新实例。

要约束的 。

用要约束的 和指定约束是否为主键的值，初始化 类的新实例。

要约束的 。 若要指示约束是主键，则为 ；否则为 。

用给定的 对象的数组初始化 类的新实例。

要约束的 对象的数组。

用要约束的 对象的数组和指定约束是否为主键的值，初始化 类的新实例。

要约束的 对象的数组。 若要指示约束是主键，则为 ；否则为 。

使用指定的名称和 初始化 类的新实例。

约束的名称。 要约束的 。

用指定名称、要约束的 和指定约束是否为主键的值，初始化 类的新实例。

约束的名称。 要约束的 。 若要指示约束是主键，则为 ；否则为 。

用指定的名称和 对象的数组初始化 类的新实例。

约束的名称。 要约束的 对象的数组。

用指定名称、要约束的 对象的数组和指定约束是否为主键的值，初始化 类的新实例。

约束的名称。 要约束的 对象的数组。 若要指示约束是主键，则为 ；否则为 。

用指定名称、要约束的 对象的数组和指定约束是否为主键的值，初始化 类的新实例。

约束的名称。 要约束的 对象的数组。 若要指示约束是主键，则为 ；否则为 。

获取此约束影响的列的数组。

一个 对象数组。

将此约束与第二个约束比较以确定两个约束是否相同。

此 将与之比较的对象。 如果约束相等，则为 ；否则为 。

获取 对象的此实例的哈希代码。

32 位有符号整数哈希代码。

获取一个值，该值指示约束是否在主键上。

如果约束在主键上，则为 ；否则为 。

获取此约束所属的表。

此约束所属的 。

指定如何将查询命令结果应用于正在更新的行。

将输出参数和第一个返回行都映射到 中的已更改的行。

将第一个返回行中的数据映射到 中的已更改的行。

忽略任何返回的参数或行。

将输出参数映射到 中的已更改的行。

指定在 期间对当前行和其余行采取的操作。

应该继续处理行。

事件处理程序报告：应将更新作为错误对待。

将不更新当前行和所有其余行。

将不更新当前行。

表示尝试返回已删除的 版本时引发的异常。

初始化 类的新实例。

使用序列化信息初始化 类的新实例。

序列化或反序列化对象时所需的数据。 指定的序列化流的源和目标的说明。

使用指定的字符串初始化 类的新实例。

引发异常时显示的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常的异常；如果未指定内部异常，则是一个 null 引用（在 Visual Basic 中为 ）。

指定如何将 XML 数据和关系架构读入 。

默认。

读取 DiffGram，将 DiffGram 中的更改应用到 。 语义与 操作的语义相同。 与 操作一样，保留 值。 对 的 DiffGram 输入只能使用 中的 DiffGram 输出来获得。

针对 SQL Server 的实例读取 XML 片段（例如，通过执行 FOR XML 查询生成的 XML 片段）。 当 设置为 时，将默认命名空间作为内联架构读取。

忽略任何内联架构并将数据读入现有的 架构。 如果任何数据与现有架构不匹配，就会丢弃这些数据（包括为 定义的不同命名空间中的数据）。 如果数据是 DiffGram， 与 具有相同的功能。

忽略任何内联架构，从数据推断出架构并加载数据。 如果 已包含架构，通过添加新表或将列添加到现有表来扩展当前架构。 如果推断表已经存在，但命名空间不同，或者任何推断列与现有列冲突，则会引发异常。

忽略任何内联架构，从数据推断出强类型架构并加载数据。 如果无法从数据中推断出类型，则将其解释为字符串数据。 如果 已包含架构，则通过添加新表或向现有表添加列来扩展当前架构。 如果推断表已经存在，但命名空间不同，或者任何推断列与现有列冲突，则会引发异常。

读取任何内联架构并加载数据。 如果 已包含架构，则可将新表添加到架构中，但是如果内联架构中的任何表在 中已经存在，则会引发异常。

指定如何从 写入 XML 数据和关系架构。

以 DiffGram 形式编写整个 ，包括原始值和当前值。 若要生成只包含已更改的值的 DiffGram，请调用 ，然后在返回的 上作为 DiffGram 调用 。

以 XML 数据形式写入 的当前内容，不带 XSD 架构。 如果无数据加载到 中，则不写入任何内容。

以 XML 数据形式写入 的当前内容，以关系结构作为内联 XSD 架构。 如果 只有架构而无数据，那么只写入内联架构。 如果 没有当前架构，则不写入任何内容。

允许通过相关的 存储、检索和操作结构化数据。

初始化 类的新实例。

使用指定的 初始化 类的新实例。

要加载到 的 。

创建当前节点的副本。

若要递归地克隆指定节点下的子树，则为 ；若仅克隆节点本身，则为 。 克隆的节点。

创建具有指定 、 和 的元素。

新元素的前缀。 如果为 String.Empty 或 ，则没有前缀。 新元素的本地名称。 新元素的命名空间统一资源标识符 (URI)。 如果为 String.Empty 或 ，则没有 namespaceURI。 一个新的 。

创建具有指定名称的 。

实体引用的名称。 具有指定名称的 。 调用此方法。

创建一个用于导航此文档的新 对象。 定位在 参数中指定的节点上。

希望导航器最初定位在的 。 用于文档导航的 。

获取 ，该数据集提供 中数据的关系表示形式。

，该数据集可用于访问使用关系模型的 中的数据。

获取具有指定 ID 的 。 类不支持该方法。 调用此方法将引发异常。

要匹配的属性 ID。 具有指定 ID 的 。 调用此方法。

检索与指定 关联的 。

想要检索其关联 的 。 包含指定 的表示形式的 。

返回一个 ，它包含与指定 匹配的所有子代元素的列表。

要匹配的限定名称。 它针对匹配节点的 属性进行匹配。 特殊值“*”匹配所有标记。 ，包含所有匹配节点的列表。

检索与指定 关联的 。

想要检索其关联 的 。 包含 的表示形式的 ；如果没有与 关联的 ，则为 。

从指定的流加载 。

包含要加载的 XML 文档的流。

从指定的 加载 。

用于将 XML 数据输送到文档中的 。

使用指定的 URL 加载 。

文件的 URL，该文件包含要加载的 XML 文档。

从指定的 加载 。

包含要加载的 XML 文档的 。 正在加载的 XML 包含实体引用，而该读取器不能解析实体。