EntityFramework

IDatabaseInitializer 的实现，它仅在数据库不存在时重新创建数据库并选择重新设置数据库的种子。若要设置数据库的种子，请创建一个派生类并重写 Seed 方法。

上下文的类型。

初始化 类的新实例。

执行策略以初始化给定上下文的数据库。

上下文。

应重写以向上下文实际添加数据来设置种子的方法。默认实现不执行任何操作。

要设置种子的上下文。

从 对象获取此类的实例，并且可使用该实例管理支持 DbContext 或连接的实际数据库。这包括对数据库执行创建、删除和存在性检查操作。请注意通过使用此类的静态方法，您只需使用一个连接（即无需完整上下文）即可对数据库执行删除和存在性检查。

对基础存储连接开始一个事务。

一个包装对基础存储的事务对象的访问的 对象。

使用指定的隔离级别对基础存储连接开始一个事务。

一个包装对基础存储的事务对象的访问的 对象。 用于控制事务中的锁定的隔离级别。

获取或设置所有上下文操作的超时值（以秒为单位）。默认值为 null，null 值指示将使用基础提供程序的默认值。

超时值（秒）；使用提供程序默认值时为 null。

检查数据库是否与当前 Code First 模型兼容。

如果上下文中的模型哈希与数据库中的模型哈希匹配，则为 true；否则为 false。 如果设置为 true，则当未在数据库中找到任何模型元数据时，将引发异常。如果设置为 false，则当未找到元数据时，此方法将返回 true。

返回此上下文使用的连接。如果连接不存在，这可能会导致创建连接。

此上下文使用的连接。

在数据库服务器上为支持上下文中定义的模型创建一个新的数据库。请注意，在运行数据库初始化策略之前调用此方法将禁止执行该策略。

在数据库服务器上为支持上下文中定义的模型创建一个新的数据库（但仅在该服务器上没有带相同名称的数据库时这样做）。

如果数据库不存在且已创建，则为 true；否则为 false。

获取在从数据库名称或连接字符串创建 时要使用的连接工厂。

连接工厂。

如果数据库服务器上存在数据库，则删除该数据库；否则不执行任何操作。从初始值设定项之外调用此方法会将数据库标记为尚未初始化。这意味着如果在删除数据库后尝试再次使用它，则将再次运行所有初始值设定项集，通常将尝试再次自动创建数据库。

如果数据库以前存在且已被删除，则为 true；否则为 false。

如果数据库服务器上存在数据库，则删除该数据库；否则不执行任何操作。

如果数据库以前存在且已被删除，则为 true；否则为 false。 与数据库的现有连接。

如果数据库服务器上存在数据库，则删除该数据库；否则不执行任何操作。按照 类的文档中描述的方法，使用给定的数据库名称或连接字符串创建与数据库的连接。

如果数据库以前存在且已被删除，则为 true；否则为 false。 数据库名称或数据库的连接字符串。

确定指定的数据库是否等于当前数据库。

如果指定的数据库等于当前数据库，则为 true；否则为 false。 要与当前对象进行比较的数据库。

对数据库执行给定的 DDL/DML 命令。

执行命令后由数据库返回的结果。 对于此命令控制事务的创建。 命令字符串。 要应用于命令字符串的参数。

对数据库执行给定的 DDL/DML 命令。

执行命令后由数据库返回的结果。 命令字符串。 要应用于命令字符串的参数。

对数据库异步执行给定的 DDL/DML 命令。

表示异步操作的任务。任务结果包含执行命令后由数据库返回的结果。 对于此命令控制事务的创建。 命令字符串。 要应用于命令字符串的参数。

对数据库异步执行给定的 DDL/DML 命令。

表示异步操作的任务。任务结果包含执行命令后由数据库返回的结果。 对于此命令控制事务的创建。 命令字符串。 等待任务完成期间要观察的 。 要应用于命令字符串的参数。

对数据库异步执行给定的 DDL/DML 命令。

表示异步操作的任务。任务结果包含执行命令后由数据库返回的结果。 命令字符串。 要应用于命令字符串的参数。

对数据库异步执行给定的 DDL/DML 命令。

表示异步操作的任务。任务结果包含执行命令后由数据库返回的结果。 命令字符串。 等待任务完成期间要观察的 。 要应用于命令字符串的参数。

检查服务器上是否存在数据库。

如果数据库存在，则为 true；否则为 false。

检查服务器上是否存在数据库。

如果数据库存在，则为 true；否则为 false。 与数据库的现有连接。

检查服务器上是否存在数据库。按照 类的文档中描述的方法，使用给定的数据库名称或连接字符串创建与数据库的连接。

如果数据库存在，则为 true；否则为 false。 数据库名称或数据库的连接字符串。

返回此数据库的哈希函数。

此数据库的哈希函数。

返回当前数据库的类型。

当前数据库的类型。

在此上下文上运行注册的 。如果将 设置为 true，则将运行初始值设定项，不管它之前是否已运行。如果在应用程序正在运行时删除了数据库并且需要重新初始化数据库时，则这样做会很有用。如果将 设置为 false，则仅在尚未为此应用程序域中的此上下文、模型和连接运行初始值设定项的情况下运行它。当必须确保在开始某些操作之前已创建数据库并设定其种子时（这样偷懒的做法会导致问题，例如，当操作是事务的一部分时），通常会使用此方法。

如果设置为 true，则将运行初始值设定项，即使它之前已运行过也是如此。

设置要用于给定上下文类型的数据库初始值设定项。当给定的 类型首次用于访问数据库时调用数据库初始值设定项。Code First 上下文的默认策略是 的实例。

要使用的初始值设定项或 null，后者对于指定的上下文类型禁用初始化。 上下文的类型。

创建一个原始 SQL 查询，该查询将返回给定泛型类型的元素。类型可以是包含与从查询返回的列名匹配的属性的任何类型，也可以是简单的基元类型。该类型不必是实体类型。即使返回对象的类型是实体类型，上下文也决不会跟踪此查询的结果。使用 方法可返回上下文跟踪的实体。

一个 对象，此对象在枚举时将执行查询。 SQL 查询字符串。 要应用于 SQL 查询字符串的参数。 查询所返回对象的类型。

创建一个原始 SQL 查询，该查询将返回给定类型的元素。类型可以是包含与从查询返回的列名匹配的属性的任何类型，也可以是简单的基元类型。该类型不必是实体类型。即使返回对象的类型是实体类型，上下文也决不会跟踪此查询的结果。使用 方法可返回上下文跟踪的实体。

一个 对象，此对象在枚举时将执行查询。 查询所返回对象的类型。 SQL 查询字符串。 要应用于 SQL 查询字符串的参数。

返回数据库的字符串表示形式。

数据库的字符串表示形式。

如果您希望实体框架在外部事务内执行命令，则允许用户传递在 对象外创建的数据库事务。或者，传递 null 以清除该事务的框架知识。

外部事务 如果事务已完成，则引发此异常。 如果与 对象关联的连接已在 事务中登记，则引发此异常。 如果与 对象关联的连接已参与事务，则引发此异常。 如果与事务关联的连接不匹配实体框架的连接，则引发此异常。

DbContext 实例表示工作单元和存储库模式的组合，可用来查询数据库并将更改组合在一起，这些更改稍后将作为一个单元写回存储区中。DbContext 在概念上与 ObjectContext 类似。

使用约定构造一个新的上下文实例以创建将连接到的数据库的名称。按照约定，该名称是派生上下文类的全名（命名空间与类名称的组合）。请参见有关这如何用于创建连接的类备注。

通过现有连接来连接到数据库以构造一个新的上下文实例。如果 contextOwnsConnection 为 false，则在释放上下文时将不释放该连接。

要用于新的上下文的现有连接。 如果设置为 true，则释放上下文时将释放该连接；否则调用方必须释放该连接。

通过使用现有连接来连接到数据库以构造一个新的上下文实例，并从给定模型初始化该实例。如果 contextOwnsConnection 为 false，则在释放上下文时将不释放该连接。

要用于新的上下文的现有连接。 支持此上下文的模型。 如果设置为 true，则释放上下文时将释放该连接；否则调用方必须释放该连接。

围绕现有 ObjectContext 构造一个新的上下文实例。

要使用新的上下文包装的现有 ObjectContext。 如果设置为 true，则释放 DbContext 时将释放 ObjectContext；否则调用方必须释放该连接。

使用约定构造一个新的上下文实例以创建将连接到的数据库的名称，并从给定模型初始化该名称。按照约定，该名称是派生上下文类的全名（命名空间与类名称的组合）。请参见有关这如何用于创建连接的类备注。

支持此上下文的模型。

可以将给定字符串用作将连接到的数据库的名称或连接字符串来构造一个新的上下文实例。请参见有关这如何用于创建连接的类备注。

数据库名称或连接字符串。

可以将给定字符串用作将连接到的数据库的名称或连接字符串来构造一个新的上下文实例，并从给定模型初始化该实例。请参见有关这如何用于创建连接的类备注。

数据库名称或连接字符串。 支持此上下文的模型。

提供对用于处理实体的更改跟踪的上下文功能的访问。

一个用于访问处理更改跟踪的功能的对象。

提供对上下文的配置选项的访问。

一个用于访问配置选项的对象。

为此上下文创建一个数据库实例，该上下文允许您对基础数据库执行创建/删除/存在性检查操作。

此上下文的一个数据库实例，该上下文允许您对基础数据库执行创建/删除/存在性检查操作。

调用受保护的 Dispose 方法。

释放上下文。在以下情况下也将释放基础 ：它由此上下文创建，或者在创建此上下文时将所有权传递给了此上下文。在以下情况下也将释放与数据库的连接（ 对象）：它由此上下文创建，或者在创建此上下文时将所有权传递给了此上下文。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

获取给定实体的 对象，以便提供对与该实体有关的信息的访问以及对实体执行操作的功能。

实体的项。 实体。

获取给定实体的 对象，以便提供对与该实体有关的信息的访问以及对实体执行操作的功能。

实体的项。 实体。 实体的类型。

确定指定的 DbContext 是否等于当前 DbContext。

如果指定的 DbContext 等于当前 DbContext，则为 true；否则为 false。 要与当前 DbContext 进行比较的 DbContext。

返回此 DBContext 的哈希函数。

此 DBContext 的哈希函数。

返回当前 DbContext 的类型。

当前 DbContext 的类型。

验证跟踪实体，并返回包含验证结果的 的集合。

无效实体的验证结果集合。集合决不为 null，且不得包含 null 值或有效实体的结果。

在完成对派生上下文的模型的初始化后，并在该模型已锁定并用于初始化上下文之前，将调用此方法。虽然此方法的默认实现不执行任何操作，但可在派生类中重写此方法，这样便能在锁定模型之前对其进行进一步的配置。

定义要创建的上下文的模型的生成器。

将在此上下文中所做的所有更改保存到基础数据库。

已写入基础数据库的对象的数目。 在已释放上下文时引发。

将在此上下文中所做的所有更改异步保存到基础数据库。

表示异步保存操作的任务。任务结果包含已写入基础数据库的对象数目。 在已释放上下文时引发。

将在此上下文中所做的所有更改异步保存到基础数据库。

表示异步保存操作的任务。任务结果包含已写入基础数据库的对象数目。 等待任务完成期间要观察的 。 在已释放上下文时引发。

针对对上下文中的给定类型的实体、ObjectStateManager 和基础存储区的访问返回一个 DbSet 实例。

给定实体类型的集。 应为其返回一个集的类型实体。

针对对上下文中的给定类型的实体、ObjectStateManager 和基础存储区的访问返回一个非泛型 DbSet 实例。

给定实体类型的集。 应为其返回一个集的实体的类型。

扩展点允许用户重写仅验证添加的实体和修改的实体的默认行为。

如果继续验证，则为 true；否则为 false。 应验证的 DbEntityEntry 实例。

返回基础化此上下文的实体框架 ObjectContext。

作为此上下文基础的实体框架 ObjectContext。

返回 DbContext 的字符串表示形式。

DbContext 的字符串表示形式。

扩展点允许用户自定义实体的验证或筛选出验证结果。由 调用。

实体验证结果。重写时可能为 null。 要验证的 DbEntityEntry 实例。 包含用于自定义验证的附加信息的用户定义的字典。它将被传递给 并将作为 公开。此参数是可选的，并且可为 null。

包装对基础存储连接的事务对象的访问并确保实体框架在该事务的上下文内对数据库执行命令。通过对 和 对象调用 BeginTransaction() 来检索此类的实例。

提交基础存储事务。

清除此事务对象并确保实体框架不再使用该事务。

清除此事务对象。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

回滚基础存储事务。

指示给定的方法是 EDM 函数的代理。

创建新的 DbFunctionAttribute 实例。

特性化方法所表示的 EDM 函数的命名空间名称。 特性化方法所表示的 EDM 函数的函数名称。

特性化方法所表示的 EDM 函数的函数名称。

特性化方法所表示的 EDM 函数的命名空间名称。

提供在 或 LINQ to Entities 查询中使用的公开 EDM 规范函数的公共语言运行时 (CLR) 方法。

调用规范 AddDays EDM 函数以将指定的天数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的天数。

调用规范 AddDays EDM 函数以将指定的天数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的天数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMonths EDM 函数以将指定的月数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的月数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMonths EDM 函数以将指定的月数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的月数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddYears EDM 函数以将指定的年数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的年数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddYears EDM 函数以将指定的年数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的年数。

作为 LINQ to Entities 查询的一部分使用时，此方法充当确保将输入作为非 Unicode 字符串处理的运算符。

作为非 Unicode 字符串处理的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法充当确保将输入作为 Unicode 字符串处理的运算符。

作为 Unicode 字符串处理的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateDateTime EDM 函数以创建新的 对象。

新的日期/时间。 年。 月（从 1 开始）。 日（从 1 开始）。 小时。 分钟。 秒，根据需要可包括秒的分数部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateDateTimeOffset EDM 函数以创建新的 对象。

新的日期/时间。 年。 月（从 1 开始）。 日（从 1 开始）。 小时。 分钟 秒，根据需要可包括秒的分数部分。 新日期的时区偏移量部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateTime EDM 函数以创建新的 对象。

新的时间跨度。 小时。 分钟。 秒，根据需要可包括秒的分数部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffDays EDM 函数以计算两个日期/时间间隔的天数。

第一个日期/时间和第二个日期/时间间隔的天数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffDays EDM 函数以计算两个日期/时间间隔的天数。

第一个日期/时间和第二个日期/时间间隔的天数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个日期/时间间隔的小时数。

第一个日期/时间和第二个日期/时间间隔的小时数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个日期/时间间隔的小时数。

第一个日期/时间和第二个日期/时间间隔的小时数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个时间跨度间隔的小时数。

第一个时间跨度和第二个时间跨度间隔的小时数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个日期/时间间隔的微秒数。

第一个日期/时间和第二个日期/时间间隔的微秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个日期/时间间隔的微秒数。

第一个日期/时间和第二个日期/时间间隔的微秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个时间跨度间隔的微秒数。

第一个时间跨度和第二个时间跨度间隔的微秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个日期/时间间隔的毫秒数。

第一个日期/时间和第二个日期/时间间隔的毫秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个日期/时间间隔的毫秒数。

第一个日期/时间和第二个日期/时间间隔的毫秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个时间跨度间隔的毫秒数。

第一个时间跨度和第二个时间跨度间隔的毫秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个日期/时间间隔的分钟数。

第一个日期/时间和第二个日期/时间间隔的分钟数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个日期/时间间隔的分钟数。

第一个日期/时间和第二个日期/时间间隔的分钟数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个时间跨度间隔的分钟数。

第一个时间跨度和第二个时间跨度间隔的分钟数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMonths EDM 函数以计算两个日期/时间间隔的月数。

第一个日期/时间和第二个日期/时间间隔的月数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMonths EDM 函数以计算两个日期/时间间隔的月数。

第一个日期/时间和第二个日期/时间间隔的月数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个日期/时间间隔的纳秒数。

第一个日期/时间和第二个日期/时间间隔的纳秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个日期/时间间隔的纳秒数。

第一个日期/时间和第二个日期/时间间隔的纳秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个时间跨度间隔的纳秒数。

第一个时间跨度和第二个时间跨度间隔的纳秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个日期/时间间隔的秒数。

第一个日期/时间和第二个日期/时间间隔的秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个日期/时间间隔的秒数。

第一个日期/时间和第二个日期/时间间隔的秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个时间跨度间隔的秒数。

第一个时间跨度和第二个时间跨度间隔的秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffYears EDM 函数以计算两个日期/时间间隔的年数。

第一个日期/时间和第二个日期/时间间隔的年数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffYears EDM 函数以计算两个日期/时间间隔的年数。

第一个日期/时间和第二个日期/时间间隔的年数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 GetTotalOffsetMinutes EDM 函数以返回指定的日期/时间偏移 UTC 的分钟数。该值通常介于 +780 到 -780 之间（+ 或 - 13 小时）。

输入对 UTC 的偏移量。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Left 函数以返回字符串中最左侧指定数目的字符。

包含从输入字符串左侧算起的所请求的字符数的字符串。 输入字符串。 要返回的字符数

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Reverse 函数以返回其字符顺序反转的指定字符串。

以反转字符顺序显示的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Right 函数以返回字符串中最右侧指定数目的字符。

包含从输入字符串右侧算起的所请求的字符数的字符串。 输入字符串。 要返回的字符数

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Truncate EDM 函数以将指定的值截断为指定的位数。

截整值。 要截断的值。 要保留的位数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Truncate EDM 函数以将指定的值截断为指定的位数。

截整值。 要截断的值。 要保留的位数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 TruncateTime EDM 函数以返回清除了时间部分的指定日期。

清除了时间部分的输入日期。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 TruncateTime EDM 函数以返回清除了时间部分的指定日期。

清除了时间部分的输入日期。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

将 CLR 类映射到数据库架构。此以代码为中心的方法称作“Code First”，可用于生成实体数据模型 (EDM) 模型。

初始化 类的新实例。发现初始模型的过程将使用您计算机上安装的实体框架的最新版本中所包含的一组约定。

初始化 类的新实例，它将使用一组特定的约定来发现初始模型。

要使用的约定的版本。

使用此生成器基于执行的配置来创建一个 。连接可用于确定要使用的数据库提供程序，因为这会影响生成的模型的数据库层。

已生成的模型。 用来确定提供程序信息的连接。

使用此生成器基于执行的配置来创建一个 。必须指定提供程序信息，因为这会影响生成的模型的数据库层。对于 SqlClient，固定名称为“System.Data.SqlClient”，清单标记为版本年份（例如，“2005”、“2008”等）。

已生成的模型。 模型将用于的数据库提供程序。

将一个类型注册为模型中的复杂类型，并返回一个可用来配置复杂类型的对象。可对同一类型多次调用此方法以执行多行配置。

指定的复杂类型的配置对象。 要注册或配置的类型。

获取此 DbModelBuilder 的 。注册器允许使用此生成器来注册派生的实体和复杂类型配置。

此 DbModelBuilder 的 。注册器允许使用此生成器来注册派生的实体和复杂类型配置。

提供对处理约定的此 DbModelBuilder 的设置的访问。

对处理约定的此 DbModelBuilder 的设置的访问。

将实体类型注册为模型的一部分，并返回一个可用来配置实体的对象。可对同一实体多次调用此方法以执行多行配置。

指定的实体类型的配置对象。 要注册或配置的类型。

指定 是否等于指定的对象。

如果 等于指定的对象，则为 true；否则为 false。 要比较的对象。

返回当前实例的哈希代码。

当前实例的哈希代码。

获取模块中定义的命名类型。

模块中定义的命名类型。

配置默认数据库架构名称。此默认数据库架构名称用于不具有显式配置的架构名称的数据库对象。

默认数据库架构名称。 默认数据库架构的名称。

从模型中排除类型。这用于在初始模型发现期间从根据约定添加的模型中移除类型。

同一个 DbModelBuilder 实例，以便多个调用可以链接在一起。 要排除的类型。

从模型中排除指定的类型。这用于在初始模型发现期间从根据约定添加的模型中移除类型。

同一个 DbModelBuilder 实例，以便多个调用可以链接在一起。 要从模型中排除的类型。

开始配置适用于模型中所有属性的轻型约定。

约定的配置对象。

开始配置适用于模型中指定类型的所有基元属性的轻型约定。

约定的配置对象。 此约定将适用于的属性类型。

返回 的字符串表示形式。

的字符串表示形式。

可直接将此枚举中的值提供给 类，也可以在应用到派生自 的类的 中使用该值。使用的值可定义在从代码生成模型（也称为“Code First”）时应使用的 DbContext 和 DbModelBuilder 约定的版本。

指示应使用 和 约定的最新版本。

指示应使用实体框架 4.1 版附带的 和 约定的版本。

指示应使用实体框架 5.0 版附带的 和 约定的版本。

指示应使用实体框架 6.0 版附带的 和 约定的版本。

此特性可应用于派生自 的类，以便在从代码生成模型（也称为“Code First”）时设置应使用的 DbContext 和 约定的版本。有关 DbModelBuilder 版本的详细信息，请参见 枚举。

初始化 类的新实例。

要使用的 约定版本。

获取 约定版本。

非泛型版本的 ，可在生成时不知道实体类型时使用。

将给定实体以“已添加”状态添加到集的基础上下文中，这样一来，当调用 SaveChanges 时，会将该实体插入到数据库中。

实体。 要添加的实体。

将指定实体的元素添加到集的末尾。

指定实体的已添加元素。 要添加的实体。

将给定实体附加到集的基础上下文中。也就是说，将实体以“未更改”的状态放置到上下文中，就好像从数据库读取了该实体一样。

实体。 要附加的实体。

返回等效泛型 对象。

泛型集对象。 已为其创建集的实体的类型。

为此集的类型创建新的实体实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理，且实体类型满足创建代理的要求，则返回的实例将是一个代理。

实体实例，可能为代理。

为此集的类型或派生自此集类型的类型创建新的实体实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理，且实体类型满足创建代理的要求，则返回的实例将是一个代理。

实体实例，可能为代理。

返回指定的集是否等于当前集。

如果指定的对象等于当前集，则为 true；否则为 false。 要与当前对象进行比较的集。

查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

找到的实体或为 null。 要查找的实体的主键值。 如果上下文中存在具有给定主键值的多个实体，则引发此异常。 如果实体类型不是此上下文的数据模型的一部分，则引发此异常。 如果键值的类型与要查找的实体类型的键值类型不匹配，则引发此异常。 在已释放上下文时引发。

异步查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

表示异步查找操作的任务。任务结果包含找到的实体或 null。 要查找的实体的主键值。 如果上下文中存在具有给定主键值的多个实体，则引发此异常。 如果实体类型不是此上下文的数据模型的一部分，则引发此异常。 如果键值的类型与要查找的实体类型的键值类型不匹配，则引发此异常。 在已释放上下文时引发。

异步查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

表示异步查找操作的任务。任务结果包含找到的实体或 null。 等待任务完成期间要观察的 。 要查找的实体的主键值。 如果上下文中存在具有给定主键值的多个实体，则引发此异常。 如果实体类型不是此上下文的数据模型的一部分，则引发此异常。 如果键值的类型与要查找的实体类型的键值类型不匹配，则引发此异常。 在已释放上下文时引发。

返回指定集的哈希函数。

集的哈希函数。

获取当前集的类型。

当前集的类型。

获取 ，它表示此集中的所有“已添加”、“未更改”和“已修改”实体的本地视图。在上下文中添加或删除实体时，该本地视图将保持同步。同样，在本地视图中添加或删除实体也会自动在上下文中添加或删除实体。

本地视图。

将给定实体标记为“已删除”，这样一来，当调用 SaveChanges 时，将从数据库中删除该实体。请注意，在调用此方法之前，该实体必须以另一种状态存在于该上下文中。

实体。 要删除的实体。

将指定实体的元素删除到集的末尾。

包含已删除实体的集。 要删除的实体。

创建一个原始 SQL 查询，该查询将返回此集中的实体。默认情况下，上下文会跟踪返回的实体；可通过对返回的 调用 AsNoTracking 来更改此设置。请注意返回实体的类型始终是此集的类型，而不会是派生的类型。如果查询的一个或多个表可能包含其他实体类型的数据，则必须编写适当的 SQL 查询以确保只返回适当类型的实体。

一个 对象，此对象在枚举时将执行查询。 SQL 查询字符串。 要应用于 SQL 查询字符串的参数。

DbSet 表示上下文中给定类型的所有实体的集合或可从数据库中查询的给定类型的所有实体的集合。可以使用 DbContext.Set 方法从 DbContext 中创建 DbSet 对象。

定义集的类型。

将给定实体以“已添加”状态添加到集的基础上下文中，这样一来，当调用 SaveChanges 时，会将该实体插入到数据库中。

要添加的实体。

将给定实体附加到集的基础上下文中。也就是说，将实体以“未更改”的状态放置到上下文中，就好像从数据库读取了该实体一样。

要附加的实体。

为此集的类型创建新的实体实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理，且实体类型满足创建代理的要求，则返回的实例将是一个代理。

为此集的类型或派生自此集类型的类型创建新的实体实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理且实体类型满足创建代理的要求，则返回的实例将是一个代理。

要创建的实体的类型。

确定指定的 DbSet 是否等于当前 DbSet。

如果指定的 DbSet 等于当前 DbSet，则为 true；否则为 false。 要与当前 DbSet 进行比较的对象。

查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

要查找的实体的主键值。 如果上下文中存在具有给定主键值的多个实体，则引发此异常。 如果实体类型不是此上下文的数据模型的一部分，则引发此异常。 如果键值的类型与要查找的实体类型的键值类型不匹配，则引发此异常。 在已释放上下文时引发。

异步查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

表示异步查找操作的任务。任务结果包含找到的实体或 null。 等待任务完成期间要观察的 。 要查找的实体的主键值。 如果上下文中存在具有给定主键值的多个实体，则引发此异常。 如果实体类型不是此上下文的数据模型的一部分，则引发此异常。 如果键值的类型与要查找的实体类型的键值类型不匹配，则引发此异常。 在已释放上下文时引发。

返回此 DbSet 的哈希函数。

此 DbSet 的哈希函数。

返回当前 DbSet 的类型。

当前 DbSet 的类型。

获取 ，它表示此集中的所有“已添加”、“未更改”和“已修改”实体的本地视图。在上下文中添加或删除实体时，该本地视图将保持同步。同样，在本地视图中添加或删除实体也会自动在上下文中添加或删除实体。

本地视图。

将给定实体标记为“已删除”，这样一来，当调用 SaveChanges 时，将从数据库中删除该实体。请注意，在调用此方法之前，该实体必须以另一种状态存在于该上下文中。

要删除的实体。

创建一个原始 SQL 查询，该查询将返回此集中的实体。默认情况下，上下文会跟踪返回的实体；可通过对返回的 调用 AsNoTracking 来更改此设置。请注意返回实体的类型始终是此集的类型，而不会是派生的类型。如果查询的一个或多个表可能包含其他实体类型的数据，则必须编写适当的 SQL 查询以确保只返回适当类型的实体。

一个 对象，此对象在枚举时将执行查询。 SQL 查询字符串。 要应用于 SQL 查询字符串的参数。

IDatabaseInitializer 的实现，它总是会在首次在应用程序域中使用上下文时，重新创建数据库并可以选择重新设置数据库的种子。若要设置数据库的种子，请创建一个派生类并重写 Seed 方法。

上下文的类型。

初始化 类的新实例。

执行策略以初始化给定上下文的数据库。

上下文。 上下文为 null

应重写以向上下文实际添加数据来设置种子的方法。默认实现不执行任何操作。

要设置种子的上下文。

IDatabaseInitializer 的实现，它仅在模型自数据库创建后发生更改时删除数据库、重新创建数据库并选择重新设置数据库的种子<b></b>。

初始化 类的新实例。

执行策略以初始化给定上下文的数据库。

上下文。 上下文为 null

应重写以向上下文实际添加数据来设置种子的方法。默认实现不执行任何操作。

要设置种子的上下文。

描述实体的状态。

实体将由上下文跟踪，但是在数据库中还不存在。

实体将由上下文跟踪并存在于数据库中，但是已被标记为在下次调用 SaveChanges 时从数据库中删除。

该实体未由上下文跟踪。刚使用新运算符或某个 Create 方法创建实体后，实体就处于此状态。

实体将由上下文跟踪并存在于数据库中，已修改其中的一些或所有属性值。

实体将由上下文跟踪并存在于数据库中，其属性值与数据库中的值相同。

此接口的实现用于在首次使用 派生类的实例时初始化基础数据库。此初始化可以有条件地创建数据库和/或使用数据设置其种子。使用 类的静态 InitializationStrategy 属性设置所用的策略。提供以下实现：、 、。

此类型参数为协变的。也就是说，您可以使用您指定的类型或者派生程度更小的任何类型。有关协变式和逆变式的详细信息，请参阅。

执行策略以初始化给定上下文的数据库。

上下文。

IDbSet 表示上下文中给定类型的所有实体的集合或可从数据库中查询的给定类型的所有实体的集合。DbSet 是 IDbSet 的具体实现。

定义集的类型。

将给定实体以“已添加”状态添加到集的基础上下文中，这样一来，当调用 SaveChanges 时，会将该实体插入到数据库中。

要添加的实体。

将给定实体附加到集的基础上下文中。也就是说，将实体以“未更改”的状态放置到上下文中，就好像从数据库读取了该实体一样。

要附加的实体。

为此集的类型创建新的实体实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理且实体类型满足创建代理的要求，则返回的实例将是一个代理。

为此集的类型或派生自此集类型的类型创建实体的新实例。请注意此实例不会添加或附加到此集。如果基础上下文配置为创建代理且实体类型满足创建代理的要求，则返回的实例将是一个代理。

要创建的实体的类型。

查找带给定主键值的实体。如果上下文中存在带给定主键值的实体，则立即返回该实体，而不会向存储区发送请求。否则，会向存储区发送查找带给定主键值的实体的请求，如果找到该实体，则将其附加到上下文并返回。如果未在上下文或存储区中找到实体，则返回 null。

要查找的实体的主键值。

获取 ，它表示此集中的所有“已添加”、“未更改”和“已修改”实体的本地视图。在上下文中添加或移除实体时，该本地视图将保持同步。同样，在本地视图中添加或移除实体也会自动在上下文中添加或移除实体。

本地视图。

将给定实体标记为“已删除”，这样一来，当调用 SaveChanges 时，将从数据库中删除该实体。请注意，在调用此方法之前，该实体必须以某些其他状态存在于上下文中。

要删除的实体。

表示将使用 Code First 迁移将数据库更新到最新版本的 的实现。

上下文的类型。 迁移配置的类型。

初始化 类的新实例。

初始化将使用配置文件中的特定连接字符串连接到数据库以执行迁移的 类的新实例。

用于迁移的连接字符串的名称。

初始化给定上下文的数据库。

上下文。

不执行任何操作的 的实现。使用此初始值设定项将禁用给定上下文类型的数据库初始化。将此类的实例传递给 将等效于传递 null。正在使用 解析初始值设定项时，此类的实例必须用于禁用初始化。

上下文的类型。

初始化 类的新实例。

执行策略以初始化给定上下文的数据库。

上下文。

提供可观察集合的扩展方法。

返回 实现，该实现与给定的 保持同步。

绑定列表。 绑定列表将与其保持同步的集合。 元素类型。

控制事务创建行为。

不确保创建事务。

确保创建事务。

表示在尝试准备或执行 CommandCompilation 时出现的失败。此异常旨在提供一个常见异常，人们可以捕获该异常以便在使用 EntityCommand 执行语句时承载提供程序异常（SqlException、OracleException）。

初始化 的新实例，没有消息，没有内部异常。可能不应该存在，但它有益于 FxCop。

使用消息（但没有内部异常）初始化 的新实例。可能不应该存在，但它有益于 FxCop。

消息。

使用消息和内部异常实例初始化 的新实例。

消息。 内部异常。

表示在尝试准备或执行 CommandExecution 时出现的失败。此异常旨在提供一个常见异常，人们可以捕获该异常以便在使用 EntityCommand 执行语句时承载提供程序异常（SqlException、OracleException）。

初始化 EntityCommandExecutionException 的新实例，没有消息，没有内部异常。可能不应该存在，但它有益于 FxCop。

使用消息（但没有内部异常）初始化 EntityCommandExecutionException 的新实例。可能不应该存在，但它有益于 FxCop。

描述错误的消息。

使用消息和内部异常实例初始化 EntityCommandExecutionException 的新实例。

描述错误的消息。 导致此当前异常的内部异常。

提供实体客户端使用的异常。

使用默认值初始化 类的新实例。

初始化 类的新实例。

序列化信息。 流上下文。

初始化接受预先格式化消息的 类的新实例。

本地化的错误消息。

初始化接受预先格式化消息和内部异常的 类的新实例。

本地化的错误消息。 内部异常。

表示实体的标识符。

初始化 类的新实例。

使用给定的键值初始化 类的新实例。

实体的 EntitySet 名称，由 EntityContainer 名称限定。 标识实体的键-值对。

使用给定的键值初始化 类的新实例。

实体的 EntitySet 名称，由 EntityContainer 名称限定。 标识实体的键-值对。

使用给定单个键名称和值初始化 类的新实例。

实体的 EntitySet 名称，由 EntityContainer 名称限定。 标识实体的键名称。 标识实体的键值。

获取或设置 EntityContainer 名称，该名称标识包含实体的实体容器。

EntityContainer 名称，该名称标识包含实体的实体容器。

获取或设置标识实体的键值。

标识实体的键值。

获取单一 EntityKey，它标识因失败的 TREAT 操作产生的实体。

单一 EntityKey，它标识因失败的 TREAT 操作产生的实体。

获取或设置 EntitySet 名称，该名称标识包含实体的实体集。

EntitySet 名称，用于标识包含实体的实体集。

指示此实例是否与给定的键相等的值。

如果此实例与给定的键相等，则为 true；否则为 false。 要与此实例进行比较的键。

指示此实例是否与给定的键相等的值。

如果此实例与给定的键相等，则为 true；否则为 false。 要与此实例进行比较的键。

从给定的元数据工作区按实体容器名称和实体集名称获取此实体键的实体集。

给定工作区中此实体键的实体集。 要在其中查找实体集的工作区。 在工作区中找不到该实体集。

返回基于值的哈希代码，以便允许在哈希表中使用 EntityKey。

此 EntityKey 的哈希值。

获取一个值，该值指示此键是否为临时键。

如果此键是临时键，则为 true；否则为 false。

获取用来标识某一只读实体的单一 EntityKey。

用来标识某一只读实体的单一 EntityKey。

在反序列化此 EntityKey 后调用。

序列化上下文。

在反序列化此 EntityKey 后调用。

序列化上下文。

指示两个键是否相等的值。

如果两个键相等，则为 true；否则为 false。 要比较的键。 要比较的键。

指示两个键是否不相等的值。

如果两个键不相等，则为 true；否则为 false。 要比较的键。 要比较的键。

与作为 EntityKey 的一部分的键有关的信息。键成员包含键名称和值。

创建空的 EntityKeyMember。此构造函数由序列化过程使用。

使用指定的键名称和值创建一个新的 EntityKeyMember。

键名称 键值

键名称

返回 EntityKeyMember 的字符串表示形式

EntityKeyMember 的字符串表示形式

键值

表示一个 eSQL Query 编译异常；可能导致引发此异常的异常条件的类别主要是： 1) 语法错误：在查询文本分析期间和在某一给定查询与 eSQL 一般语法不符时引发； 2) 语义错误：在 eSQL 语言的语义规则未满足（例如元数据或架构信息不准确或未提供、类型验证错误、作用域规则冲突、未定义变量的用户等）时引发。有关更多信息，请参见 eSQL 语言规范。

使用一般性错误消息初始化 的新实例。

使用给定的消息初始化 的新实例。

错误消息。

使用给定的消息和 innerException 实例初始化 的新实例。

错误消息。 内部异常。

获取发生错误的大致列号。

发生错误的大致列号。

获取发生错误的大致上下文（如果有）。

发生错误的大致上下文（如果有）。

获取解释未接受查询或空 String.Empty 的原因的错误说明

解释未接受查询或空 String.Empty 的原因的错误说明。

获取发生错误的大致行号

发生错误的大致行号。

提供支持结构化类型和丰富元数据信息的 DataRecord 接口。

获取描述记录内容的 DataRecordInfo 属性。

描述记录内容的 DataRecordInfo 属性。

以 DbDataReader 对象的形式返回嵌套的读取器。

作为 DbDataReader 对象的嵌套读取器。 列的序号。

使用指定的索引获取一个 DbDataRecord 对象。

DbDataRecord 对象。 行的索引。

引发来指示命令目录树无效。

使用默认消息构造一个新的 InvalidCommandTreeException。

使用指定的消息构造一个新的 InvalidCommandTreeException。

异常消息

使用指定的消息和内部异常构造一个新的 InvalidCommandTreeException。

异常消息。 导致此 InvalidCommandTreeException 的异常。

映射异常类。请注意，此类具有状态 - 因此，即使您更改其内部，也可能是重大更改

具有默认消息的构造函数

默认构造函数

本地化的错误消息

构造函数

本地化的错误消息 内部异常

元数据异常类

具有默认消息的构造函数

默认构造函数

本地化的错误消息

构造函数

本地化的错误消息 内部异常

在存储区中找不到请求的对象时将引发此异常。

初始化 类的新实例。

初始化 类的新实例。

本地化的错误消息。

初始化 类的新实例以及初始化获取消息和内部异常的构造函数的新实例。

本地化的错误消息。 内部异常。

在更新操作与并发约束冲突时将会引发此异常。

使用默认值初始化 类的新实例。

使用指定的消息初始化 类的新实例。

与异常关联的消息。

使用指定的消息和内部异常初始化 类的新实例。

与异常关联的消息。 导致异常的错误。

使用指定的消息和内部异常初始化 类的新实例。

消息。 导致异常的错误。 状态项。

表示属性约束异常类。请注意，此类具有状态 - 因此，即使您更改其内部，也可能是重大更改。

初始化 类的新实例。

初始化 类的新实例。

本地化的错误消息。

使用提供的消息和内部异常初始化 类的新实例

本地化的错误消息。 内部异常。

初始化 类的新实例。

本地化的错误消息。 属性名称。

初始化 类的新实例。

本地化的错误消息。 属性名称。 内部异常。

获取违反了约束的属性的名称。

违反了约束的属性的名称。

在存储提供程序表现出的行为与实体客户端提供程序不兼容时引发的异常。

初始化 类的新实例。

使用指定的错误消息初始化 类的新实例。

描述此异常的错误消息。

使用指定的错误消息和内部异常初始化 类的新实例。

描述此异常的错误消息。 造成当前异常的内部异常。

将更改保存到存储区期间发生的异常

默认构造函数

序列化的受保护的构造函数

接受消息的构造函数

接受消息和内部异常的构造函数

接受消息和内部异常的构造函数

获取在错误中暗含的状态项。

提供一个简单方法以便访问类型信息和列信息的 DataRecordInfo 类。

使用数据字段的可枚举集合初始化一个特定类型的新 对象。

此对象表示的类型的元数据，由 提供。 表示列信息的 对象的可枚举集合。

获取此 对象的 。

对象。

获取此对象的类型信息作为 对象。

一个 值。

准备好的命令定义，可以缓存和重复使用以便避免重新准备命令。

初始化 类的新实例。

使用提供的 初始化 类的新实例。

提供的 。

创建并返回一个可执行的 对象。

用于数据库的命令。

所有 CLR 类型的元数据接口

初始化 类的新实例。

排序规则方面的名称

要传递给 GetInformation 以便获取 ConceptualSchemaDefinition 的值

要传递给 GetInformation 以便获取 ConceptualSchemaDefinitionVersion3 的值

DefaultValue 方面的名称

提供程序编写人员应重写此方法，以返回带有已转义的通配符和转义符的参数。仅当 SupportsEscapingLikeArgument 返回 true 时才使用此方法。

带有已转义的通配符和转义符的参数。 要转义的参数。

FixedLength 方面的名称

在派生类中重写时，此方法返回特定于提供程序的信息。

表示基础数据存储目录的映射的 XmlReader 对象。 要返回的信息的类型。

在派生类中重写时，此方法将指定的存储类型以及该类型的一组方面映射到 EDM 类型。

描述 EDM 类型以及该类型的一组方面的 实例。 TypeUsage 实例，它描述要映射到 EDM 类型的存储类型以及该类型的一组方面。

返回特定类型的 FacetDescription 对象。

用于指定的 EDM 类型的 FacetDescription 对象。 要返回方面描述的 EDM 类型。

获取特定于提供程序的信息。

特定于提供程序的信息。 要返回的信息的类型。

在派生类中重写时，返回提供程序清单支持的 EDM 函数的集合。

EDM 函数的集合。

在派生类中重写时，此方法将指定的 EDM 类型以及该类型的一组方面映射到存储类型。

TypeUsage 实例，它描述存储类型以及该类型的一组方面。 TypeUsage 实例，它描述要映射到存储类型的 EDM 类型以及该类型的一组方面。

在派生类中重写时，返回数据源支持的一组基元类型。

数据源支持的一组类型。

IsStrict 方面的名称

MaxLength 方面的名称

获取此提供程序清单使用的命名空间。

此提供程序清单使用的命名空间。

Nullable 方面的名称

Precision 方面的名称

Scale 方面的名称

SRID 方面的名称

要传递给 GetInformation 以便获取 StoreSchemaDefinition 的值

要传递给 GetInformation 以便获取 StoreSchemaDefinitionVersion3 的值

要传递给 GetInformation 以便获取 StoreSchemaMapping 的值

要传递给 GetInformation 以便获取 StoreSchemaMappingVersion3 的值

指示提供程序是否支持在 Like 表达式中使用转义字符串作为模式。

如果此提供程序支持在 Like 表达式中使用转义字符串作为模式，则返回 true；否则返回 false。 如果提供程序支持转义，则为要用作转义符的字符。

返回一个布尔值，该布尔值指定提供程序是否可处理包含 DbInExpression 的实例的表达式目录树。默认实现返回 false 以保证向后兼容性。派生类可以重写此方法。

false

Unicode 方面的名称

用于生成命令定义的工厂；使用该对象的类型作为提供程序工厂上 IServiceProvider.GetService 方法的参数；

构建一个 EF 提供程序，该提供程序将使用从用于解析 EF 依赖项（例如，要使用的 实例）的应用程序域 Singleton 获取的 。

添加一个 ，它将用于在使用应用程序配置文件中的某一项或通过 中基于代码的注册将某派生类型注册为 EF 提供程序时解析附加的默认提供程序服务。

要添加的解析程序。

基于原型命令创建默认的 DbCommandDefinition 对象。此方法旨在供提供程序编写者从命令生成默认命令定义。注意：这将克隆原型

可执行的命令定义对象 原型命令

从给定的命令目录树创建命令定义对象。

可执行的命令定义对象 语句的命令目录树

从指定的清单和命令目录树创建命令定义。

已创建的命令定义。 清单。 命令目录树。

创建一个由连接指示的数据库并且基于 storeItemCollection 的内容创建架构对象（表、主键、外键）。

与需要创建并且用 storeItemCollection 参数指示的存储对象进行填充的不存在的数据库的连接。 创建数据库所需的任何命令的执行超时。 创建脚本所应基于的所有存储项的集合。

基于 StoreItemCollection 参数的内容并针对与提供程序清单标记相对应的数据库版本，生成可创建架构对象（表、主键、外键）的数据定义语言 (DDL) 脚本。

基于 StoreItemCollection 参数的内容并针对与提供程序清单标记相对应的数据库版本创建架构对象的 DDL 脚本。 标识目标版本的提供程序清单标记。 数据库的结构。

为指定的提供程序清单和命令目录树创建命令定义对象。

可执行的命令定义对象。 以前从存储提供程序检索的提供程序清单。 语句的命令目录树。

返回一个值，该值指示服务器上是否存在给定数据库。

如果提供程序仅基于连接就可推导数据库，则为 true。 与通过此方法检查其是否存在的数据库的连接。 确定数据库是否存在所需的任何命令的执行超时。 模型中所有存储项的集合。该参数不再用于确定数据库是否存在。

创建一个由连接指示的数据库并且基于 StoreItemCollection 的内容创建架构对象（表、主键、外键）。

与需要创建并且用 storeItemCollection 参数指示的存储对象进行填充的不存在的数据库的连接。 创建数据库所需的任何命令的执行超时。 创建脚本所应基于的所有存储项的集合。

基于 StoreItemCollection 参数的内容并针对与提供程序清单标记相对应的数据库版本，生成可创建架构对象（表、主键、外键）的数据定义语言 (DDL) 脚本。

基于 StoreItemCollection 参数的内容并针对与提供程序清单标记相对应的数据库版本创建架构对象的 DDL 脚本。 标识目标版本的提供程序清单标记。 数据库的结构。

返回一个值，该值指示服务器上是否存在给定数据库。

如果提供程序仅基于连接就可推导数据库，则为 true。 与通过此方法检查其是否存在的数据库的连接。 确定数据库是否存在所需的任何命令的执行超时。 模型中所有存储项的集合。该参数不再用于确定数据库是否存在。

删除指定的数据库。

到某个需要删除的现有数据库的连接。 删除数据库所需的任何命令的执行超时。 模型中所有存储项的集合。该参数不再用于删除数据库。

为 获取空间服务。

空间服务。 与提供程序清单关联的标记信息。

删除指定的数据库。

到某个需要删除的现有数据库的连接。 删除数据库所需的任何命令的执行超时。 模型中所有存储项的集合。该参数不再用于删除数据库。

如果给定路径以 |DataDirectory| 开头则展开该路径中的 |DataDirectory| 并且返回扩展的路径；如果给定路径未以 |DataDirectory| 开头，则返回给定字符串。

展开的路径。 要展开的路径。

返回表示 CSDL 说明的 XML 读取器

表示 CSDL 说明的 XmlReader

在派生类中重写时，返回派生自 DbProviderManifest 的类的实例。

表示提供程序清单的 DbProviderManifest 对象。 与提供程序清单关联的标记信息。

返回给定连接的提供程序清单标记。

指定连接的提供程序清单标记。 从中查找清单标记的连接。

为 获取空间数据读取器。

空间数据读取器。 空间数据来自于的读取器。 与提供程序清单关联的标记信息。

获取将用于执行使用指定连接的方法的 。

的一个新实例。 数据库连接

基于指定的 DbConnection 检索 DbProviderFactory。

检索到的 DbProviderFactory。 要使用的连接。

使用指定的版本信息返回提供程序清单。

使用指定版本信息的提供程序清单。 与提供程序清单关联的标记信息。

返回给定连接的提供程序清单标记。

提供程序清单标记。 到提供程序的连接。

返回给定连接的提供程序。

基于指定连接实例化的 。 到提供程序的连接。

在使用应用程序配置文件中的某一项或通过 中基于代码的注册将某一派生类型注册为 EF 提供程序时调用，用于解析附加的默认提供程序服务。此类中此方法的实现使用通过 AddDependencyResolver 方法添加的解析程序来解析依赖项。

给定类型的实例；如果无法解析服务，则为 null。 要解析的服务的类型。 为解析服务提供附加信息的可选键。

在使用应用程序配置文件中的某一项或通过 中基于代码的注册将某一派生类型注册为 EF 提供程序时调用，用于解析附加的默认提供程序服务。此类中此方法的实现使用通过 AddDependencyResolver 方法添加的解析程序来解析依赖项。

满足给定类型和键的所有注册的服务；如果没有，则为空枚举。 要解析的服务的类型。 为解析服务提供附加信息的可选键。

为 获取空间数据读取器。

空间数据读取器。 空间数据来自于的读取器。 与提供程序清单关联的清单标记。

为 获取空间服务。

空间服务。 有关将对其使用空间服务的数据库的信息。

为 获取空间服务。

空间服务。 与提供程序清单关联的标记信息。

注册一个处理程序，以处理来自数据库提供程序的非错误消息。

用来接收信息的连接。 用于处理消息的处理程序。

为给定的 设置参数值和适当的方面。

参数。 参数的类型。 参数的值。

接受 XmlReader 的 ProviderManifest 的专用化

初始化 类的新实例。

一个 对象，该对象提供对提供程序清单文件中的 XML 数据的访问。

返回指定的 Entity Data Model (EDM) 类型的方面说明列表。

一个 类型的集合，其中包含指定的 EDM 类型的方面说明列表。 要为其检索方面说明的 。

返回提供程序支持的函数的列表。

一个 类型的集合，其中包含提供程序支持的函数的列表。

返回存储提供程序支持的基元类型的列表。

一个 类型的集合，其中包含存储提供程序支持的基元类型的列表。

获取此提供程序清单支持的命名空间名称。

此提供程序清单支持的命名空间名称。

获取指定的存储类型名称的最佳映射等效 Entity Data Model (EDM) 类型。

指定的存储类型名称的最佳映射等效 EDM 类型。

获取指定的存储类型名称的最佳映射等效存储基元类型。

指定的存储类型名称的最佳映射等效存储基元类型。

提供一个简单方法以便访问类型信息和列信息的 EntityRecordInfo 类。

使用数据字段的可枚举集合、特定键和实体集信息初始化特定实体类型的 类的新实例。

实体的 ，由该 对象描述的 表示。 表示列信息的 对象的可枚举集合。 实体的键。 该实体所属的实体集。

获取实体的 。

实体的键。

在列序号和 MemberMetadata 之间提供关联的 FieldMetadata 类。

使用指定的序号值和字段类型初始化新的 对象。

用于指定元数据位置的整数。 字段类型。

获取此 对象的字段类型。

此 对象的字段类型。

获取此 对象的序号。

表示序号值的整数。

表示实现要派生自的 IExpressionVisitor 接口的类型的抽象基类型。

初始化 类的新实例。

实现命令目录树的访问者模式。

命令目录树。

实现删除命令目录树的访问者模式。

删除命令目录树。

实现函数命令目录树的访问者模式。

函数命令目录树。

实现插入命令目录树的访问者模式。

插入命令目录树。

实现修改子句的访问者模式。

修改子句。

实现修改子句的集合的访问者模式。

修改子句。

实现查询命令目录树的访问者模式。

查询命令目录树。

实现 set 子句的访问者模式。

set 子句。

实现更新命令目录树的访问者模式。

更新命令目录树。

实现要派生自的 IExpressionVisitor 接口的类型的抽象基类型。

初始化 类的新实例。

的访问者模式方法。

正在访问的 DbAndExpression。 为 null

的访问者模式方法。

正在访问的 DbApplyExpression。 为 null

的访问者模式方法。

正在访问的 DbArithmeticExpression。 为 null

的访问者模式方法。

正在访问的 DbCaseExpression。 为 null

的访问者模式方法。

正在访问的 DbCastExpression。 为 null

的访问者模式方法。

正在访问的 DbComparisonExpression。 为 null

的访问者模式方法。

正在访问的 DbConstantExpression。 为 null

的访问者模式方法。

正在访问的 DbCrossJoinExpression。 为 null

的访问者模式方法。

正在访问的 DeRefExpression。 为 null

的访问者模式方法。

正在访问的 DbDistinctExpression。 为 null

的访问者模式方法。

正在访问的 DbElementExpression。 为 null

的访问者模式方法。

正在访问的 DbEntityRefExpression。 为 null

的访问者模式方法。

正在访问的 DbExceptExpression。 为 null

遇到其他无法识别的类型的 时进行调用。

表达式 为 null 如果调用此方法，则始终引发，因为它指示 属于不支持的类型

的访问者模式方法。

正在访问的 DbFilterExpression。 为 null

的访问者模式方法。

正在访问的 DbFunctionExpression。 为 null

的访问者模式方法。

正在访问的 DbExpression。 为 null

的访问者模式方法。

正在访问的 DbInExpression。 为 null

的访问者模式方法。

正在访问的 DbIntersectExpression。 为 null

的访问者模式方法。

正在访问的 DbIsEmptyExpression。 为 null

的访问者模式方法。

正在访问的 DbIsNullExpression。 为 null

的访问者模式方法。

正在访问的 DbIsOfExpression。 为 null

的访问者模式方法。

正在访问的 DbJoinExpression。 为 null

的访问者模式方法。

正在访问的 DbLambdaExpression。 为 null

的访问者模式方法。

正在访问的 DbLikeExpression。 为 null

的访问者模式方法。

正在访问的 DbLimitExpression。 为 null

的访问者模式方法。

正在访问的 DbNewInstanceExpression。 为 null

的访问者模式方法。

正在访问的 DbNotExpression。 为 null

的访问者模式方法。

正在访问的 DbNullExpression。 为 null

的访问者模式方法。

正在访问的 DbOfTypeExpression。 为 null

的访问者模式方法。

正在访问的 DbOrExpression。 为 null

的访问者模式方法。

正在访问的 DbParameterReferenceExpression。 为 null

的访问者模式方法。

正在访问的 DbProjectExpression。 为 null

的访问者模式方法。

正在访问的 DbPropertyExpression。 为 null

的访问者模式方法。

正在访问的 DbQuantifierExpression。 为 null

的访问者模式方法。

正在访问的 DbRefExpression。 为 null

的访问者模式方法。

正在访问的 DbRefKeyExpression。 为 null

的访问者模式方法。

正在访问的 DbRelationshipNavigationExpression。 为 null

的访问者模式方法。

正在访问的 DbScanExpression。 为 null

的访问者模式方法。

正在访问的 DbSkipExpression。 为 null

的访问者模式方法。

正在访问的 DbSortExpression。 为 null

的访问者模式方法。

正在访问的 DbTreatExpression。 为 null

的访问者模式方法。

正在访问的 DbUnionAllExpression。 为 null

的访问者模式方法。

正在访问的 DbVariableReferenceExpression。 为 null

用于访问指定的 的方便的方法。

要访问的聚合。 为 null

用于访问列表中的每个 （如果列表是非 null 的）的方便的方法。

要访问的聚合的列表。 为 null

用于访问指定的 的方便的方法。

要访问的 DbBinaryExpression。 为 null

用于访问指定的 的方便的方法（如果非 null）。

要访问的表达式。 为 null

用于在访问了 DbExpressionBinding 后进行后处理的方便的方法。

以前访问的 DbExpressionBinding。

用于访问指定的 的方便的方法。

要访问的 DbExpressionBinding。 为 null

用于访问给定列表中的每个 （如果列表是非 null 的）的方便的方法。

要访问的表达式的列表。 为 null

指示 的分组键已访问并且现在将要访问聚合的方便的方法。

DbGroupByExpression 的 DbGroupExpressionBinding

用于在访问了 DbGroupExpressionBinding 后进行后处理的方便的方法。

以前访问的 DbGroupExpressionBinding。

用于访问指定的 的方便的方法。

要访问的 DbGroupExpressionBinding。 为 null

用于在访问了 DbLambda 后进行后处理的方便的方法。

以前访问的 DbLambda。

指示现在将要访问的 Lambda 的正文的方便方法。

将要访问的 DbLambda。 为 null

用于访问指定的 的方便的方法。

要访问的 DbUnaryExpression。 为 null

聚合是伪表达式。聚合在外观上与表达式相似，但其可以出现的位置有严格的限制 - 只能出现在 group-by 表达式的聚合子句中。

获取定义要聚合的参数的表达式列表。

获取此聚合的结果类型。

表示两个 Boolean 参数之间的逻辑与运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示一个应用运算，它是对指定输入集中的每个元素的指定 functor 调用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取 ，它指定对输入集中的每个元素调用的 functor。

获取用于指定输入集的 。

表示应用于两个数值参数的算术运算（加法、减法、乘法、除法、取模或求反）。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取用于定义当前参数的表达式列表。

接受两个表达式操作数的表达式的抽象基类型。

获取定义左边参数的 。

获取定义右边参数的 。

表示 Case When...Then...Else 逻辑运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取此 DbCaseExpression 的 Else 子句。

获取此 DbCaseExpression 的 Then 子句。

获取此 DbCaseExpression 的 When 子句。

表示应用于多态参数的强制转换运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

DbCommandTree 是删除、查询、插入和更新 DbCommandTree 类型的抽象基类型。

获取此命令目录树的类型。

获取此命令目录树所使用的元数据必须驻留于其中的数据空间。

获取此命令目录树使用的元数据工作区。

获取在此命令目录树中可以引用的每个参数的名称和相应类型。

描述命令目录树的不同“种类”（类）。

指定删除命令。

指定函数命令。

指定插入命令。

指定查询命令。

指定更新命令。

表示应用于两个参数的比较运算（相等、大于、大于或等于、小于、小于或等于、不相等）。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示常量值。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取常量值。

表示给定集合参数之间的无条件联接运算

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取一个 列表，该列表提供要联接的输入集。

表示用一个规范命令目录树代表的单行删除操作。

获取此命令目录树的类型。

此命令目录树的类型。

获取一个 ，它指定用于确定目标集合中应删除的成员的谓词。

用于确定目标集合中应删除的成员的谓词。

使用指定的 Ref 表示给定实体的检索。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示从指定的集操作数中删除重复的元素。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示指定的集操作数到单一实例的转换。如果该集为空，则转换将返回 null；否则，该转换将返回集中的元素之一。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示作为 Ref 对指定实体的引用的检索。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示左右操作数之间的集减法运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示所有表达式的基类型。

实现不生成结果值的表达式访问者的访问者模式接口。

DbExpressionVisitor 的实例。 为 null。

实现生成特定类型的结果值的表达式访问者的访问者模式接口方法。

的一个实例。 生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 生成的结果的类型。 为 null。

确定指定的对象是否等于当前 DbExpression 实例。

如果指定的对象等于当前 DbExpression 实例，则为 true；否则为 false。 要与当前 进行比较的对象。

获取表达式的类型，类型指示该表达式的运算。

表达式的类型，指示该表达式的运算。

创建表示指定的二进制值的 ，可以为 null。

表示指定的二进制值的 。 返回的表达式应基于的二进制值。

创建表示指定的（可以为 null）布尔值的 。

表示指定的布尔值的 。 返回的表达式应基于的布尔值。

创建表示指定的（可以为 null）字节值的 。

表示指定的字节值的 。 返回的表达式应基于的字节值。

创建表示指定的（可以为 null） 值的 。

表示指定的 DateTime 值的 。 返回的表达式应基于的 DateTime 值。

创建表示指定的（可以为 null） 值的 。

表示指定的 DateTimeOffset 值的 。 返回的表达式应基于的 DateTimeOffset 值。

创建表示指定的（可以为 null）十进制值的 。

表示指定的十进制值的 。 返回的表达式应基于的十进制值。

创建表示指定的（可以为 null）双精度值的 。

表示指定的双精度值的 。 返回的表达式应基于的双精度值。

创建表示指定的 值的 ，可以为 null。

表示指定的 DbGeography 值的 。 返回的表达式应基于的 DbGeography 值。

创建表示指定的 值的 ，可以为 null。

表示指定的 DbGeometry 值的 。 返回的表达式应基于的 DbGeometry 值。

创建表示指定的（可以为 null） 值的 。

表示指定的 Guid 值的 。 返回的表达式应基于的 Guid 值。

创建表示指定的（可以为 null）Int16 值的 。

表示指定的 Int16 值的 。 返回的表达式应基于的 Int16 值。

创建表示指定的（可以为 null）Int32 值的 。

表示指定的 Int32 值的 。 返回的表达式应基于的 Int32 值。

创建表示指定的（可以为 null）Int64 值的 。

表示指定的 Int64 值的 。 返回的表达式应基于的 Int64 值。

创建表示指定的（可以为 null）单精度值的 。

表示指定的单精度值的 。 返回的表达式应基于的单精度值。

创建表示指定的字符串值的 。

表示指定的字符串值的 。 返回的表达式应基于的字符串值。

用作此类型的哈希函数。

返回当前表达式的哈希代码。

将一个 8 位无符号整数数组转换成 。

一个 ，表示转换后的 8 位无符号整数数组。 一个 8 位无符号整数数组。

将一个 DbGeography 对象转换成 。

表示转换后的 DbGeography 对象的 。 DbGeography 对象。

将一个 DBGeometry 对象转换成 。

表示转换后的 DbGeography 对象的 。 DbGeometry 对象。

将一个可以为 null 的布尔对象转换为 。

表示转换后的可以为 null 的布尔对象的 。 可以为 null 的布尔对象。

将一个可以为 null 的 8 位无符号整数转换成 。

表示转换后的 8 位无符号整数的 。 可以为 null 的 8 位无符号整数。

将一个可以为 null 的 对象转换成 。

一个表示 对象的 。 可为 null 的 对象。

将一个可以为 null 的 对象转换成 。

一个表示可以为 null 的 的 。 可为 null 的 对象。

将一个可以为 null 的十进制对象转换为 。

表示可以为 null 的十进制对象的 。 可以为 null 的十进制对象。

将一个可以为 null 的双精度对象转换为 。

表示可以为 null 的双精度对象的 。 可以为 null 的双精度对象。

将一个可以为 null 的 Guid 对象转换为 。

一个 ，表示可为 null 的 对象。 可为 null 的 对象。

将一个可以为 null 的 16 位无符号整数转换成 。

一个 ，表示可为 null 的 16 位无符号整数。 可以为 null 的 16 位无符号整数。

将一个可以为 null 的 32 位无符号整数转换成 。

一个 ，表示可为 null 的 32 位无符号整数。 可以为 null 的 32 位无符号整数。

将一个可以为 null 的 64 位无符号整数转换成 。

一个 ，表示可为 null 的 64 位无符号整数。 可以为 null 的 64 位无符号整数。

将一个可以为 null 的单精度浮点数字转换成 。

一个表示单精度浮点数字的 。 单精度浮点数。

转换 Unicode 字符 的有序集合。

表示 Unicode 字符的有序集合的 。 Unicode 字符的有序集合。

获取表达式的结果类型的类型元数据。

表达式的结果类型的类型元数据。

描述表达式的绑定。在概念上与 C# 中的 foreach 循环类似。DbExpression 属性定义要循环访问的集合，而 Var 属性提供一个方式以便在迭代过程中引用该集合的当前元素。DbExpressionBinding 用于描述关系表达式（例如 、 和 ）的集参数。

获取用于定义输入集的 。

获取引用元素变量的 。

获取指定给元素变量的名称。

获取元素变量的类型元数据。

描述表达式的不同“种类”（类）

全部为 True。

逻辑与。

任何项均为 True。

条件 Case 语句。

多态类型转换。

一个常量值。

交叉应用

交叉联接

引用。

重复删除。

除法。

集到单一转换。

实体引用值检索。

相等

Set 减法

限制。

完全外部联接

独立函数的调用

大于。

大于或等于。

分组。

在其中。

内部联接

交集。

空集确定。

Null 确定。

类型比较（指定的类型或子类型）。

类型比较（仅限指定的类型）。

lambda 函数的应用

左外部联接

小于。

小于或等于。

字符串比较。

结果计数限制 (TOP n)。

减法。

取模。

乘法。

实例、行和集构造。

逻辑非。

不相等。

Null。

按类型（或子类型）的集成员。

按（确切）类型的集成员。

逻辑或。

外部应用。

对参数的引用。

加法。

投影。

静态或实例属性检索。

引用。

引用键值检索。

（组合或关联）关系的导航。

实体集或关系集扫描。

跳过有序集合中的元素。

排序。

类型转换。

求反。

并集（包含重复项）。

对变量的引用。

确保某一给定表达式目录树中的所有元数据都来自指定的元数据工作区，并且可能在需要时将表达式重新绑定和重新生成到适当的替代元数据。

初始化 类的新实例。

目标工作区。

实现检索实例属性的访问者模式。

实现的访问者。 表达式。

实现对实体集的访问者模式。

实现的访问者模式。 实体集。

实现函数的访问者模式。

实现的访问者模式。 函数元数据。

实现类型的访问者模式。

实现的访问者模式。 类型。

实现类型用法的访问者模式。

实现的访问者模式。 类型。

应由不返回结果值的访问者实现的表达式访问者模式抽象基类。

初始化 类的新实例。

DbAndExpression 的访问者模式方法。

正在访问的 DbAndExpression。

DbApplyExpression 的访问者模式方法。

正在访问的 DbApplyExpression。

DbArithmeticExpression 的访问者模式方法。

正在访问的 DbArithmeticExpression。

DbCaseExpression 的访问者模式方法。

正在访问的 DbCaseExpression。

DbCastExpression 的访问者模式方法。

正在访问的 DbCastExpression。

DbComparisonExpression 的访问者模式方法。

正在访问的 DbComparisonExpression。

DbConstantExpression 的访问者模式方法。

正在访问的 DbConstantExpression。

DbCrossJoinExpression 的访问者模式方法。

正在访问的 DbCrossJoinExpression。

DbDerefExpression 的访问者模式方法。

正在访问的 DbDerefExpression。

DbDistinctExpression 的访问者模式方法。

正在访问的 DbDistinctExpression。

DbElementExpression 的访问者模式方法。

正在访问的 DbElementExpression。

DbEntityRefExpression 的访问者模式方法。

正在访问的 DbEntityRefExpression。

DbExceptExpression 的访问者模式方法。

正在访问的 DbExceptExpression。

遇到其他无法识别的类型的表达式时进行调用。

表达式。

DbFilterExpression 的访问者模式方法。

正在访问的 DbFilterExpression。

DbFunctionExpression 的访问者模式方法。

正在访问的 DbFunctionExpression。

DbGroupByExpression 的访问者模式方法。

正在访问的 DbGroupByExpression。

DbInExpression 的访问者模式方法。

正在访问的 DbInExpression。

DbIntersectExpression 的访问者模式方法。

正在访问的 DbIntersectExpression。

DbIsEmptyExpression 的访问者模式方法。

正在访问的 DbIsEmptyExpression。

DbIsNullExpression 的访问者模式方法。

正在访问的 DbIsNullExpression。

DbIsOfExpression 的访问者模式方法。

正在访问的 DbIsOfExpression。

DbJoinExpression 的访问者模式方法。

正在访问的 DbJoinExpression。

DbLambdaExpression 的访问者模式方法。

正在访问的 DbLambdaExpression。

DbLikeExpression 的访问者模式方法。

正在访问的 DbLikeExpression。

DbLimitExpression 的访问者模式方法。

正在访问的 DbLimitExpression。

DbNewInstanceExpression 的访问者模式方法。

正在访问的 DbNewInstanceExpression。

DbNotExpression 的访问者模式方法。

正在访问的 DbNotExpression。

DbNullExpression 的访问者模式方法。

正在访问的 DbNullExpression。

DbOfTypeExpression 的访问者模式方法。

正在访问的 DbOfTypeExpression。

DbOrExpression 的访问者模式方法。

正在访问的 DbOrExpression。

DbParameterReferenceExpression 的访问者模式方法。

正在访问的 DbParameterReferenceExpression。

DbProjectExpression 的访问者模式方法。

正在访问的 DbProjectExpression。

DbPropertyExpression 的访问者模式方法。

正在访问的 DbPropertyExpression。

DbQuantifierExpression 的访问者模式方法。

正在访问的 DbQuantifierExpression。

DbRefExpression 的访问者模式方法。

正在访问的 DbRefExpression。

DbRefKeyExpression 的访问者模式方法。

正在访问的 DbRefKeyExpression。

DbRelationshipNavigationExpression 的访问者模式方法。

正在访问的 DbRelationshipNavigationExpression。

DbScanExpression 的访问者模式方法。

正在访问的 DbScanExpression。

DbSkipExpression 的访问者模式方法。

正在访问的 DbSkipExpression。

DbSortExpression 的访问者模式方法。

正在访问的 DbSortExpression。

DbTreatExpression 的访问者模式方法。

正在访问的 DbTreatExpression。

DbUnionAllExpression 的访问者模式方法。

正在访问的 DbUnionAllExpression。

DbVariableReferenceExpression 的访问者模式方法。

正在访问的 DbVariableReferenceExpression。

应由返回特定类型的结果值的访问者实现的表达式访问者模式抽象基类。

访问者生成的结果值的类型。

初始化 类的新实例。

DbAndExpression 的类型化访问者模式方法。

正在访问的 DbAndExpression。

DbApplyExpression 的类型化访问者模式方法。

正在访问的 DbApplyExpression。

DbArithmeticExpression 的类型化访问者模式方法。

正在访问的 DbArithmeticExpression。

DbCaseExpression 的类型化访问者模式方法。

正在访问的 DbCaseExpression。

DbCastExpression 的类型化访问者模式方法。

正在访问的 DbCastExpression。

DbComparisonExpression 的类型化访问者模式方法。

正在访问的 DbComparisonExpression。

DbConstantExpression 的类型化访问者模式方法。

正在访问的 DbConstantExpression。

DbCrossJoinExpression 的类型化访问者模式方法。

正在访问的 DbCrossJoinExpression。

DbDerefExpression 的访问者模式方法。

正在访问的 DbDerefExpression。

DbDistinctExpression 的类型化访问者模式方法。

正在访问的 DbDistinctExpression。

DbElementExpression 的类型化访问者模式方法。

正在访问的 DbElementExpression。

DbEntityRefExpression 的访问者模式方法。

正在访问的 DbEntityRefExpression。

DbExceptExpression 的类型化访问者模式方法。

正在访问的 DbExceptExpression。

遇到其他无法识别的类型的表达式时进行调用。

表达式。

DbFilterExpression 的类型化访问者模式方法。

正在访问的 DbFilterExpression。

DbFunctionExpression 的访问者模式方法

正在访问的 DbFunctionExpression。

DbGroupByExpression 的类型化访问者模式方法。

正在访问的 DbGroupByExpression。

DbInExpression 的类型化访问者模式方法。

正在访问的 DbInExpression。

DbIntersectExpression 的类型化访问者模式方法。

正在访问的 DbIntersectExpression。

DbIsEmptyExpression 的类型化访问者模式方法。

正在访问的 DbIsEmptyExpression。

DbIsNullExpression 的类型化访问者模式方法。

正在访问的 DbIsNullExpression。

DbIsOfExpression 的类型化访问者模式方法。

正在访问的 DbIsOfExpression。

DbJoinExpression 的类型化访问者模式方法。

正在访问的 DbJoinExpression。

DbLambdaExpression 的访问者模式方法。

正在访问的 DbLambdaExpression。

DbLikeExpression 的访问者模式方法。

正在访问的 DbLikeExpression。

DbLimitExpression 的访问者模式方法。

正在访问的 DbLimitExpression。

DbNewInstanceExpression 的类型化访问者模式方法。

正在访问的 DbNewInstanceExpression。

DbNotExpression 的类型化访问者模式方法。

正在访问的 DbNotExpression。

DbNullExpression 的类型化访问者模式方法。

正在访问的 DbNullExpression。

DbOfTypeExpression 的类型化访问者模式方法。

正在访问的 DbOfTypeExpression。

DbOrExpression 的类型化访问者模式方法。

正在访问的 DbOrExpression。

DbParameterReferenceExpression 的类型化访问者模式方法。

正在访问的 DbParameterReferenceExpression。

DbProjectExpression 的类型化访问者模式方法。

正在访问的 DbProjectExpression。

DbPropertyExpression 的类型化访问者模式方法。

正在访问的 DbPropertyExpression。

DbQuantifierExpression 的类型化访问者模式方法。

正在访问的 DbQuantifierExpression。

DbRefExpression 的类型化访问者模式方法。

正在访问的 DbRefExpression。

DbRefKeyExpression 的访问者模式方法。

正在访问的 DbRefKeyExpression。

DbRelationshipNavigationExpression 的类型化访问者模式方法。

正在访问的 DbRelationshipNavigationExpression。

DbScanExpression 的类型化访问者模式方法。

正在访问的 DbScanExpression。

DbSkipExpression 的类型化访问者模式方法。

正在访问的 DbSkipExpression。

DbSortExpression 的类型化访问者模式方法。

正在访问的 DbSortExpression。

DbTreatExpression 的类型化访问者模式方法。

正在访问的 DbTreatExpression。

DbUnionAllExpression 的类型化访问者模式方法。

正在访问的 DbUnionAllExpression。

DbVariableReferenceExpression 的类型化访问者模式方法。

正在访问的 DbVariableReferenceExpression。

表示一个谓词，该谓词应用于某一输入集以便生成满足它的一组元素。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取用于指定输入集的 。

获取指定用于筛选输入集的谓词的 。

对应于聚合函数的调用的聚合类型。

获取一个值，该值指示是否以不同风格应用聚合函数

获取指定要调用的聚合函数的方法元数据。

表示以规范命令树表示的函数调用。

构造一个新的 DbFunctionCommandTree，它使用指定的元数据工作区、数据空间和函数元数据。

命令目录树应使用的元数据工作区。 在此命令目录树中使用的表达式中的元数据必须属于的逻辑“空间”。 要调用的 EDM 函数。 函数的结果类型。 与要调用的函数关联的参数。

获取或设置命令目录树类型。

命令目录树类型。

获取表示要调用的函数的 。

表示要调用的函数的 。

获取函数的结果类型；当前被约束为 RowTypes 的集合。与典型的 RowType 实例不同，仅指示名称/类型不是参数顺序。

函数的结果类型。

表示对函数的调用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取 列表，该列表提供函数的参数。

获取要调用的函数的元数据。

表示构成组的元素的集合。

表示一个分组运算，分组运算是根据指定的键表达式将输入集中的元素分组，后接指定聚合函数的应用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取 列表，该列表提供要应用的聚合函数。

获取 ，它指定输入集，并提供对集元素和组元素变量的访问。

获取 列表，该列表提供分组键。

定义输入集到 的绑定。除了 的属性之外，DbGroupExpressionBinding 还通过 <seealso cref="P:System.Data.Entity.Core.Common.CommandTrees.DbGroupExpressionBinding.GroupVariable" /> 变量引用提供对组元素的访问，并且通过 <seealso cref="P:System.Data.Entity.Core.Common.CommandTrees.DbGroupExpressionBinding.GroupAggregate" /> 属性提供对组聚合的访问。

获取用于定义输入集的 。

获取 DbGroupAggregate，它表示组的元素集合。

获取引用组元素变量的 DbVariableReferenceExpression。

获取指定给组元素变量的名称。

获取组元素变量的类型元数据。

获取引用元素变量的 DbVariableReferenceExpression。

获取指定给元素变量的名称。

获取元素变量的类型元数据。

表示一个布尔表达式，该布尔表达式测试某一指定的项是否与列表中的任何元素匹配。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取指定要匹配的项的 DbExpression。

获取要针对某一匹配进行测试的 DbExpression 的列表。

表示用一个规范命令目录树代表的单行插入操作。如果设置了 属性，此命令将返回一个读取器；否则，它将返回一个指示受影响的行数的标量值。

获取命令目录树类型。

命令目录树类型。

获取一个 ，它指定要基于修改的行返回的结果投影。如果为 null，则指示不应从此命令返回任何结果。

指定要基于修改的行返回的结果投影的 。

获取确定插入的行中的列值的 Set 子句。

确定插入的行中的列值的 Set 子句。

表示左右操作数之间的交集运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示应用于单集参数的空集确定。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示应用于单个参数的 null 确定。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示单个参数针对指定类型的类型比较。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取参数的类型元数据将与其进行比较的类型元数据。

表示在指定的联接条件下，在给定的集合参数之间进行的内部、左外部或完全外部联接运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取定义要应用的联接条件的 。

获取提供左输入的 。

获取提供右输入的 。

表示 Lambda 函数的应用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取一个 列表，该列表提供 Lambda 函数应该应用于的参数。

获取表示此表达式应用的 Lambda 函数的 。

表示针对指定的模式与可选的转义字符串进行的字符串比较

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取一个表达式，它指定要针对给定模式进行比较的字符串

获取一个表达式，它提供用于比较的可选的转义字符串

获取一个表达式，它指定比较给定字符串时所针对的模式

表示将参数集合中的元素数限制为指定的限值。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取指定输入集合的表达式。

获取指定从输入集合中返回的元素数限制的表达式。

获取限制操作是否将包括等值结果，在存在等值时，这可以生成比该限值指定的结果更多的结果。

在插入或更新修改操作中指定单个子句，请参见 和

表示以规范命令目录树表示的 DML 操作

获取为 DML 操作指定目标表的 。

表示给定类型（包括集类型和记录类型）的新实例的构造。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取一个 列表，该列表可为新实例提供属性/列值或集元素。

表示对单个 Boolean 参数执行的逻辑非运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示 null。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示从给定的集参数中检索属于指定类型的元素。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取应从集参数中检索的元素类型的元数据。

表示两个 Boolean 参数的逻辑或。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示对在包含此表达式的命令目录树上声明的参数的引用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取所引用的参数的名称。

表示给定值集在指定输入集上的投影。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取用于指定输入集的 。

获取定义投影的 。

提供用于检索实例属性的方法和属性。此类不能被继承。

为不生成结果值的表达式实现访问者模式。

的一个实例。 visitor 为 null。

为生成特定类型的结果值的表达式实现访问者模式。

一个由 生成的特定类型结果值。 生成特定类型结果值的类型化 的一个实例。 访问者生成的结果类型。 visitor 为 null。

获取 ，它定义应从中检索属性的实例。

用于定义应从中检索属性的实例的 。

允许隐式强制转换为 。

转换后的值。 要转换的表达式。

获取要检索的属性的属性元数据。

要检索的属性的属性元数据。

基于此属性表达式创建一个新的键/值对。

具有从 派生的键和值的新键/值对。

表示对指定输入集中的元素执行的指定种类（Any、All）的限定符操作。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取用于指定输入集的 。

获取应为输入集中的每个元素计算的 Boolean 谓词。

表示一项以规范命令目录树形式表示的查询操作。

构造一个新的 DbQueryCommandTree，它使用指定的元数据工作区。

命令目录树应使用的元数据工作区。 在此命令目录树中使用的表达式中的元数据必须属于的逻辑“空间”。 一个定义查询逻辑的 。 或 为 null。 不表示有效数据空间。

构造一个新的 DbQueryCommandTree，它使用指定的元数据工作区。

命令目录树应使用的元数据工作区。 在此命令目录树中使用的表达式中的元数据必须属于的逻辑“空间”。 一个定义查询逻辑的 。 在设置为 false 时，将禁用对目录树的验证。 或 为 null。 不表示有效数据空间。

获取此命令目录树的类型。

此命令目录树的类型。

获取定义查询逻辑的 。

一个定义查询逻辑的 。

表示对某一给定实体集中的特定实例的（强类型）引用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取包含该实例的实体集的元数据。

表示将指定引用的键值作为行检索。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示给定“源”角色、“目标”角色和源角色的实例的情况下关系的导航（组合或关联）

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取要从其开始导航的关系端的元数据

获取要导航到的关系端的元数据

获取 ，它指定应从其开始导航的“源”关系端的实例。

获取要导航的关系的元数据

表示某一给定实体集的所有元素的“扫描”。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取所引用的实体集或关系集的元数据。

指定用于设置属性值的修改操作中的子句。

获取一个指定应更新的属性的 。

获取一个 ，它指定用于更新属性的新值。

表示应用在给定排序键中描述的顺序后输入集的指定数目的元素的跳过操作。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取指定要在输入集合中跳过的元素数的表达式。

获取用于指定输入集的 。

获取一个定义排序顺序的 列表。

指定可在 DbSortExpression 中用作排序顺序的一部分的排序关键字。

获取一个布尔值，该值指示此排序关键字是否按升序排序。

获取一个字符串值，该值指定此排序关键字的排序规则。

获取为此排序关键字提供值的 。

表示一项基于给定的排序关键字应用于指定输入集中的元素的排序操作。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取用于指定输入集的 。

获取一个定义排序顺序的 列表。

表示单个参数向指定类型的类型转换。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

接受单个表达式操作数的表达式的抽象基类型

获取定义参数的 。

表示左右操作数之间的 set 联合（不移除重复项）运算。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

表示一项以命令目录树形式表示的单行更行操作。此类不能被继承。

初始化 类的新实例。

将对其运行此命令的模型。 数据空间。 数据操作语言 (DML) 操作的目标表。 一个谓词，用于确定目标集合中应更新的成员。 定义更新操作的更新 Set 子句列表。 一个 ，它指定要基于修改的行返回的结果投影。

获取此命令目录树的类型。

此命令目录树的类型。

获取一个 ，它指定用于确定目标集合中应更新的成员的谓词。

一个 ，指定用于确定目标集合中应更新的成员的谓词。

获取一个 ，它指定要基于修改的行返回的结果投影。

一个 ，它指定要基于修改的行返回的结果投影。如果为 null，则指示不应从此命令返回任何结果。

获取定义更新操作的更新 Set 子句列表。

定义更新操作的更新 Set 子句列表。

表示对当前处于范围内的某个变量的引用。

不生成结果值的表达式访问者的访问者模式方法。

DbExpressionVisitor 的实例。 visitor

生成特定类型的结果值的表达式访问者的访问者模式方法。

生成 TResultType 类型的结果值的类型化 DbExpressionVisitor 的一个实例。 visitor 生成的结果类型 visitor

获取所引用的变量的名称。

从给定的根表达式访问表达式目录树的每个元素。如果任何元素发生更改，则目录树将被重新生成回根目录并且返回新的根表达式；否则，返回原始根表达式。

初始化 类的新实例。

当使用指定的范围变量进入表达式访问者的范围时表示事件。

范围变量的集合。

退出表达式访问者的范围。

用表达式访问者的新表达式替换旧表达式。

旧表达式。 新表达式。

当重新绑定表达式访问者的变量时表示事件。

变量的位置。 重新绑定的变量的引用。

实现逻辑与表达式的访问者模式。

实现的访问者。 正在访问的 DbAndExpression。

为调用指定输入集中每个元素的指定函数实现访问者模式。

实现的访问者。 正在访问的 DbApplyExpression。

实现应用于数值参数的算术运算的访问者模式。

实现的访问者。 正在访问的 DbArithmeticExpression。

实现 When、Then 和 Else 子句的访问者模式。

实现的访问者。 正在访问的 DbCaseExpression。

实现将单个参数转换为指定类型的类型转换的访问者模式。

实现的访问者。 正在访问的 DbCastExpression。

实现应用于两个参数的比较运算的访问者模式。

实现的访问者。 正在访问的 DbComparisonExpression。

实现不同类型常量的访问者模式。

实现的访问者。 正在访问的 DbConstantExpression。

实现给定集合参数之间的无条件联接操作的访问者模式。

实现的访问者。 正在访问的 DbCrossJoinExpression。

实现基于指定引用检索实体的表达式的访问者模式。

实现的访问者。 正在访问的 DbDerefExpression。

实现从指定的集参数中删除的重复元素的访问者模式。

实现的访问者。 正在访问的 DbDistinctExpression。

实现指定的集参数到单一实例的转换的访问者模式。

实现的访问者。 正在访问的 DbElementExpression。

实现从基础实体实例提取引用的表达式的访问者模式。

实现的访问者。 正在访问的 DbEntityRefExpression。

实现左操作数和右操作数之间设置的减法运算的访问者模式。

实现的访问者。 正在访问的 DbExceptExpression。

实现表达式类型所需的基本功能的访问者模式。

实现的访问者。 正在访问的 DbExpression。

实现应用于筛选输入集的谓语的访问者模式。

实现的访问者。 正在访问的 DbFilterExpression。

实现调用某个函数的访问者模式。

实现的访问者。 正在访问的 DbFunctionExpression。

通过运算实现针对某个组的访问者模式。

实现的访问者。 正在访问的 DbGroupByExpression。

实现 DbInExpression 的访问者模式。

实现的访问者。 正在访问的 DbInExpression。

实现左操作数和右操作数之间设置的交集运算的访问者模式。

实现的访问者。 正在访问的 DbIntersectExpression。

实现应用于单集参数的空集确定的访问者模式。

实现的访问者。 正在访问的 DbIsEmptyExpression。

实现应用于单个参数的 null 确定的访问者模式。

实现的访问者。 正在访问的 DbIsNullExpression。

实现将单个参数与指定类型进行比较的类型比较的访问者模式。

实现的访问者。 正在访问的 DbIsOfExpression。

实现指定联接条件下给定集合参数之间内部联接、左外部联接或完全外部联接运算的访问者模式。

实现的访问者。 正在访问的 DbJoinExpression。

实现将 lambda 函数应用于 DbExpression 对象所表示的参数的访问者模式。

实现的访问者。 正在访问的 DbLambdaExpression。

实现与带有可选转义字符串的指定模式进行字符串比较的访问者模式。

实现的访问者。 正在访问的 DbLikeExpression。

实现将参数集合中的元素数目限制为指定限值的访问者模式。

实现的访问者。 正在访问的 DbLimitExpression。

实现构建给定类型的新实例（包括集和记录类型）的访问者模式。

实现的访问者。 正在访问的 DbNewInstanceExpression。

实现单个布尔参数的逻辑非运算的访问者模式。

实现的访问者。 正在访问的 DbNotExpression。

实现对类型化 null 文本的引用的访问者模式。

实现的访问者。 正在访问的 DbNullExpression。

实现根据给定集参数检索指定类型的元素的访问者模式。

实现的访问者。 正在访问的 DbOfTypeExpression。

实现两个布尔参数的逻辑或的访问者模式。

实现的访问者。 正在访问的 DbOrExpression。

实现对包含此表达式的命令目录树中所声明参数的引用的访问者模式。

实现的访问者。 正在访问的 DbParameterReferenceExpression。

实现对指定表达式的给定输入集的投影的访问者模式。

实现的访问者。 正在访问的 DbProjectExpression。

实现检索实例属性的访问者模式。

实现的访问者。 正在访问的 DbPropertyExpression。

实现对指定输入集元素执行的指定类型的限定符运算的访问者模式。

实现的访问者。 正在访问的 DbQuantifierExpression。

实现对实体集内特定实例的强类型引用的访问者模式。

实现的访问者。 正在访问的 DbRefExpression。

实现根据基础引用值检索键值的访问者模式。

实现的访问者。 正在访问的 DbRefKeyExpression。

实现关系导航的访问者模式。

实现的访问者。 正在访问的 DbRelationshipNavigationExpression。

实现对 Target 属性所指示的实体集或关系集的扫描的访问者模式。

实现的访问者。 正在访问的 DbScanExpression。

实现 skip 表达式的访问者模式。

实现的访问者。 正在访问的 DbSkipExpression。

实现可用作排序顺序一部分的排序关键字的访问者模式。

实现的访问者。 正在访问的 DbSortExpression。

实现应用于多态参数的类型转换运算的访问者模式。

实现的访问者。 正在访问的 DbTreatExpression。

实现左操作数和右操作数之间设置的并集运算的访问者模式。

实现的访问者。 正在访问的 DbUnionAllExpression。

实现对当前处于范围内的变量的引用的访问者模式。

实现的访问者。 正在访问的 DbVariableReferenceExpression。

实现对聚合的访问者模式。

实现的访问者模式。 要访问的聚合。

实现对实体集的访问者模式。

实现的访问者模式。 实体集。

实现表达式的访问者模式。

实现的访问者模式。 表达式。

实现表达式绑定的访问者模式。

实现的访问者模式。 表达式绑定。

实现表达式绑定列表的访问者模式。

实现的访问者模式。 表达式绑定列表。

实现表达式列表的访问者模式。

实现的访问者模式。 表达式列表。

实现函数的访问者模式。

实现的访问者模式。 函数元数据。

实现函数聚合的访问者模式。

实现的访问者模式。 聚合。

实现组聚合的访问者模式。

实现的访问者模式。 聚合。

实现组表达式绑定的访问者模式。

实现的访问者模式。 绑定。

实现 Lambda 函数的访问者模式。

实现的访问者模式。 Lambda 函数。

实现排序子句的访问者模式。

实现的访问者模式。 排序子句。

实现排序顺序的访问者模式。

实现的访问者模式。 排序顺序。

实现类型的访问者模式。

实现的访问者模式。 类型。

实现类型用法的访问者模式。

实现的访问者模式。 类型。

提供一个用于构造 的 API，并且允许该 API 作为针对表达式类型本身的扩展方法来访问。

创建一个新的 。

具有对给定函数和参数的引用的一个新的函数聚合。该函数聚合的 Distinct 属性将具有值 false。 定义聚合运算的函数。 要对其计算聚合函数的参数。 或 为 null。 不是聚合函数，或者具有多个实参；或者 的结果类型不相等或不能提升为 的形参类型。

创建以不同风格应用的一个新的 。

具有对给定函数和参数的引用的一个新的函数聚合。该函数聚合的 Distinct 属性将具有值 true。 定义聚合运算的函数。 要对其计算聚合函数的参数。 或 为 null。 不是聚合函数，或者具有多个实参；或者 的结果类型不相等或不能提升为 的形参类型。

创建一个新的 ，它确定给定的谓词是否适用于输入集的所有元素。

表示 All 运算的一个新的 DbQuantifierExpression。 一个指定输入集的表达式。 一个方法，它表示要为输入集的每个成员计算的谓词。此方法必须生成一个表达式，该表达式具有提供谓词逻辑的 Boolean 结果类型。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有布尔结果类型。

创建一个新的 ，它确定给定的谓词是否适用于输入集的所有元素。

表示 All 运算的一个新的 DbQuantifierExpression。 一个指定输入集的表达式绑定。 一个表达式，它表示要针对输入集的每个成员计算的谓词。 或 为 null。 生成的表达式不具有布尔结果类型。

创建一个 ，它对左边参数和右边参数执行逻辑与运算。

具有指定参数的新 DbAndExpression。 指定左边参数的布尔表达式。 指定右边参数的布尔表达式。 或 为 null。 或 不具有布尔结果类型。

创建一个新的 ，它确定指定的集参数是否非空。

一个新的 ，它使用指定的参数应用于新的 。 一个指定输入集的表达式 为 null。 没有集合结果类型。

创建一个新的 ，它确定给定的谓词是否适用于输入集的任何元素。

表示 Any 运算的一个新的 DbQuantifierExpression。 一个指定输入集的表达式。 一个方法，它表示要为输入集的每个成员计算的谓词。此方法必须生成一个表达式，该表达式具有提供谓词逻辑的 Boolean 结果类型。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有布尔结果类型。

创建一个新的 ，它确定给定的谓词是否适用于输入集的任何元素。

表示 Any 运算的一个新的 DbQuantifierExpression。 一个指定输入集的表达式绑定。 一个表达式，它表示要针对输入集的每个成员计算的谓词。 或 为 null。 不具有布尔结果类型。

以键/值对对象的形式返回指定参数。

键/值对对象。 键/值对中的值。 键/值对中的键。

以键/值对对象的形式返回指定参数。

键/值对对象。 键/值对中的值。 键/值对中的键。

创建一个新的 ，它使用生成的变量名称绑定给定的表达式。

具有指定的表达式和生成的变量名称的一个新的表达式绑定。 要绑定的表达式。 为 null。 没有集合结果类型。

创建一个新的 ，它使用指定的变量名称绑定给定的表达式。

具有指定的表达式和变量名称的一个新的表达式绑定 要绑定的表达式 应该用于绑定的变量名称 或 为 null。 没有集合结果类型。

创建一个新的 。

具有指定事例和默认结果的一个新的 DbCaseExpression。 为每个事例提供条件的表达式的列表。 提供每个事例的结果的表达式列表。 定义没有匹配事例时的结果的表达式。 或 为 null 或包含 null，或者 为 null。 或 为空，或者 包含带有非布尔结果类型的表达式，或者没有适用于 和 中所有表达式的通用结果类型。

创建一个新的 ，它将强制转换运算应用于一个多态参数。

具有指定的参数和目标类型的一个新的 DbCastExpression。 应对其应用强制转换的参数。 指定要强制转换为的类型的类型元数据。 或 为 null。 指定的强制转换无效。

使用给定的常量值创建一个具有指定基元类型的新的 。

具有给定值和 结果类型的一个新的 DbConstantExpression。 常量值的类型。 要表示的常量值。 valueconstantType 不是有效常量类型的实例， 不表示基元类型，或者 所属的基元类型与 表示的基元类型不同。

使用给定的常量值创建一个新的 。

具有给定值的一个新的 DbConstantExpression。 要表示的常量值。 为 null。 不是有效常量类型的实例。

创建一个新的 ，它对基于键值对特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 提供键值的 的集合。在数目、类型和顺序上，这些表达式必须匹配引用的实体类型的键属性。 为 null，或者 为 null 或包含 null。 的计数与 的元素类型声明的键成员的计数不符，或者 所包含表达式的结果类型与对应的键成员的类型不兼容。

创建一个新的 ，它对基于键值对特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 提供键值的 的集合。在数目、类型和顺序上，这些表达式必须匹配引用的实体类型的键属性。 为 null，或者 为 null 或包含 null。 的计数与 的元素类型声明的键成员的计数不符，或者 所包含表达式的结果类型与对应的键成员的类型不兼容。

创建一个新的 ，它对基于键值对给定类型的特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 引用的实体的特定类型。此实体类型必须与实体集的元素类型处于同一层次结构。 提供键值的 的集合。在数目、类型和顺序上，这些表达式必须匹配引用的实体类型的键属性。 或 为 null，或者 为 null 或包含 null。 不是来自 的元素类型所在的层次结构（子类型、超类型或相同类型）。 的计数与 的元素类型声明的键成员的计数不符，或者 所包含表达式的结果类型与对应的键成员的类型不兼容。

创建一个新的 ，它对基于键值对给定类型的特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 引用的实体的特定类型。此实体类型必须与实体集的元素类型处于同一层次结构。 提供键值的 的集合。在数目、类型和顺序上，这些表达式必须匹配引用的实体类型的键属性。 或 为 null，或者 为 null 或包含 null。 不是来自 的元素类型所在的类型层次结构（子类型、超类型或相同类型）。 的计数与 的元素类型声明的键成员的计数不符，或者 所包含表达式的结果类型与对应的键成员的类型不兼容。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。不包括 计算结果为空集的行。

具有指定的输入和应用绑定以及 CrossApply 的 的一个新的 DbApplyExpression。 指定输入集的 。 一个方法，它指定要对输入集的每个成员计算一次的逻辑。 或 为 null。 没有集合结果类型。 的结果包含为 Null 的名称或表达式。 的结果包含在表达式绑定中无效的名称或表达式。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。不包括 计算结果为空集的行。

具有指定的输入和应用绑定以及 CrossApply 的 的一个新的 DbApplyExpression。 指定输入集的 。 一个 ，它指定要对输入集的每个成员计算一次的逻辑。 或 为 null。

创建一个新的 ，它无条件联接输入表达式绑定列表指定的集。

具有 CrossJoin 的 的一个新的 DbCrossJoinExpression，它表示输入集的无条件联接。 指定输入集的表达式绑定列表。 为 null 或包含 null。 包含的表达式绑定数目少于 2。

创建一个新的 ，它根据给定的引用表达式检索特定实体。

检索指定实体的一个新 DbDerefExpression 一个提供引用的 。此表达式必须具有引用类型。 为 null 没有引用结果类型。

创建一个新的 ，它从给定的集参数中删除重复项。

一个新的 DbDistinctExpression，它表示应用于指定集参数的不同运算。 定义要对其执行不同运算的集的表达式。 为 null。 没有引用结果类型。

创建一个新的 ，它用左边参数除以右边参数。

表示除法运算的一个新的 DbArithmeticExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用数值结果类型。

创建一个新的 ，它将一个集转换为单一实例。

一个 DbElementExpression，它表示从集参数到单一实例的转换。 一个指定输入集的表达式。 为 null。 没有引用结果类型。

创建一个新的 ，它比较左边参数和右边参数是否相等。

表示相等比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用数值结果类型。

创建一个新的 ，它计算从左边集参数中减去右边集参数的结果。

一个新的 DbExceptExpression，它表示从左边参数中减去右边参数之差。 一个定义左边集参数的表达式。 一个定义右边集参数的表达式。 或 为 null。 与 之间不存在任何常用数值结果类型。

创建一个新的 ，它确定指定的集参数是否非空。

一个新的 ，它使用指定的参数应用于新的 。 一个指定输入集的表达式 为 null。 没有集合结果类型。

使用布尔值 false 创建一个 。

创建一个新的 ，它使用指定的谓词筛选给定输入集中的元素。

生成筛选的集的一个新的 DbFilterExpression。 一个指定输入集的表达式绑定。 一个表达式，它表示要针对输入集的每个成员计算的谓词。 或 为 null。 有布尔结果类型。

创建一个新的 ，它按照指定的联接条件联接左边表达式和右边表达式指定的集，并且使用 FullOuterJoin 作为 。

一个 为 FullOuterJoin 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的完全外部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个表示联接条件的方法。此方法必须生成一个具有布尔结果类型的表达式，该表达式提供联接条件的逻辑。 、 或 为 null。 或 没有集合结果类型。 由 生成的表达式为 null。 生成的表达式不具有布尔结果类型。

创建一个新的 ，它按照指定的联接条件联接左边表达式绑定和右边表达式绑定指定的集，并且使用 FullOuterJoin 作为 。

一个 为 FullOuterJoin 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的完全外部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个指定联接条件的表达式。 、 或 为 null。 有布尔结果类型。

创建一个新的 ，它以结构化形式检索指定实体的引用。

检索对指定实体的引用的一个新的 DbEntityRefExpression。 提供实体的表达式。此表达式必须具有实体结果类型。 为 null。 没有实体结果类型。

创建一个新的 ，它以结构化形式检索指定引用的键值。

检索指定引用的键值的一个新的 DbRefKeyExpression。 提供引用的表达式。此表达式的引用类型必须具有实体元素类型。 为 null。 没有实体结果类型。

创建一个新的 ，它确定左边参数是否大于右边参数。

表示大于比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它确定左边参数是否大于或等于右边参数。

表示大于或等于比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 left 或 right 为 null。 left 与 right 之间不存在任何常用的可进行顺序比较的结果类型。

对指定参数创建一个新的 。

一个新的组聚合，它表示按给定参数引用的组的元素。 要对其执行嵌套运算的参数 为 null。

创建一个新的组表达式绑定，该绑定使用生成的变量名称和组变量名称来绑定给定的表达式。

一个新的组表达式绑定，该绑定具有指定的表达式以及生成的变量名称和组变量名称。 要绑定的表达式。 为 null。 没有集合结果类型。

创建一个新的 ，它使用指定的变量名称和组变量名称来绑定给定的表达式。

具有指定的表达式、变量名称和组变量名称的一个新的组表达式绑定。 要绑定的表达式。 应该用于绑定的变量名称。 在分组表达式中使用新的组表达式绑定时应该用于引用该组的变量名称。 、 或 为 null。 没有集合结果类型。

创建一个新的 ，它根据指定的组键对输入集的元素进行分组并应用给定的聚合。

具有指定的输入集、分组键和聚合的一个新的 DbGroupByExpression。 指定输入集的 。 定义分组列的字符串表达式对的列表。 指定要应用的聚合的表达式列表。 、 或 为 null， 包含为 null 的键列名称或表达式，或者聚合包含为 null 的聚合列名称或 。 和 均为空，或指定了无效或重复的列名称。

创建一个 ，它将指定表达式的结果与指定列表中常量表达式的结果进行匹配。

如果 DbConstantExpression 列表非空，则为具有指定参数的一个新的 DbInExpression；否则为 false 常量表达式。 要匹配的 DbExpression。 要针对某一匹配进行测试的 DbConstantExpression 的列表。 或 为 null。 的结果类型与来自 的表达式的结果类型不同。

创建一个新的 ，它按照指定的联接条件联接左边表达式和右边表达式指定的集，并且使用 InnerJoin 作为 。

一个 InnerJoin 为 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的内部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个表示联接条件的方法。此方法必须生成一个具有布尔结果类型的表达式，该表达式提供联接条件的逻辑。 、 或 为 null。 或 没有集合结果类型。 由 生成的表达式为 null。 生成的表达式不具有布尔结果类型。

创建一个新的 ，它按照指定的联接条件联接左边表达式和右边表达式指定的集，并且使用 InnerJoin 作为 。

一个 InnerJoin 为 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的内部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个指定联接条件的表达式。 、 或 为 null。 有布尔结果类型。

创建一个新的 ，它计算左边集参数和右边集参数的交集。

一个新的 DbIntersectExpression，它表示左边参数和右边参数的交集。 一个定义左边集参数的表达式。 一个定义右边集参数的表达式。 或 right 为 。 与 之间不存在任何常用集合结果类型。

创建一个新的 ，它表示对给定参数应用指定的 Lambda 函数。

表示 Lambda 函数应用的一个新的 DbLambdaExpression。 一个 实例，它表示要应用的 Lambda 函数。 提供参数的表达式列表。 为 null，或者 为 null 或包含 null。 的计数与 声明的变量数目不相等，或者 所包含表达式的结果类型不等于或不可提升为对应的变量类型。

创建一个新的 ，它表示对给定参数应用指定的 Lambda 函数。

表示 Lambda 函数应用的一个新的 DbLambdaExpression。 一个 实例，它表示要应用的 Lambda 函数。 提供参数的表达式。 为 null，或者 为 null 或包含 null。 的计数与 声明的变量数目不相等，或者 所包含表达式的结果类型不等于或不可提升为对应的变量类型。

创建一个新的 ，它表示使用给定的参数调用指定的函数。

表示函数调用的一个新的 DbFunctionExpression。 要调用的函数的元数据。 为函数提供参数的表达式列表。 为 null，或者 为 null 或包含 null。 的计数与 声明的变量数目不相等，或者 所包含表达式的结果类型不等于或不可提升为对应的变量类型。

创建一个新的 ，它表示使用给定的参数调用指定的函数。

表示函数调用的一个新的 DbFunctionExpression。 要调用的函数的元数据。 为函数提供参数的表达式。 为 null，或者 为 null 或包含 null。 的计数与 声明的变量数目不相等，或者 所包含表达式的结果类型不等于或不可提升为对应的变量类型。

创建一个新的 ，它确定指定的集参数是否为空集。

具有指定参数的一个新的 DbIsEmptyExpression。 一个指定输入集的表达式。 为 null。 没有集合结果类型。

创建一个新的 ，它确定指定的参数是否为 null。

具有指定参数的一个新的 DbIsNullExpression。 指定参数的表达式。 为 null。 有一个集合结果类型。

创建一个新的 ，它确定给定的参数是否为指定的类型或子类型。

具有指定的实例和类型以及 DbExpressionKind IsOf 的一个新的 DbIsOfExpression。 指定实例的表达式。 类型元数据，它指定应与实例的结果类型进行比较的类型。 或 为 null。 与 的结果类型不处于相同的类型层次结构中。

创建一个新的 表达式，该表达式确定给定的参数是否属于指定的类型且只属于该类型（而非子类型）。

具有指定的实例和类型以及 DbExpressionKind IsOfOnly 的一个新的 DbIsOfExpression。 指定实例的表达式。 类型元数据，它指定应与实例的结果类型进行比较的类型。 或 为 null。 与 的结果类型不处于相同的类型层次结构中。

创建一个新的 ，它基于指定的外部键和内部键之间的相等条件联接外部表达式和内部表达式指定的集，并且使用 InnerJoin 作为 。

一个 InnerJoin 为 的新的 DbJoinExpression，它表示基于比较外部键值和内部键值是否相等的联接条件应用于左边输入集和右边输入集的内部联接运算。 指定外部集参数的 。 指定内部集参数的 。 一个方法，它指定如何从外部集的元素派生外部键值。 一个方法，它指定如何从内部集的元素派生内部键值。 、、 或 为 null。 或 没有集合结果类型。 由 或 生成的表达式为 null。 或 生成的表达式不能比较是否相等。

创建一个新的 ，它对外部和内部表达式指定的集投影指定的选择器，基于指定的外部键和内部键之间的相等条件进行联接，并且使用 InnerJoin 作为 。

一个新的 DbProjectExpression，它使用指定的选择器作为其投影并且使用一个新的 DbJoinExpression 作为其输入。输入 DbJoinExpression 是使用 InnerJoin 的 创建的，它表示基于比较外部键值和内部键值是否相等的联接条件应用于左边输入集和右边输入集的内部联接运算。 指定外部集参数的 。 指定内部集参数的 。 一个方法，它指定如何从外部集的元素派生外部键值。 一个方法，它指定如何从内部集的元素派生内部键值。 一个方法，它指定如何从内部和外部集的元素派生结果集的元素。此方法必须生成与 Join 兼容且可以解析为 的类型的实例。备注中说明了针对 的兼容性要求。 选择器的类型。 、、、 或 为 null。 或 没有集合结果类型。 由 或 生成的表达式为 null。 在转换为 DbExpression 之后 的结果为 null。 和 生成的表达式不能比较是否相等。 的结果与 SelectMany 不兼容。

使用指定的内联 Lambda 函数实现和形参创建 。

一个新的 DbLambda，它描述具有指定主体和形参的内联 Lambda 函数 一个定义 Lambda 函数的逻辑的表达式。 一个 集合，该集合表示 Lambda 函数的形参。这些变量可以有效地在 表达式中使用。 为 null 或包含 null，或者 为 null。 包含多个具有相同变量名称的元素。

使用指定的内联 Lambda 函数实现和形参创建 。

一个新的 DbLambda，它描述具有指定主体和形参的内联 Lambda 函数。 一个定义 Lambda 函数的逻辑的表达式 一个 集合，该集合表示 Lambda 函数的形参。这些变量可以有效地在 body 表达式中使用。 为 null 或包含 null，或者 为 null。 包含多个具有相同变量名称的元素。

创建一个新的 ，它按照指定的联接条件联接左边表达式和右边表达式指定的集，并且使用 LeftOuterJoin 作为 。

一个 为 LeftOuterJoin 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的左外部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个表示联接条件的方法。此方法必须生成一个具有布尔结果类型的表达式，该表达式提供联接条件的逻辑。 、 或 为 null。 或 没有集合结果类型。 由 生成的表达式为 null。 生成的表达式不具有布尔结果类型。

创建一个新的 ，它按照指定的联接条件联接左边表达式绑定和右边表达式绑定指定的集，并且使用 LeftOuterJoin 作为 。

一个 为 LeftOuterJoin 的新的 DbJoinExpression，它表示基于给定联接条件应用于左边输入集和右边输入集的左外部联接运算。 一个指定左边集参数的 。 一个指定右边集参数的 。 一个指定联接条件的表达式。 、 或 为 null。 有布尔结果类型。

创建一个新的 ，它确定左边参数是否小于右边参数。

表示小于比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它确定左边参数是否小于或等于右边参数。

表示小于或等于比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它将指定的输入字符串与给定的模式进行比较。

具有指定输入、模式和 null 转义的一个新的 DbLikeExpression。 指定输入字符串的表达式。 指定模式字符串的表达式。 或 为 null。 或 不具有字符串结果类型。

创建一个新的 ，它使用可选转义符将指定的输入字符串与给定的模式进行比较。

具有指定的输入、模式和转义符的一个新的 DbLikeExpression。 指定输入字符串的表达式。 指定模式字符串的表达式。 指定转义字符串的可选表达式。 、 或转义符为 。 、 或转义符不具有字符串结果类型。

创建一个新的 ，它将参数集合中的元素数目限制为指定的计数限值。输出中不包括等值结果。

一个新的 DbLimitExpression，它具有指定参数以及不包括等值结果的计数限值。 一个指定输入集合的表达式。 指定限值的表达式。 或 为 null。 不具有集合结果类型，或者 不具有等同于或可提升为 64 位整数类型的结果类型。

创建一个新的 ，它从左边参数中减去右边参数。

表示减法运算的一个新的 DbArithmeticExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它计算左边参数除以右边参数所得的余数。

表示取模运算的一个新的 DbArithmeticExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它用左边参数乘以右边参数。

表示乘法运算的一个新的 DbArithmeticExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行顺序比较的结果类型。

创建一个新的 ，它表示组合或关联的导航。

一个新的 DbRelationshipNavigationExpression，它表示从指定的导航源实例的指定关系类型的指定源和目标关系端的导航。 一个表达式，它指定应作为导航起点的实例。 属性的元数据，表示作为导航的源的关系端。 属性的元数据，表示作为导航的目标的关系端。 、 或 为 null。 和 不是由相同关系类型声明的，或者 的结果类型与 的属性类型不兼容。

创建一个新的 ，它表示组合或关联的导航。

一个新的 DbRelationshipNavigationExpression，它表示从指定的导航源实例的指定关系类型的指定源和目标关系端的导航。 表示关系的关系类型的元数据。 关系类型的属性名称，它表示作为导航的源的关系端。 关系类型的属性名称，它表示作为导航的目标的关系端。 一个表达式，它指定应作为导航起点的实例。 、 或 为 null。 与此命令目录树的元数据工作区不关联，或者 与其他命令目录树相关联，或者 未声明具有 或 名称的关系端属性，或者 具有与 不兼容的结果类型。

创建一个新的 ，它对参数值求反。

表示求反运算的一个新的 DbArithmeticExpression。 指定参数的表达式。 为 null。 不存在针对 的任何数值结果类型。

创建一个新的 。如果类型参数为集合类型，则参数将指定集合的元素。否则，参数将用作新实例中的属性值或列值。

具有指定的类型和参数的一个新的 DbNewInstanceExpression。 新实例的类型。 指定新实例的值的表达式，根据实例的类型对其进行解释。 或 为 null，或者 包含 null。 为空，或者包含的表达式的结果类型与 的要求不匹配（在备注部分中进行了说明）。

创建一个新的 。如果类型参数为集合类型，则参数将指定集合的元素。否则，参数将用作新实例中的属性值或列值。

具有指定的类型和参数的一个新的 DbNewInstanceExpression。 新实例的类型。 指定新实例的值的表达式，根据实例的类型对其进行解释。 instanceTypeargumentsarguments 或 为 null，或者 包含 null。

创建一个新的 ，它构造一个包含指定元素的集合。集合的类型基于元素的通用类型。如果不存在通用元素类型，将引发异常。

具有指定的集合类型和参数的一个新的 DbNewInstanceExpression。 提供集合元素的表达式列表 为 null 或包含 null。 为空，或包含不存在通用结果类型的表达式。

创建一个新的 ，它构造一个包含指定元素的集合。集合的类型基于元素的通用类型。如果不存在通用元素类型，将引发异常。

具有指定的集合类型和参数的一个新的 DbNewInstanceExpression。 提供集合元素的表达式列表 为 null 或包含 null。 为空，或包含不存在通用结果类型的表达式。

创建一个新的 ，它构造指定集合类型的空集合。

具有指定的集合类型和空 Arguments 列表的一个新的 DbNewInstanceExpression。 要创建的集合的类型元数据 为 null。 不是集合类型。

创建一个新的 ，它生成具有指定的命名列和给定值并且指定为表达式的一行。

表示行的构造的一个新的 DbNewInstanceExpression。 定义行的结构和值的字符串-DbExpression 键/值对的列表。 为 null，或者包含具有 null 列名或表达式的元素。 为空，或包含重复的或无效的列名称。

创建一个 ，它对给定的参数执行逻辑求反运算。

使用指定参数的一个新的 DbNotExpression。 一个指定参数的布尔表达式。 为 null。 参数不具有布尔结果类型。

创建一个新的 ，它比较左边参数和右边参数是否不相等。

表示不相等比较的一个新的 DbComparisonExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 与 之间不存在任何常用的可进行相等比较的结果类型。

创建一个新的 ，它表示类型化的 null 值。

DbNullExpression 的实例。 null 值的类型。 为 null。

创建一个新的 ，它生成一个集，该集由属于指定类型的给定输入集的元素构成。

具有指定的集参数和类型以及 为 ExpressionKind 的一个新的 DbOfTypeExpression。 指定输入集的 。 要使输入集的元素包括在结果集中，这些元素必须具有的类型的类型元数据。 或 为 null。 不具有集合结果 ，或者类型所处于的类型层次结构与 的集合结果类型的元素类型不同。

创建一个新的 ，它生成一个集，该集由恰好属于指定类型的给定输入集的元素构成。

具有指定的集参数和类型以及 为 ExpressionKind 的一个新的 DbOfTypeExpression。 指定输入集的 。 要使输入集的元素包括在结果集中，这些元素必须严格匹配的类型的类型元数据。 或 为 null。 不具有集合结果 ，或者类型所处于的类型层次结构与 的集合结果类型的元素类型不同。

创建一个 ，它对左边参数和右边参数执行逻辑或运算。

具有指定参数的一个新的 DbOrExpression。 指定左边参数的布尔表达式。 指定右边参数的布尔表达式。 leftright leftright

创建一个新的 ，它使用升序排序顺序和默认排序规则按照指定的排序键对给定的输入集进行排序。

表示排序依据运算的一个新的 DbSortExpression。 一个指定输入集的表达式。 一个方法，该方法指定在给定输入集的成员时如何派生排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的结果类型。

创建一个新的 ，它使用升序排序顺序和指定排序规则按照指定的排序键对给定的输入集进行排序。

表示排序依据运算的一个新的 DbSortExpression。 一个指定输入集的表达式。 一个方法，该方法指定在给定输入集的成员时如何派生排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 排序所依据的排序规则 、 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的字符串结果类型。 为空，或者只包含空白字符。

创建一个新的 ，它使用降序排序顺序和默认排序规则按照指定的排序键对给定的输入集进行排序。

表示排序依据运算的一个新的 DbSortExpression。 一个指定输入集的表达式。 一个方法，该方法指定在给定输入集的成员时如何派生排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的字符串结果类型。

创建一个新的 ，它使用降序排序顺序和默认排序规则按照指定的排序键对给定的输入集进行排序。

表示排序依据运算的一个新的 DbSortExpression。 一个指定输入集的表达式。 一个方法，该方法指定在给定输入集的成员时如何派生排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 排序所依据的排序规则 、 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的字符串结果类型。 为空，或者只包含空白字符。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。其 计算结果为空集的行具有值为 null 的 apply 列值。

具有指定的输入和应用绑定且 OuterApply 为 的一个新的 DbApplyExpression。 指定输入集的 。 一个方法，它指定要对输入集的每个成员计算一次的逻辑。 或 为 null。 没有集合结果类型。 apply 的结果包含为 null 的名称或表达式。 apply 的结果包含在表达式绑定中无效的名称或表达式。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。其 计算结果为空集的行具有值为 null 的 apply 列值。

具有指定的输入和应用绑定且 OuterApply 为 的一个新的 DbApplyExpression。 指定输入集的 。 一个 ，它指定要对输入集的每个成员计算一次的逻辑。 或 为 null。

创建一个新的 ，它使用指定的名称和类型引用参数。

表示对具有指定名称和类型的参数的引用的 DbParameterReferenceExpression；表达式的结果类型将与 相同。 引用的参数的类型 引用的参数的名称

创建一个新的 ，它将左边参数与右边参数相加。

表示加法运算的一个新的 DbArithmeticExpression。 一个指定左边参数的表达式。 一个指定右边参数的表达式。 或 为 null。 left 与 right 之间不存在任何常用数值结果类型。

创建一个新的 ，它对给定的输入集投影指定的表达式。

表示投影运算的一个新的 DbProjectExpression。 一个指定输入集的表达式绑定。 要对集投影的表达式。 或 为 null。

创建一个新的 ，它表示对指定属性的检索。

表示属性检索的一个新的 DbPropertyExpression。 要从中检索属性的实例。如果该属性是静态的，则可能为 null。 要检索的属性的元数据。 为 null，或者 为 null 并且属性不是静态的。

创建一个新的 ，它表示对指定导航属性的检索。

表示导航属性检索的一个新的 DbPropertyExpression。 要从中检索导航属性的实例。 要检索的导航属性的元数据。 为 null 或 为 null。

创建一个新的 ，它表示对指定关系端成员的检索。

表示关系端成员检索的一个新的 DbPropertyExpression。 要从中检索关系端成员的实例。 要检索的关系端成员的元数据。 为 null，或者 为 null 并且属性不是静态的。

创建一个新的 ，它表示从给定实例中检索具有指定名称的实例属性。

表示属性检索的一个新的 DbPropertyExpression 要从中检索属性的实例。 要检索的属性的名称。 为 null，或者 为 null 并且属性不是静态的。 没有具有指定名称的属性是由 类型声明的。

创建一个新的 ，它对基于键值对特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 一个 ，它使用与引用的实体类型的 Key 属性在数目、类型和顺序上相匹配的列构造一个记录。 或 为 null。 keyRow

创建一个新的 ，它对基于键值对特定实体的引用进行编码。

一个新的 DbRefExpression，它引用在给定实体集中具有指定键值的元素。 引用的元素所在的实体集。 一个 ，它使用与引用的实体类型的 Key 属性在数目、类型和顺序上相匹配的列构造一个记录。 引用应针对的实体的类型。 、 或 为 null。 与实体集的实体类型不处于相同的类型层次结构，或者 不具有与引用的实体集的实体类型的键属性匹配的记录结果类型。

创建一个新的 ，它引用指定的实体集或关系集。

基于指定的实体或关系集的一个新的 DbScanExpression。 要引用的实体或关系集的元数据。 为 null。

创建一个新的 ，它对给定的输入集选择指定的表达式。

表示选择运算的一个新的 DbProjectExpression。 一个指定输入集的表达式。 一个方法，该方法指定在给定输入集的成员时如何派生投影的表达式。此方法必须生成与 Select 兼容且可以解析为 的类型的实例。备注中说明了针对 的兼容性要求。 的方法结果类型。 或 为 null 的结果为 null。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。不包括 计算结果为空集的行。然后创建了 ，它对每一行选择指定的 ，并且生成结果的整个集合。

一个新的 DbProjectExpression，它从具有指定输入和应用绑定且 CrossApply 为 的一个新的 DbApplyExpression 中选择 apply 列。 指定输入集的 。 一个方法，它表示要对输入集的每个成员计算一次的逻辑。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有集合类型。

创建一个新的 ，它为给定输入集的每个元素计算一次给定的 表达式，并生成具有相应 input 和 apply 列的行集合。不包括 计算结果为空集的行。然后创建了 ，它对每一行选择指定的 ，并且生成结果的整个集合。

一个新的 DbProjectExpression，它从具有指定输入和应用绑定且 CrossApply 为 的一个新的 DbApplyExpression 中选择给定选择器的结果。 指定输入集的 。 一个方法，它表示要对输入集的每个成员计算一次的逻辑。 一个方法，它指定如何在给定输入集和应用集的元素的情况下派生结果集的元素。此方法必须生成与 SelectMany 兼容且可以解析为 的类型的实例。备注中说明了针对 的兼容性要求。 的方法结果类型。 、 或 为 null。 由 生成的表达式为 null。 在转换为 DbExpression 时 的结果为 null。 没有集合结果类型。 生成的表达式不具有集合类型。

创建一个新的 ，它在跳过指定数目的元素之前，按照指定的排序规范对给定的输入集进行排序。

表示跳过操作的一个新的 DbSkipExpression。 一个指定输入集的表达式绑定。 确定应如何对输入集元素进行排序的排序规范列表。 一个表达式，它指定要在有序集中跳过的元素数目。 、 或 为 null，或者 包含 null。 为空，或者 不是 或 ，或者具有不等同于或不能提升为 64 位整数类型的结果类型。

创建一个新的 ，它从给定的有序输入集中跳过指定数目的元素。

表示跳过操作的一个新的 DbSkipExpression。 指定有序输入集的 。 一个表达式，它指定要在有序集中跳过的元素数目。 或 为 null。 不是 或 ，或者具有不等同于或不能提升为 64 位整数类型的结果类型。

创建一个新的 ，它按照指定的排序规范对给定的输入集进行排序。

表示排序运算的一个新的 DbSortExpression。 一个指定输入集的表达式绑定。 确定应如何对输入集元素进行排序的排序规范列表。 或 为 null，或者 包含 null。 为空。

创建一个新的 ，它将参数集合中的元素数目限制为指定的计数限值。输出中不包括等值结果。

一个新的 DbLimitExpression，它具有指定参数以及不包括等值结果的计数限值。 一个指定输入集合的表达式。 指定限值的表达式。 或 为 null。 不具有集合结果类型，或者 不具有等同于或可提升为 64 位整数类型的结果类型。

创建具有排序顺序的一个新的 ，它包括给定顺序输入集的排序顺序以及按升序排序顺序的指定排序键和默认排序规则。

表示新的整体的排序依据运算的一个新的 DbSortExpression。 指定有序输入集的 DbSortExpression。 一个方法，该方法指定在给定输入集的成员时如何派生附加排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的结果类型。

创建具有排序顺序的一个新的 ，它包括给定顺序输入集的排序顺序以及按升序排序顺序的指定排序键和指定的排序规则。

表示新的整体的排序依据运算的一个新的 DbSortExpression。 指定有序输入集的 DbSortExpression。 一个方法，该方法指定在给定输入集的成员时如何派生附加排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 排序所依据的排序规则 、 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的字符串结果类型。 为空，或者只包含空白字符。

创建具有排序顺序的一个新的 ，它包括给定顺序输入集的排序顺序以及按降序排序顺序的指定排序键和默认排序规则。

表示新的整体的排序依据运算的一个新的 DbSortExpression。 指定有序输入集的 DbSortExpression。 一个方法，该方法指定在给定输入集的成员时如何派生附加排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的结果类型。

创建具有排序顺序的一个新的 ，它包括给定顺序输入集的排序顺序以及按降序排序顺序的指定排序键和指定的排序规则。

表示新的整体的排序依据运算的一个新的 DbSortExpression。 指定有序输入集的 DbSortExpression。 一个方法，该方法指定在给定输入集的成员时如何派生附加排序键表达式。此方法必须生成一个具有可比较顺序的结果类型（该类型提供排序键定义）的表达式。 排序所依据的排序规则 、 或 为 null。 由 生成的表达式为 null。 没有集合结果类型。 生成的表达式不具有可比较顺序的字符串结果类型。 为空，或者只包含空白字符。

使用升序排序顺序和默认排序规则创建一个新的 。

使用给定的排序关键字和升序排序顺序的一个新的排序子句。 定义排序键的表达式 为 null。 不具有可比较顺序的结果类型。

使用升序排序顺序和指定的排序规则创建一个新的 。

具有给定的排序键和排序规则以及升序排序顺序的一个新的排序子句 定义排序键的表达式 排序所依据的排序规则 为 null。 为空，或者只包含空白字符。 不具有可比较顺序的结果类型。

使用降序排序顺序和默认排序规则创建一个新的

使用给定的排序关键字和降序排序顺序的一个新的排序子句 定义排序键的表达式 为 null。 不具有可比较顺序的结果类型。

使用降序排序顺序和指定的排序规则创建一个新的 。

具有给定的排序键和排序规则以及降序排序顺序的一个新的排序子句 定义排序键的表达式 排序所依据的排序规则 为 null。 为空，或者只包含空白字符。 不具有可比较顺序的结果类型。

创建一个新的 。

具有指定的参数和类型的一个新的 DbTreatExpression。 指定实例的表达式。 treat-as 类型的类型元数据。 或 为 null。 与 的结果类型不处于相同的类型层次结构中。

使用布尔值 true 创建一个 。

创建一个新的 ，它对参数值求反。

表示求反运算的一个新的 DbArithmeticExpression。 指定参数的表达式。 为 null。 不存在针对 的任何数值结果类型。

创建一个新的 ，它计算左边集参数和右边集参数的并集并且删除了重复项。

一个新的 DbExpression，它计算左边参数和右边参数的并集，并且不含重复项。 一个定义左边集参数的表达式。 一个定义右边集参数的表达式。 或 为 null。 和 之间不存在具有可进行相等比较的元素类型的任何常用集合结果类型。

创建一个新的 ，它计算左边集参数和右边集参数的并集且不删除重复项。

一个新的 DbUnionAllExpression，它是左边参数和右边参数的并集并且包括重复项。 一个定义左边集参数的表达式。 一个定义右边集参数的表达式。 或 为 null。 与 之间不存在任何常用集合结果类型。

创建一个新的 ，它使用指定的名称和类型引用变量。

一个 DbVariableReferenceExpression，它表示对具有指定名称和类型的变量的引用；表达式的结果类型将与 相同。 引用的变量的类型 引用的变量的名称

创建一个新的 ，它使用指定的谓词筛选给定输入集中的元素。

表示 Any 运算的一个新的 DbQuantifierExpression。 一个指定输入集的表达式。 一个方法，它表示要为输入集的每个成员计算的谓词。此方法必须生成一个表达式，该表达式具有提供谓词逻辑的 Boolean 结果类型。 或 为 null。 由 生成的表达式为 null。 生成的表达式不具有布尔结果类型。

提供一个用于构造调用规范 EDM 函数的 的 API，并且允许该 API 作为针对表达式类型本身的扩展方法来访问。

创建一个 ，它使用指定的参数（每个参数都必须具有数值结果类型）调用规范“Abs”函数。表达式的结果类型与 的结果类型相同。

返回 的绝对值的一个新的 DbFunctionExpression。 一个指定数值的表达式。 为 null。 没有规范“Abs”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime 或 DateTimeOffset 以及整数结果类型）调用规范“AddDays”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的天数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的天数。 或 为 null。 没有规范“AddDays”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddHours”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的小时数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的小时数。 或 为 null。 没有规范“AddHours”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddMicroseconds”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的微秒数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的微秒数。 或 为 null。 没有规范“AddMicroseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddMilliseconds”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的毫秒数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的毫秒数。 或 为 null。 没有规范“AddMilliseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddMinutes”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的分钟数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的分钟数。 或 为 null。 没有规范“AddMinutes”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime 或 DateTimeOffset 以及整数结果类型）调用规范“AddMonths”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的月份数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的月份数。 或 为 null。 没有规范“AddMonths”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddNanoseconds”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的纳秒数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的纳秒数。 或 为 null。 没有规范“AddNanoseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime、DateTimeOffset 或 Time 以及整数结果类型）调用规范“AddSeconds”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的秒数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的秒数。 或 为 null。 没有规范“AddSeconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有 DateTime 或 DateTimeOffset 以及整数结果类型）调用规范“AddYears”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将按 指定的年份数加到按 指定的值。 一个表达式，它指定应与 相加的值。 一个表达式，它指定要加到 中的年份数。 或 为 null。 没有规范“AddYears”函数的重载接受结果类型为 和 的参数。

创建一个 ，它对指定的集合调用规范“Avg”函数。表达式的结果类型与集合的元素类型相同。

生成平均值的新的 DbFunctionExpression。 一个表达式，它指定应计算平均值的集合。 为 null。 没有规范“Avg”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有相同的整数结果类型）调用规范“BitwiseAnd”函数。表达式的结果类型为此同一类型。

一个新的 DbFunctionExpression，它返回通过对 和 执行按位与运算生成的值。 指定第一个操作数的表达式。 指定第二个操作数的表达式。 或 为 null。 没有规范“BitwiseAnd”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（该参数必须具有整数结果类型）调用规范“BitwiseNot”函数。表达式的结果类型为此同一类型。

一个新的 DbFunctionExpression，它返回通过对 执行按位取非运算生成的值。 指定第一个操作数的表达式。 为 null。 没有规范“BitwiseNot”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有相同的整数结果类型）调用规范“BitwiseOr”函数。表达式的结果类型为此同一类型。

一个新的 DbFunctionExpression，它返回通过对 和 执行按位或运算生成的值。 指定第一个操作数的表达式。 指定第二个操作数的表达式。 或 为 null。 没有规范“BitwiseOr”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有相同的整数结果类型）调用规范“BitwiseXor”函数。表达式的结果类型为此同一类型。

一个新的 DbFunctionExpression，它返回通过对 和 执行按位异或（异或）运算生成的值。 指定第一个操作数的表达式。 指定第二个操作数的表达式。 或 为 null。 没有规范“BitwiseXor”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有单精度、双精度或十进制结果类型）调用规范“Ceiling”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它返回不小于 的最小整数值。 一个指定数值的表达式。 为 null。 没有规范“Ceiling”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“Concat”函数。表达式的结果类型为字符串。

一个生成串联字符串的新的 DbFunctionExpression。 一个表达式，它指定在串连结果字符串中应在最前面出现的字符串。 一个表达式，它指定在串连结果字符串中应在第二位出现的字符串。 或 为 null。 没有规范“Concat”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“Contains”函数。表达式的结果类型为 Boolean。

一个新的 DbFunctionExpression，它返回指示 是否在 之内出现的布尔值。 一个表达式，它指定要从中搜索出现的任何 的字符串。 一个表达式，它指定要在 中搜索的字符串。 或 为 null。 没有规范“Contains”函数的重载接受结果类型为 和 的参数。

创建一个 ，它对指定的集合调用规范“Count”函数。表达式的结果类型为 Edm.Int32。

生成计数值的新的 DbFunctionExpression。 一个表达式，它指定应对其计算计数值的集合。 为 null。 没有规范“Count”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数调用规范“CreateDateTime”函数。 必须具有结果类型 Edm.Double，所有其他参数必须具有结果类型 Edm.Int32。表达式的结果类型为 Edm.DateTime。

一个新 DbFunctionExpression，它基于指定的值返回新的 DateTime。 一个表达式，它为新的 DateTime 实例提供年份值。 一个表达式，它为新的 DateTime 实例提供月份值。 一个表达式，它为新的 DateTime 实例提供日期值。 一个表达式，它为新的 DateTime 实例提供小时值。 一个表达式，它为新的 DateTime 实例提供分钟值。 一个表达式，它为新的 DateTime 实例提供秒钟值。 、、、、、 为 null。 没有规范“CreateDateTime”函数的重载接受结果类型为 、、、、 和 的参数。

创建一个 ，它使用指定的参数调用规范“CreateDateTimeOffset”函数。 必须具有结果类型 Edm.Double，所有其他参数必须具有结果类型 Edm.Int32。表达式的结果类型为 Edm.DateTimeOffset。

一个新 DbFunctionExpression，它基于指定的值返回新的 DateTimeOffset。 一个表达式，它为新的 DateTimeOffset 实例提供年份值。 一个表达式，它为新的 DateTimeOffset 实例提供月份值。 一个表达式，它为新的 DateTimeOffset 实例提供日期值。 一个表达式，它为新的 DateTimeOffset 实例提供小时值。 一个表达式，它为新的 DateTimeOffset 实例提供分钟值。 一个表达式，它为新的 DateTimeOffset 实例提供秒钟值。 一个表达式，它为新的 DateTimeOffset 实例按时区偏移量值提供分钟数。 、、、、、 或 为 null。 没有规范“CreateDateTimeOffset”函数的重载接受结果类型为 、、、、、 和 的参数。

创建一个 ，它使用指定的参数调用规范“CreateTime”函数。 必须具有结果类型 Edm.Double，所有其他参数必须具有结果类型 Edm.Int32。表达式的结果类型为 Edm.Time。

一个新 DbFunctionExpression，它基于指定的值返回新的时间。 一个表达式，它为新的 DateTime 实例提供小时值。 一个表达式，它为新的 DateTime 实例提供分钟值。 一个表达式，它为新的 DateTime 实例提供秒钟值。 、 或 为 null。 没有规范“CreateTime”函数的重载接受结果类型为 、 和 的参数。

创建一个 ，它调用规范“CurrentDateTime”函数。

一个新的 DbFunctionExpression，它将当前日期和时间作为 Edm.DateTime 实例返回。

创建一个 ，它调用规范“CurrentDateTimeOffset”函数。

一个新的 DbFunctionExpression，它将当前日期和时间作为 Edm.DateTimeOffset 实例返回。

创建一个 ，它调用规范“CurrentUtcDateTime”函数。

一个新的 DbFunctionExpression，它将当前 UTC 日期和时间作为 Edm.DateTime 实例返回。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“Day”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数日期值。 一个表达式，它指定应从中检索日期的值。 为 null。 没有规范“Day”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“DayOfYear”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回年份值的整数日期。 一个表达式，它指定应从中检索日期（以一年中的第几天表示）的值。 为 null。 没有规范“DayOfYear”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“DiffDays”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的天数差。 一个表达式，它指定第一个 DateTime 或 DateTimeOffset 值。 一个表达式，它指定应为其计算距离 的天数差的 DateTime 或 DateTimeOffset。 或 为 null。 没有规范“DiffDays”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffHours”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的小时差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的小时差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffHours”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffMicroseconds”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的微秒差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的微秒差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffMicroseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffMilliseconds”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的毫秒差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的毫秒差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffMilliseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffMinutes”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的分钟差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的分钟差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffMinutes”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“DiffMonths”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的月份差。 一个表达式，它指定第一个 DateTime 或 DateTimeOffset 值。 一个表达式，它指定应为其计算距离 的月份差的 DateTime 或 DateTimeOffset。 或 为 null 没有规范“DiffMonths”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffNanoseconds”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的纳秒差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的纳秒差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffNanoseconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“DiffSeconds”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的秒钟差。 一个表达式，它指定第一个 DateTime、DateTimeOffset 或 Time 值。 一个表达式，它指定应为其计算距离 的秒钟差的 DateTime、DateTimeOffset 或 Time。 或 为 null。 没有规范“DiffSeconds”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“DiffYears”函数。 的结果类型必须与 的结果类型匹配。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 和 之间的年份差。 一个表达式，它指定第一个 DateTime 或 DateTimeOffset 值。 一个表达式，它指定应为其计算距离 的年份差的 DateTime 或 DateTimeOffset。 或 为 null。 没有规范“DiffYears”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“EndsWith”函数。表达式的结果类型为 Boolean。

一个新的 DbFunctionExpression，它指示 是否以 结尾。 一个表达式，指定要在其中查找指定的 的字符串。 一个表达式，指定应在 中查找的后缀。 或 为 null。 没有规范“EndsWith”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有单精度、双精度或十进制结果类型）调用规范“Floor”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它返回不大于 的最大整数值。 一个指定数值的表达式。 为 null。 没有规范“Floor”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTimeOffset 结果类型）调用规范“GetTotalOffsetMinutes”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 相对于 GMT 的偏移分钟数。 一个表达式，它指定应从中检索相对于 GMT 的偏移分钟数的 DateTimeOffset 值。 为 null。 没有规范“GetTotalOffsetMinutes”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“Hour”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数小时值。 一个表达式，它指定应从中检索小时的值。 为 null。 没有规范“Hours”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“IndexOf”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 中 的第一个索引。 一个表达式，它指定要在 中搜索的字符串。 一个表达式，它指定应检查的位于 内的字符串。 或 为 null。 没有规范“IndexOf”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串和整数结果类型）调用规范“Left”函数。表达式的结果类型为字符串。

一个新的 DbFunctionExpression，它从 中返回长度为 的最左侧子字符串。 一个表达式，它指定要从中提取最左侧子字符串的字符串。 一个表达式，它指定要从 中提取的最左侧子字符串的长度。 或 为 null。 没有规范“Left”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“Length”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回 的长度。 一个表达式，它指定应计算其长度的字符串。 为 null。 没有规范“Length”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定的集合调用规范“BigCount”函数。表达式的结果类型为 Edm.Int64。

生成计数值的新的 DbFunctionExpression。 一个表达式，它指定应对其计算计数值的集合。 为 null。 没有规范“BigCount”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定的集合调用规范“Max”函数。表达式的结果类型与集合的元素类型相同。

生成最大值的新的 DbFunctionExpression。 一个表达式，它指定应从中检索最大值的集合。 为 null。 没有规范“Max”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“Millisecond”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 中返回整数毫秒值。 一个表达式，它指定应从中检索毫秒的值。 为 null。 没有规范“Millisecond”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定的集合调用规范“Min”函数。表达式的结果类型与集合的元素类型相同。

生成最小值的新的 DbFunctionExpression。 一个表达式，它指定应从中检索最小值的集合。 为 null。 没有规范“Min”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“Minute”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数分钟值。 一个表达式，它指定应从中检索分钟的值。 为 null。 没有规范“Minute”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“Month”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数月份值。 一个表达式，它指定应从中检索月份的值。 为 null。 没有规范“Month”函数的重载接受结果类型为 的参数。

创建一个 ，它调用规范“NewGuid”函数。

返回新的 GUID 值的新的 DbFunctionExpression。

创建一个 ，它使用指定的参数（每个参数都必须具有数值结果类型）调用规范“Power”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它返回按 指定的幂次执行幂运算的 的值。 一个表达式，它指定要计算给定幂次的数值。 一个表达式，它指定应对 进行幂运算的幂值。 或 为 null。 没有规范“Power”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“Replace”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它基于 返回一个新字符串，其中，出现的每个 都会被 替代。 一个表达式，它指定要在其中执行替代操作的字符串。 指定要替代的字符串的表达式。 指定替代字符串的表达式。 、 或 为 null。 没有规范“Replace”函数的重载接受结果类型为 、 和 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“Reverse”函数。表达式的结果类型也为字符串。

一个 DbFunctionExpression，它生成 的颠倒顺序的值。 指定要颠倒顺序的字符串的表达式。 为 null。 没有规范“Reverse”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串和整数结果类型）调用规范“Right”函数。表达式的结果类型为字符串。

一个新的 DbFunctionExpression，它从 中返回长度为 的最右侧子字符串。 一个表达式，它指定要从中提取最右侧子字符串的字符串。 一个表达式，它指定要从 中提取的最右侧子字符串的长度。 或 为 null。 没有规范“Right”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有单精度、双精度或十进制结果类型）调用规范“Round”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它将指定的参数舍入为最接近的整数值。 指定要舍入的数值的表达式。 为 null。 没有规范“Round”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有单精度、双精度或十进制以及整数结果类型）调用规范“Round”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它按照 指定的精度将指定的参数舍入为最接近的整数值。 指定要舍入的数值的表达式。 一个表达式，它指定在舍入时要使用的精度的位数。 或 为 null 没有规范“Round”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime、DateTimeOffset 或 Time 结果类型）调用规范“Second”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数秒钟值。 一个表达式，它指定应从中检索秒钟的值。 为 null。 没有规范“Second”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（每个参数都必须具有字符串结果类型）调用规范“StartsWith”函数。表达式的结果类型为 Boolean。

一个新的 DbFunctionExpression，它指示 是否以 开头。 一个表达式，指定要在其中查找指定的 的字符串。 一个表达式，指定应在 中查找的前缀。 或 为 null。 没有规范“StartsWith”函数的重载接受结果类型为 和 的参数。

创建一个 ，它对指定集合的非 null 成员调用规范“StDev”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它对集合的非 null 成员生成标准偏差值。 一个表达式，它指定应计算标准偏差的集合。 为 null。 没有规范“StDev”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定集合的总体调用规范“StDevP”函数。表达式的结果类型为 Edm.Double。

生成标准偏差值的新的 DbFunctionExpression。 一个表达式，它指定应计算标准偏差的集合。 为 null。 没有规范“StDevP”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串和整数结果类型）调用规范“Substring”函数。表达式的结果类型为字符串。

一个新的 DbFunctionExpression，它从 中返回以 开头的长度为 的子字符串。 一个表达式，它指定要从中提取子字符串的字符串。 一个表达式，它指定要从其获取子字符串的起始索引。 一个表达式，它指定子字符串的长度。 、 或 为 null。 没有规范“Substring”函数的重载接受结果类型为 、 和 的参数。

创建一个 ，它对指定的集合调用规范“Sum”函数。表达式的结果类型与集合的元素类型相同。

生成总和的新的 DbFunctionExpression。 一个表达式，它指定应计算总和的集合。 为 null。 没有规范“Sum”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“ToLower”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回转换为小写的 的值。 一个表达式，它指定应转换为小写的字符串。 为 null。 没有规范“ToLower”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“ToUpper”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回转换为大写的 的值。 一个表达式，它指定应转换为大写的字符串。 为 null。 没有规范“ToUpper”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“Trim”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回删除了前导和尾随空格的 的值。 一个表达式，它指定应删除其前导和尾随空格的字符串。 为 null。 没有规范“Trim”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“RTrim”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回删除了尾随空格的 的值。 一个表达式，它指定应删除其尾随空格的字符串。 为 null。 没有规范“RTrim”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“LTrim”函数。表达式的结果类型也为字符串。

一个新的 DbFunctionExpression，它返回删除了前导空格的 的值。 一个表达式，它指定应删除其前导空格的字符串。 为 null。 没有规范“LTrim”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（这些参数必须具有单精度、双精度或十进制以及整数结果类型）调用规范“Truncate”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它按照 指定的精度将指定的参数截断为最接近的整数值。 一个表达式，它指定要截断的数值。 一个表达式，它指定要在截断时要使用的精度位数。 或 为 null。 没有规范“Truncate”函数的重载接受结果类型为 和 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“TruncateTime”函数。表达式的结果类型与 的结果类型相同。

一个新的 DbFunctionExpression，它返回其时间设置为零的 的值。 一个表达式，它指定应截断其时间部分的值。 为 null。 没有规范“TruncateTime”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定集合的非 null 成员调用规范“Var”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它生成集合的非 null 成员的方差值。 一个表达式，它指定应计算其方差的集合。 为 null。 没有规范“Var”函数的重载接受结果类型为 的参数。

创建一个 ，它对指定集合的总体调用规范“VarP”函数。表达式的结果类型为 Edm.Double。

生成方差值的新的 DbFunctionExpression。 一个表达式，它指定应计算其方差的集合。 为 null。 没有规范“VarP”函数的重载接受结果类型为 的参数。

创建一个 ，它使用指定的参数（该参数必须具有 DateTime 或 DateTimeOffset 结果类型）调用规范“Year”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 返回整数年份值。 一个表达式，它指定应从中检索年份的值。 为 null。 没有规范“Year”函数的重载接受结果类型为 的参数。

表示 Row 类，它旨在提供用于调用 <see cref="M:System.Data.Entity.Core.Common.CommandTrees.ExpressionBuilder.DbExpressionBuilder.NewRow(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.Data.Entity.Core.Common.CommandTrees.DbExpression}})" /> 的类似构造函数的方法。

使用指定的第一列值和可选的连续列值来初始化 类的新实例。

提供新的行实例中的第一列的键/值对（必需）。 提供新的行实例中的任何后续列的键/值对（可选）。

将一个 Row 对象转换成 。

表示转换后的 Row 对象的 。 Row 对象。

创建一个新的 ，它基于此行实例中包含的列构造一个新行。

一个新的 DbNewInstanceExpression，它使用与此行实例相同的列名和 DbExpression 值构造一行。

提供一个 API 以便构造调用空间相关的规范 EDM 函数的 ，并且在适用时允许该 API 作为针对表达式类型本身的扩展方法来访问。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“Area”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 spatialValue 的区域，如果 spatialValue 不是图面，则返回 null。 一个表达式，它指定应为其计算面积的空间表面值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“AsBinary”函数。表达式的结果类型为 Edm.Binary。

一个新的 DbFunctionExpression，它返回 spatialValue 的已知二进制表示形式。 一个表达式，它指定应从其生成已知二进制表示形式的空间值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“AsGml”函数。表达式的结果类型为 Edm.String。

一个新的 DbFunctionExpression，它返回 spatialValue 的地理标记语言 (GML) 表示形式。 一个表达式，它指定应从其生成地理标记语言 (GML) 表示形式的空间值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“AsText”函数。表达式的结果类型为 Edm.String。

一个新的 DbFunctionExpression，它返回 spatialValue 的已知文本表示形式。 一个表达式，它指定应从其生成已知文本表示形式的空间值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“Centroid”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回 geometryValue 的形心点（可能不在图面本身上），如果 geometryValue 不是图面，则返回 null。 一个表达式，它指定应从其检索形心的几何表面值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“CoordinateSystemId”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 spatialValue 返回整数 SRID 值。 一个表达式，它指定应从其检索坐标系 ID (SRID) 的值。

创建一个 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“Distance”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 spatialValue1 和 spatialValue1 最近两点之间的距离。 指定第一个空间值的表达式。 一个表达式，它指定将测量其与 spatialValue1 之间距离的空间值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“Elevation”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 spatialValue 的海拔值，如果 spatialValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索海拔（Z 坐标）值的空间点值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“EndPoint”函数。结果类型与 spatialValue 的结果类型相同。

一个新的 DbFunctionExpression，它返回 spatialValue 的结束点，如果 spatialValue 不是曲线，则返回 null。 一个表达式，它指定应从其检索端点的空间曲线值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“ExteriorRing”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回多边形 geometryValue 的外部环，如果 geometryValue 不是多边形，则返回 null。 几何值。

创建一个 ，它使用指定的参数调用规范“GeographyCollectionFromBinary”函数。geographyCollectionWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理集合值。 提供地理集合值的已知二进制表示形式的表达式。 提供地理集合值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyCollectionFromText”函数。geographyCollectionWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理集合值。 提供地理集合值的已知文本表示形式的表达式。 提供地理集合值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有二进制结果类型）调用规范“GeographyFromBinary”函数。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的二进制值返回新的地理值。 提供地理值的已知二进制表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyFromBinary”函数。wellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理值。 提供地理值的已知二进制表示形式的表达式。 提供地理值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“GeographyFromGml”函数。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于具有基础提供程序的默认坐标系 ID (SRID) 的指定值返回新的地理值。 提供地理值的地理标记语言 (GML) 表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyFromGml”函数。geographyMarkup 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理值。 提供地理值的地理标记语言 (GML) 表示形式的表达式。 提供地理值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“GeographyFromText”函数。表达式的结果类型为 Edm.Geography。其值具有基础提供程序的默认坐标系 ID (SRID)。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理值。 提供地理值的已知文本表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyFromText”函数。wellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理值。 提供地理值的已知文本表示形式的表达式。 提供地理值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyLineFromBinary”函数。lineWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理线条值。 提供地理线条值的已知二进制表示形式的表达式。 提供地理线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyLineFromText”函数。lineWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理线条值。 提供地理线条值的已知文本表示形式的表达式。 提供地理线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiLineFromBinary”函数。multiLineWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多线条值。 提供地理多线条值的已知二进制表示形式的表达式。 提供地理多线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiLineFromText”函数。multiLineWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多线条值。 提供地理多线条值的已知文本表示形式的表达式。 提供地理多线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiPointFromBinary”函数。multiPointWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多点值。 提供地理多点值的已知二进制表示形式的表达式。 提供地理多点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiPointFromText”函数。multiPointWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多点值。 提供地理多点值的已知文本表示形式的表达式。 提供地理多点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiPolygonFromBinary”函数。multiPolygonWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多多边形值。 提供地理多多边形值的已知二进制表示形式的表达式。 提供地理多多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyMultiPolygonFromText”函数。multiPolygonWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多多边形值。 提供地理多多边形值的已知文本表示形式的表达式。 提供地理多多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyPointFromBinary”函数。pointWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理点值。 提供地理点值的已知二进制表示形式的表达式。 提供地理多点值的 systempointWellKnownBinaryValue 的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyPointFromText”函数。

规范的“GeographyPointFromText”函数。 提供地理点值的已知文本表示形式的表达式。 提供地理点值的坐标 systempointWellKnownTextValue 的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyPolygonFromBinary”函数。polygonWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多边形值。 提供地理多边形值的已知二进制表示形式的表达式。 提供地理多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeographyPolygonFromText”函数。polygonWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geography。

一个新的 DbFunctionExpression，它基于指定的值返回新的地理多边形值。 提供地理多边形值的已知文本表示形式的表达式。 提供地理多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryCollectionFromBinary”函数。geometryCollectionWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何集合值。 提供几何集合值的已知二进制表示形式的表达式。 提供几何集合值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryCollectionFromText”函数。geometryCollectionWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何集合值。 提供几何集合值的已知文本表示形式的表达式。 提供几何集合值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有二进制结果类型）调用规范“GeometryFromBinary”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的二进制值返回新的几何值。 提供几何值的已知二进制表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryFromBinary”函数。wellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何值。 提供几何值的已知二进制表示形式的表达式。 提供几何值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“GeometryFromGml”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于具有基础提供程序的默认坐标系 ID (SRID) 的指定值返回新的几何值。 提供几何值的地理标记语言 (GML) 表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryFromGml”函数。geometryMarkup 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何值。 提供几何值的地理标记语言 (GML) 表示形式的表达式。 提供几何值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数（该参数必须具有字符串结果类型）调用规范“GeometryFromText”函数。表达式的结果类型为 Edm.Geometry。其值具有基础提供程序的默认坐标系 ID (SRID)。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何值。 提供几何值的已知文本表示形式的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryFromText”函数。wellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何值。 提供几何值的已知文本表示形式的表达式。 提供几何值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryLineFromBinary”函数。lineWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何线条值。 提供几何线条值的已知二进制表示形式的表达式。 提供几何线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryLineFromText”函数。lineWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何线条值。 提供几何线条值的已知文本表示形式的表达式。 提供几何线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiLineFromBinary”函数。multiLineWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多线条值。 提供几何多线条值的已知二进制表示形式的表达式。 提供几何多线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiLineFromText”函数。multiLineWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多线条值。 提供几何多线条值的已知文本表示形式的表达式。 提供几何多线条值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiPointFromBinary”函数。multiPointWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多点值。 提供几何多点值的已知二进制表示形式的表达式。 提供几何多点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiPointFromText”函数。multiPointWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多点值。 提供几何多点值的已知文本表示形式的表达式。 提供几何多点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiPolygonFromBinary”函数。multiPolygonWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多多边形值。 提供几何多多边形值的已知二进制表示形式的表达式。 提供几何多多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryMultiPolygonFromText”函数。multiPolygonWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多多边形值。 提供几何多多边形值的已知文本表示形式的表达式。 提供几何多多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryPointFromBinary”函数。pointWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何点值。 提供几何点值的已知二进制表示形式的表达式。 提供几何点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryPointFromText”函数。pointWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何点值。 提供几何点值的已知文本表示形式的表达式。 提供几何点值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryPolygonFromBinary”函数。polygonWellKnownBinaryValue 必须是二进制结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多边形值。 提供几何多边形值的已知二进制表示形式的表达式。 提供几何多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“GeometryPolygonFromText”函数。polygonWellKnownText 必须是字符串结果类型，而 coordinateSystemId 必须是整数数值结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它基于指定的值返回新的几何多边形值。 提供几何多边形值的已知文本表示形式的表达式。 提供几何多边形值的坐标系的坐标系 ID (SRID) 的表达式。

创建一个 ，它使用指定的参数调用规范“InteriorRingAt”函数。第一个参数必须具有 Edm.Geometry 结果类型。第二个参数必须具有整数结果类型。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回 geometryValue 中位置 indexValue 处的内部环，如果 geometryValue 不是多边形，则返回 null。 几何值。 一个表达式，它指定要从多边形中检索的内部环的位置。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“InteriorRingCount”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回多边形 geometryValue 中的内部环数，如果 geometryValue 不是多边形，则返回 null。 几何值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“IsClosedSpatial”函数。结果类型是 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 spatialValue 是否闭合的布尔值，如果 spatialValue 不是曲线，则返回 null。 一个表达式，它指定应从其检索 IsClosedSpatial 值的空间曲线值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“IsEmptySpatial”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 spatialValue 是否为空的布尔值。 一个表达式，它指定应从其检索 IsEmptySptiaal 值的空间值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“IsRing”函数。结果类型是 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue 是否为圆环（闭合和简单）的布尔值，如果 geometryValue 不是曲线，则返回 null。 一个表达式，它指定应从其检索 IsRing 值的几何曲线值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“IsSimpleGeometry”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue 是否为简单几何图形的布尔值。 几何值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“IsValidGeometry”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue 是否有效的布尔值。 指定应进行空间有效性测试的几何值的表达式。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geography 结果类型）调用规范“Latitude”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 geographyValue 的纬度值，如果 geographyValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索 Latitude 值的地理点值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geography 结果类型）调用规范“Longitude”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 geographyValue 的经度值，如果 geographyValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索 Longitude 值的地理点值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“Measure”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 spatialValue 的度量值，如果 spatialValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索测量 (M) 坐标值的空间点值。

创建一个 ，它使用指定的参数调用规范“PointAt”函数。第一个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型。第二个参数必须具有整数结果类型。表达式的结果类型与 spatialValue 的结果类型相同。

一个新的 DbFunctionExpression，它返回 spatialValue 中位置 indexValue 处的点，如果 spatialValue 不是线串，则返回 null。 指定空间线串值的表达式。 指定要从线串内检索的点的位置的表达式。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“PointCount”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 spatialValue 中点的数目，如果 spatialValue 不是线串，则返回 null。 一个表达式，它指定应从其检索点的数目的空间线串值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“PointOnSurface”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回保证位于图面 geometryValue 上的点，如果 geometryValue 不是图面，则返回 null。 一个表达式，它指定应从其检索点的几何表面值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialBoundary”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回 geometryValue 的边界。 一个表达式，它指定应从其检索 SpatialBoundary 值的几何值。

创建 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 和 Edm.Double 结果类型）调用规范“SpatialBuffer”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回一个几何值，该值表示小于或等于与 spatialValue 的距离的所有点。 一个指定空间值的表达式。 一个指定缓冲距离的表达式。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialContains”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue1 是否在空间上包含 geometryValue2 的布尔值。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialConvexHull”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回 geometryValue 的凸包。 一个表达式，它指定应从其检索凸包值的几何值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialCrosses”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue1 是否与 geometryValue2 相交的布尔值。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialDifference”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型与 spatialValue1 和 spatialValue2 的类型相同。

一个新的 DbFunctionExpression，它返回表示 spatialValue1 与 spatialValue2 之间的差异的几何值。 指定第一个空间值的表达式。 一个表达式，它指定应计算与 spatialValue1 之间的差异的空间值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialDimension”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它从 spatialValue 返回维度值。 一个表达式，它指定应从其检索 Dimension 值的值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialDisjoint”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 spatialValue1 与 spatialValue2 是否在空间上不相交的布尔值。 指定第一个空间值的表达式。 一个表达式，它指定应与 spatialValue1 进行不相交性比较的空间值。

创建一个 ，它使用指定的参数调用规范“SpatialElementAt”函数。第一个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型。第二个参数必须具有整数结果类型。表达式的结果类型与 spatialValue 的结果类型相同。

一个新的 DbFunctionExpression，它返回 spatialValue 中位置 indexValue 处的集合元素，如果 spatialValue 不是集合，则返回 null。 一个表达式，它指定地理或几何集合值。 一个表达式，它指定要从几何或地理集合中检索的元素的位置。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialElementCount”函数。表达式的结果类型为 Edm.Int32。

一个新的 DbFunctionExpression，它返回 spatialValue 中元素的数目，如果 spatialValue 不是集合，则返回 null。 一个表达式，它指定应从其检索某个数目的元素的地理或几何集合值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialEnvelope”函数。表达式的结果类型为 Edm.Geometry。

一个新的 DbFunctionExpression，它返回 geometryValue 的最小边框。 一个表达式，它指定应从其检索 Envelope 值的值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialEquals”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 spatialValue1 是否与 spatialValue2 相等的布尔值。 指定第一个空间值的表达式。 一个表达式，它指定应与 spatialValue1 比较是否相等的空间值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialIntersection”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型与 spatialValue1 和 spatialValue2 的类型相同。

一个新的 DbFunctionExpression，它返回表示 spatialValue1 和 spatialValue2 的交集的空间值。 指定第一个空间值的表达式。 一个表达式，它指定要计算与 spatialValue1 的交集的空间值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialIntersects”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 spatialValue1 是否与 spatialValue2 相交的布尔值。 指定第一个空间值的表达式。 一个表达式，它指定应与 spatialValue1 进行相交性比较的空间值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialLength”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 spatialValue 的长度，如果 spatialValue 不是曲线，则返回 null。 一个表达式，它指定应从其检索长度的空间曲线值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialOverlaps”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue1 是否在空间上与 geometryValue2 重叠的布尔值。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。

创建 ，它使用指定参数（参数必须具有 Edm.Geometry 和字符串结果类型）调用规范“SpatialRelate”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回一个布尔值，该值根据 intersectionPatternMatrix 指定的空间关系指示 geometryValue1 在空间上是否与 geometryValue2 相关。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。 一个表达式，它指定用于比较 geometryValue1 和 geometryValue2 的维度扩展九交模型 (DE-9IM) 交集模式的文本表示形式。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialSymmetricDifference”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型与 spatialValue1 和 spatialValue2 的类型相同。

一个新的 DbFunctionExpression，它返回表示 spatialValue1 与 spatialValue2 之间的对称差异的几何值。 指定第一个空间值的表达式。 一个表达式，它指定应计算与 spatialValue1 之间的对称差异的空间值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialTouches”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue1 是否与 geometryValue2 接触的布尔值。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialTypeName”函数。表达式的结果类型为 Edm.String。

一个新的 DbFunctionExpression，它从 spatialValue 中返回字符串几何类型名称。 一个表达式，它指定应从中检索几何类型名称的值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“SpatialUnion”函数。spatialValue1 的结果类型必须与 spatialValue2 的结果类型相匹配。表达式的结果类型与 spatialValue1 和 spatialValue2 的类型相同。

一个新的 DbFunctionExpression，它返回表示 spatialValue1 和 spatialValue2 的并集的空间值。 指定第一个空间值的表达式。 一个表达式，它指定应计算与 spatialValue1 的并集的空间值。

创建 ，它使用指定参数（每个参数必须具有 Edm.Geometry 结果类型）调用规范“SpatialWithin”函数。表达式的结果类型为 Edm.Boolean。

一个新的 DbFunctionExpression，它返回指示 geometryValue1 是否在 geometryValue2 空间内的布尔值。 一个指定第一个几何值的表达式。 一个表达式，它指定应与 geometryValue1 进行比较的几何值。

创建一个 ，它使用指定参数（该参数必须具有 Edm.Geography 或 Edm.Geometry 结果类型）调用规范“StartPoint”函数。结果类型与 spatialValue 的结果类型相同。

一个新的 DbFunctionExpression，它返回 spatialValue 的起始点，如果 spatialValue 不是曲线，则返回 null。 一个表达式，它指定应从其检索起点的空间曲线值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“XCoordinate”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 geometryValue 的 X 坐标值，如果 geometryValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索 X 坐标值的几何点值。

创建一个 ，它使用指定的参数（该参数必须具有 Edm.Geometry 结果类型）调用规范“YCoordinate”函数。表达式的结果类型为 Edm.Double。

一个新的 DbFunctionExpression，它返回 geometryValue 的 Y 坐标值，如果 geometryValue 不是一个点，则返回 null。 一个表达式，它指定应从其检索 Y 坐标值的几何点值。

公共实体 SQL 分析器类。

分析具有指定参数的指定查询。

包含 的 以及描述内联函数定义的信息（如果有）。 要分析的 EntitySQL 查询。 可选查询参数。

分析具有特定设置变量的特定查询并生成 。

包含 的 以及描述内联函数定义的信息（如果有）。 要分析的查询。 可选查询变量。

实体 SQL 查询内联函数定义，作为 的一部分返回。

eSQL 查询文本中函数定义的结束位置。

函数体和参数。

函数名。

eSQL 查询文本中函数定义的起始位置。

实体 SQL 分析器结果信息。

在分析过程中生成的命令目录树。

描述查询内联函数定义的 对象的列表。

表示概念层的命令的类

使用指定的值初始化 类的新实例。

使用指定的语句初始化 类的新实例。

命令的文本。

使用指定的语句和连接初始化 类的新实例。

命令的文本。 与数据源的连接。

使用指定的语句、连接和事务初始化 类的新实例。

命令的文本。 与数据源的连接。 在其中执行命令的事务。

构造具有给定 eSQL 语句以及要使用的连接对象的 EntityCommand 对象

要执行的 eSQL 命令文本 连接对象 用于解析 DbProviderServices 的解析程序

取消执行 。

获取或设置指定要执行的命令或存储过程的实体 SQL 语句。

指定要执行的命令或存储过程的实体 SQL 语句。

获取或设置超时前要等待的时间长度。

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

获取或设置要执行的命令目录树；只能设置命令目录树或命令文本中的其中一个，而不能同时设置二者。

要执行的命令目录树。

获取或设置一个值，该值指示如何解释 属性。

枚举值之一。

获取或设置 使用的 。

由实体命令使用的连接。

创建并返回一个新的参数对象，该对象表示 eSQL 语句中的参数

创建 对象的新实例。

对象的一个新实例。

用于执行命令的连接对象

此命令的参数集合

此命令要在其中执行的事务

获取或设置一个值，该值指示命令对象在 Windows 窗体设计器控件中是否应该可见。

如果该命令对象应在 Windows 窗体设计器中可见，则为 true；否则为 false。

获取或设置一个值，该值指示查询计划缓存是否启用。

如果查询计划缓存已启用，则为 true；否则为 false。

执行命令并且返回用于读取结果的数据读取器

DbDataReader 对象 执行命令时要使用的行为

异步执行命令并且返回用于读取结果的数据读取器

表示异步操作的任务。任务结果包含一个 DbDataReader 对象。 执行命令时要使用的行为 针对取消请求监视的标记

执行当前命令。

受影响的行数。

异步执行此命令并且放弃从此命令返回的任何结果

表示异步操作的任务。任务结果包含受影响的行数。 等待任务完成期间要观察的 。

执行命令并返回一个数据读取器。

包含结果的 。

将 编译成命令目录树，并将其传递到基础存储区提供程序以供执行，然后使用指定的 根据生成的结果集生成一个 。

包含结果的 。 值之一。

异步执行命令并且返回用于读取结果的数据读取器。只能对 CommandType.CommandText 调用（否则，使用标准 Execute* 方法）

表示异步操作的任务。任务结果包含一个 EntityDataReader 对象。 对于存储过程命令；对于实体集合结果以外的任何项，则调用

异步执行命令并且返回用于读取结果的数据读取器。只能对 CommandType.CommandText 调用（否则，使用标准 Execute* 方法）

表示异步操作的任务。任务结果包含一个 EntityDataReader 对象。 执行命令时要使用的行为 对于存储过程命令；对于实体集合结果以外的任何项，则调用

异步执行命令并且返回用于读取结果的数据读取器。只能对 CommandType.CommandText 调用（否则，使用标准 Execute* 方法）

表示异步操作的任务。任务结果包含一个 EntityDataReader 对象。 执行命令时要使用的行为 等待任务完成期间要观察的 。 对于存储过程命令；对于实体集合结果以外的任何项，则调用

异步执行命令并且返回用于读取结果的数据读取器。只能对 CommandType.CommandText 调用（否则，使用标准 Execute* 方法）

表示异步操作的任务。任务结果包含一个 EntityDataReader 对象。 等待任务完成期间要观察的 。 对于存储过程命令；对于实体集合结果以外的任何项，则调用

执行命令，并返回结果集中第一行的第一列。其他列或行将被忽略。

结果集中第一行的第一列；如果结果集为空，则为空引用（在 Visual Basic 中为 Nothing）。

获取实体 SQL 语句或存储过程的参数。

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

编译实体级别的命令并创建该命令的预制版本。

编译实体级别的命令并返回存储命令文本。

存储命令文本。

获取或设置在其中执行 的事务。

在其中执行 的事务。

获取或设置向正在更新的行应用命令结果的方式。

值之一。

表示概念层的连接的类。一个实体连接只能被初始化一次（通过打开该连接）。之后将无法更改连接字符串、附加新的存储连接或更改存储连接字符串。

初始化 类的新实例。

使用指定的 和 来初始化 类的新实例。

与此 关联的 。 此 对象的基础数据源连接。 workspace 或 connection 参数为 null。 工作区缺少概念模型。-或-工作区缺少映射文件。-或-工作区缺少存储模型。-或-连接未处于关闭状态。 connection 并非来自与 ADO.NET Entity Framework 兼容的提供程序。

从内存中加载的元数据构造 EntityConnection

包含元数据信息的工作区。 存储连接。 如果设置为 true，则释放实体连接时将释放该存储连接；否则调用方必须释放该存储连接。

基于连接字符串初始化 类的新实例。

提供程序特定的连接字符串。 提供的连接字符串关键字无效，或未提供所需的连接字符串关键字。

开始一个数据库事务

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

使用基础提供程序开始一个事务。

一个新的 。返回的 实例以后可以与 关联以执行该事务下的命令。 基础提供程序未知。-或-对已具有当前事务的 调用 。-或- 的状态不是 。

使用基础提供程序开始一个具有指定隔离级别的事务。

一个新的 。返回的 实例以后可以与 关联以执行该事务下的命令。 事务的隔离级别。 基础提供程序未知。-或-对已具有当前事务的 调用 。-或- 的状态不是 。

不提供支持。

不提供支持。 调用该方法时。

关闭与数据库之间的连接。

关闭连接时出错。

获取或设置 连接字符串。

建立与数据源的初始连接所需的连接字符串。默认值为一个空字符串。连接关闭时，将返回当前设置的值。如果未设置任何值，则将返回一个空字符串。

获取从尝试建立连接到结束尝试并生成错误需要等待的秒数。

等待连接打开所需的时间（以秒为单位）。默认值为基础数据提供程序的默认超时值。

在 设置为此 的情况下创建 的新实例。

一个 对象。 基础数据提供程序的名称未知。

创建使用此连接对象的新命令对象

获取当前数据库或将在连接打开后使用的数据库的名称。

基础数据提供程序的 Database 属性值。

获取要连接到的数据源的名称或网络地址。

数据源的名称。默认值为一个空字符串。

获取与此 EntityConnection 关联的提供程序工厂

清除此连接对象

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源

在指定的事务中登记此 。

要在其中进行登记的事务对象。 的状态不是 。

返回与此 关联的 。

与此 关联的 。 内联连接字符串包含一个无效的 Metadata 关键字值。

通过调用基础数据提供程序的 Open 方法建立到数据源的连接。

打开连接时出错，或基础数据提供程序的名称未知。 内联连接字符串包含一个无效的 Metadata 关键字值。

通过在基础数据提供程序上调用 Open 方法以异步方式建立与数据存储的连接

表示异步操作的任务。 等待任务完成期间要观察的 。

获取一个字符串，该字符串包含客户端连接到的数据源的版本。

提供程序连接字符串中包含的数据源的版本。

如果 打开，则获取基础提供程序的 属性。否则，返回 。

当且仅当 的内部状态和基础提供程序 均处于打开状态时，才返回 。如果 处于打开状态，但提供程序的 处于关闭状态，则该属性返回 。否则，将返回 。

提供对 对象使用的基础数据源连接的访问。

数据源连接的 。

表示实体客户端提供程序的连接字符串生成器的类

初始化 类的新实例。

使用提供的连接字符串初始化 类的新实例。

一个指向基础数据源的提供程序特定的连接字符串。

清除 实例的内容。

确定 是否包含特定的键。

如果 包含具有指定键的元素，则返回 true；否则返回 false。 要在 中定位的键。

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

无论在何种情况下，都将返回 true，因为 始终提供固定大小的关键字/值对集合。

获取或设置与指定的键关联的值。在 C# 中，此属性为索引器。

与指定的键相关联的值。

获取包含 中的键的 。

一个 ，包含 中的键。

获取或设置连接字符串中的元数据位置。

获取或设置连接字符串中的元数据位置。

获取或设置配置文件中定义的节名称。

配置文件中的节名称。

获取或设置连接字符串中的基础 .NET Framework 数据提供程序的名称。

基础 .NET Framework 数据提供程序的固定名称。

获取或设置提供程序特定的内部连接字符串。

提供程序特定的内部连接字符串。

从 实例中移除具有指定的键的项。

如果该键存在于连接字符串中并被移除，则返回 true；如果该键不存在，则返回 false。 要从此 中的连接字符串删除的关键字/值对的键。 关键字为 null（在 Visual Basic 中为 Nothing）

从此 中检索与提供的键相对应的值。

如果在连接字符串中找到 keyword，则返回 true；否则返回 false。 要检索的项的键。 与 keyword 相对应的值。 keyword 包含一个 null 值（在 Visual Basic 中为 Nothing）。

实体客户端提供程序的数据读取器类

关闭 对象。

获取此 的 。

数据记录信息。

获取一个值，该值指示当前行的嵌套深度。

当前行的嵌套深度。

释放由此 占用的资源并调用 。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

获取当前行中的列数。

当前行中的列数。

以布尔值的形式获取指定列的值。

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

以字节的形式获取指定列的值。

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

在指定列中从 dataIndex 指示的位置开始，将字节流读入缓冲区，读入缓冲区的起始位置由 bufferIndex 指示。

读取的实际字节数。 从零开始的列序号。 行中作为读取操作起始位置的索引。 要将数据复制到的缓冲区。 要将数据复制到的位置的缓冲区索引。 要读取的最多字符数。

以单个字符的形式获取指定列的值。

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

在指定列中从 dataIndex 指示的位置开始，将字符流读入缓冲区，读入缓冲区的起始位置由 bufferIndex 指示。

读取的实际字符数。 从零开始的列序号。 行中作为读取操作起始位置的索引。 要将数据复制到的缓冲区。 要将数据复制到的位置的缓冲区索引。 要读取的最多字符数。

以 对象的形式返回嵌套的读取器。

作为 对象嵌套的读取器。 列的序号。

返回嵌套的 。

嵌套的数据记录。 要返回的 DbDataRecord 的编号。

获取指定列的数据类型的名称。

数据类型的名称。 从零开始的列序号。

以 对象的形式获取指定列的值。

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

为可用提供程序特定的实现重写的已请求的列序号返回一个 对象。

数据读取器。 从零开始的列序号。

以 对象的形式获取指定列的值。

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

以双精度浮点数字的形式获取指定列的值。

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

返回一个可用于循环访问数据读取器中的行的 。

一个 ，可用于循环访问数据读取器中的行。

获取指定列的数据类型。

指定列的数据类型。 从零开始的列序号。

以单精度浮点数字的形式获取指定列的值。

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

以全局唯一标识符 (GUID) 的形式获取指定列的值。

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

以 16 位有符号整数的形式获取指定列的值。

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

以 32 位有符号整数的形式获取指定列的值。

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

以 64 位有符号整数的形式获取指定列的值。

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

在给定从零开始的列序号时获取该列的名称。

指定列的名称。 从零开始的列序号。

在给定列名时获取相应的列序号。

从零开始的列序号。 列的名称。 指定的名称不是有效的列名。

返回指定列的提供程序特定的字段类型。

描述指定列的数据类型的 对象。 从零开始的列序号。

以 实例的形式获取指定列的值。

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

在当前行的集合中获取提供程序特定的所有属性列。

数组中的 实例数。 要将属性列复制到的 数组。

返回一个描述 的列元数据的 。

一个描述列元数据的 。

以 实例的形式获取指定列的值。

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

以 实例的形式获取指定列的值。

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

使用当前行的列值来填充对象数组。

数组中的 实例数。 要将属性列复制到的 数组。

获取一个值，该值指示此 是否包含一个或多个行。

如果 包含一行或多行，则为 true；否则为 false。

获取一个值，该值指示 是否已关闭。

如果 已关闭，则为 true；否则为 false。

获取一个值，该值指示列中是否包含不存在或丢失的值。

如果指定的列等效于 ，则为 true；否则为 false。 从零开始的列序号。

以 实例的形式获取指定列的值。

指定列的值。

以 实例的形式获取指定列的值。

指定列的值。

在读取一批语句的结果时，使读取器前进到下一个结果。

如果存在其他结果集，则为 true；否则为 false。

在读取一批语句时，以异步方式将读取器移到下一结果集

表示异步操作的任务。如果存在其他结果集，则任务结果将包含 true；否则为 false。 等待任务完成期间要观察的 。

使读取器前进到结果集中的下一条记录。

如果存在其他行，则为 true；否则为 false。

以异步方式将读取器移到当前结果集的下一行

表示异步操作的任务。如果存在其他行，则任务结果将包含 true；否则为 false。 等待任务完成期间要观察的 。

获取通过执行 SQL 语句更改、插入或删除的行数。

更改、插入或删除的行数。如果是 SELECT 语句，则返回 -1；如果未影响任何行或语句失败，则返回 0。

获取 中未隐藏的字段的数目。

未隐藏的字段的数目。

表示在 EntityCommand 中使用的参数的类

使用默认值初始化 类的新实例。

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

参数名。 值之一。

使用指定的参数名称、数据类型和大小初始化 类的新实例。

参数名。 值之一。 参数的大小。

使用指定的属性初始化 类的新实例。

参数名。 值之一。 参数的大小。 值之一。 若为 true，则指示参数接受 null 值，否则为 false。 用于表示值的位数。 值所解析的小数位数。 源列的名称。 值之一。 参数的值。

使用指定的属性初始化 类的新实例。

参数名。 值之一。 参数的大小。 源列的名称。

获取或设置参数的 。

值之一。

获取或设置参数的方向。

值之一。

获取或设置表示为 EdmType 的参数类型。

表示为 EdmType 的参数的类型。

获取或设置一个值，该值指示参数是否接受 null 值。

如果接受 null 值，则为 true；否则为 false。

获取或设置实体参数的名称。

实体参数的名称。

获取或设置用于表示 属性的位数。

用于表示值的位数。

重置与 关联的类型。

获取或设置所解析的 的小数位数。

值所解析的小数位数。

获取或设置列内数据的最大大小。

列内数据的最大大小。

获取或设置源列的名称，该源列映射到 并用于加载或返回 。

映射到数据集并用于加载或返回值的源列的名称。

获取或设置一个值，该值指示源列是否可以为 null。

如果源列可以为 null，则为 true；否则为 false。

获取或设置在加载值时要使用的 。

值之一。

返回参数的字符串表示形式。

参数的字符串表示形式。

获取或设置参数的值。

参数的值。

表示在 EntityCommand 中使用的参数集合的类

将指定的 对象添加到 中。

一个新的 对象。 要添加到集合中的 。 值参数中指定的 已添加到这个或其他 中。 传递的参数不是 。 value 参数为 null。

将指定的对象添加到 中。

新的 对象的索引。 一个 。

在给定参数名称和数据类型时向 中添加一个 。

一个新的 对象。 参数名。 值之一。

使用给定的参数名称、数据类型和列长度向 中添加一个 。

一个新的 对象。 参数名。 值之一。 列的长度。

向 的末尾添加一个值数组。

要添加的 值。

向 的末尾添加一个 值数组。

要添加的 值。

向 的末尾添加一个值。

对象。 参数名。 要添加的值。

从 中删除所有的 对象。

确定指定的 是否在此 中。

如果 包含该值，则为 true；否则为 false。 值。

确定指定的 是否在此 中。

如果 包含该值，则为 true；否则为 false。 值。

将当前 的所有元素复制到指定的一维 中，并以指定的目标 索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的一维 。 一个 32 位整数，表示 中开始复制的位置的索引。

将当前 的所有元素复制到指定的 中，并以指定的目标索引位置作为复制到的起始位置。

作为当前 中的元素的复制目标的 。 一个 32 位整数，表示 中开始复制的位置的索引。

获取一个包含 中的元素数的整数。

以整数形式表示的 中的元素数。

返回一个循环访问 的枚举器。

用于 的 。

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

作为集合中的 的指定 的位置（从零开始）。如果 中不存在该对象，则返回 -1。 要查找的 。

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

作为集合中的 的指定 的位置（从零开始）。如果 中不存在该对象，则返回 -1。 要查找的 。

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

具有指定名称（区分大小写）的指定 的位置（从零开始）。如果 中不存在该对象，则返回 -1。 要查找的 的名称（区分大小写）。

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

应将值插入到的位置的索引（从零开始）。 要插入到 中的 对象。

将 插入 的指定索引处。

应将值插入到的位置的索引（从零开始）。 要插入到 中的 。

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

如果 具有固定大小，则返回 true；否则返回 false。

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

如果 是只读的，则返回 true；否则返回 false。

获取一个值，该值指示 是否已同步。

如果 已同步，则返回 true；否则返回 false。

获取位于指定索引处的 。

指定索引处的 。

获取具有指定名称的 。

具有指定名称的 。

从集合中移除指定的 。

要从集合中移除的 对象。 该参数不是 。 集合中不存在该参数。

从集合中移除指定的参数。

要从集合中移除的 对象。

从 的指定索引处移除 。

要移除的 对象的索引（从零开始）。

从 中移除具有指定参数名称的 。

要移除的 的名称。

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

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

类，表示实体客户端提供程序的提供程序工厂

返回实现 类的提供程序类的一个新实例。

的一个新实例。

引发 。当前不支持该方法。

当前不支持该方法。

返回实现 类的提供程序类的一个新实例。

的一个新实例。

返回实现 类的提供程序类的一个新实例。

的一个新实例。

引发 。当前不支持该方法。

当前不支持该方法。

返回实现 类的提供程序类的一个新实例。

的一个新实例。

引发 。当前不支持该方法。

当前不支持该方法。

实体客户端提供程序工厂对象的单一实例对象。这保留一个公共字段（而非属性），因为 DbProviderFactory 应为字段。

返回请求的 类。

的一个新实例。支持的类型是 、 和 。对于所有其他类型均返回 null（在 Visual Basic 中为 Nothing）。 要返回的 。

表示概念层的事务的类

提交基础事务。

获取此 的 。

一个指向基础数据源的 。

拥有此事务对象的连接对象

清除此事务对象

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源

获取此 的隔离级别。

一个 枚举值，表示基础事务的隔离级别。

回滚基础事务。

在设计时创建的、用于存储生成的视图的类型的基类。

初始化 类的新实例。

获取或设置 的名称。

容器名称。

返回指定索引处的键/值对，其中包含视图和其键。

索引处的键/值对，其中包含视图以及视图的键。 视图的索引。

视图的哈希值。

哈希值。

哈希值。

哈希值。

获取或设置存储架构中的 。

容器名称。

获取或设置视图计数。

视图计数。

用于标记包含生成的视图类型的程序集的特性。

初始化 类的新实例。

视图的类型。

获取视图的 T:System.Type。

视图的 T:System.Type。

表示 Edm 空间中映射项的集合的类。

表示存储映射（CS 映射）空间中的项集合。

使用指定的 、 和 XML 读取器初始化 类的新实例。

此映射要使用的 。 此映射要使用的 。 此映射要使用的 XML 读取器。

使用指定的 、 以及指示元数据文件路径的字符串的集合初始化 类的新实例。

此映射要使用的 。 此映射要使用的 。 此映射要使用的文件路径。

计算集合中单个容器映射的哈希值。

指定计算出的哈希值的字符串。

计算由已映射容器的名称指定的容器映射的哈希值。

指定计算出的哈希值的字符串。 概念模型中容器的名称。 存储模型中容器的名称。

创建 的工厂方法。

如果未遇到错误，则为 实例。否则为 null。 要映射的 edm 元数据集合。不得是 null。 要映射的存储元数据集合。不得是 null。 要加载的 MSL 项目。不得是 null。 MSL 项目的路径。用于错误消息中。可为 null，在此情况下，XmlReader 的基 Uri 将用作路径。 加载时遇到的错误的集合。

为集合中的单个容器映射创建（范围、生成的视图）字典。

用于指定生成的视图（、）的字典。 积累潜在错误的列表。

为由已映射容器的名称指定的容器映射创建（范围，生成的视图）字典。

用于指定生成的视图（、）的字典。 概念模型中容器的名称。 存储模型中容器的名称。 积累潜在错误的列表。

获取此 表示的版本。

此 表示的版本。

获取或设置一个 ，它用于创建在检索预生成的映射视图时使用的 实例。

表示关联类型的端

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

创建一个只读的 AssociationEndMember 实例。

新创建的 AssociationEndMember 实例。 关联端成员的名称。 端的引用类型。 端的多重性。 指示端的删除行为的标志。 要与该实例相关联的元数据属性。 指定的名称为 null 或空。 指定的引用类型为 null。

表示关联集的类

获取此 的 End。

一个 类型的集合，其中包含此 的 End。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

从指定的参数创建一个只读 AssociationSet 实例。

新创建的 AssociationSet 实例。 关联集的名称。 关联集中元素的关联类型。 源关联集端的实体集。 目标关联集端的实体集。 要与该实例相关联的元数据属性。 指定的名称为 null 或空。 指定的关联类型为 null。 指定的关联类型的其中一端的实体类型与相应实体集端的实体类型不匹配。

获取与此 有关的关联。

一个 对象，表示与此 有关的关联。

表示 AssociationSet 端的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取与此 对象相对应的 End 成员。

一个 对象，表示与此 对象相对应的 End 成员。

获取由此 End 角色引用的实体集。

一个 对象，表示由此 End 角色引用的实体集。

获取此 的 End 名称。

此 的 End 名称。

获取此 的父关联集。

一个 对象，表示此 的父关联集。

获取此 的 End 角色名称。

此 的 End 角色名称。

返回此 的 End 角色名称。

此 的 End 角色名称。

描述概念模型中两个实体之间的关联/关系，或者描述存储模型中两个表之间的外键关系。在概念模型中，相关类不一定定义外键属性。如果定义了某一外键，则 属性将为 true，并且 属性将包含外键的详细信息

获取此 的端的列表。

一个 类型的集合，其中包含此 的 End 列表。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取或设置引用约束。

引用约束。

从指定的参数创建一个只读 AssociationType 实例。

新创建的 AssociationType 实例。 关联类型的名称。 关联类型的命名空间。 指示外键 (FK) 关系的标志。 关联类型的数据空间。 源关联端成员。 目标关联端成员。 一个引用约束。 要与该实例相关联的元数据属性。 指定的名称为 null 或空。 指定的命名空间为 null 或空。

获取一个布尔属性值，该值指定列是否为外键。

一个指定列是否为外键的布尔值。如果为 true，则列是外键。如果为 false（默认值），则列不是外键。

获取此 的约束列表。

一个 类型的集合，其中包含此 的约束列表。

所有内置类型的列表

关联类型种类

AssociationSet 种类

AssociationSetEnd 种类

关联类型种类

集合种类

集合类型种类

复杂类型种类

文档种类

EdmFunction 种类

EdmMember 类型种类

EdmProperty 类型种类

Edm 类型种类

实体容器种类

实体集种类

EntitySetBase 种类

实体类型种类

实体类型基种类

枚举成员种类

枚举类型种类

方面种类

函数参数种类

全局项类型种类

元数据项类型种类

元数据属性种类

导航属性种类

DeleteAction 类型种类

参数模式种类

基元类型种类

基元类型种类

ProviderManifest 类型种类

引用约束类型种类

Ref 类型种类

RelationshipEnd 类型种类

关系多重性类型种类

RelationshipEnd 类型种类

关系类型

行类型种类

简单类型种类

结构化类型种类

类型信息种类

集合的种类（适用于属性）

集合具有包语义（允许未排序和重复项）

集合具有列表语义（顺序明确并且允许重复项）

属性不是集合

表示 Edm 集合类型

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取 类的一个实例，其中包含此当前 对象所包括的元素的类型以及该类型的各个方面。

类的一个实例，其中包含此当前 对象所包括的元素的类型以及该类型的各个方面。

表示 Edm 复杂类型。这可用于从概念空间基于模型的约定配置复杂类型。在存储模型中不支持复杂类型。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

创建 类型的新实例。

类型的新实例。 复杂类型的名称。 复杂类型的命名空间。 复杂类型属于的数据空间。 复杂类型的成员。 要与该实例相关联的元数据属性。 在 name、namespace 或 members 参数为 null 时引发。

获取此 的属性列表。

一个 类型的集合，其中包含此 的属性列表。

属性的并发模式。

固定并发模式：执行写入操作时始终验证属性

默认并发模式：执行写入操作时从不验证属性

DataSpace

CSpace 指示 CSpace 中的项 - edm 基元类型 + 在 csdl 中定义的类型

CSpace 和 SSpace 之间的映射

OSpace 和 CSpace 之间的映射

OSpace 指示 clr 空间中的项

SSpace 指示 SSpace 中的项

表示与某一项相关联的文档的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取一个值，该值指示此 对象是否只包含一个 null（即空的） 和一个 。

如果此 对象只包含一个 null（即空的） 和一个 ，则为 true；否则为 false。

获取有关此 的详细说明。

有关此 的详细说明。

获取此 的摘要。

此 的摘要。

返回此 的摘要。

此 的摘要。

此类包装有关一般性 EDM 错误的错误信息。

获取错误消息。

错误消息。

表示某一函数的类

向此函数添加参数。

要添加的参数。

获取此函数的聚合特性。

获取一个值，该值指示此函数中是否存在内置特性。

如果存在内置特性，则为 true；否则为 false。

获取此 的内置类型种类。

枚举的枚举值之一。

获取采用数据库管理系统或存储模型所使用的语言的查询。

采用数据库管理系统或存储模型所使用语法的一个字符串值，其中包含 的查询或更新语句。

构造该 对象的工厂方法。

类型的新的只读实例。 函数的名称。 函数的命名空间。 函数所属的命名空间。 其他函数特性和属性。 将添加到该函数的元数据属性。可以为 null。

返回此类型的全名（命名空间加名称）。

类型的全名。

获取是将此实例映射到函数还是映射到存储过程的信息。

如果将此实例映射到函数，则为 true；如果将此实例映射到存储过程，则为 false。

获取一个值，该值指示此实例是否来自提供程序清单。

如果此实例来自提供程序清单，则为 true；否则为 false。

获取一个值，该值指示此函数是否为 niladic 函数（不接受任何参数的函数）。

如果此函数为 niladic 函数，则为 true；否则为 false。

获取此 的参数。

一个 类型的集合，其中包含此 的参数。

获取此函数的参数类型语义特性。

获取此 的返回参数。

一个 对象，表示此 的返回参数。

获取此 的返回参数。

一个 类型的集合，表示 的返回参数。

获取或设置与函数关联的架构。

与函数关联的架构。

获取此函数的存储函数名称特性。

包含 的其他特性和属性

获取或设置与函数关联的命令文本。

与函数关联的命令文本。

获取或设置函数的实体集。

函数的实体集。

获取指示这是否为聚合函数的值。

如果这是聚合函数，则为 true；否则为 false。

获取或设置此函数是否为内置函数的信息。

如果此函数为内置函数，则为 true；否则为 false。

获取或设置此函数是否为缓存存储函数的信息。

如果此函数为缓存的存储函数，则为 true；否则为 false。

获取或设置此函数是否可以组合的信息。

如果此函数可以组合，则为 true；否则为 false。

获取或设置此函数是否来自提供程序清单的信息。

如果此函数来自提供程序清单，则为 true；否则为 false。

获取或设置此函数是否为函数导入的信息。

如果此函数为函数导入，则为 true；否则为 false。

获取或设置函数是否不包含参数的信息。

如果函数不包含参数，则为 true；否则为 false。

获取或设置函数参数。

函数参数。

获取或设置参数类型语义。

参数类型语义。

获取或设置返回参数。

返回参数。

获取或设置函数架构。

函数架构。

获取或设置存储函数名称。

存储函数名称。

表示 Edm 空间中项的集合的类。

使用概念架构定义语言 (CSDL) 文件所在的 XMLReader 对象的集合初始化 类的新实例。

概念架构定义语言 (CSDL) 文件所在的 XMLReader 对象的集合。

初始化 类的新实例。

实体数据模型。

使用概念架构定义语言 (CSDL) 文件所在的路径初始化 类的新实例。

概念架构定义语言 (CSDL) 文件所在的路径。

创建 的工厂方法。

如果未遇到错误，则为 实例。否则为 null。 要加载的 CSDL 项目。不得是 null。 CSDL 项目的路径。用于错误消息中。可为 null，在此情况下，XmlReader 的基 Uri 将用作路径。 加载时遇到的错误的集合。

获取此集合的概念模型版本。

此集合的概念模型版本。

返回一个由 对象构成的集合。

一个 ReadOnlyCollection 对象，表示 对象的集合。

返回具有指定的概念模型版本的 对象的集合。

一个 ReadOnlyCollection 对象，表示 对象的集合。 概念模型版本。

表示 edm 成员类

获取已对其声明此成员的类型。

一个 对象，表示已对其声明此成员的类型。

指示此成员是否在 EDM 定义中标记为计算成员

指示此成员的存储生成的模式是否在 EDM 定义中标记为标识

获取或设置属性的名称。从存储空间模型约定对此进行设置将更改此属性的数据库列的名称。在概念模型中，这应该与来自实体类的相应属性保持一致并且不应更改。

此成员的名称。

返回此成员的名称。

此成员的名称。

获取既包含此成员的类型又包含该类型的各个方面的 类实例。

一个 对象，其中既包含此成员的类型又包含该类型的各个方面。

表示概念模型或存储模型。该类可用于访问与模型的形状有关的信息以及对其进行配置的方式。

将关联类型添加到模型中。

要添加的 AssociationType 实例。

将复杂类型添加到模型中。

要添加的 ComplexType 实例。

将函数添加到模型中。

要添加的 EdmFunction 实例。

将实体类型添加到模型中。

要添加的 EntityType 实例。

将枚举类型添加到模型中。

要添加的 EnumType 实例。

获取模型中的关联类型。

获取此类型的内置类型种类。

一个 对象，表示此类型的内置类型种类。

获取模型中的复杂类型。

获取存储实体和关联集以及函数导入的容器。

获取与此模型关联的数据空间，该数据空间指示它是概念模型 (DataSpace.CSpace) 还是存储模型 (DataSpace.SSpace)。

获取模型中的实体类型。

获取模型中的枚举类型。

获取模型中的函数。

获取与模型关联的全局项。

与模型关联的全局项。

从模型中删除关联类型。

要删除的 AssociationType 实例。

从模型中删除复杂类型。

要删除的 ComplexType 实例。

从模型中删除函数。

要删除的 EdmFunction 实例。

从模型中删除实体类型。

要删除的 EntityType 实例。

从模型中删除枚举类型。

要删除的 EnumType 实例。

在概念空间中，EdmProperty 表示某个实体的属性。在存储空间中，EdmProperty 表示某个表中的列。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取或设置此模型的集合种类。

此模型的集合种类。

获取此属性的复杂类型信息。

此属性的复杂类型信息。

获取或设置属性的并发模式。

属性的并发模式。

创建 EdmProperty 类型的新实例。

EdmProperty 类型的新实例 属性的名称。 属性

新建复杂属性。

新创建的属性。 属性的名称。 属性的类型。

新建枚举属性。

新创建的属性。 属性的名称。 属性的类型。

新建基元属性。

新创建的属性。 属性的名称。 属性的类型。

获取此 的默认值。

此 的默认值。

获取此属性的枚举类型信息。

此属性的枚举类型信息。

获取属性是否为集合类型属性的信息。

如果属性为集合类型属性，则为 true；否则为 false。

获取此属性是否为复杂类型属性的信息。

如果此属性为复杂类型属性，则为 true；否则为 false。

获取此属性是否为枚举类型属性的信息。

如果此属性为枚举类型属性，则为 true；否则为 false。

获取或设置此属性的长度是否是固定的信息。

如果此属性的长度是固定的，则为 true；否则为 false。

获取固定长度方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取或设置此属性是否使用提供程序支持的最大长度的信息。

如果此属性使用提供程序支持的最大长度，则为 true；否则为 false。

获取最大长度方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取精度方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取此属性是否为基元类型的信息。

如果此属性为基元类型，则为 true；否则为 false。

获取小数位数方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取此属性是否为基础基元类型的信息。

如果此属性为基础基元类型，则为 true；否则为 false。

获取或设置此属性是否为 Unicode 属性的信息。

如果此属性为 Unicode 属性，则为 true；否则为 false。

获取 Unicode 方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获得或设置属性的最大长度。

属性的最大长度。

获取一个值，该值指示此 的值是否可以为 null。

如果此 的值可以为 null，则为 true；否则为 false。

获取或设置此属性的精度。

此属性的精度。

获取此属性的基元类型信息。

此属性的基元类型信息。

获取或设置此属性的小数位数。

此属性的小数位数。

设置元数据属性。

要设置的元数据属性。

获取或设置与此属性相关联的数据库列的生成方法

属性的存储生成模式。

获取属性的类型名称。

属性的类型名称。

获取此属性的基础基元类型信息。

此属性的基础基元类型信息。

该类包装已遇到的架构错误的错误信息。

构造 EdmSchemaError 对象。

该错误的说明。 与此错误关联的代码。 错误的严重级别。

获取发生错误的列。

发生错误的列。

获取错误代码。

错误代码。

获取发生错误的行号。

发生错误的行号。

获取包含错误的架构的位置。此字符串还包括位于末尾的架构的名称。

包含错误的架构所在的位置。

获取包含错误的架构的名称。

包含错误的架构的名称。

获取错误的严重级别。

值之一。默认值为 。

获取发生错误时的堆栈跟踪的字符串表示形式。

发生错误时的堆栈跟踪的字符串表示形式。

返回错误消息。

错误消息。

定义在验证实体框架模型时可能出现的错误的不同严重级别。

导致无法使用模型的错误。

不会导致无法使用模型的警告。

用于所有模型类型的 EdmType 基类

获取一个值，该值指示此类型是否为抽象的。

如果此类型是抽象的，则为 true；否则为 false。

获取此类型的基类型。

此类型的基类型。

获取此类型的全名。

此类型的全名。

返回其元素类型属于此类型的 的实例。

其元素类型属于此类型的 对象。

获取此类型的名称。

此类型的名称。

获取此类型的命名空间。

此类型的命名空间。

返回此类型的全名。

此类型的全名。

表示某一实体容器的类

获取此实体容器的关联集。

此实体容器的关联集。

获取此 包括的实体集和关联集的列表。

一个 对象，其中包含此 包括的实体集和关联集的列表。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

用于构造 EntityContainer 对象的工厂方法。

要创建的实体容器的名称。 此实体容器所属的 DataSpace。 将包含在新容器中的实体集。可以为 null。 将包含在新容器中的函数。可以为 null。 要与该实例相关联的元数据属性。 在名称参数为 null 或是空字符串时引发。

获取此实体容器的实体集。

此实体容器的实体集。

指定 元素的集合。每个函数都包含数据库中存在的存储过程的详细信息，或映射到实体及其属性的等效 CommandText 的详细信息。

一个包含 元素的 。

使用实体集的指定名称返回一个 对象。

一个 对象，表示具有指定名称的实体集。 要搜索的实体集的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。

使用关系集的指定名称返回一个 对象。

一个 对象，表示具有指定名称的关系集。 要搜索的关系集的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。

获取此 的名称。

此 的名称。

从容器中删除特定实体集。

要删除的实体集。

返回此 的名称。

此 的名称。

使用实体集的指定名称返回一个 对象。

如果存在与搜索条件匹配的实体集，则为 true；否则为 false。 要搜索的实体集的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。 在此方法返回时，包含一个 对象。如果不存在实体集，此输出参数将包含 null。

使用关系集的指定名称返回一个 对象。

如果存在与搜索条件匹配的关系集，则为 true；否则为 false。 要搜索的关系集的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。 在此方法返回时，包含一个 对象。

表示在 EntityType 中定义的结构的特定用法。在概念模型中，这表示可以查询和存储实体的集。在存储模型中，它表示一个表。从存储空间模型约定中，它可用来通过 属性配置表名称，通过 属性配置表架构。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

构造该 EntitySet 对象的工厂方法。

EntitySet 的名称。 db 架构。可以为 null。 db 表。可以为 null。 应该用于检索此 EntitySet 的数据的提供程序特定的查询。可以为 null。 此实体集类型包含的实体的实体类型。 将添加到新创建的 EntitySet 的元数据属性。可以为 null。 在名称参数为 null 或是空字符串时引发。

获取此 的实体类型。

一个 对象，表示此 的实体类型。

表示某一实体集的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取描述此实体集的已转义提供程序特定的 SQL。

获取此 的实体类型。

一个 对象，表示此 的实体类型。

获取当前实体集或关系集的实体容器。

一个 对象，表示当前实体集或关系集的实体容器。

获取或设置当前实体集或关系集的名称。如果从存储空间更改此属性，则也必须更新映射层，以便反映新名称。若要更改存储空间 的表名称，请使用 Table 属性。

当前实体集或关系集的名称。

获取或设置此实体集的数据库架构。

获取或设置此实体集的数据库表名称。

返回当前实体集或关系集的名称。

当前实体集或关系集的名称。

表示 的结构。在概念模型中，这表示某一实体的形状和结构。在存储模型中，这表示表的结构。若要更改架构和表名称，请使用 EntitySet。

将指定的导航属性添加到此类型的成员。添加导航属性，而与只读标志无关。

要添加的导航属性。

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

构造该 EntityType 对象的工厂方法。

实体类型的名称。 此实体类型的命名空间。 此 EntityType 属于的数据空间。 该类型的键成员的名称。 该实体类型的成员（基元和导航属性）。 要与该实例相关联的元数据属性。 在 name 或 namespace 参数为 null 时引发。

获取实体类型的已声明成员的集合。

实体类型的已声明成员的集合。

获取与实体类型关联的已声明导航属性。

与实体类型关联的已声明导航属性。

获取实体类型的已声明属性的列表。

实体类型的已声明属性。

返回一个引用此 的 对象。

一个引用此 的 对象。

获取此 的导航属性。

一个 类型的集合，其中包含此 的导航属性列表。

获取此 的属性列表。

一个 类型的集合，其中包含此 的属性列表。

表示实体类型

将指定的属性添加到当前实体的键的列表。

如果成员参数为 null 在 EntityType 具有另一个 EntityTypeBase 的基类型时引发。在此情形下，KeyMembers 应该作为基类型添加 如果 EntityType 实例处于 ReadOnly 状态

获取当前实体或关系类型的所有键成员的列表。

一个 对象，表示当前实体或关系类型的键成员的列表。

获取此实体类型的所有键属性的列表。

此实体类型的所有键属性的列表。

从集合中删除指定的键成员。

要删除的键成员。

表示一个枚举成员。

获取此类型的种类。

获取该枚举成员的名称。

重写 System.Object.ToString 以提供针对此类型的更好的字符串表示形式。

获取该枚举成员的值。

表示一个枚举类型。

返回类型的种类

获取一个值，该值指示 enum 类型是否已定义为标志（即，可被视为位域）

获取此枚举类型的枚举成员的集合。

获取此枚举类型的基础类型。

表示某一 Facet 对象的类。此对象是不可变的（不是仅设置为只读）并且系统的某些部分正依赖于该行为

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取有关此 的说明。

对象，表示有关此 的说明。

获取此 的类型。

对象，表示此 的类型。

获取一个值，该值指示是否未绑定方面的值。

如果未绑定方面的值，则为 true；否则为 false。

获取此 的名称。

此 的名称。

返回此 的名称。

此 的名称。

获取此 的值。

此 的值。

表示 FacetDescription 对象的类

获取具有此方面说明的方面的默认值。

具有此方面说明的方面的默认值。

获取此方面的名称。

此方面的名称。

获取此方面的类型。

一个 对象，表示此方面的类型。

获取一个值，该值指示此方面的值是否为常量。

如果此方面是一个常量，则为 true；否则为 false。

获取一个值，该值指示此方面是否为必需的方面。

如果此方面是必需的方面，则为 true；否则为 false。

获取此方面的最大值。

此方面的最大值。

获取此方面的最小值。

此方面的最小值。

返回此方面的名称。

此方面的名称。

表示函数参数的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

构造该 对象的工厂方法。

类型的新的只读实例。 参数名。 参数的 EdmType。 参数的 。

获取已对其声明此参数的 。

一个 对象，表示已对其声明此参数的函数。

获取此参数是否使用数据库提供程序支持的最大长度的信息。

如果此参数使用数据库提供程序支持的最大长度，则为 true；否则为 false。

获取最大长度方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取精度方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取小数位数方面是否为数据库提供程序的常量的信息。

如果此方面为常量，则为 true；否则为 false。

获取参数的最大长度。

参数的最大长度。

获取此 的模式。

值之一。

获取此 的名称。

此 的名称。

获取参数的精度值。

参数的精度值。

获取参数的小数位数值。

参数的小数位数值。

返回此 的名称。

此 的名称。

获取此参数的类型名称。

此参数的类型名称。

获取既包含该参数的类型又包含该类型的各个方面的 类实例。

一个 对象，其中既包含该参数的类型又包含该类型的各个方面。

表示所有元数据的项基类

表示项的集合的类。该集合的实际维护的大部分实现由 MetadataCollection 完成

获取与此项集合关联的数据模型。

与此项集合关联的数据模型。

使用指定的实体容器名称返回一个 对象。

如果不存在实体容器，此方法将返回 null；否则它将返回第一个实体容器。 实体容器的名称。

使用指定的实体容器名称返回一个 对象。

如果不存在实体容器，此方法将返回 null；否则它将返回第一个实体容器。 实体容器的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。

使用指定的名称从此项集合中返回所有函数重载。

一个 ReadOnlyCollection 类型的集合，其中包含具有指定名称的所有函数。 一个函数字典。 函数的全名。 如果执行不区分大小写的搜索，则为 true；否则为 false。

使用指定的名称从此项集合中返回所有函数重载。

一个 类型的集合，其中包含具有指定名称的所有函数。 函数的全名。

使用指定的名称从此项集合中返回所有函数重载。

一个 类型的集合，其中包含具有指定名称的所有函数。 函数的全名。 如果执行不区分大小写的搜索，则为 true；否则为 false。

使用指定的标识返回一个强类型的 对象。

由标识指定的项。 项的标识。 由方法返回的类型。

通过使用指定的标识进行区分大小写或不区分大小写的搜索，返回一个强类型的 对象。

由标识指定的项。 项的标识。 如果执行不区分大小写的搜索，则为 true；否则为 false。 由方法返回的类型。

从此项集合中返回属于指定类型的所有项。

一个 类型的集合，其中包含属于指定类型的所有项。 由方法返回的类型。

使用指定的类型名称和命名空间名称从此项集合中返回一个 对象。

一个 对象，表示此项集合中与指定的类型名称和命名空间名称匹配的类型。如果不存在匹配的类型，此方法将返回 null。 类型名称。 类型的命名空间。

使用指定的类型名称和命名空间名称从此项集合中返回一个 对象。

一个 对象，表示此项集合中与指定的类型名称和命名空间名称匹配的类型。如果不存在匹配的类型，此方法将返回 null。 类型名称。 类型的命名空间。 如果执行不区分大小写的搜索，则为 true；否则为 false。

使用指定的实体容器名称返回一个 对象。如果不存在实体容器，此输出参数将包含 null；否则，它将包含第一个实体容器。

如果存在与搜索条件匹配的实体容器，则为 true；否则为 false。 实体容器的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。 它在此方法返回时会包含一个 对象。如果不存在实体容器，此输出参数将包含 null；否则，它将包含第一个实体容器。

使用指定的实体容器名称返回一个 对象。如果不存在实体容器，该输出参数将包含 null；否则，它将包含第一个实体容器。

如果存在与搜索条件匹配的实体容器，则为 true；否则为 false。 实体容器的名称。 它在此方法返回时会包含一个 对象。如果不存在实体容器，此输出参数将包含 null；否则，它将包含第一个实体容器。

使用指定的标识从此项集合中返回一个强类型的 对象。

如果存在与搜索条件匹配的项，则为 true；否则为 false。 项的标识。 如果执行不区分大小写的搜索，则为 true；否则为 false。 在此方法返回时，此输出参数会包含一个 对象。如果项集合中不存在具有指定标识的全局项，此输出参数将包含 null。 由方法返回的类型。

使用指定的标识从此项集合中返回一个强类型的 对象。

如果存在与搜索条件匹配的项，则为 true；否则为 false。 项的标识。 在此方法返回时，此输出参数会包含一个 对象。如果项集合中不存在具有指定标识的全局项，此输出参数将包含 null。 由方法返回的类型。

使用指定的类型名称和命名空间名称从此项集合中返回一个 对象。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 类型名称。 类型的命名空间。 如果执行不区分大小写的搜索，则为 true；否则为 false。 在此方法返回时，此输出参数会包含一个 对象。如果此项集合中不存在具有指定的名称和命名空间名称的类型，此输出参数将包含 null。

使用指定的类型名称和命名空间名称从此项集合中返回一个 对象。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 类型名称。 类型的命名空间。 在此方法返回时，此输出参数会包含一个 对象。如果此项集合中不存在具有指定的名称和命名空间名称的类型，此输出参数将包含 null。

表示所有元数据的项基类

添加具有指定名称和值的批注。

批注属性的名称。 批注属性的值。

获取此类型的内置类型种类。

一个 对象，表示此类型的内置类型种类。

获取或设置与此类型关联的文档。

一个 对象，表示介绍此类型的文档。

返回一个与 值之一匹配的概念模型内置类型。

一个 对象，表示 EDM 中的内置类型。 值之一。

返回有关指定类型的常规方面的说明列表。

一个 对象，表示有关指定类型的常规方面的说明列表。

获取当前类型的属性列表。

一个 类型的集合，其中包含当前类型的属性列表。

删除具有指定名称的批注。

批注属性的名称。

表示某一项的元数据特性的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

构造该 MetadataProperty 对象的工厂方法。

元数据属性的名称。 该元数据属性的类型用法。 元数据属性的值。 为 null 时引发。

获取此 的名称。

此 的名称。

获取此 的值。

此 的值。

获取既包含此 的类型又包含该类型的各个方面的 类实例。

一个 对象，其中既包含此 的类型又包含该类型的各个方面。

获取此 的值。

此 的值。

运行时元数据工作区

初始化 类的新实例。

使用指定的路径和程序集初始化 类的新实例。

工作区元数据的路径。 用于构造工作区的程序集的名称。

使用来自传统 EDMX 映射的所有项集合 () 的加载程序构造一个 。将使用默认的 o-space 和 o/c 映射集合。首次使用给定集合时，会惰式执行项集合委托。可以传递一个委托，以便在集合从不会被使用时返回 null，但极少这样做，因为在这种情况下，EF 使用集合的任何尝试都将导致异常。

委托以返回 c-space (CSDL) 项集合。 委托以返回 s-space (SSDL) 项集合。 委托以返回 c/s 映射 (MSL) 项集合。

使用 EF 所需的所有项集合 () 的加载程序构造一个 ，o/c 映射除外，将基于给定的 o-space 和 c-space 加载程序自动创建该映射。首次使用给定集合时，会惰式执行项集合委托。可以传递一个委托，以便在集合从不会被使用时返回 null，但极少这样做，因为在这种情况下，EF 使用集合的任何尝试都将导致异常。

委托以返回 c-space (CSDL) 项集合。 委托以返回 s-space (SSDL) 项集合。 委托以返回 c/s 映射 (MSL) 项集合。 委托以返回 o-space 项集合。

清除所有的元数据缓存条目。

创建配置为使用 数据空间的 。

创建的分析器对象。

基于指定的查询表达式，创建限定为此元数据工作区的新 。

使用指定表达式作为其 属性的新 。 一个定义查询的 。 如果 为 null 如果 包含在此元数据工作区无法解析的元数据 如果 因为包含无法解析的变量引用导致结构无效

返回一个 对象，该对象表示与参数 objectSpaceType 提供的类型匹配的 。

一个表示 的 对象。如果不存在匹配的类型，此方法将返回 null。 一个在对象空间中提供类型的 。

返回一个 对象，该对象表示与参数 objectSpaceType 提供的类型匹配的 。

一个表示 的 对象。如果不存在匹配的类型，此方法将返回 null。 一个在对象空间中提供类型的 。

使用指定的实体容器名称和数据模型返回一个 对象。

如果不存在实体容器，此方法将返回 null；否则它将返回第一个实体容器。 实体容器的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索实体容器的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的实体容器名称和数据模型返回一个 对象。

如果不存在实体容器，此方法将返回 null；否则它将返回第一个实体容器。 实体容器的名称。 要从中搜索实体容器的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的名称、命名空间名称和数据模型返回所有函数重载。

一个 类型的集合，其中包含给定命名空间和数据模型中与指定名称匹配的所有函数。 函数的名称。 函数的命名空间。 要从中搜索函数的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的名称、命名空间名称和数据模型返回所有函数重载。

一个 类型的集合，其中包含给定命名空间和数据模型中与指定名称匹配的所有函数。 函数的名称。 函数的命名空间。 要从中搜索函数的概念模型。 如果执行不区分大小写的搜索，则为 true；否则为 false。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的标识和数据模型返回一个项。

指定的数据模型中与给定标识匹配的项。 项的标识。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索项的概念模型。 由方法返回的类型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的标识和数据模型返回一个项。

指定的数据模型中与给定标识匹配的项。 项的标识。 要从中搜索项的概念模型。 由方法返回的类型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

获取 项。

项。 要从其中检索项的 。

获取指定数据模型中的所有项。

一个 类型的集合，其中包含指定数据模型中的所有项。 需要其项列表的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

获取指定数据模型中的所有项。

一个 类型的集合，其中包含指定数据模型中的所有项。 需要其项列表的概念模型。 由方法返回的类型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

返回一个 对象，该对象表示与参数 edmSpaceType 提供的类型匹配的对象空间类型。

一个表示对象空间类型的 对象。如果不存在匹配的类型，此方法将返回 null。 一个表示 的 对象。

返回一个 对象，该对象表示与参数 edmSpaceType 提供的类型匹配的对象空间类型。

一个表示对象空间类型的 对象。如果不存在匹配的类型，此方法将返回 null。 一个表示 的 对象。

返回指定数据模型中的基元类型列表。

一个 类型的集合，其中包含指定数据模型中的所有基元类型。 需要获取其基元类型列表的数据模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

返回在修改实体时需要对其使用原始值的给定 / 的成员。

需要原始值的 。 属于 C-Space 的 。 参与给定 的 。 如果可以部分更新实体，则为 true；否则为 false。

从实体集和实体类型获取原始值成员。

实体集和实体类型中的原始值成员。 从中检索原始值的实体集。 对其检索原始值的实体类型。

使用指定的类型名称、命名空间名称和数据模型返回一个 对象。

一个 对象。 类型名称。 类型的命名空间。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索类型的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

使用指定的类型名称、命名空间名称和数据模型返回一个 对象。

一个 对象，表示指定的数据模型中与给定的类型名称和命名空间名称匹配的类型。如果不存在匹配的类型，此方法将返回 null。 类型名称。 类型的命名空间。 要从中搜索类型的概念模型。 空间无效时引发。有效空间为 C、O、CS 或 OCSpace

加载给定程序集中的元数据。

将加载其元数据的程序集。

加载给定程序集中的元数据。

将加载其元数据的程序集。 用于记录加载消息的委托。

运行时将支持的最高 EDM 版本。

在每个关联的数据模型中注册项集合。

需要填充的输出参数集合。

通过输出参数 edmSpaceType 返回一个 对象，该对象表示与参数 objectSpaceType 提供的类型匹配的 。

如果成功，则为 true；如果失败，则为 false。 一个表示对象空间类型的 对象。 在此方法返回时，包含一个表示 的 对象。此参数未经初始化即被传递。

通过输出参数 edmSpaceType 返回一个 对象，该对象表示与参数 objectSpaceType 提供的类型匹配的 。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 一个表示对象空间类型的 对象。 在此方法返回时，包含一个表示 的 对象。此参数未经初始化即被传递。

使用指定的实体容器名称和数据模型返回一个 对象。

如果存在与搜索条件匹配的实体容器，则为 true；否则为 false。 实体容器的名称。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索实体容器的概念模型。 在此方法返回时，包含一个 对象。如果不存在实体容器，此输出参数将包含 null；否则，它将返回第一个实体容器。此参数未经初始化即被传递。

使用指定的实体容器名称和数据模型返回一个 对象。

如果存在与搜索条件匹配的实体容器，则为 true；否则为 false。 实体容器的名称。 要从中搜索实体容器的概念模型。 在此方法返回时，包含一个 对象。如果不存在实体容器，此输出参数将包含 null；否则，它将返回第一个实体容器。此参数未经初始化即被传递。

使用指定的标识和数据模型返回一个项。

如果存在与搜索条件匹配的项，则为 true；否则为 false。 要从中搜索项的概念模型。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索项的概念模型。 在此方法返回时，包含一个 对象。此参数未经初始化即被传递。 由方法返回的类型。

使用指定的标识和数据模型返回一个项。

如果存在与搜索条件匹配的项，则为 true；否则为 false。 要从中搜索项的概念模型。 要从中搜索项的概念模型。 在此方法返回时，包含一个 对象。此参数未经初始化即被传递。 由方法返回的类型。

测试对 的检索。

如果检索成功，则为 true，否则为 false。 从中尝试 检索的 。 在此方法返回时，包含项集合。此参数未经初始化即被传递。

通过输出参数 objectSpaceType 返回一个 对象，该对象表示与参数 edmSpaceType 提供的 匹配的类型。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 一个表示 的 对象。 此方法返回时，包含一个 对象，该对象表示对象空间类型。此参数未经初始化即被传递。

通过输出参数 objectSpaceType 返回一个 对象，该对象表示与参数 edmSpaceType 提供的 匹配的类型。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 一个表示 的 对象。 此方法返回时，包含一个 对象，该对象表示对象空间类型。此参数未经初始化即被传递。

使用指定的类型名称、命名空间名称和数据模型返回一个 对象。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 类型名称。 类型的命名空间。 如果执行不区分大小写的搜索，则为 true；否则为 false。 要从中搜索类型的概念模型。 在此方法返回时，包含一个 对象。此参数未经初始化即被传递。

使用指定的类型名称、命名空间名称和数据模型返回一个 对象。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 类型名称。 类型的命名空间。 要从中搜索类型的概念模型。 在此方法返回时，包含一个 对象。此参数未经初始化即被传递。

表示 edm 导航属性类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

从指定的参数创建一个 NavigationProperty 实例。

新创建的 NavigationProperty 实例。 导航属性的名称。 指定导航属性类型及其方面。 导航的关系类型。 导航中的源端成员。 导航中的目标端成员。

获取此导航中的“源”关系 End 成员。

此导航中的“源”关系 End 成员。

在给定的导航属性位于引用约束的依赖端时，返回外键属性。否则，返回空集。我们将按主体端键属性的顺序返回这些成员。

外键属性的集合。

获取此导航属性操作的关系类型。

此导航属性操作的关系类型。

获取此导航的“目标”关系 End 成员。

此导航的“目标”关系 End 成员。

表示对象层的项集合的类。该集合的实际维护的大部分实现由 ItemCollection 完成

初始化 类的新实例。

该方法返回指定 OSpace 类型参数的基础 CLR 类型。如果该参数的 DataSpace 不为 OSpace，则引发 ArgumentException。

OSpace 参数的 CLR 类型。 要查找的 OSpace 类型。

返回与 objectSpaceType 参数提供的 相对应的 CLR 类型。

OSpace 参数的 CLR 类型。 一个表示对象空间类型的 。

从此项集合中返回属于指定类型的所有项。

一个 类型的集合，其中包含属于指定类型的所有项。 由方法返回的类型。

返回基元类型对象集合。

基元类型对象的集合。

加载给定程序集中的元数据。

将加载其元数据的程序集。

从指定的程序集加载元数据。

将加载其元数据的程序集。 O space 元数据的 EDM 元数据源。

加载给定程序集中的元数据。

将加载其元数据的程序集。 O space 元数据的 EDM 元数据源。 将向其发送日志消息的委托。

返回指定的枚举类型参数的基础 CLR 类型。如果该参数的 DataSpace 不为 OSpace，则此方法返回 false 并将 out 参数设置为 null。

如果成功，则为 true；如果失败，则为 false 要查找的 OSpace 枚举类型 OSpace 参数的 CLR 枚举类型

返回与 objectSpaceType 参数提供的 相对应的 CLR 类型。

如果存在与搜索条件匹配的类型，则为 true；否则为 false。 一个表示对象空间类型的 。 CLR 类型。

表示针对删除操作的可能操作的列表

级联到其他端

不执行任何操作

定义参数的模式的枚举

In 参数

in 和 out 参数

Out 参数

返回参数

定义用于解析函数重载的类型语义的枚举。这些标志是在提供程序清单中根据函数定义来定义的。

允许在给定参数类型和形参类型（默认值）之间进行隐式转换。

允许在给定参数类型和形参类型之间进行类型提升。

仅使用严格等效。

表示基元类型的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

返回与此 等效的公共语言运行时 (CLR) 类型。请注意， 属性始终返回不可以为 null 的类型值。

一个 对象，表示与此 等效的公共语言运行时 (CLR) 类型。

获取有关此 各方面的说明列表。

一个 类型的集合，其中包含有关此 的方面说明列表。

返回与此 等效的 。

一个与此 等效的 对象。

返回 的等效 。

一个 对象，该对象是指定的 的等效项。 一个 类型的值。

返回基元类型的列表。

一个 类型的集合，其中包含基元类型的列表。

获取一个 枚举值，该值指示此 的基元类型。

一个指示此 的基元类型的 枚举值。

EDM 定义的基元类型

Binary 类型种类

Boolean 类型种类

Byte 类型种类

DateTime 类型种类

DateTimeOffset 类型种类

Decimal 类型种类

Double 类型种类

Geography 类型种类

Geographic 集合类型种类

Geographic 线性环类型种类

Geographic 多线性环类型种类

Geographic 多点类型种类

Geographic 多多边形类型种类

Geographic 单点类型种类

Geographic 多边形类型种类

Geometry 类型种类

Geometric 集合类型种类

Geometric 线性环类型种类

Geometric 多线性环类型种类

Geometric 多点类型种类

Geometric 多多边形类型种类

Geometric 单点类型种类

Geometric 多边形类型种类

Guid 类型种类

Int16 类型种类

Int32 类型种类

Int64 类型种类

SByte 类型种类

Single 类型种类

String 类型种类

Time 类型种类

指定概念模型中项特性的种类。

一个指示项特性为 Extended 的枚举成员。

一个指示项特性为 System 的枚举成员

表示 MetadataCollection 周围的只读包装的类

此集合中项的类型

确定集合中是否包含具有指定标识的项。

如果集合中包含要搜索的项，则为 true；否则为 false。默认值为 false。 项的标识。

返回一个可循环访问此集合的枚举器。

一个可用于循环访问此 的 。

使用指定的标识从此集合中检索一个项。

此集合中的一个项。 要搜索的项的标识。 如果执行不区分大小写的搜索，则为 true；否则为 false。

返回指定的值在此集合中的索引。

指定的值在此集合中的索引。 要搜寻的值。

获取一个值，该值指示此集合是否是只读的。

如果此集合是只读的，则为 true；否则为 false。

使用指定的标识从此集合中获取一个项。

此集合中的一个项。

使用指定的标识从此集合中检索一个项。

如果存在与搜索条件匹配的项，则为 true；否则为 false。 要搜索的项的标识。 如果执行不区分大小写的搜索，则为 true；否则为 false。 在此方法返回时，此输出参数会包含集合中的一个项。如果不存在匹配的项，此输出参数将包含 null。

MetadataCollection 的枚举器

获取位于当前位置的成员。

位于当前位置的成员。

释放此枚举器。

移至 类型的集合中的下一个成员。

如果枚举器在 类型的集合中发生了移动，则为 true；否则为 false。

将枚举器定位在 类型的集合中的第一个位置之前。

获取位于当前位置的成员

该类表示指定关系的“to”和“from”端的两个实体之间的引用约束。

在该关系上构造一个新约束

该关系源自的角色 该关系链接到/针对的角色 参与约束的目标角色的实体类型上的属性 参与约束的源角色的实体类型上的属性 如果任何参数为 null，则引发参数 Null 异常

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取定义此 时使用的“源角色”的属性列表。

一个 类型的集合，其中包含定义此 时使用的“源角色”的属性列表。

获取参与此 的“源角色”。

一个 对象，表示参与此 的“源角色”。

获取定义此 时使用的“目标角色”的属性列表。

一个 类型的集合，其中包含定义此 时使用的“目标角色”的属性列表。

获取参与此 的“目标角色”。

一个 对象，表示参与此 的“目标角色”。

返回 和 的名称组合。

和 的名称组合。

表示 ref 类型的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取此 引用的实体类型。

一个 对象，表示此 引用的实体类型。

初始化 RelationshipEndMember 类的新实例

获取此关系 End 成员的操作行为。

值之一。默认值为 。

访问关联中的 EndMember 的 EntityType。

关联中的 EndMember 的 EntityType。

获取此关系 End 成员的重数。

值之一。

表示与关系类型的端有关的多重性信息

下限为 0，上限为 null

下限和上限均为 1

下限为 0，上限为 1

表示关系集的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

获取此 的关系类型。

一个 对象，表示此 的关系类型。

表示关系类型

获取此关系类型的 End 列表。

一个 类型的集合，其中包含此关系类型的 End 列表。

表示 Edm 行类型

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

构造该 对象的工厂方法。

对象的新的只读实例。 行类型对象的属性。 将添加到该函数的元数据属性。可以为 null。

获取由当前类型定义的属性集合。

由当前类型定义的属性集合。

获取此 的属性列表。

一个 类型的集合，其中包含此 的属性列表。

表示简单类型的类

服务器生成的属性的模式。

执行 INSERT 和 UPDATE 时都将生成一个值。

执行 INSERT 时生成一个值，但在执行 UPDATE 时保持不变。

不是服务器生成的属性。这是默认值。

表示存储空间中项的集合的类。

使用指定的 XMLReader 初始化 类的新实例。

用于创建元数据的 XMLReader。

初始化 类的新实例。

的模型。

使用指定的文件路径初始化 类的新实例。

用于创建元数据的文件路径。

创建 的工厂方法。

如果未遇到错误，则为 实例。否则为 null。 要加载的 SSDL 项目。不得是 null。 SSDL 项目的路径。用于错误消息中。可为 null，在此情况下，XmlReader 的基 Uri 将用作路径。 自定义解析程序。目前用于解析 DbProviderServices 实现。如果为 null，将使用默认解析程序。 加载时遇到的错误的集合。

返回一个由 对象构成的集合。

一个 对象，表示 对象的集合。

获取 StoreItemCollection 的提供程序工厂。

StoreItemCollection 的提供程序工厂。

获取 StoreItemCollection 的固定名称。

StoreItemCollection 的固定名称。

获取 StoreItemCollection 的提供程序清单。

StoreItemCollection 的提供程序清单。

获取 StoreItemCollection 的清单标记。

StoreItemCollection 的清单标记。

获取此集合的存储架构版本。

此集合的存储架构版本。

表示结构化类型

向此类型添加成员

要添加的成员

获取此类型的成员列表。

一个 类型的集合，其中包含此类型的一组成员。

从此类型删除成员。

要删除的成员。

表示某一项的类型信息的类

获取此 的内置类型种类。

一个 对象，表示此 的内置类型种类。

用于创建具有指定 EdmType 和方面的 TypeUsage 的工厂方法

新的 TypeUsage 实例 要为其创建类型用法的 EdmType 要复制到新的 TypeUsage 中的方面

创建一个使用指定方面值描述二进制类型的 对象。

一个使用指定方面值描述二进制类型的 对象。 要为其创建 对象的 。 如果将二进制类型的长度设置为固定数值，则为 true；否则为 false。

创建一个使用指定方面值描述二进制类型的 对象。

一个使用指定方面值描述二进制类型的 对象。 要为其创建 对象的 。 如果将二进制类型的长度设置为固定数值，则为 true；否则为 false。 二进制类型的最大长度。

创建参数所描述类型的 对象。

对象。 用于定义偏移的度量单位的简单类型。 用秒的小数部分（基于支持的小数位数）表示的 DateTimeOffset 的粒度。例如，精度为 3 表示支持的粒度为毫秒。

创建参数所描述类型的 对象。

对象。 用于定义 DateTime 对象的度量单位的简单类型。 用秒的小数部分（基于支持的小数位数）表示的 DateTimeOffset 的粒度。例如，精度为 3 表示支持的粒度为毫秒。

创建一个用无限精度和小数位数方面值描述十进制类型的 对象。

一个使用无限精度和小数位数方面值描述十进制类型的 对象。 要为其创建 对象的 。

创建一个使用指定方面值描述十进制类型的 对象。

一个使用指定方面值描述十进制类型的 对象。 要为其创建 对象的 。 十进制类型（以 类型表示）的精度。 十进制类型（以 类型表示）的小数位数。

创建一个具有指定概念模型类型的 对象。

一个具有指定 的默认方面值的 对象。 要为其创建 对象的 。

创建一个使用指定方面值和无限 MaxLength 描述字符串类型的 对象。

一个使用指定方面和无限 MaxLength 描述字符串类型的 对象。 要为其创建 对象的 。 如果将字符串类型的字符编码标准设置为 Unicode，则为 true；否则为 false。 如果将字符串类型的长度设置为固定数值，则为 true；否则为 false

创建一个使用指定方面值描述字符串类型的 对象。

一个使用指定方面值描述字符串类型的 对象。 要为其创建 对象的 。 如果将字符串类型的字符编码标准设置为 Unicode，则为 true；否则为 false。 如果将字符串类型的字符编码标准设置为 Unicode，则为 true；否则为 false。 如果将字符串类型的长度设置为固定数值，则为 true；否则为 false。

创建参数所描述类型的 对象。

对象。 用于定义 DateTime 对象的度量单位的简单类型。 用秒的小数部分（基于支持的小数位数）表示的 DateTimeOffset 的粒度。例如，精度为 3 表示支持的粒度为毫秒。

获取由此 描述的类型信息。

一个 对象，表示由此 描述的类型信息。

获取由此 描述的类型的方面列表。

一个 类型的集合，其中包含由此 描述的类型的方面列表。

检查此 是否为指定 的子类型。

如果此 是指定 的子类型，则为 true；否则为 false。 要检查的 对象。

返回某一提供程序类型的模型类型用法

模型 (CSpace) 类型用法

返回由此 描述的类型的全名。

此 描述的类型的全名（采用字符串的形式）。

缓存 ELinq 查询

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg11 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg11 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg12 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg11 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg12 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg13 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg11 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg12 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg13 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg14 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg8 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg9 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg10 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg11 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg12 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg13 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg14 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg15 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

创建一个表示已编译的 LINQ to Entities 查询的新委托。

，这是一个表示已编译的 LINQ to Entities 查询的泛型委托。 要编译的 lambda 表达式。 由 派生的类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg1 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg2 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg3 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg4 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg5 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg6 必须为基元类型。 表示在执行由此方法返回的委托时必须传入的参数的类型。TArg7 必须为基元类型。 通过执行由 方法返回的委托所返回的查询结果的类型 T。

当前赋给实体的各个属性的值。

提供对对象数据的原始值的访问。DbUpdatableDataRecord 实现可用于更新对象的原始值的方法。

获取数据记录信息。

对象。

获取记录中的字段数。

整数值字段数。

检索布尔值形式的字段值。

布尔值形式的字段值。 字段的序号。

检索字节形式的字段值。

字节形式的字段值。 字段的序号。

检索字节数组形式的字段值。

已复制的字节数。 字段的序号。 开始复制数据的位置的索引。 将数据复制到其中的目标缓冲区。 目标缓冲区中开始复制的位置的索引。 要复制的字节数。

检索字符形式的字段值。

字符形式的字段值。 字段的序号。

检索字符数组形式的字段值。

已复制的字符数。 字段的序号。 开始复制数据的位置的索引。 将数据复制到其中的目标缓冲区。 目标缓冲区中开始复制的位置的索引。 要复制的字符数。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索字段数据类型的名称。

字段数据类型的名称。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索十进制形式的字段值。

十进制形式的字段值。 字段的序号。

检索双精度值形式的字段值。

双精度值形式的字段值。 字段的序号。

检索字段的类型。

字段类型。 字段的序号。

检索浮点形式的字段值。

浮点形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索 形式的字段值。

形式的字段值。 字段的序号。

检索字段的名称。

字段的名称。 字段的序号。

使用字段名检索字段的序号。

字段的序号。 字段的名称。

检索字段的值。

字段值。 字段的序号。

检索字符串形式的字段值。

字段值。 字段的序号。

检索字段的值。

字段值。 字段的序号。

使用当前记录的字段值来填充对象数组。

返回的字段值的数目。 用于存储字段值的对象数组。

返回指定字段是否设置为 。

如果字段设置为 ，则为 true；否则为 false。 字段的序号。

返回具有给定字段序号的值。

具有给定字段序号的值。

获取具有给定字段名称的值。

字段值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

将一个字段设置为 值。

字段的序号。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中一个字段的值。

字段的序号。 字段的值。

设置记录中的字段值。

已设置的字段数。 字段的值。

检索 形式的字段值。

形式的字段值。 字段的序号。

提供在 或 LINQ to Entities 查询中使用的公开 EDM 规范函数的公共语言运行时 (CLR) 方法。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddDays EDM 函数以将指定的天数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的天数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddDays EDM 函数以将指定的天数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的天数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddHours EDM 函数以将指定的小时数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的小时数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMicroseconds EDM 函数以将指定的微秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的微秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMilliseconds EDM 函数以将指定的毫秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的毫秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMinutes EDM 函数以将指定的分钟数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的分钟数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMonths EDM 函数以将指定的月数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的月数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddMonths EDM 函数以将指定的月数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的月数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddNanoseconds EDM 函数以将指定的纳秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的纳秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddSeconds EDM 函数以将指定的秒数加到某个时间跨度。

所得到的时间跨度。 输入日期/时间。 要添加的秒数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddYears EDM 函数以将指定的年数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的年数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 AddYears EDM 函数以将指定的年数加到某个日期/时间。

所得到的日期/时间。 输入日期/时间。 要添加的年数。

作为 LINQ to Entities 查询的一部分使用时，此方法充当确保将输入作为非 Unicode 字符串处理的运算符。

作为非 Unicode 字符串处理的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法充当确保将输入作为 Unicode 字符串处理的运算符。

作为 Unicode 字符串处理的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateDateTime EDM 函数以创建新的 对象。

新的日期/时间。 年。 月（从 1 开始）。 日（从 1 开始）。 小时。 分钟。 秒，根据需要可包括秒的分数部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateDateTimeOffset EDM 函数以创建新的 对象。

新的日期/时间。 年。 月（从 1 开始）。 日（从 1 开始）。 小时。 分钟。 秒，根据需要可包括秒的分数部分。 新日期的时区偏移量部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 CreateTime EDM 函数以创建新的 对象。

新的时间跨度。 小时。 分钟。 秒，根据需要可包括秒的分数部分。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffDays EDM 函数以计算两个日期/时间间隔的天数。

第一个日期/时间和第二个日期/时间间隔的天数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffDays EDM 函数以计算两个日期/时间间隔的天数。

第一个日期/时间和第二个日期/时间间隔的天数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个日期/时间间隔的小时数。

第一个日期/时间和第二个日期/时间间隔的小时数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个日期/时间间隔的小时数。

第一个日期/时间和第二个日期/时间间隔的小时数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffHours EDM 函数以计算两个时间跨度间隔的小时数。

第一个时间跨度和第二个时间跨度间隔的小时数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个日期/时间间隔的微秒数。

第一个日期/时间和第二个日期/时间间隔的微秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个日期/时间间隔的微秒数。

第一个日期/时间和第二个日期/时间间隔的微秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMicroseconds EDM 函数以计算两个时间跨度间隔的微秒数。

第一个时间跨度和第二个时间跨度间隔的微秒数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个日期/时间间隔的毫秒数。

第一个日期/时间和第二个日期/时间间隔的毫秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个日期/时间间隔的毫秒数。

第一个日期/时间和第二个日期/时间间隔的毫秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMilliseconds EDM 函数以计算两个时间跨度间隔的毫秒数。

第一个时间跨度和第二个时间跨度间隔的毫秒数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个日期/时间间隔的分钟数。

第一个日期/时间和第二个日期/时间间隔的分钟数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个日期/时间间隔的分钟数。

第一个日期/时间和第二个日期/时间间隔的分钟数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMinutes EDM 函数以计算两个时间跨度间隔的分钟数。

第一个时间跨度和第二个时间跨度间隔的分钟数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMonths EDM 函数以计算两个日期/时间间隔的月数。

第一个日期/时间和第二个日期/时间间隔的月数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffMonths EDM 函数以计算两个日期/时间间隔的月数。

第一个日期/时间和第二个日期/时间间隔的月数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个日期/时间间隔的纳秒数。

第一个日期/时间和第二个日期/时间间隔的纳秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个日期/时间间隔的纳秒数。

第一个日期/时间和第二个日期/时间间隔的纳秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffNanoseconds EDM 函数以计算两个时间跨度间隔的纳秒数。

第一个时间跨度和第二个时间跨度间隔的纳秒数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个日期/时间间隔的秒数。

第一个日期/时间和第二个日期/时间间隔的秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个日期/时间间隔的秒数。

第一个日期/时间和第二个日期/时间间隔的秒数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffSeconds EDM 函数以计算两个时间跨度间隔的秒数。

第一个时间跨度和第二个时间跨度间隔的秒数。 第一个时间跨度。 第二个时间跨度。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffYears EDM 函数以计算两个日期/时间间隔的年数。

第一个日期/时间和第二个日期/时间间隔的年数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 DiffYears EDM 函数以计算两个日期/时间间隔的年数。

第一个日期/时间和第二个日期/时间间隔的年数。 第一个日期/时间。 第二个日期/时间。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 GetTotalOffsetMinutes EDM 函数以返回指定的日期/时间偏移 UTC 的分钟数。该值通常介于 +780 到 -780 之间（+ 或 - 13 小时）。

输入对 UTC 的偏移量。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Left 函数以返回字符串中最左侧指定数目的字符。

包含从输入字符串左侧算起的所请求的字符数的字符串。 输入字符串。 要返回的字符数

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Reverse 函数以返回其字符顺序反转的指定字符串。

以反转字符顺序显示的输入字符串。 输入字符串。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Right 函数以返回字符串中最右侧指定数目的字符。

包含从输入字符串右侧算起的所请求的字符数的字符串。 输入字符串。 要返回的字符数

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDev EDM 函数以计算集合的标准差。

标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 StDevP EDM 函数以计算总体的标准差。

总体的标准差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Truncate EDM 函数以将指定的值截断为指定的位数。

截整值。 要截断的值。 要保留的位数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Truncate EDM 函数以将指定的值截断为指定的位数。

截整值。 要截断的值。 要保留的位数。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 TruncateTime EDM 函数以返回清除了时间部分的指定日期。

清除了时间部分的输入日期。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 TruncateTime EDM 函数以返回清除了时间部分的指定日期。

清除了时间部分的输入日期。 要使用的日期/时间值。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 Var EDM 函数以计算集合的方差。

方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

作为 LINQ to Entities 查询的一部分使用时，此方法调用规范 VarP EDM 函数以计算总体的方差。

总体的方差。 要对其执行计算的集合。

用于查询执行的选项。

创建 的新实例。

要用于实体结果的合并选项。 查询是流式处理还是缓存。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象

用作特定类型的哈希函数。

当前对象的哈希代码。

要用于实体结果的合并选项。

确定指定的对象是否相等。

如果两个对象相等，则为 true；否则为 false。 要比较的左侧对象。 要比较的右侧对象。

确定指定的对象是否不相等。

如果两个对象不相等，则为 true；否则为 false。 要比较的左侧对象。 要比较的右侧对象。

查询是流式处理还是缓存。

定义 IQueryable 实现的行为，该实现允许修改结果集的成员资格。

从查询返回的实体类型。

通知对象集，必须将表示新实体的对象添加到该集中。

要添加到集中的新对象。

通知对象集，必须将表示现有实体的对象添加到该集中。

要添加到集中的现有对象。

通知对象集，必须从中删除表示现有实体的对象。

要从集中删除的现有对象。

通知对象集，必须从中分离表示现有实体的对象。

要从对象集中分离的对象。

可将从数据库加载的新对象与内存中现有对象合并的不同方法。

将仅追加新的（顶级唯一）行。这是默认行为。

将不修改缓存。

与 LoadOption.OverwriteChanges 的行为相同。

与 LoadOption.PreserveChanges 的行为相同。

ObjectContext 是封装 CLR 和数据库之间的连接的顶级元素，充当“创建”、“读取”、“更新”和“删除”操作的网关。

使用给定的连接初始化 类的新实例。在构造过程中，从 对象提取元数据工作区。

一种包含对模型和数据源连接的引用的 。 connection 为 null。 connection 无效或元数据工作区无效。

使用给定的连接和元数据工作区创建 ObjectContext。

与存储区的连接 如果设置为 true，则释放上下文时将释放该连接；否则调用方必须释放该连接。

使用给定连接和实体容器名称初始化 类的新实例。

一种包含对模型和数据源连接的引用的 。 默认实体容器的名称。通过此方法设置 defaultContainerName 时，该属性为只读属性。 connection 为 null。 connection、defaultContainerName 或元数据工作区无效。

使用给定连接字符串和默认实体容器名称初始化 类的新实例。

连接字符串，该连接字符串还提供对元数据信息的访问。 connectionString 为 null。 connectionString 无效或元数据工作区无效。

使用给定连接字符串和实体容器名称初始化 类的新实例。

连接字符串，该连接字符串还提供对元数据信息的访问。 默认实体容器的名称。通过此方法设置 defaultContainerName 时，该属性为只读属性。 connectionString 为 null。 connectionString、defaultContainerName 或元数据工作区无效。

接受在对象上下文中对对象所做的所有更改。

将对象添加到对象上下文。

表示实体集名称，可以选择通过实体容器名称对它进行限定。 要添加的 。 entity 参数为 null 或 entitySetName 未限定。

将标量值从提供的对象复制到 中具有相同键的对象中。

已更新的对象。 对象所属实体集的名称。 其属性更新将应用于原始对象的已分离对象。currentEntity 的实体键必须与 中某个项的 属性相匹配。 对象的实体类型。 entitySetName 或 current 为 null。 来自 entitySetName 的 与对象的 的 不匹配，或对象不在 中，或对象处于 状态，或所提供对象的实体键无效。 entitySetName 为空字符串。

将标量值从提供的对象复制到 中具有相同键的对象的原始值集中。

已更新的对象。 对象所属实体集的名称。 具有要应用于对象的原始值的已分离对象。originalEntity 的实体键必须与 中某个项的 属性相匹配。 实体对象的类型。 entitySetName 或 original 为 null。 来自 entitySetName 的 与对象的 的 不匹配，或在 中找不到对象的 ，或对象处于 或 状态，或所提供对象的实体键无效或属性发生了更改。 entitySetName 为空字符串。

将已分离对象的属性更改应用于已附加到对象上下文的对象。

对象所属实体集的名称。 其属性更新将应用于原始对象的已分离对象。 当 entitySetName 为 null 或空字符串时，或当 changed 为 null 时。 当来自 entitySetName 的 与对象的 的 不匹配时，或实体未处于 或 状态时，或原始对象未附加到上下文时。 当 changed 对象的类型与原始对象的类型不同时。

在对象具有实体键时将对象或对象图附加到对象上下文。

要附加的对象。 entity 为 null。 无效的实体键。

将特定实体集中的对象或对象图附加到对象上下文。

表示实体集名称，可以选择通过实体容器名称对它进行限定。 要附加的 。 entity 为 null。 实体集无效，或对象具有临时键，或对象具有 且 与作为方法参数传入的实体集不匹配，或对象没有 且未提供任何实体集，或对象图的任意对象具有临时 ，或对象图的任意对象具有无效的 （例如，键中的值与对象中的值不匹配），或无法根据给定的 entitySetName 名称和实体容器名称找到实体集，或对象图的任意对象已存于其他状态管理器中。

获取或设置所有对象上下文操作的超时值（以秒为单位）。null 值指示将使用基础提供程序的默认值。

作为超时值的 值（以秒为单位）。

获取对象上下文使用的连接。

一个作为连接的 对象。

获取 实例，该实例包含影响 行为的选项。

实例，该实例包含影响 的行为的选项。

使用当前数据源连接和 中的元数据创建数据库。

生成数据定义语言 (DDL) 脚本，该脚本为 中的元数据创建架构对象（表、主键、外键）。 用于加载存储架构定义语言 (SSDL) 文件中的元数据。

一个 DDL 脚本，该脚本为 中的元数据创建架构对象。

为特定对象创建实体键，如果实体键已存在，则返回该键。

对象的 。 实体对象所属实体集的完全限定名称。 要为其检索实体键的对象。 当任一参数为 null 时。 当 entitySetName 为空时，或实体对象的类型在实体集中不存在时，或 entitySetName 没有完全限定时。 当无法根据提供的参数成功构造实体键时。

创建并返回所请求的类型的实例。

所请求类型 T 的实例，或一个使得 T 能够与实体框架一起使用的派生类型的实例。返回的对象是所请求类型的实例或使得请求的类型能够与实体框架一起使用的派生类型的实例。 要返回的对象的类型。

创建新的 实例，该实例用于查询、添加、修改和删除指定实体类型的对象。

新的 实例。 所请求的 的实体类型。 未在 上设置 属性，或指定的类型属于多个实体集。

创建新的 实例，该实例用于查询、添加、修改和删除具有指定类型和指定实体集名称的对象。

新的 实例。 返回的 的实体集的名称。如果未在 上设置 属性，则字符串必须使用默认容器名称进行限定。 所请求的 的实体类型。 来自 entitySetName 的 与对象的 的 不匹配，或未在 上设置 属性且名称未限定为 entitySetName 参数的一部分，或指定的类型属于多个实体集。

为提供的枚举中的每个类型生成可与实体框架一同使用的等效类型。

对象的枚举，这些对象表示映射到概念模型的自定义数据类。

使用指定查询字符串在当前对象上下文中创建 。

具有指定类型的 。 要执行的查询字符串。 要传递给查询的参数。 返回的 的实体类型。 queryString 或 parameters 参数为 null。

检查在当前存储连接中指定为数据库的数据库是否在存储区上存在。大部分实际工作由当前存储连接的 DbProviderServices 实现完成。

获取或设置默认容器名称。

作为默认容器名称的 。

删除在当前数据源连接中指定为数据库的数据库。

标记对象以备删除。

指定待删除实体的对象。该对象可以为任何状态（ 除外）。

从对象上下文移除对象。

要分离的对象。仅移除实体；如果存在任何由相同 跟踪的相关对象，则不会自动分离这些对象。 entity 为 null。 实体不与此 关联（例如，是新创建的，仍未与任何上下文关联，或是通过其他上下文获取，或是已分离）。

确保 更改与由 跟踪的所有对象中的更改进行同步。

释放对象上下文使用的资源。

释放对象上下文使用的资源。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

对默认容器执行给定的函数。

函数的名称。可能包含容器名称（例如 ContainerName.FunctionName），如果知道 DefaultContainerName，也可以仅包含函数名称。 用于执行此函数的选项。 要用于函数的参数值。 函数结果的元素类型。 如果函数为 null 或为空 如果函数无效（语法错误、不存在或引用其返回类型与 T 不兼容的函数）

使用指定的参数和合并选项，执行在数据源中定义并在概念模型中表示的给定存储过程或函数。返回一个类型化的 。

存储过程返回的数据的 。 存储过程或函数的名称。该名称可以包含容器名称，如 &lt;容器名称&gt;.&lt;函数名称&gt;。如果默认容器名称已知，则只需要函数名称。 要在执行查询时使用的 。 一个 对象数组。 对数据源执行函数时，将返回 的实体类型。该类型必须实现 。 function 为 null 或为空，或未找到 function。 实体读取器不支持此函数或读取器和函数的类型不匹配。

执行在数据源中定义并在概念模型中表示的存储过程或函数，丢弃该函数返回的任何结果，并返回执行该函数影响的行数。

受影响的行数。 存储过程或函数的名称。该名称可以包含容器名称，如 &lt;容器名称&gt;.&lt;函数名称&gt;。如果默认容器名称已知，则只需要函数名称。 一个 对象数组。 function 为 null 或为空，或未找到 function。 实体读取器不支持此函数或读取器和函数的类型不匹配。

使用指定的参数，执行在数据源中定义并在概念模型中映射的存储过程或函数。返回一个类型化的 。

存储过程返回的数据的 。 存储过程或函数的名称。该名称可以包含容器名称，如 &lt;容器名称&gt;.&lt;函数名称&gt;。如果默认容器名称已知，则只需要函数名称。 一个 对象数组。 对数据源执行函数时，将返回 的实体类型。该类型必须实现 。 function 为 null 或为空，或未找到 function。 实体读取器不支持此函数或读取器和函数的类型不匹配。

使用现有连接对数据源直接执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

受影响的行数。 对于此命令控制事务的创建。 使用服务器的本机查询语言指定的命令。 要用于查询的参数值。

使用现有连接对数据源直接执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommand("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

受影响的行数。 使用服务器的本机查询语言指定的命令。 要用于查询的参数值。

使用现有连接对数据源直接异步执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含受影响的行数。 对于此命令控制事务的创建。 使用服务器的本机查询语言指定的命令。 要用于查询的参数值。

使用现有连接对数据源直接异步执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含受影响的行数。 对于此命令控制事务的创建。 使用服务器的本机查询语言指定的命令。 等待任务完成期间要观察的 。 要用于查询的参数值。

使用现有连接对数据源直接异步执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含受影响的行数。 使用服务器的本机查询语言指定的命令。 要用于查询的参数值。

使用现有连接对数据源直接异步执行任意命令。使用服务器的本机查询语言（如 SQL）指定该命令。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreCommandAsync("UPDATE dbo.Posts SET Rating = 5 WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含受影响的行数。 使用服务器的本机查询语言指定的命令。 等待任务完成期间要观察的 。 要用于查询的参数值。

对数据源直接执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 用于执行此查询的选项。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。如果指定了实体集名称，则上下文会跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 TResult 类型的实体集。如果未提供实体集名称，则不会跟踪结果。 用于执行此查询的选项。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。如果指定了实体集名称，则上下文会跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQuery&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 TResult 类型的实体集。如果未提供实体集名称，则不会跟踪结果。 要在执行查询时使用的 。默认值为 。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 用于执行此查询的选项。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 用于执行此查询的选项。 等待任务完成期间要观察的 。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。如果指定了实体集名称，则上下文会跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 TResult 类型的实体集。如果未提供实体集名称，则不会跟踪结果。 用于执行此查询的选项。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。如果指定了实体集名称，则上下文会跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 TResult 类型的实体集。如果未提供实体集名称，则不会跟踪结果。 用于执行此查询的选项。 等待任务完成期间要观察的 。 要用于查询的参数值。 结果序列的元素类型。

对数据源直接异步执行查询并返回类型化结果的序列。使用服务器的本机查询语言（如 SQL）指定该查询。上下文未跟踪这些结果，请使用指定实体集名称的重载跟踪结果。与接受 SQL 的任何 API 一样，对任何用户输入进行参数化以便避免 SQL 注入攻击是十分重要的。您可以在 SQL 查询字符串中包含参数占位符，然后将参数值作为附加参数提供。您提供的任何参数值都将自动转换为 DbParameter。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @p0", userSuppliedAuthor); 或者，您还可以构建一个 DbParameter 并且将其提供给 SqlQuery。这允许您在 SQL 查询字符串中使用命名参数。context.ExecuteStoreQueryAsync&amp;lt;Post&amp;gt;("SELECT * FROM dbo.Posts WHERE Author = @author", new SqlParameter("@author", userSuppliedAuthor));

表示异步操作的任务。任务结果包含类型为 的对象的枚举。 使用服务器的本机查询语言指定的查询。 等待任务完成期间要观察的 。 要用于查询的参数值。 结果序列的元素类型。

返回所有现有代理类型。

所有现有代理类型的 。

返回具有指定实体键的对象。

一个 ，它是实体类型的实例。 要查找的对象的键。 key 参数为 null。 在 和数据源中都未找到对象。

返回与指定类型的代理对象关联的 POCO 实体的实体类型。

关联的 POCO 实体的 。 代理对象的 。

通过指定的导航属性并使用默认合并选项，显式加载与提供的对象相关的对象。

要为其加载相关对象的实体。 可返回要加载的相关对象的导航属性的名称。 实体处于 、 或 状态，或实体已附加到 的另一个实例。

通过指定的导航属性并使用指定的合并选项，显式加载与提供的对象相关的对象。

要为其加载相关对象的实体。 可返回要加载的相关对象的导航属性的名称。 在加载相关对象时要使用的 值。 实体处于 、 或 状态，或实体已附加到 的另一个实例。

通过指定的 LINQ 查询并使用默认合并选项，显式加载与提供的对象相关的对象。

要为其加载相关对象的源对象。 定义要加载的相关对象的 LINQ 表达式。 selector 未提供有效的输入参数。 selector 为 null。 实体处于 、 或 状态，或实体已附加到 的另一个实例。

通过指定的 LINQ 查询并使用指定的合并选项，显式加载与提供的对象相关的对象。

要为其加载相关对象的源对象。 定义要加载的相关对象的 LINQ 表达式。 在加载相关对象时要使用的 值。 selector 未提供有效的输入参数。 selector 为 null。 实体处于 、 或 状态，或实体已附加到 的另一个实例。

获取对象上下文使用的元数据工作区。

与此 关联的 对象。

当使用数据源中的数据创建新的实体对象（作为查询或加载操作的一部分）时发生。

获取对象上下文用于跟踪对象更改的对象状态管理器。

此 使用的 。

获取与此对象上下文关联的 LINQ 查询提供程序。

由此对象上下文使用的 实例。

使用数据库中的数据更新对象上下文中的对象集合。

一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象的 集合。 collection 为 null。 refreshMode 无效。 collection 为空或对象未附加到上下文。

使用数据库中的数据更新对象上下文中的对象。

一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象。 entity 为 null。 refreshMode 无效。 实体未附加到上下文。

使用数据库中的数据异步更新对象上下文中的对象集合。

表示异步操作的任务。 一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象的 集合。 collection 为 null。 refreshMode 无效。 collection 为空或对象未附加到上下文。

使用数据库中的数据异步更新对象上下文中的对象集合。

表示异步操作的任务。 一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象的 集合。 等待任务完成期间要观察的 。 collection 为 null。 refreshMode 无效。 collection 为空或对象未附加到上下文。

使用数据库中的数据异步更新对象上下文中的对象。

表示异步操作的任务。 一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象。 entity 为 null。 refreshMode 无效。 实体未附加到上下文。

使用数据库中的数据异步更新对象上下文中的对象。

表示异步操作的任务。 一个 值，指示是否使用数据库中的属性值重写对象上下文中的属性更改。 要刷新的对象。 等待任务完成期间要观察的 。 entity 为 null。 refreshMode 无效。 实体未附加到上下文。

将所有更新保存到数据库并重置对象上下文中的更改跟踪。

在调用 时处于 、 或 状态的对象数。 保存更改时发生了开放式并发冲突。

将所有更新保存到数据库并可选择重置对象上下文中的更改跟踪。

在调用 时处于 、 或 状态的对象数。 客户端事务支持需要此参数。如果为 true，则所有对象上的更改跟踪都会在 完成后重置。如果为 false，则必须在 之后调用 方法。 保存更改时发生了开放式并发冲突。

将所有更新保存到数据库并可选择重置对象上下文中的更改跟踪。

在调用 时处于 、 或 状态的对象数。 一个确定操作的行为的 值。 保存更改时发生了开放式并发冲突。

将所有更新异步保存到数据库并重置对象上下文中的更改跟踪。

表示异步操作的任务。任务结果包含在调用 时处于 、 或 状态的对象数。 保存更改时发生了开放式并发冲突。

将所有更新异步保存到数据库并可选择重置对象上下文中的更改跟踪。

表示异步操作的任务。任务结果包含在调用 时处于 、 或 状态的对象数。 一个确定操作的行为的 值。 保存更改时发生了开放式并发冲突。

将所有更新异步保存到数据库并可选择重置对象上下文中的更改跟踪。

表示异步操作的任务。任务结果包含在调用 时处于 、 或 状态的对象数。 一个确定操作的行为的 值。 等待任务完成期间要观察的 。 保存更改时发生了开放式并发冲突。

将所有更新异步保存到数据库并重置对象上下文中的更改跟踪。

表示异步操作的任务。任务结果包含在调用 时处于 、 或 状态的对象数。 等待任务完成期间要观察的 。 保存更改时发生了开放式并发冲突。

在将更改保存到数据源时发生。

返回自身。ObjectContext 实现 以便为 和 ObjectContext（这两者将返回基础 ObjectContext）提供通用接口。

将包含实体数据行的 转换为请求的实体类型的对象。

类型为 TResult 的对象的枚举。 包含要转换为实体对象的实体数据的 。 当 reader 为 null 时。

在特定的实体集中，使用指定的合并选项将包含实体数据行的 转换为请求的实体类型的对象。

类型为 TResult 的对象的枚举。 包含要转换为实体对象的实体数据的 。 TResult 类型的实体集。 在将转换后的对象添加到对象上下文时要使用的 。默认值为 。 当 reader 为 null 时。 当提供的 mergeOption 不是有效的 值时。 当提供的 entitySetName 不是 TResult 类型的有效实体集时。

返回具有指定实体键的对象。

如果成功检索到对象，则为 true。如果 key 是临时的、connection 为 null 或值为 null，则为 false。 要查找的对象的键。 在此方法返回时包含对象。 元数据对 key 不兼容。 key 为 null。

定义影响 ObjectContext 的行为的选项。

获取或设置一个布尔值，该值确定在访问导航属性时是否自动加载相关对象。

如果启用了延迟加载，则为 true；否则为 false。

获取或设置一个布尔值，该值确定是否为持久性未知的自定义数据类创建代理实例。

如果创建了代理，则为 true；否则为 false。默认值为 true。

获取或设置一个布尔值，该值确定是否要使用一致的 NullReference 行为。

如果应使用一致的 NullReference 行为，则为 true；否则为 false。

获取或设置一个布尔值，该值确定是否要使用 C# NullComparison 行为。

如果应使用 C# NullComparison 行为，则为 true；否则为 false。

获取或设置一个布尔值，该值确定是否要使用旧式 PreserveChanges 行为。

如果应使用旧式 PreserveChanges 行为，则为 true；否则为 false。

ObjectMaterialized 事件的 EventArgs。

获取已创建的实体对象。

已创建的实体对象。

ObjectMaterialized 事件的委托。

此类表示对象层的查询参数，它包含 Name、Type 和 Value。

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

参数名称。此名称不应包含“@”参数标记（它用在实体 SQL 语句中），只能为实际名称。表达式的第一个字符必须为字母。表达式中的所有后续字符都必须为字母、数字或下划线 (_) 字符。 参数的初始值（及固有类型）。 如果任一参数的值为 null。 如果名称参数的值无效。参数名称必须以字母开头，并且只能包含字母、数字和下划线。

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

参数名称。此名称不应包含“@”参数标记（它用在实体 SQL 语句中），只能为实际名称。表达式的第一个字符必须为字母。表达式中的所有后续字符都必须为字母、数字或下划线 (_) 字符。 参数的公共语言运行库 (CLR) 类型。 如果任一参数的值为 null。 如果名称参数的值无效。参数名称必须以字母开头，并且只能包含字母、数字和下划线。

获取参数名称，该名称只能通过构造函数进行设置。

参数名称，它只能通过构造函数进行设置。

获取参数类型。

参数的 。

获取或设置参数值。

参数值。

此类表示对象层上的查询参数集合。

将指定的 添加到集合。

要添加到集合的参数。 parameter 参数为 null。 parameter 参数已存在于集合中。此行为与允许重复项的大多数集合的行为不同。-或-与实参同名的另一个形参已存在于集合中。注意，查找是区分大小写的。此行为与大多数集合的行为不同，更类似于 的行为。 parameter 的类型无效。

删除集合中的所有 实例。

按引用检查集合中是否存在指定的 。

如果在集合中找到参数对象，则返回 true；否则返回 false。 要在集合中查找的 。 parameter 参数为 null。

确定集合中是否存在具有指定名称的 。

如果在集合中找到具有指定名称的参数，则返回 true；否则返回 false。 要在集合中查找的参数的名称。此名称不应包含“@”参数标记（它用在实体 SQL 语句中），只能为实际名称。 name 参数为 null。

允许将集合中的参数复制到提供的数组中（从指定索引处的对象开始）。

要将参数复制到其中的数组。 数组中开始复制参数的位置的索引。

获取集合中当前存在的参数的数量。

集合中当前存在的 对象的数量。

这些方法返回枚举器实例，这些实例允许循环访问和遍历集合。

提供一个索引器，供调用方按名称检索参数。

实例。

按引用从集合中移除 的实例（如果集合中存在该实例）。

如果从集合中找到并移除参数对象，则返回 true；否则返回 false。 要从集合中移除的对象。 parameter 参数为 null。

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

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

返回集合上的非类型化枚举器。

一个 实例。

此类在对象层实现非类型化的查询。

返回查询的命令文本。

一个字符串值。

获取与此对象查询相关联的对象上下文。

与此 实例关联的 。

获取或设置一个值，该值指示是否应缓存查询计划。

一个指示是否应缓存查询计划的值。

使用指定合并选项执行非类型化对象查询。

一个 ，它包含查询返回的实体对象的集合。 要在执行查询时使用的 。默认值为 。

使用指定合并选项异步执行非类型化对象查询。

表示异步操作的任务。任务结果包含一个 ，其中包含查询返回的实体对象集合。 要在执行查询时使用的 。默认值为 。

使用指定合并选项异步执行非类型化对象查询。

表示异步操作的任务。任务结果包含一个 ，其中包含查询返回的实体对象集合。 要在执行查询时使用的 。默认值为 。 等待任务完成期间要观察的 。

返回有关查询的结果类型的信息。

一个 值，它包含有关查询的结果类型的信息。

获取或设置从查询返回的对象添加到对象上下文的方式。

查询 。

获取此对象查询的参数集合。

此 的参数集合。

查询是流式处理还是缓存

返回一个循环访问集合的枚举器。

可用于循环访问集合的 。

获取一个值，该值指示此查询是否包含查询对象的集合。

如果此查询包含查询对象的集合，则为 true；否则为 false。

返回 形式的集合用于数据绑定。

实体对象的 。

返回 ，被枚举时它将针对数据库执行给定的 SQL 查询。

查询结果。

获取此查询实例的结果元素类型。

获取描述此查询的表达式。对于使用 LINQ 生成器模式生成的查询，会返回完全 LINQ 表达式树；否则，返回包装此查询的常量表达式。请注意，默认表达式不进行缓存。这允许用户区分 LINQ 和 Entity-SQL 查询。

获取与此查询实例关联的 。

返回对数据源执行的命令。

一个 string，表示查询对数据源执行的命令。

ObjectQuery 在对象层实现强类型化的查询。使用 Entity-SQL 字符串指定查询并可以通过调用由 ObjectQuery 声明的基于 Entity-SQL 的查询生成器方法来创建它们。

此 ObjectQuery 的结果类型

使用指定的实体 SQL 命令作为初始查询来创建新的 实例。

实体 SQL 查询。 对其执行查询的 。

使用指定的实体 SQL 命令（作为初始查询）和指定的合并选项创建新的 实例。

实体 SQL 查询。 对其执行查询的 。 指定此查询所检索的实体应如何与以前对同一 的查询所返回的实体合并。

将查询限制为唯一结果。

一个新的 实例，等效于应用了 SELECT DISTINCT 的原始实例。

此查询生成器方法创建其结果是此查询的所有结果（除了那些也是指定另一个查询结果的一部分之外）的新查询。

新的 ObjectQuery 实例。 表示要排除的结果的查询。 如果查询参数是 null。

使用指定的合并选项执行对象查询。

一个 ，它包含查询返回的实体对象的集合。 要在执行查询时使用的 。默认值为 。

使用指定的合并选项异步执行对象查询。

表示异步操作的任务。任务结果包含一个 ，其中包含查询返回的实体对象集合。 要在执行查询时使用的 。默认值为 。

使用指定的合并选项异步执行对象查询。

表示异步操作的任务。任务结果包含一个 ，其中包含查询返回的实体对象集合。 要在执行查询时使用的 。默认值为 。 等待任务完成期间要观察的 。

按指定的条件对查询结果进行分组。

一个 类型的新 实例，等效于应用了 GROUP BY 的原始实例。 作为结果分组依据的键列。 用于定义投影的所选属性的列表。 此方法中使用的零个或多个参数。 query 参数为 null 或空字符串，或 projection 参数为 null 或空字符串。

指定要包括在查询结果中的相关对象。

一个新的 ，它具有定义的查询路径。 要在查询结果中返回的相关对象的列表（以点分隔）。 path 为 null。 path 为 empty。

此查询生成器方法创建其结果同时包含在此查询和指定的另一查询的结果中的新查询。

新的 ObjectQuery 实例。 表示结果要与其相交的查询。 如果查询参数是 null。

获取或设置此对象查询的名称。

一个字符串值，它是此 的名称。

将查询限制为仅包括特定类型的结果。

一个新的 实例，等效于应用了 OFTYPE 的原始实例。 使用应用筛选器执行查询时， 的类型返回。 指定的类型无效。

按指定条件对查询结果进行排序。

一个新的 实例，等效于应用了 ORDER BY 的原始实例。 作为结果排序依据的键列。 此方法中使用的零个或多个参数。 keys 或 parameters 参数为 null。 key 为空字符串。

将查询结果限制为仅包含在指定投影中定义的属性。

一个 类型的新 实例，等效于应用了 SELECT 的原始实例。 用于定义投影的所选属性的列表。 此方法中使用的零个或多个参数。 projection 为 null 或 parameters 为 null。 projection 为空字符串。

将查询结果限制为仅包含投影中指定的属性。

一个类型与特定投影兼容的新 。返回的 等效于应用了 SELECT VALUE 的原始实例。 投影列表。 在分析时应在作用域内的一组可选查询参数。 由 方法返回的 的类型。 projection 为 null 或 parameters 为 null。 projection 为空字符串。

按指定条件对查询结果进行排序并跳过指定数目的结果。

一个新 实例，等效于同时应用了 ORDER BY 和 SKIP 的原始实例。 作为结果排序依据的键列。 要跳过的结果数。它可以是常量或参数引用。 在分析时应在作用域内的一组可选查询参数。 任何参数为 null。 keys 为空字符串或 count 为空字符串。

返回 ，被枚举时它将针对数据库执行给定的 SQL 查询。

查询结果。

返回 ，被枚举时它将针对数据库执行给定的 SQL 查询。

查询结果。

将查询结果限制为指定的项数。

一个新的 实例，等效于应用了 TOP 的原始实例。 字符串形式的结果项数。 在分析时应在作用域内的一组可选查询参数。 count 为 null。 count 为空字符串。

此查询生成器方法创建其结果是此查询的所有结果加上另一个查询的所有结果但是不允许重复（即结果是唯一的）的新查询。

新的 ObjectQuery 实例。 表示要添加的结果的查询。 如果查询参数是 null。

此查询生成器方法创建其结果是此查询的所有结果加上另一个查询的所有结果且包括所有重复项（即结果不一定是唯一的）的新查询。

新的 ObjectQuery 实例。 表示要添加的结果的查询。 如果查询参数是 null。

将查询限制为包含与指定筛选条件匹配的结果。

一个新的 实例，等效于应用了 WHERE 的原始实例。 筛选谓词。 此方法中使用的零个或多个参数。 predicate 为 null 或 parameters 为 null。 predicate 为空字符串。

此类实现 IEnumerable 和 IDisposable。从 ObjectQuery.Execute 方法返回此类的实例。

执行与释放 (free)、释放 (release) 或重置资源关联的任务。

释放对象结果使用的资源。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

在派生类中重写时，获取泛型 的类型。

泛型 的类型。

获取存储过程的下一个结果集。

枚举下一个结果集的值的 ObjectResult。如果没有其他值，或 ObjectResult 不是存储过程调用的结果，则为 Null。 元素的类型。

返回一个循环访问查询结果的枚举器。

一个循环访问查询结果的枚举器。

IListSource.ContainsListCollection 实现。始终返回 false。

以数据绑定所用的格式返回结果。

实体对象的 。

返回一个循环访问查询结果的异步枚举器。

一个循环访问查询结果的异步枚举器。

此类表示 方法的结果。

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

如果为 true，则释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

获取 的类型。

一个 ，它是 的类型。

返回一个循环访问查询结果的枚举器。

一个循环访问查询结果的枚举器。

异步获取循环访问 的枚举器。

循环访问 的枚举器。

表示用于执行创建、读取、更新和删除操作的类型化实体集。

实体的类型。

将对象添加到当前实体集中的对象上下文。

要添加的对象。

将标量值从提供的对象复制到 中具有相同键的对象中。

已更新的对象。 其属性更新将应用于原始对象的已分离对象。currentEntity 的实体键必须与 中某个项的 属性相匹配。

将 的 属性设置为与所提供对象的属性值相匹配。

已更新的对象。 其属性更新将应用于原始对象的已分离对象。originalEntity 的实体键必须与 中某个项的 属性相匹配。

将对象或对象图附加到当前实体集中的对象上下文。

要附加的对象。

创建指定类型的实例。

所请求类型 T 的实例，或与类型 T 对应的代理类型的实例。 要返回的对象的类型。

创建一个新的实体类型对象。

新的实体类型对象，或与实体类型对应的代理类型的实例。

标记对象以备删除。

表示要删除的实体的对象。该对象可以为任何状态（ 除外）。

从对象上下文移除对象。

要分离的对象。仅移除实体；如果存在任何由相同 跟踪的相关对象，则不会自动分离这些对象。

获取用此 实例表示的实体集的元数据。

一个 对象。

表示实体、实体存根或关系

接受当前值作为原始值。

设置项的当前值，使其与所提供对象的属性值相匹配。

具有要应用于对象的更新值的已分离对象。currentEntity 还可以是对象的实体键。

设置项的原始值，使其与所提供对象的属性值相匹配。

具有要应用于对象的原始值的已分离对象。originalEntity 还可以是对象的实体键。

将该项的状态更改为指定的 值。

要为该项的 属性设置的 值。

获取与此 关联的对象或关系的当前属性值。

一个 ，它包含与此 关联的对象或关系的当前值。

将实体标记为已删除。

获取实体对象。

实体对象。

获取实体键。

实体键。

获取该对象或关系的 。

用于对象或关系的 。

返回自上次调用 以来已更改的对象属性的名称。

一个 集合，包含字符串形式的名称。

获取与此 关联的对象的原始值的可更新版本。

对象数据的可更新原始值。

使用 DetectChanges 确定具有给定名称的属性的当前值与原始值是否不同。请注意这可能不同于正在标记为“已修改”的属性，因为尚未更改的属性仍可能标记为“已修改”。

如果属性已更改，则为 true；否则为 false。 属性的名称。

获取一个值，该值指示 是否表示一个关系。

如果 表示一个关系，则为 true；否则为 false。

获取 的 。

的 。

获取与此的对象或关系关联的原始值的只读版本。

关系集项或实体的原始值的只读版本。

拒绝自上次加载、附加或保存属性以来对具有给定名称的属性所做的任何更改，或接受更改。存储属性的原始值，且属性将不再标记为“已修改”。

要更改的属性的名称。

获取项所表示的对象的 实例。

对象。

将对象或关系的状态设置为 modify。

如果状态不为“已修改”或“未更改”

将指定属性标记为已修改。

属性的名称。 如果状态不为“已修改”或“未更改”

获取 的状态。

的状态。

用于报告复杂属性已更改。现在将在 EntityMemberChanging 期间缓存的属性值添加到 OriginalValues

已更改的顶级实体属性的名称 包含已更改属性的复杂对象 complexObject 上更改的属性的名称

用于报告将要更改复杂属性。在调用此方法时，缓存指定属性的当前值。

要更改的顶级实体属性的名称 包含要更改的属性的复杂对象 complexObject 上要更改的属性的名称

用于报告标量实体属性已更改。现在将在 EntityMemberChanging 期间缓存的属性值添加到 OriginalValues

要更改的实体属性的名称

用于报告将要更改标量实体属性。在调用此方法时，缓存指定属性的当前值。

要更改的实体属性的名称

从 ObjectStateEntry 返回 EntityState

维护实体类型实例和关系实例的对象状态和标识管理。

初始化 类的新实例。

提供映射和元数据信息的 。

将特定对象的 状态更改为指定的 entityState。

所提供实体的 。 必须更改状态的对象。 对象的新状态。 当 entity 为 null 时。 当对象未分离且在状态管理器没有任何项时，或当您尝试将状态从任何其他 更改为 时，或状态为无效的 值时。

更改两个实体对象之间的指定关系的状态，其中的关系状态根据两个相关对象和导航属性的名称来指定。

已更改的关系的 。 位于关系一端的对象实例或源实体的 。 位于关系另一端的对象实例或目标实体的 。 源上可返回指定目标的导航属性的名称。 请求的所指定关系的 。 当 source 或 target 为 null 时。 当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当状态为无效的 值时。

更改两个实体对象之间的指定关系的状态，其中的关系状态根据两个相关对象和关系属性来指定。

已更改的关系的 。 位于关系一端的对象实例或源实体的 。 位于关系另一端的对象实例或目标实体的 。 关系的名称。 关系的目标端的角色名称。 请求的所指定关系的 。 当 source 或 target 为 null 时。 当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当状态为无效的 值时。

更改两个实体对象之间的指定关系的状态，根据两个相关对象和用于定义导航属性的 LINQ 表达式来指定关系。

已更改的关系的 。 位于关系一端的对象实例或源实体的 。 位于关系另一端的对象实例或目标实体的 。 一个 LINQ 表示式，用于选择返回指定 target 的 source 的导航属性。 请求的所指定关系的 。 源对象的实体类型。 当 source、target 或 selector 为 null 时。 selector 格式不正确或无法返回导航属性。 当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当您尝试在 source 或 target 处于 状态时将关系的状态更改为 或 以外的状态时，或当状态为无效的 值时。

返回具有给定状态的对象或关系的 对象的集合。

具有给定 的 对象的集合。 用于筛选返回的 对象的 。 当状态为 时。

返回具有指定键的对象或关系项的 。

给定 的对应 。 。 当 key 为 null 时。 在状态管理器中找不到指定的 key 时。 中不存在具有指定 的实体。

返回指定对象的 。

给定 的对应 。 检索到的 所属的 。 中不存在具有指定 的实体。

返回指定对象所使用的 。

所指定对象的 。 要为其返回 的对象。 实体不实现 IEntityWithRelationships 且不由此 ObjectStateManager 跟踪

获取与此状态管理器关联的 。

与此 关联的 。

在从状态管理器中添加或移除实体时发生。

尝试检索具有指定 的对象或关系的对应 。

一个布尔值，如果给定的 有对应的 ，则为 true；否则为 false。 给定的 。 此方法返回时，包含给定 的 。此参数传递时未经初始化。 为 key 提供了一个 null（在 Visual Basic 中为 Nothing）值。

尝试检索指定的 的对应 。

一个布尔值，如果给定的对象有对应的 ，则为 true；否则为 false。 检索到的 所属的 。 此方法返回时，包含给定 的 。此参数传递时未经初始化。

返回指定对象所使用的 。

如果为提供的实体返回了 实例，则为 true；否则为 false。 要为其返回 的对象。 此方法返回时将包含实体的 。

从数据库检索实体时，实体各属性的原始值。

一个 DataContractResolver，它知道如何将为持久未知的类创建的代理类型解析为基类型。它与 DataContractSerializer 一起使用。

初始化 类的新实例。

在反序列化过程中，将任何 xsi:type 信息映射到持久性未知对象的实际类型。

返回 xsi:type 映射到的类型。如果找不到与 xsi:type 匹配的已知类型，则返回 null。 要映射的 xsi:type 信息。 xsi:type 的命名空间。 已声明的类型。 的一个实例。

在序列化过程中，将实际类型映射到 xsi:type 信息。

如果类型已解析，则为 true；否则为 false。 持久性未知对象的实际类型。 已声明的类型。 的一个实例。 此方法返回时，包含 xsi:type 声明的列表。 此方法返回时，包含使用的命名空间的列表。

定义在从数据库刷新内存中数据时处理已修改属性的不同方法。

对于未修改的客户端对象，行为与 StoreWins 相同。对于已修改的客户端对象，使用存储值刷新原始值，保留客户端对象上的所有值。下次更新时，所有客户端更改单元将被视为“已修改”，需要更新。

丢弃客户端上的所有更改并使用存储值刷新值。更新客户端原始值以匹配存储值。

用于修改 ObjectContext.SaveChanges() 行为的标志

在保存更改后，调用 AcceptAllChangesAfterSave 方法，该方法会在 ObjectStateManager 中重置更改跟踪。

在保存更改之前，调用 DetectChanges 方法，使用 ObjectStateManager 中的数据同步附加到对象上下文的对象的属性值。

保存更改，不调用 DetectChanges 或 AcceptAllChangesAfterSave 方法。

这是表示在 ADO.NET 中成为某一实体所需的最小接口的接口。

初始化 类的新实例。

通知更改跟踪器，某个复杂对象的属性已更改。

已更改的属性的名称。 property 为 null。

通知更改跟踪器，对复杂对象的属性更改挂起。

更改的属性的名称。 property 为 null。

针对复杂属性的特性。隐含的默认 AttributeUsage 属性 Inherited=True、AllowMultiple=False。元数据系统要求此行为，并且将仅查看其中每个特性的第一个，即使存在多个。

初始化 类的新实例。

复杂类型的特性

初始化 类的新实例。

标识 Edm 基类的特性

初始化 类的新实例。

指示枚举类型的特性。

初始化 类的新实例。

指示给定的方法是 EDM 函数的代理。

创建新的 DbFunctionAttribute 实例。

特性化方法所表示的 EDM 函数的命名空间名称。 特性化方法所表示的 EDM 函数的函数名称。

映射到存储元素的属性的基特性。隐含的默认 AttributeUsage 属性 Inherited=True、AllowMultiple=False。元数据系统要求此行为，并且将仅查看其中每个特性的第一个，即使存在多个。

定义两个实体类型之间的基于概念性模型中关联的关系。

创建 类的实例。

此实体所参与的关联的命名空间名称。 此实体所参与的关系的名称。 关联一端的类型的角色名称。 的值，指示在关联一端的重数，例如一重或多重。 关联一端的实体类型。 关联另一端的类型的角色名称。 的值，指示在关联另一端的重数，例如一重或多重。 关联另一端的实体类型。

初始化 类的新实例。

此实体所参与的关联的命名空间名称。 此实体所参与的关系的名称。 关联一端的类型的角色名称。 的值，指示在关联一端的重数，例如一重或多重。 关联一端的实体类型。 关联另一端的类型的角色名称。 的值，指示在关联另一端的重数，例如一重或多重。 关联另一端的实体类型。 一个指示关系是否基于外键值的值。

获取一个布尔值，该值指示关系是否基于外键值。

如果关系基于外键值，则为 true；否则为 false。

关系的名称。

一个 ，表示此 定义的关系的名称。

关系的命名空间。

表示关系命名空间的 。

关系一端的重数。

指示重数的 值。

关系一端的角色名称。

表示角色名称的 。

关系一端的实体类型。

表示关联此端对象类型的 。

关系另一端的重数。

指示重数的 值。

关系另一端的角色名称。

表示角色名称的 。

关系另一端的实体类型。

表示关联另一端对象类型的 。

标识为 RelationshipSet 定义的端的特性。隐含的默认 AttributeUsage 属性 Inherited=True、AllowMultiple=False。元数据系统要求此行为，并且将仅查看其中每个特性的第一个，即使存在多个。

初始化 类的新实例。

关系属性的命名空间名称。 关系的名称。关系名称不由命名空间限定。 关系另一端的角色名称。

获取非限定的关系名称。

关系名。

导航属性的命名空间名称。

表示命名空间名称的 。

获取关系另一端的角色名称。

目标角色名称由在概念性模型中定义此关系的关联中的另一个 End 元素的 Role 属性指定。有关更多信息，请参见“关联 (EDM)”。

IEntity 中标量属性的特性。隐含的默认 AttributeUsage 属性 Inherited=True、AllowMultiple=False。元数据系统要求此行为，并且将仅查看其中每个特性的第一个，即使存在多个。

初始化 类的新实例。

获取或设置一个值，该值指示属性是否为实体键的一部分。

一个指示属性是否为实体键的一部分的值。

获取或设置一个值，该值指示属性是否可以具有 null 值。

一个值，该值指示属性是否可以具有 null 值。

静态类型的特性

初始化 类的新实例。

使用对程序集引用的每个模型都唯一的值初始化 类的新实例。

一个字符串，表示程序集中模型的唯一 GUID 值。

程式化类型的基特性

概念性架构中类型的名称，该类型映射到此属性所应用于的类。

表示名称的 。

概念性架构中映射到此类型的实体对象类型或复杂类型的命名空间名称。

表示命名空间名称的 。

对某一特定 EDM 构造进行建模的实体（可以是某一特定类型的所有实体或者是参与某一特定关系的实体）的集合。

初始化 类的新实例。

将对象添加到集合。

添加到集合的对象。entity 必须实现 。 entity 为 null。

定义对象上下文中对象和相关对象集合之间的关系。

对象上下文中与源对象相关的对象集合。 entities 集合为 null。 源对象或 entities 集合中的对象为 null 或者不处于 或 状态。-或-关系不能基于 EDM 元数据定义。这会在概念性架构中的关联不支持两种类型间的关系时发生。

定义对象上下文中两个附加对象之间的关系。

附加的对象。 当 entity 为 null 时。 当 entity 无法与源对象关联时。这会在概念性架构中的关联不支持两种类型间的关系时发生。-或-当对象为 null 或不处于 或 状态时。

从集合中移除所有实体。

确定特定对象是否存在于集合中。

如果在 中找到该对象，则为 true；否则为 false。 要在 中定位的对象。

将集合中的所有内容复制到数组，从目标数组的指定索引处开始。

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

获取集合中包含的对象数。

中包含的元素数。

返回一个对象查询，执行该查询时返回的对象集合与当前集合包含的对象相同。

表示实体集合的 。 当对象处于 状态时，或当对象处于 状态且 不为 时。

返回一个枚举器，用于循环访问集合中的对象。

一个 ，循环访问 缓存的值集。

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

始终返回 false。

使用指定的合并选项将相关对象加载到集合中。

指定此集合中的对象应如何与从以前针对相同 的查询中返回的对象合并。

使用默认合并选项异步将一个或多个相关实体加载到相关端中。

表示异步操作的任务。 合并选项。 等待任务完成期间要观察的 CancellationToken。

在内部使用，用于反序列化实体对象。

流上下文。

在内部使用，用于序列化实体对象。

流上下文。

从集合移除对象，并标记要删除的关系。

如果成功移除该项，则为 true；否则为 false。 要从集合中移除的对象。 实体对象为 null。 实体对象未附加到相同的对象上下文，或者，实体对象没有有效的关系管理器。

返回一个枚举器，用于循环访问 缓存的值集。

一个 ，循环访问 缓存的值集。

IListSource.ContainsListCollection 实现。始终返回 false。这意味着我们返回的 IList 是包含我们的实际数据的 IList，而不是集合的列表。

返回 形式的集合用于数据绑定。

实体对象的 。

这是所有描述的 EntityObject 类的基类。

初始化 类的新实例。

获取或设置此对象的键。

此对象的 。

获取对象的实体状态。

此对象的 。

通知更改跟踪器，属性已更改。

已更改的属性的名称。 property 为 null。

通知更改跟踪器，属性更改挂起。

更改的属性的名称。 property 为 null。

由 ObjectStateManager 用来将此 EntityObject 附加到缓存或者分离这两者。

对包含此实体的 ObjectStateEntry 的引用

返回惰式创建的关系导航属性对象、集合和 ref 的容器。

对多重性为 1 的关系端进行建模。

返回相关对象的键。

一个 ，表示相关对象的键。

对多重性为 1 的关系端进行建模。

创建 的新实例。

在对象上下文中创建两个对象之间的多对一或一对一关系。

附加的对象。 当 entity 为 null 时。 当 entity 无法与当前相关端关联时。这会在概念性架构中的关联不支持两种类型间的关系时发生。

创建一个返回相关对象的等效对象查询。

一个 ，其返回相关对象。 当对象处于 状态时，或当对象处于 状态且 不为 时。

使用指定的合并选项为此 加载相关对象。

指定当 中已存在该对象时，应如何返回它。 的源为 null；或一个查询返回多个相关端；或一个查询返回零个相关端，但应返回一个相关端。

使用默认合并选项异步将一个或多个相关实体加载到相关端中。

已加载到相关端的相关实体。 合并选项。 等待任务完成期间要观察的 CancellationToken。

此方法在内部使用，用于序列化相关实体对象。

序列化的流。

此方法在内部使用，用于序列化相关实体对象。

序列化的流。

获取或设置此 返回的相关对象。

此 返回的对象。

此接口由更改跟踪器实现并且由数据类用来报告更改

通知更改跟踪器，某个复杂类型的属性已更改。

已更改的实体类型的复杂属性的名称。 包含已更改属性的复杂类型。 复杂类型上更改的属性的名称。

通知更改跟踪器，复杂属性更改挂起。

要更改的顶级实体属性的名称。 包含要更改的属性的复杂类型。 复杂类型上要更改的属性的名称。

通知更改跟踪器，某个实体类型的属性已更改。

已更改的属性的名称。

通知更改跟踪器即将更改某个实体类型的属性。

要更改的属性的名称。

获取所跟踪对象的当前状态。

一个 ，它是所跟踪对象的状态。有关更多信息，请参见“标识解析、状态管理和更改跟踪”和“在 POCO 实体中跟踪更改”。

数据类必须实现以便由更改跟踪器进行管理的最小接口。

获取或设置用于报告更改的 。

用于报告更改的 。

定义包含键的实体的接口。

为实现此接口的实体类型的实例获取或设置 。

实现此接口的实体类型实例的 。

在公开关系时数据类必须实现的接口

返回关系管理器，该管理器管理实体类型的实例的关系。

此实体的 。

表示关系的一端。

将对象添加到相关端。

添加到集合的对象。entity 必须实现 。

将对象添加到相关端。

添加到集合的对象。

定义两个附加对象之间的关系。

附加的对象。entity 必须实现 。

定义两个附加对象之间的关系。

附加的对象。

返回一个 ，它表示属于相关端的对象。

一个 ，它表示属于相关端的对象。

返回一个 ，它循环访问相关对象的集合。

一个 ，它循环访问相关对象的集合。

获取一个值，该值指示是否已加载所有相关对象。

如果相关端包含数据库中的所有相关实体，则为 true；否则为 false。

使用默认合并选项将一个或多个相关对象加载到此相关端中。

使用指定合并选项将一个或多个相关对象加载到相关端中。

将对象合并到现有 时使用的 。

使用指定合并选项将一个或多个相关对象异步加载到相关端中。

表示异步操作的任务。 将对象合并到现有 时使用的 。 等待任务完成期间要观察的 。

使用默认合并选项将一个或多个相关对象异步加载到此相关端中。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取此相关端所参与的关系的名称。

此 所参与的关系的名称。关系名称不由命名空间限定。

返回对相关端的元数据的引用。

包含关系一端的元数据的 对象。

从相关端的对象的集合中移除一个对象。

如果 entity 已成功删除，则为 true；如果 entity 不是 的一部分，则为 false。 要从集合中移除的对象。entity 必须实现 。

从相关端的对象的集合中移除一个对象。

如果 entity 已成功删除，则为 true；如果 entity 不是 的一部分，则为 false。 要从集合中移除的对象。

获取关系的源端的角色名称。

关系的源端的角色名称。

获取关系的目标端的角色名称。

关系的目标端的角色名称。

EntityCollection 和 EntityReference 的基类

对相关端进行更改时发生。

返回一个 ，它循环访问相关对象的集合。

一个 ，它循环访问相关对象的集合。

获取一个值，该值指示是否已加载所有相关对象。

如果相关端包含数据库中的所有相关对象，则为 true；否则为 false。

使用默认合并选项将一个或多个相关对象加载到相关端中。

当源对象是使用 查询检索的，且 不是 或相关对象已加载时；或当源对象未附加到 时；或当正在跟踪源对象，但是它处于 或 状态，或用于 的 是 时。

使用指定合并选项从相关端加载一个或多个对象。

将对象合并到现有 时使用的 。 当源对象是使用 查询检索的，且 不是 或相关对象已加载时；或当源对象未附加到 时；或当正在跟踪源对象，但是它处于 或 状态，或用于 的 是 时。

使用指定合并选项从相关端异步加载一个或多个对象。

表示异步操作的任务。 将对象合并到现有 时使用的 。 等待任务完成期间要观察的 。 当源对象是使用 查询检索的，且 不是 或相关对象已加载时；或当源对象未附加到 时；或当正在跟踪源对象，但是它处于 或 状态，或用于 的 是 时。

使用默认合并选项将一个或多个相关对象异步加载到相关端中。

表示异步操作的任务。 等待任务完成期间要观察的 。 当源对象是使用 查询检索的，且 不是 或相关对象已加载时；或当源对象未附加到 时；或当正在跟踪源对象，但是它处于 或 状态，或用于 的 是 时。

在内部使用，用于反序列化实体对象及 实例。

序列化的流。

获取此相关端所参与的关系的名称。

此 所参与的关系的名称。关系名称不由命名空间限定。

获取对相关端的元数据的引用。

包含关系一端的元数据的 对象。

获取关系的源端的角色名称。

表示角色名称的 。

将实体添加到相关端。此方法与 Add(object) 的工作方式完全相同。保留此方法是为了与以前版本的 IRelatedEnd 向后兼容。

要添加到相关端的实体实例

将实体添加到相关端。如果所有者附加到某一缓存，则所有连接端都添加到该对象缓存，并且其对应关系也添加到 ObjectStateManager。关系的 RelatedEnd 也是固定的。

要添加到相关端的实体实例

将实体附加到相关端。此方法与 Attach(object) 的工作方式完全相同。保留此方法是为了与以前版本的 IRelatedEnd 向后兼容。

要附加到相关端的实体 当 为 null 时引发。 在无法通过当前关系端与实体相关时引发。

将实体附加到相关端。如果相关端已经填充或部分填充，则此操作将合并现有实体和给定实体。不假定给定实体为相关实体的完整集。所有者和所有传入的实体必须处于 Unchanged 或 Modified 状态。仅当状态管理器已在跟踪关系实例时，才允许已删除的元素。

要附加到相关端的实体 当 为 null 时引发。 在无法通过当前关系端与实体相关时引发。

返回一个 ，它表示属于相关端的对象。

一个 ，它表示属于相关端的对象。

从相关端删除实体。此方法与 Remove(object) 的工作方式完全相同。保留此方法是为了与以前版本的 IRelatedEnd 向后兼容。

如果实体已成功删除，则返回 true；如果实体不是 RelatedEnd 的一部分，则返回 false。 要从相关端中删除的实体实例

从相关端删除实体。如果所有者附加到缓存，则将关系标记为待删除；如果关系是复合关系，也将实体标记为待删除。

如果实体已成功删除，则返回 true；如果实体不是 RelatedEnd 的一部分，则返回 false。 要从相关端中删除的实体实例

获取关系的目标端的角色名称。

表示角色名称的 。

标识关系的种类

该关系为关联

惰式创建的关系导航属性对象（集合和 ref）的容器。

创建一个新的 对象。

请求的 。 对调用此方法的实体的引用。

返回关系管理器管理的所有相关端的枚举。

实现 的对象的 。如果尚未填充关系，则返回空枚举。

获取具有指定关系名称和目标角色名称的相关对象的 。

相关对象的 。 要浏览的关系的名称。关系名称不由命名空间限定。 要浏览的目标角色的名称。指示在关系中浏览的方向。 返回的 的类型。 指定角色返回 而不是 。

为关系中的指定目标角色返回正确类型的 或 。

已检索的表示 或 的 。 在其中定义 targetRoleName 的关系的名称。关系名称不由命名空间限定。 用于检索 relationshipName 的另一端的目标角色. relationshipName 或 targetRoleName 为 null。 源类型不匹配所有者类型。 targetRoleName 无效或无法在元数据中找到关系类型。

通过使用关系名称和目标角色名称的指定组合，获取相关对象的 。

相关对象的 。 要浏览的关系的名称。关系名称不由命名空间限定。 要浏览的目标角色的名称。指示在关系中浏览的方向。 返回的 的类型。 指定角色返回 而不是 。

采用通过默认构造函数创建的现有 EntityCollection，并且使用提供的关系和目标角色名称初始化它。此方法设计为仅在反序列化期间使用；如果已初始化提供的 EntityCollection 或者关系管理器已附加到某一 ObjectContext，此方法将引发异常。

targetRoleName 表示的实体的类型

采用通过默认构造函数创建的现有 EntityReference，并且使用提供的关系和目标角色名称初始化它。此方法设计为仅在反序列化期间使用；并且在以下情况下此方法将引发异常：已初始化提供的 EntityReference、关系管理器已包含具有此名称和目标角色的关系或者关系管理器已附加到某一 ObjectContext。

关系名。 相关端的角色名称。 要初始化的 。 正在初始化的 的类型。 当提供的 已初始化时。-或-当关系管理器已附加到某一 时，或当关系管理器已包含具有此名称和目标角色的关系时。

在内部使用，用于反序列化实体对象及 实例。

序列化的流。

由对象服务调用，用来准备 以序列化关系进行二进制序列化。

说明给定序列化流的源和目标，并提供另一个调用方定义的上下文。

此类包含某一日期对象所需的公共方法。

初始化 类的新实例。

确定指定的字节数组是否包含完全相同的值。

如果两个数组具有相同长度且包含相同字节值，或两个数组都为 null，则为 true；否则为 false。 要比较的第一个字节数组值。 要比较的第二个字节数组。

返回数据源支持的最小日期时间值。

一个 值，表示数据源支持的最小日期时间值。

用于更改跟踪的公共常量名称。通过提供此定义可允许用户使用此常量，而不是对字符串进行硬编码。这有助于确保属性名称正确，并且允许在我们在查找此特定字符串的位置更快地进行比较。用户仍可以直接使用区分大小写的字符串，而不是常量，只是在比较时速度稍慢。在名称周围包括短划线 (-) 字符将确保这将不会与某一真实的数据属性冲突，因为 -EntityKey- 不是有效的标识符名称

返回当前字节值的副本。

当前 值的副本。 当前字节数组值。

返回指定属性的复杂类型。

属性的复杂类型对象。 从复杂对象继承的复杂对象。 复杂属性的名称，该复杂属性为复杂对象。 指示类型是否允许 Null 值。 指示类型是否已初始化。 正在请求的复杂对象的类型。

引发 事件。

已更改的属性的名称。

引发 事件。

更改的属性的名称。

属性已更改的通知。

属性将要更改的通知。

引发用于报告属性已更改的事件。

已更改的属性的名称。

引发用于报告属性更改挂起的事件。

更改的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 布尔值。

确保正在为属性设置的 值有效。

正在设置的 值。 布尔值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

设置的 值。 正在验证的值。

确保正在为属性设置的 值有效。

一个已设置的 。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 正在设置的值。 指示属性是否可为 null。

确保正在为属性设置的 值有效。

正在验证的 值。 传入属性 setter 中的值。 指示此属性是否允许为 null 的标志。 要验证的属性的名称。 对于不可为 null 的值如果值为 null。

验证属性是否不为 null，如果为 null 则引发。

正在设置的 值。 要检查的 值。 指示此属性是否允许为 null 的标志。 对于不可以为 null 的属性，该值为 null。

验证属性是否不为 null，如果为 null 则引发。

正在设置的 值。 待检查的 值。 指示此属性是否允许为 null 的标志。 要验证的属性的名称。 对于不可以为 null 的属性，该值为 null。

验证属性是否不为 null，如果为 null 则引发。

正在设置的 值。 待检查的 值。 指示此属性是否允许为 null 的标志。 对于不可以为 null 的属性，该值为 null。

验证属性是否不为 null，如果为 null 则引发。

正在设置的 值。 要检查的 值。 指示此属性是否允许为 null 的标志。 要验证的属性的名称。 对于不可以为 null 的属性，该值为 null。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 值。 可以为 null 的 值。 要验证的属性的名称。

确保要为属性设置的 UInt16 值有效。

正在设置的可以为 null 的 UInt16 值。 可以为 null 的 UInt16 值。

确保要为属性设置的 UInt16 值有效。

正在设置的可以为 null 的 UInt16 值。 可以为 null 的 UInt16 值。 要验证的属性的名称。

确保要为属性设置的 UInt32 值有效。

正在设置的可以为 null 的 UInt32 值。 可以为 null 的 UInt32 值。

确保要为属性设置的 UInt32 值有效。

正在设置的可以为 null 的 UInt32 值。 可以为 null 的 UInt32 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 UInt64 值。 可以为 null 的 UInt64 值。

确保正在为属性设置的 值有效。

正在设置的可以为 null 的 UInt64 值。 可以为 null 的 UInt64 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保要为属性设置的单精度值有效。

正在设置的 值。 值。

确保要为属性设置的单精度值有效。

正在设置的 值。 值。 要验证的属性的名称。

验证属性是否不为 null，如果为 null 则引发。

验证的 值。 待检查的字符串值。 指示此属性是否允许为 null 的标志。

验证属性是否不为 null，如果为 null 则引发。

经过验证的属性。 待检查的字符串值。 指示此属性是否允许为 null 的标志。 要验证的属性的名称。 该字符串值对于不可以为 null 的字符串为 null。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

确保正在为属性设置的 值有效。

正在设置的 值。 值。

确保正在为属性设置的 值有效。

正在设置的 值。 值。 要验证的属性的名称。

设置指定属性的复杂对象。

从复杂对象派生的复杂类型。 属性的原始复杂对象（如果有）。 正在设置的复杂对象。 正在设置为复杂对象的复杂属性。 被替换的对象的类型。

检验复杂对象是否不为 null。

正在验证的复杂对象。 正在检验的复杂对象。 与 complexObject 关联的父对象上的复杂属性。 正在验证的复杂对象的类型。

由 的 ChangeTracker 方法返回以提供对与实体的更改跟踪相关的上下文的功能的访问。

检测对 POCO 实体的属性和关系所做的更改。请注意，某些类型的实体（如更改跟踪代理和派生自 的实体）会自动报告更改，并且这些类型的实体通常不需要调用 DetectChanges。另请注意，通常， 的许多方法及其相关类会自动调用 DetectChanges，这样一来，便很少需要显式调用此方法。但通常出于性能原因，可能需要使用 中的 AutoDetectChangesEnabled 标志来关闭对 DetectChanges 的自动调用。

获取此上下文跟踪的所有实体的 对象。

项。

获取此上下文跟踪的给定类型的所有实体的 对象。

项。 实体的类型。

指定 是否与指定的对象相同。

如果 与指定的对象相同，则为 true；否则为 false。 要比较的对象。

获取与 关联的哈希代码。

与 关联的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

检查 是否正在跟踪任何新建、已删除或有更改的实体或关系，这些实体或关系将在调用 时，发送到数据库。

如果基础 有更改，则为 true；否则为 false。

返回 的字符串表示形式。

的字符串表示形式。

非泛型版本的 类。

返回等效泛型 对象。

等效泛型对象。 在其上声明该成员的实体的类型。 集合元素的类型。

获取或设置导航属性的当前值。当前值为导航属性引用的实体。

当前值。

此导航属性所属的 。

拥有此导航属性的实体的项。

获取或设置一个值，该值指示是否已从数据库加载此集合的所有实体。

如果加载所有相关实体或 IsLoaded 已显式设置为 true，则为 true；否则为 false。

从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

异步从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

表示异步操作的任务。

异步从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取属性名称。

属性名称。

返回将用于从数据库加载此集合的查询。可使用 LINQ 修改返回的查询以便在数据库中执行筛选或操作，例如，计算数据库中的集合中的实体数，而不实际加载这些实体。

针对集合的查询。

此类的实例从 的 Collection 方法返回，并且允许对实体的集合导航属性执行各种操作（如加载）。

此属性所属的实体的类型。 实体集合中的元素的类型。

获取或设置导航属性的当前值。当前值为导航属性引用的实体。

当前值。

此导航属性所属的 。

拥有此导航属性的实体的项。

获取或设置一个值，该值指示是否已从数据库加载此集合的所有实体。

如果加载所有相关实体或 IsLoaded 已显式设置为 true，则为 true；否则为 false。

从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

异步从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

表示异步操作的任务。

异步从数据库中加载实体的集合。请注意，不会使用数据库中的值覆盖上下文中已存在的实体。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取属性名称。

属性名称。

返回由此对象表示的导航属性的非泛型 类的新实例。

非泛型版本。

返回将用于从数据库加载此集合的查询。可使用 LINQ 修改返回的查询以便在数据库中执行筛选或操作，例如，计算数据库中的集合中的实体数，而不实际加载这些实体。

针对集合的查询。

实体数据模型 (EDM) 模型的不可变表示形式，该模型可用于创建 ，也可将该模型传递给 的构造函数。为了提高性能，应缓存和重用此类型的实例以构造上下文。

创建 ObjectContext 的实例或派生自 ObjectContext 的类的实例。请注意，可使用适当的 DbContext 构造函数来改为创建 DbContext 的实例。如果使用派生的 ObjectContext，则它必须具有带单个 EntityConnection 参数的公共构造函数。传递的连接由创建的 ObjectContext 使用，但不属于上下文。在释放上下文后，调用方必须释放连接。

供上下文使用的数据库的现有连接。 要创建的上下文的类型。

非泛型版本的 类。

返回等效泛型 对象。

等效泛型对象。 在其上声明该成员的实体的类型。 复杂属性的类型。

获取表示此属性的嵌套复杂属性的对象。

表示嵌套属性的对象。 嵌套属性的名称。

获取表示此属性的嵌套属性的对象。此方法可用于标量属性和/或复杂属性。

表示嵌套属性的对象。 嵌套属性的名称。

此类的实例从 的 ComplexProperty 方法返回，并允许访问复杂属性的状态。

此属性所属的实体的类型。 属性的类型。

获取表示此属性的嵌套复杂属性的对象。

表示嵌套属性的对象。 表示嵌套属性的表达式。 嵌套属性的类型。

获取表示此属性的嵌套复杂属性的对象。

表示嵌套属性的对象。 嵌套属性的名称。

获取表示此属性的嵌套复杂属性的对象。

表示嵌套属性的对象。 嵌套属性的名称。 嵌套属性的类型。

返回由此对象表示的属性的非泛型 类的新实例。

非泛型版本。

获取表示此属性的嵌套属性的对象。此方法可用于标量属性和/或复杂属性。

表示嵌套属性的对象。 表示嵌套属性的表达式。 嵌套属性的类型。

获取表示此属性的嵌套属性的对象。此方法可用于标量属性和/或复杂属性。

表示嵌套属性的对象。 嵌套属性的名称。 嵌套属性的类型。

获取表示此属性的嵌套属性的对象。此方法可用于标量属性和/或复杂属性。

表示嵌套属性的对象。 嵌套属性的名称。

表示有关数据库连接的信息。

创建表示应用程序配置文件中指定的连接的 DbConnectionInfo 的新实例。

应用程序配置中的连接字符串的名称。

基于连接字符串创建 DbConnectionInfo 的新实例。

用于连接的连接字符串。 用于连接的提供程序的名称。将“System.Data.SqlClient”用于 SQL Server。

确定当前 类型是否等于提供的对象类型。

如果当前 类型等于指定的对象类型，则为 true；否则为 false。 要与当前 对象进行比较的对象。

生成表示当前连接的值。

表示当前连接的值。

获取当前实例的 。

当前实例的准确运行时类型。

将 对象转换为字符串。

当前驱动器。

描述与 关联的数据库连接字符串的来源。

该连接字符串是从外部配置中进行读取的。

该连接字符串是按约定创建的。

该连接字符串是由提供给 DbContextInfo 的连接信息重写的。

该连接字符串是在运行时显式指定的。

由 的 Configuration 方法返回以提供对上下文的配置选项的访问。

获取或设置一个值，该值指示是否通过 和相关类的方法自动调用 方法。默认值为 true。

如果应自动调用，则为 true；否则为 false。

指定配置是否与指定的对象相同。

如果配置与指定的对象相同，则为 true；否则为 false。 要比较的对象。

获取与配置关联的哈希代码。

与配置关联的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

获取或设置一个值，该值指示是否启用针对公开为导航属性的关系的延迟加载。延迟加载在默认情况下处于启用状态。

如果启用延迟加载，则为 true；否则为 false。

获取或设置一个值，该值指示框架在创建实体类型的实例时是否会创建动态生成的代理类的实例。请注意，即使使用此标记启用了代理创建，也只会为满足代理设置要求的实体类型创建代理实例。默认情况下启用代理创建。

如果启用了代理创建，则为 true；否则为 false。

返回 的字符串表示形式。

的字符串表示形式。

获取或设置一个值，该值指示当比较两个操作数，而它们都可能为 null 时，是否展示数据库 null 语义。默认值为 false。例如，如果 UseDatabaseNullSemantics 为 true，则 (operand1 == operand2) 将转换为：(operand1 = operand2)；如果 UseDatabaseNullSemantics 为 false，则将转换为：(((operand1 = operand2) AND (NOT (operand1 IS NULL OR operand2 IS NULL))) OR ((operand1 IS NULL) AND (operand2 IS NULL)))。

如果启用数据库 null 比较行为，则为 true；否则为 false。

获取或设置一个值，该值指示在调用 时，是否应自动验证所跟踪的实体。默认值为 true。

提供有关给定 类型的运行时信息。

创建表示给定 类型的新实例。

派生自 的类型。

创建表示给定 类型的新实例。可以提供外部配置对象（如app.config 或 web.config），并将在解析连接字符串期间使用该对象。这包括查找连接字符串和 DefaultConnectionFactory 条目。

派生自 的类型。 表示配置文件的对象。

创建表示给定的面向特定数据库的 的新实例。可以提供外部配置对象（如app.config 或 web.config），并将在解析连接字符串期间使用该对象。这包括查找连接字符串和 DefaultConnectionFactory 条目。

派生自 的类型。 表示配置文件的对象。 要使用的数据库的连接信息。

创建表示给定 类型的新实例。可以提供外部配置对象（如app.config 或 web.config），并将在解析连接字符串期间使用该对象。这包括查找连接字符串和 DefaultConnectionFactory 条目。可以提供 ，以重写构造基础 EDM 模型时使用的默认确定的提供程序。这对于防止 EF 连接以发现清单标记很有用。

派生自 的类型。 表示配置文件的对象。 指定要面向的基础 ADO.NET 提供程序的 。

创建表示给定 类型的新实例。可提供连接字符串的外部列表，并且将在解析连接字符串期间使用该列表，用于替代外部配置文件中指定的所有连接字符串。

派生自 的类型。 连接字符串的集合。

创建表示给定的面向特定数据库的 的新实例。

派生自 的类型。 要使用的数据库的连接信息。

创建表示给定 类型的新实例。可以提供 ，以重写构造基础 EDM 模型时使用的默认确定的提供程序。

派生自 的类型。 指定要面向的基础 ADO.NET 提供程序的 。

基础 类型使用的连接的 ADO.NET 提供程序名称。

基础 类型使用的连接字符串。

基础 类型使用的连接字符串名称。

基础 类型使用的连接字符串的来源。

具体 类型。

如果可以创建基础 类型的实例，则返回新实例；否则返回 null。

一个 实例。

是否可以创建基础 类型的实例。

在 OnModelCreating 已在上下文中运行后将对 DbModelBuilder 执行的操作。

非泛型版本的 类。

返回由此对象表示的跟踪实体的给定泛型类型的泛型 类的新实例。请注意跟踪实体的类型必须与泛型类型兼容，否则将引发异常。

泛型版本。 实体的类型。

获取一个对象，该对象表示从该实体到相关实体集合的集合导航属性。

表示导航属性的对象。 导航属性的名称。

获取一个对象，此对象表示该实体的复杂属性。

表示复杂属性的对象。 复杂属性的名称。

获取由此对象表示的跟踪实体的当前属性值。

当前值。

获取实体。

实体。

确定指定的 是否等于此实例。如果两个 实例都是同一 上的同一实体的项，则将这两个实例视为相等。

如果指定的 等于此实例，则为 true；否则为 false。 要与此实例进行比较的 。

确定指定的 是否等于此实例。如果两个 实例都是同一 上的同一实体的项，则将这两个实例视为相等。

如果指定的 等于此实例，则为 true；否则为 false。 要与此实例进行比较的 。

在数据库中查询跟踪实体的值的副本，因为当前它们位于数据库中。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

存储值。

跟踪的实体当前位于数据库中时，在数据库中异步查询这些实体的值的副本。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

表示异步操作的任务。任务结果包含存储值。

跟踪的实体当前位于数据库中时，在数据库中异步查询这些实体的值的副本。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

表示异步操作的任务。任务结果包含存储值。 等待任务完成期间要观察的 。

返回此实例的哈希代码。

此实例的哈希代码，适合在哈希算法和类似哈希表的数据结构中使用。

获取当前实例的 。

当前实例的准确运行时类型。

验证此 实例并返回验证结果。

实体验证结果。如果重写 方法，则可能为 Null。

获取表示实体成员的对象。返回的对象的运行时类型将随要求的成员类型的不同而不同。当前支持的成员类型及其返回类型为：引用导航属性：。集合导航属性：。基元/标量属性：。复杂属性：。

表示成员的对象。 成员名。

获取由此对象表示的跟踪实体的原始属性值。原始值通常是实体的属性值，就像上次从数据库查询这些值一样。

原始值。

获取一个对象，此对象表示该实体的标量属性或复杂属性。

表示属性的对象。 属性的名称。

获取一个对象，该对象表示从该实体到其他实体的引用（即非集合）导航属性。

表示导航属性的对象。 导航属性的名称。

从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

异步从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

表示异步操作的任务。

异步从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取或设置实体的状态。

状态。

返回 的字符串表示形式。

的字符串表示形式。

此类的实例提供对有关由 跟踪的实体的信息和控制的访问权。使用上下文的 Entity 或 Entities 方法来获取此类型的对象。

实体的类型。

获取一个对象，该对象表示从该实体到相关实体集合的集合导航属性。

表示导航属性的对象。 表示导航属性的表达式。 集合中的元素类型。

获取一个对象，该对象表示从该实体到相关实体集合的集合导航属性。

表示导航属性的对象。 导航属性的名称。 集合中的元素类型。

获取一个对象，该对象表示从该实体到相关实体集合的集合导航属性。

表示导航属性的对象。 导航属性的名称。

获取一个对象，此对象表示该实体的复杂属性。

表示复杂属性的对象。 表示复杂属性的表达式。 复杂属性的类型。

获取一个对象，此对象表示该实体的复杂属性。

表示复杂属性的对象。 复杂属性的名称。 复杂属性的类型。

获取一个对象，此对象表示该实体的复杂属性。

表示复杂属性的对象。 复杂属性的名称。

获取由此对象表示的跟踪实体的当前属性值。

当前值。

获取实体。

实体。

确定指定的 是否等于此实例。如果两个 实例都是同一 上的同一实体的项，则将这两个实例视为相等。

如果指定的 等于此实例，则为 true；否则为 false。 要与此实例进行比较的 。

确定指定的 是否等于此实例。如果两个 实例都是同一 上的同一实体的项，则将这两个实例视为相等。

如果指定的 等于此实例，则为 true；否则为 false。 要与此实例进行比较的 。

在数据库中查询跟踪实体的值的副本，因为当前它们位于数据库中。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

存储值。

跟踪的实体当前位于数据库中时，在数据库中异步查询这些实体的值的副本。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

表示异步操作的任务。任务结果包含存储值。

跟踪的实体当前位于数据库中时，在数据库中异步查询这些实体的值的副本。请注意更改返回的字典中的值将不会更新数据库中的值。如果未在数据库中找到实体，则返回 null。

表示异步操作的任务。任务结果包含存储值。 等待任务完成期间要观察的 。

返回此实例的哈希代码。

此实例的哈希代码，适合在哈希算法和类似哈希表的数据结构中使用。

获取当前实例的 。

当前实例的准确运行时类型。

验证此 实例并返回验证结果。

实体验证结果。如果重写 方法，则可能为 Null。

获取表示实体成员的对象。返回的对象的运行时类型将随要求的成员类型的不同而不同。当前支持的成员类型及其返回类型为：引用导航属性：。集合导航属性：。基元/标量属性：。复杂属性：。

表示成员的对象。 成员名。 成员的类型。

获取表示实体成员的对象。返回的对象的运行时类型将随要求的成员类型的不同而不同。当前支持的成员类型及其返回类型为：引用导航属性：。集合导航属性：。基元/标量属性：。复杂属性：。

表示成员的对象。 成员名。

返回此对象所表示跟踪实体的非泛型 类的新实例。

非泛型版本。

获取由此对象表示的跟踪实体的原始属性值。原始值通常是实体的属性值，就像上次从数据库查询这些值一样。

原始值。

获取一个对象，此对象表示该实体的标量属性或复杂属性。

表示属性的对象。 表示属性的表达式。 属性的类型。

获取一个对象，此对象表示该实体的标量属性或复杂属性。

表示属性的对象。 属性的名称。

获取一个对象，此对象表示该实体的标量属性或复杂属性。

表示属性的对象。 属性的名称。 属性的类型。

获取一个对象，该对象表示从该实体到其他实体的引用（即非集合）导航属性。

表示导航属性的对象。 表示导航属性的表达式。 属性的类型。

获取一个对象，该对象表示从该实体到其他实体的引用（即非集合）导航属性。

表示导航属性的对象。 导航属性的名称。

获取一个对象，该对象表示从该实体到其他实体的引用（即非集合）导航属性。

表示导航属性的对象。 导航属性的名称。 属性的类型。

从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

异步从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

表示异步操作的任务。

异步从数据库重新加载该实体时会用数据库中的值覆盖任何属性值。调用此方法后，该实体将处于“未更改”状态。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取或设置实体的状态。

状态。

返回数据库实体值的字符串表示形式。

数据库实体值的字符串表示形式。

这是一个抽象基类，用于表示实体的标量/复杂属性或导航属性。标量和复杂属性使用派生类 ，引用导航属性使用派生类 ，而集合导航属性使用派生类 。

初始化 类的新实例。

返回等效泛型 对象。

等效泛型对象。 在其上声明该成员的实体的类型。 属性的类型。

获取或设置此属性的当前值。

当前值。

此成员所属的 。

拥有此成员的实体的项。

确定指定的项是否等于当前项。

如果指定的项等于当前项，则为 true；否则为 false。 要与当前项进行比较的对象。

返回此项的哈希函数。

此项的哈希函数。

获取当前实例的 。

当前实例的准确运行时类型。

验证此属性。

对象的集合。绝不会为 null。如果实体有效，则集合将为空。

获取属性的名称。

属性名称。

返回数据库属性值的字符串表示形式。

数据库属性值的字符串表示形式。

这是一个抽象基类，用于表示实体的标量/复杂属性或导航属性。标量和复杂属性使用派生类 ，引用导航属性使用派生类 ，而集合导航属性使用派生类 。

此属性所属的实体的类型。 属性的类型。

初始化 类的新实例。

获取或设置此属性的当前值。

当前值。

此成员所属的 。

拥有此成员的实体的项。

指定对象是否等于指定的对象。

如果对象等于指定的对象，则为 true；否则为 false。 要比较的对象。

获取与对象关联的哈希代码。

与对象关联的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

验证此属性。

对象的集合。绝不会为 null。如果实体有效，则集合将为空。

获取属性的名称。

属性的名称。

返回由此对象表示的属性的非泛型 类的新实例。

非泛型版本。

返回 的字符串表示形式。

的字符串表示形式。

表示由 创建的实体数据模型 (EDM)。Compile 方法，可用来从此 EDM 的表示形式转换到 ，后者是适合缓存和创建 或 实例的模型的编译快照。

为此模式创建 ，它是适合缓存和创建 实例的编译快照。

已编译的模型。

获取提供程序信息。

获取提供程序清单。

非泛型版本的 类。

返回等效泛型 对象。

等效泛型对象。 在其上声明该成员的实体的类型。 属性的类型。

获取或设置此属性的当前值。

当前值。

此属性所属的 。

拥有此属性的实体的项。

获取或设置一个值，该值指示是否在从数据库加载此属性的值后修改了该值。

如果修改此实例，则为 true；否则为 false。

获取属性名称。

属性名称。

获取或设置此属性的原始值。

原始值。

此属性嵌套在其中的属性的 。此方法仅为复杂对象的属性返回非 null 项；它将为实体本身的属性返回 null。

父复杂属性的项，如果这是一个实体属性，则为 null。

此类的实例从 的 Property 方法返回，并允许访问标量属性或复杂属性。

此属性所属的实体的类型。 属性的类型。

获取或设置此属性的当前值。

当前值。

此属性所属的 。

拥有此属性的实体的项。

获取或设置一个值，该值指示是否在从数据库加载此属性的值后修改了该值。

如果修改此实例，则为 true；否则为 false。

获取属性名称。

属性名称。

返回由此对象表示的属性的非泛型 类的新实例。

非泛型版本。

获取或设置此属性的原始值。

原始值。

此属性嵌套在其中的属性的 。此方法仅为复杂对象的属性返回非 null 项；它将为实体本身的属性返回 null。

父复杂属性的项，如果这是一个实体属性，则为 null。

基础实体或复杂对象的所有属性的集合。

创建一个包含此字典中所有属性的副本的新字典。对新字典所做的更改不会反映在此字典中，反之亦然。

此字典的副本。

指定 是否等于特定对象。

如果 等于特定对象，则为 true；否则为 false。 要比较的对象。

获取与属性值关联的哈希代码。

与属性值关联的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

获取属性的值，正如使用索引属性 getter 但将类型设置为泛型参数的类型一样。这在使用嵌套字典以避免编写包含大量强制转换的表达式时特别有用。

属性的值。 属性的名称。 属性的类型。

获取或设置带指定属性名称的属性的值。该值可能为此类的嵌套实例。

属性的值。

获取作为只读集的此字典中所有属性的名称集。

属性名称。

通过从其他字典中读取值来设置此字典的值。另一个字典必须基于与此字典相同的类型，或基于此字典的类型所派生的类型。

从中读取值的字典。

通过从给定对象中读取值来设置此字典的值。给定对象可以是任何类型。如果对象具有任何与字典中的属性名称匹配且可读取的名称的属性，则将读取这些属性。其他属性将被忽略。例如，这样便能从简单的数据传输对象 (DTO) 中复制属性。

从中读取值的对象。

为此字典创建一个基础类型对象，并使用此字典中的属性值冻结该对象。

已复制到新对象中的此字典的属性。

返回 的字符串表示形式。

的字符串表示形式。

分组一对字符串，它们将提供程序和服务器版本一起标识为一个对象。

为给定的提供程序固定名称和清单标记创建一个新对象。

标识该提供程序的字符串。例如，SQL Server 提供程序使用字符串“System.Data.SqlCient”。 标识正在使用的数据库服务器版本的字符串。例如，SQL Server 提供程序对 SQL Server 2008 使用字符串“2008”。此值不能为 null 但可以为空。清单标记有时也称为版本提示。

确定指定的对象是否等于此当前对象。

如果指定的对象等于此当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

获取此当前对象的哈希函数。

此当前对象的哈希函数。

标识该提供程序的字符串。例如，SQL Server 提供程序使用字符串“System.Data.SqlCient”。

标识正在使用的数据库服务器版本的字符串。例如，SQL Server 提供程序对 SQL Server 2008 使用字符串“2008”。此值不能为 null 但可以为空。

表示针对 DbContext 的非泛型 LINQ to Entities 查询。

返回一个新查询，其中返回的实体将不会在 中进行缓存。

应用了 NoTracking 的新查询。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

返回等效泛型 对象。

泛型集对象。 已为其创建查询的元素的类型。

IQueryable 元素类型。

指定查询是否等于指定的对象。

如果查询等于指定的对象，则为 true；否则为 false。 要比较的对象。

获取与查询关联的哈希代码。

与查询关联的哈希代码。

获取与查询关联的类型。

与查询关联的类型。

指定要包括在查询结果中的相关对象。

一个新的 DbQuery&lt;T&gt;，它具有所定义的查询路径。 要在查询结果中返回的相关对象列表（以点号分隔）。

返回 ，其枚举的对象将针对数据库执行查询。

查询结果。

返回 false。

false .

引发一个异常，该异常指示不支持直接绑定到存储查询。相反，用数据填充 DbSet，例如，使用 Load 扩展方法，然后绑定到本地数据。对于 WPF，绑定到 DbSet.Local。对于 Windows 窗体，则绑定到 DbSet.Local.ToBindingList()。

决不返回；总是引发。

返回 ，其枚举的对象将针对数据库执行查询。

查询结果。

IQueryable LINQ 表达式。

IQueryable 提供程序。

返回基础查询的 表示形式。

查询字符串。

表示针对 DbContext 的 LINQ to Entities 查询。

要查询的实体的类型。

返回一个新查询，其中返回的实体将不会在 中进行缓存。

应用了 NoTracking 的新查询。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

确定当前查询是否等于指定的查询。

如果当前查询等于指定的查询，则为 true；否则为 false。 要与当前查询进行比较的对象。

返回此查询的哈希函数。

此查询的哈希函数。

获取当前查询的类型。

当前查询的类型。

指定要包括在查询结果中的相关对象。

一个新的 ，它具有定义的查询路径。 要在查询结果中返回的相关对象列表（以点号分隔）。

返回此查询的非泛型 类的新实例。

非泛型版本。

获取此查询的枚举会导致对存储区执行此查询。

查询的 。

返回 ，其枚举的对象将针对数据库执行查询。

查询结果。

返回 false。

false .

引发一个异常，该异常指示不支持直接绑定到存储查询。相反，用数据填充 DbSet，例如，使用 Load 扩展方法，然后绑定到本地数据。对于 WPF，绑定到 DbSet.Local。对于 Windows 窗体，则绑定到 DbSet.Local.ToBindingList()。

决不返回；总是引发。

返回 ，其枚举的对象将针对数据库执行查询。

查询结果。

返回 ，其枚举的对象将针对数据库执行查询。

查询结果。

IQueryable 元素类型。

IQueryable LINQ 表达式。

IQueryable 提供程序。

返回基础查询的 表示形式。

查询字符串。

表示非实体的一个 SQL 查询，该查询从 创建并通过该上下文中的连接来执行。此类的实例是从 实例中获取的。创建此对象时不会执行该查询；只要枚举该查询，该查询就会执行（例如，使用 foreach）。实体的 SQL 查询是使用 创建的。请参见 了解此类的泛型版本。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

指定查询是否等于指定的对象。

如果查询等于指定的对象，则为 true；否则为 false。 要比较的对象。

异步枚举查询结果并对每个元素执行指定的操作。

表示异步操作的任务。 要对每个元素执行的操作。

异步枚举查询结果并对每个元素执行指定的操作。

表示异步操作的任务。 要对每个元素执行的操作。 等待任务完成期间要观察的 。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

获取与查询关联的哈希代码。

与查询关联的哈希代码。

获取与查询关联的类型。

与查询关联的类型。

返回 false。

false .

引发一个异常，该异常指示不支持直接绑定到存储查询。

决不返回；总是引发。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

通过异步枚举它从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含查询的元素。

通过异步枚举它从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含查询的元素。 等待任务完成期间要观察的 。

返回一个包含 SQL 字符串的 ，该字符串是在创建查询时设置的。不包括参数。

表示此实例的 。

表示非实体的一个 SQL 查询，该查询从 创建并通过该上下文中的连接来执行。此类的实例是从 实例中获取的。创建此对象时不会执行该查询；只要枚举该查询，该查询就会执行（例如，使用 foreach）。实体的 SQL 查询是使用 创建的。请参见 了解此类的非泛型版本。

异步确定查询的所有元素是否满足条件。

表示异步操作的任务。如果查询结果的每个元素都通过指定谓词中的测试，则任务结果包含 true；否则包含 false。 用于测试每个元素是否满足条件的函数。 为 null。

异步确定查询的所有元素是否满足条件。

表示异步操作的任务。如果查询结果的每个元素都通过指定谓词中的测试，则任务结果包含 true；否则包含 false。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 为 null。

异步确定查询是否包含任何元素。

表示异步操作的任务。如果查询结果包含任何元素，则任务结果包含 true；否则包含 false。

异步确定查询的任何元素是否满足条件。

表示异步操作的任务。如果查询结果的任何元素通过指定谓词中的测试，则任务结果包含 true；否则包含 false。 用于测试每个元素是否满足条件的函数。

异步确定查询的任何元素是否满足条件。

表示异步操作的任务。如果查询结果的任何元素通过指定谓词中的测试，则任务结果包含 true；否则包含 false。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。

异步确定查询是否包含任何元素。

表示异步操作的任务。如果查询结果包含任何元素，则任务结果包含 true；否则包含 false。 等待任务完成期间要观察的 。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

通过使用默认的相等比较器异步确定查询是否包含指定的元素。

表示异步操作的任务。如果查询结果包含指定的值，则任务结果包含 true；否则包含 false。 要在查询结果中查找的对象。

通过使用默认的相等比较器异步确定查询是否包含指定的元素。

表示异步操作的任务。如果查询结果包含指定的值，则任务结果包含 true；否则包含 false。 要在查询结果中查找的对象。 等待任务完成期间要观察的 。

异步返回查询中的元素数。

表示异步操作的任务。任务结果包含查询结果中的元素数。 查询结果中的元素数大于 。

异步返回满足条件的查询中的元素数。

表示异步操作的任务。任务结果包含满足谓词函数中的条件的查询结果中的元素数。 用于测试每个元素是否满足条件的函数。 满足谓词函数中的条件的查询结果中的元素数大于 。

异步返回满足条件的查询中的元素数。

表示异步操作的任务。任务结果包含满足谓词函数中的条件的查询结果中的元素数。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 满足谓词函数中的条件的查询结果中的元素数大于 。

异步返回查询中的元素数。

表示异步操作的任务。任务结果包含查询结果中的元素数。 等待任务完成期间要观察的 。 查询结果中的元素数大于 。

确定当前查询是否等于指定的查询。

如果当前查询等于指定的查询，则为 true；否则为 false。 要与当前查询进行比较的查询。

异步返回查询的第一个元素。

表示异步操作的任务。任务结果包含查询结果中的第一个元素。 查询结果为空。

异步返回满足指定条件的查询的第一个元素。

表示异步操作的任务。任务结果包含满足指定条件的查询结果中的第一个元素。 用于测试每个元素是否满足条件的函数。 为 null。 查询结果为空。

异步返回满足指定条件的查询的第一个元素。

表示异步操作的任务。任务结果包含满足指定条件的查询结果中的第一个元素。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 为 null。 查询结果为空。

异步返回查询的第一个元素。

表示异步操作的任务。任务结果包含查询结果中的第一个元素。 等待任务完成期间要观察的 。 查询结果为空。

异步返回查询的第一个元素；如果查询结果不包含任何元素，则返回默认值。

表示异步操作的任务。如果查询结果为空，则任务结果包含 default ()；否则包含查询结果中的第一个元素。

异步返回满足指定条件的查询的第一个元素；如果未找到这样的元素，则返回默认值。

表示异步操作的任务。如果查询结果为空或没有元素通过 所指定的测试，则任务结果包含 default ()；否则它包含通过 所指定的测试的查询结果中的第一个元素。 用于测试每个元素是否满足条件的函数。 为 null。

异步返回满足指定条件的查询的第一个元素；如果未找到这样的元素，则返回默认值。

表示异步操作的任务。如果查询结果为空或没有元素通过 default 所指定的测试，则任务结果包含 ()；否则它包含通过 所指定的测试的查询结果中的第一个元素。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 为 null。

异步返回查询的第一个元素；如果查询结果不包含任何元素，则返回默认值。

表示异步操作的任务。如果查询结果为空，则任务结果包含 default ()；否则包含查询结果中的第一个元素。 等待任务完成期间要观察的 。

异步枚举查询结果并对每个元素执行指定的操作。

表示异步操作的任务。 要执行的操作。

异步枚举查询结果并对每个元素执行指定的操作。

表示异步操作的任务。 要执行的操作。 等待任务完成期间要观察的 。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

返回此查询的哈希函数。

此查询的哈希函数。

获取当前查询的类型。

当前查询的类型。

异步返回表示查询中的总元素数的 。

表示异步操作的任务。任务结果包含查询结果中的元素数。 查询结果中的元素数大于 。

异步返回表示满足条件的查询中元素数的 。

表示异步操作的任务。任务结果包含满足谓词函数中的条件的查询结果中的元素数。 用于测试每个元素是否满足条件的函数。 满足谓词函数中的条件的查询结果中的元素数大于 。

异步返回表示满足条件的查询中元素数的 。

表示异步操作的任务。任务结果包含满足谓词函数中的条件的查询结果中的元素数。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 满足谓词函数中的条件的查询结果中的元素数大于 。

异步返回表示查询中的总元素数的 。

表示异步操作的任务。任务结果包含查询结果中的元素数。 等待任务完成期间要观察的 。 查询结果中的元素数大于 。

异步返回查询的最大值。

表示异步操作的任务。任务结果包含查询结果中的最大值。

异步返回查询的最大值。

表示异步操作的任务。任务结果包含查询结果中的最大值。 等待任务完成期间要观察的 。

异步返回查询的最小值。

表示异步操作的任务。任务结果包含查询结果中的最小值。

异步返回查询的最小值。

表示异步操作的任务。任务结果包含查询结果中的最小值。 等待任务完成期间要观察的 。

异步返回查询的唯一元素；如果该查询结果并非恰好包含一个元素，则引发异常。

表示异步操作的任务。任务结果包含查询结果的单个元素。 查询结果有多个元素。 查询结果为空。

异步返回满足指定条件的查询的唯一元素；如果有多个这样的元素，则引发异常。

表示异步操作的任务。任务结果包含满足 中条件的查询结果的单个元素。 用于测试每个元素是否满足条件的函数。 为 null。 没有元素满足 中的条件。 多个元素满足 中的条件。

异步返回满足指定条件的查询的唯一元素；如果有多个这样的元素，则引发异常。

表示异步操作的任务。任务结果包含满足 中条件的查询结果的单个元素。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 为 null。 没有元素满足 中的条件。 多个元素满足 中的条件。

异步返回查询的唯一元素；如果该查询结果并非恰好包含一个元素，则引发异常。

表示异步操作的任务。任务结果包含查询结果的单个元素。 等待任务完成期间要观察的 。 查询结果有多个元素。 查询结果为空。

异步返回序列中的唯一元素；如果该序列为空，则返回默认值；如果该序列包含多个元素，此方法将引发异常。

表示异步操作的任务。任务结果包含查询结果的单个元素；如果该序列不包含元素，则任务结果包含 default ()。 查询结果有多个元素。

异步返回满足指定条件的查询的唯一元素；如果这类元素不存在，则返回默认值；如果有多个元素满足该条件，此方法将引发异常。

表示异步操作的任务。任务结果包含满足 中条件的查询结果的单个元素；如果没有找到这样的元素，则任务结果包含 default ()。 用于测试每个元素是否满足条件的函数。 为 null。 多个元素满足 中的条件。

异步返回满足指定条件的查询的唯一元素；如果这类元素不存在，则返回默认值；如果有多个元素满足该条件，此方法将引发异常。

表示异步操作的任务。任务结果包含满足 中条件的查询结果的单个元素；如果没有找到这样的元素，则任务结果包含 default ()。 用于测试每个元素是否满足条件的函数。 等待任务完成期间要观察的 。 为 null。 多个元素满足 中的条件。

异步返回序列中的唯一元素；如果该序列为空，则返回默认值；如果该序列包含多个元素，此方法将引发异常。

表示异步操作的任务。任务结果包含查询结果的单个元素；如果该序列不包含元素，则任务结果包含 default ()。 等待任务完成期间要观察的 。 查询结果有多个元素。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

返回 false。

false .

引发一个异常，该异常指示不支持直接绑定到存储查询。

决不返回；总是引发。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

返回 ，其枚举的对象将针对数据库执行 SQL 查询。

一个 对象，可用于循环访问元素。

通过异步枚举从查询创建数组。

表示异步操作的任务。任务结果包含一个数组，该数组包含输入序列的元素。

通过异步枚举从查询创建数组。

表示异步操作的任务。任务结果包含一个数组，该数组包含输入序列的元素。 等待任务完成期间要观察的 。

通过异步枚举它根据指定的键选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含所选的键和值。 用于从每个元素中提取键的函数。 返回的键类型。

通过异步枚举它根据指定的键选择器函数和比较器从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含所选的键和值。 用于从每个元素中提取键的函数。 一个用于比较键的 。 返回的键类型。

通过异步枚举它根据指定的键选择器函数和比较器从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含所选的键和值。 用于从每个元素中提取键的函数。 一个用于比较键的 。 等待任务完成期间要观察的 。 返回的键类型。

通过异步枚举它根据指定的键选择器函数和元素选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含从查询选择的类型 的值。 用于从每个元素中提取键的函数。 用于从每个元素产生结果元素值的转换函数。 返回的键类型。 返回的值的类型。

通过异步枚举它根据指定的键选择器函数、比较器和元素选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含从输入序列选择的类型 的值。 用于从每个元素中提取键的函数。 用于从每个元素产生结果元素值的转换函数。 一个用于比较键的 。 返回的键类型。 返回的值的类型。

通过异步枚举它根据指定的键选择器函数、比较器和元素选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含从输入序列选择的类型 的值。 用于从每个元素中提取键的函数。 用于从每个元素产生结果元素值的转换函数。 一个用于比较键的 。 等待任务完成期间要观察的 。 返回的键类型。 返回的值的类型。

通过异步枚举它根据指定的键选择器函数和元素选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含从查询选择的类型 的值。 用于从每个元素中提取键的函数。 用于从每个元素产生结果元素值的转换函数。 等待任务完成期间要观察的 。 返回的键类型。 返回的值的类型。

通过异步枚举它根据指定的键选择器函数从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含所选的键和值。 用于从每个元素中提取键的函数。 等待任务完成期间要观察的 。 返回的键类型。

通过异步枚举它从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含输入序列的元素。

通过异步枚举它从查询创建 。

表示异步操作的任务。任务结果包含一个 ，后者包含输入序列的元素。 等待任务完成期间要观察的 。

返回一个包含 SQL 字符串的 ，该字符串是在创建查询时设置的。不包括参数。

表示此实例的 。

非泛型版本的 类。

返回等效泛型 对象。

等效泛型对象。 在其上声明该成员的实体的类型。 属性的类型。

获取或设置导航属性的当前值。当前值为导航属性引用的实体。

当前值。

此导航属性所属的 。

拥有此导航属性的实体的项。

获取或设置一个值，该值指示是否已从数据库加载该实体。

如果加载了该实体或 IsLoaded 已显式设置为 true，则为 true；否则为 false。

从数据库加载实体。请注意，如果该实体已在上下文中，则不会使用数据库中的值覆盖该实体。

从数据库异步加载实体。请注意，如果该实体已在上下文中，则不会使用数据库中的值覆盖该实体。

表示异步操作的任务。

从数据库异步加载实体。请注意，如果实体已在上下文中，则不会使用数据库中的值覆盖该实体。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取属性名称。

属性名称。

返回将用于从数据库加载此实体的查询。可使用 LINQ 修改返回的查询以便在数据库中执行筛选或操作。

针对实体的查询。

此类的实例从 的 Reference 方法返回，并且允许对实体的引用导航属性执行各种操作（如加载）。

此属性所属的实体的类型。 属性的类型。

获取或设置导航属性的当前值。当前值为导航属性引用的实体。

当前值。

此导航属性所属的 。

拥有此导航属性的实体的项。

获取或设置一个值，该值指示是否已从数据库加载该实体。

如果加载了该实体或 IsLoaded 已显式设置为 true，则为 true；否则为 false。

从数据库加载实体。请注意，如果该实体已在上下文中，则不会使用数据库中的值覆盖该实体。

从数据库异步加载实体。请注意，如果该实体已在上下文中，则不会使用数据库中的值覆盖该实体。

表示异步操作的任务。

从数据库异步加载实体。请注意，如果该实体已在上下文中，则不会使用数据库中的值覆盖该实体。

表示异步操作的任务。 等待任务完成期间要观察的 。

获取属性名称。

属性名称。

返回由此对象表示的导航属性的非泛型 类的新实例。

非泛型版本。

返回将用于从数据库加载此实体的查询。可使用 LINQ 修改返回的查询以便在数据库中执行筛选或操作。

针对实体的查询。

表示实体的一个 SQL 查询，该查询从 创建并通过该上下文中的连接来执行。此类的实例是从该实体类型的 实例中获取的。创建此对象时不会执行该查询；只要枚举该查询，该查询就会执行（例如，使用 foreach）。非实体的 SQL 查询是使用 创建的。请参见 了解此类的泛型版本。

从派生类的构造函数中进行调用时，创建一个 实例，它将用作 的测试替身。将由测试替身使用的方法和属性必须由测试替身来实现，除了 AsNoTracking 和 AsStreaming，它们的默认实现是空操作。

返回一个新查询，其中查询的结果将不由关联的 跟踪。

应用了 NoTracking 的新查询。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

表示实体的一个 SQL 查询，该查询从 创建并通过该上下文中的连接来执行。此类的实例是从该实体类型的 实例中获取的。创建此对象时不会执行该查询；只要枚举该查询，该查询就会执行（例如，使用 foreach）。非实体的 SQL 查询是使用 创建的。请参见 了解此类的非泛型版本。

从派生类的构造函数中进行调用时，创建一个 实例，它将用作 的测试替身。将由测试替身使用的方法和属性必须由测试替身来实现，除了 AsNoTracking 和 AsStreaming，它们的默认实现是空操作。

返回一个新查询，其中返回的实体将不会在 中进行缓存。

应用了 NoTracking 的新查询。

返回将流式处理结果而非缓存它的新查询。

应用了 AsStreaming 的新查询。

当预期实体的 SaveChanges 将导致数据库更新而实际上未影响数据库中的任何行时 引发的异常。这通常指示，当前已并发更新数据库，使得应匹配的并发标记实际上并不匹配。请注意为了安全起见，不会序列化此异常引用的状态项，并且在序列化后对状态项的访问将返回 null。

初始化 类的新实例。

初始化 类的新实例。

消息。

初始化 类的新实例。

消息。 内部异常。

将更改保存到数据库失败时，由 引发的异常。请注意为了安全起见，不会序列化此异常引用的状态项，并且在序列化后对状态项的访问将返回 null。

初始化 类的新实例。

初始化 类的新实例。

消息。

初始化 类的新实例。

消息。 内部异常。

获取表示无法保存到数据库的实体的 对象。

表示无法保存的实体的项。

表示用于存储有关数据库中 EDM 的元数据的实体。

初始化 类的新实例。

获取或设置元数据实体的 ID，它当前总是为 1。

ID。

获取或设置模型哈希，用于检查自从模型中创建数据库后，模型是否发生了更改。

模型哈希。

尝试为给定上下文获取 Code First 计算的模型哈希。如果未在 Code First 模式中使用上下文，则此方法将返回 null。

哈希字符串。 上下文。

包含用于访问由 Code First 创建的 EDMX 格式的实体数据模型的方法。通常，在需要查看 Code First 内部创建的模型时，这些方法将用于调试。

将 Code First 用于给定上下文，然后以 EDMX 形式将生成的实体数据模型写入给定编写器。此方法只能用于使用 Code First 且内部创建模型的上下文实例。此方法不能用于使用 Database First 或 Model First 创建的上下文、使用预先存在的 创建的上下文或使用预先存在的 创建的上下文。

上下文。 编写器。

将给定的 表示的实体数据模型以 EDMX 形式写入给定编写器。

表示 EDM 的对象。 编写器。

一个用于解析 的键。它包含 ADO.NET 提供程序固定名称和在连接字符串中指定的数据库服务器名称。

初始化 的新实例。

ADO.NET 提供程序固定名称，指示此执行策略将用于的 ADO.NET 连接的类型。 将与连接字符串中的服务器名称进行匹配的字符串。

确定指定的对象是否等于此键。

如果指定的对象等于此键，则为 true；否则为 false。 要比较的对象。

返回当前实例的哈希代码。

当前实例的哈希代码。

ADO.NET 提供程序固定名称，指示此执行策略将用于的 ADO.NET 连接的类型。

将与连接字符串中的服务器名称进行匹配的字符串。

接口的异步版本，它允许异步检索元素。此接口用于与实体框架查询交互且不应由自定义类来实现。

获取一个枚举器，它可用于异步枚举序列。

用于对序列异步枚举的枚举器。

接口的异步版本，它允许异步检索可枚举序列的元素。此接口用于与实体框架查询交互且不应由自定义类来实现。

要枚举的对象的类型。此类型参数是协变式的。也就是说，您可以使用您指定的类型或者派生程度更大的任何类型。有关协变式和逆变式的详细信息，请参阅。

获取一个枚举器，它可用于异步枚举序列。

用于对序列异步枚举的枚举器。

接口的异步版本，它允许异步检索元素。此接口用于与实体框架查询交互且不应由自定义类来实现。

获取迭代中的当前元素。

将枚举器前移到序列中的下一个元素，异步返回结果。

表示异步操作的任务。如果枚举器成功前移到下一个元素，则任务结果包含 true；如果枚举器已过序列末尾，则包含 false。 等待任务完成期间要观察的 。

接口的异步版本，它允许异步检索元素。此接口用于与实体框架查询交互且不应由自定义类来实现。

要枚举的对象的类型。此类型参数是协变式的。也就是说，您可以使用您指定的类型或者派生程度更大的任何类型。有关协变式和逆变式的详细信息，请参阅。

获取迭代中的当前元素。

定义用于创建和异步执行 对象所描述的查询的方法。此接口用于与实体框架查询交互且不应由自定义类来实现。

异步执行指定表达式树所表示的强类型查询。

表示异步操作的任务。任务结果包含执行指定查询所生成的值。 表示 LINQ 查询的表达式树。 等待任务完成期间要观察的 。 执行查询所生成的值的类型。

异步执行指定表达式树所表示的查询。

表示异步操作的任务。任务结果包含执行指定查询所生成的值。 表示 LINQ 查询的表达式树。 等待任务完成期间要观察的 。

此接口的实现用来基于给定的数据库名称创建某个数据库服务器类型的 DbConnection 对象。默认情况下，可在 类上设置一个实例以便创建所有 DbContext 对象（不具有连接信息或只有数据库名称或连接字符串）以使用特定类型的数据库服务器。提供了此接口的两个实现：，用于创建与 Microsoft SQL Server（包括 EXPRESS 版本）的连接。 用于创建与 Microsoft SQL Server Compact Edition 的连接。可根据需要添加其他数据库服务器的其他实现。请注意实现应视为是线程安全的或不可变的，因为实现可同时被多个线程访问。

基于给定的数据库名称或连接字符串创建连接。

已初始化的 DbConnection。 数据库名称或连接字符串。

用于创建派生 实例的工厂。实现此接口可为没有公共默认构造函数的上下文类型启用设计时服务。在设计时，可以创建派生的 实例，以启用特定设计时体验，如模型呈现和 DDL 生成。要为没有公共默认构造函数的派生 启用设计时实例化，请实现此接口。设计时服务将自动发现与派生 类型位于同一程序集中的此接口的实现。

此类型参数是协变式的。也就是说，您可以使用您指定的类型或者派生程度更大的任何类型。有关协变式和逆变式的详细信息，请参阅。

创建派生 类型的新实例。

TContext 的一个实例

表示一个键值，它唯一地标识已加载到内存中的实体框架模型。

确定当前缓存的模型键是否等于指定的缓存模型键。

如果当前缓存的模型键等于指定的缓存模型键，则为 true；否则为 false。 要与当前缓存的模型键比较的缓存模型键。

返回此缓存模型键的哈希函数。

此缓存模型键的哈希函数。

对您的上下文实现此接口，使用自定义逻辑来计算在缓存中查找已创建模型时所用的键。此接口允许您具有可与同一 AppDomain 中不同模型一起使用的单个上下文类型，或是具有使用同一模型的多个上下文类型。

获取与提供程序关联的缓存键。

与提供程序关联的缓存键。

此 约定将导致 DbModelBuilder 在生成模型时包含有关该模型的元数据。当 按约定创建模型时，它会将此约定添加到由 DbModelBuilder 使用的项的列表中。如果使用 DbContext 创建数据库，则会导致将模型元数据写入数据库中。然后，可使用它来快速检查自上次对数据库使用模型后，模型是否发生了更改。可通过重写派生 DbContext 类的 OnModelCreating 方法，从 约定中移除此约定。

初始化 类的新实例。

由可提供 实例的对象实现的接口。 类实现此接口以提供对基础 ObjectContext 的访问。

获取对象上下文。

对象上下文。

从 解析提供程序固定名称时由 和 使用。

获取提供程序的名称。

提供程序的名称。

此类的实例用来基于给定的数据库名称或连接字符串创建 SQL Server LocalDb 的 DbConnection 对象。

为给定版本的 LocalDb 创建连接工厂的新实例。对于 SQL Server 2012 LocalDb，请使用“v11.0”。

要使用的 LocalDb 版本。

为给定版本的 LocalDb 创建连接工厂的新实例。对于 SQL Server 2012 LocalDb，请使用“v11.0”。

要使用的 LocalDb 版本。 用于“初始目录”、“数据源”和“AttachDbFilename”之外的数据库选项的连接字符串。调用 CreateConnection 时，将基于数据库名称在此字符串前添加“初始目录”和“AttachDbFilename”。将基于 LocalDbVersion 参数设置“数据源”。

用于“初始目录”、“数据源”和“AttachDbFilename”之外的数据库选项的连接字符串。调用 CreateConnection 时，将基于数据库名称在此字符串前添加“初始目录”和“AttachDbFilename”。将基于 LocalDbVersion 参数设置“数据源”。默认值为“Integrated Security=True;”。

基于给定的数据库名称或连接字符串为 SQL Server LocalDb 创建连接。如果给定的字符串包含“=”字符，则将其视为一个完整的连接字符串，否则仅将其视为数据库名称。

已初始化的 DbConnection。 数据库名称或连接字符串。

此 约定将派生的 类的名称用作由 Code First 生成的概念模型的容器。

将此约定应用到给定的模型。

要将约定应用到的容器。 模型。

此 约定将派生的 类的命名空间用作由 Code First 生成的概念模型的命名空间。

此类的实例用于内部创建 的常量表达式，这些表达式将插入表达式树中以替换对 和 的引用。

元素的类型。

LINQ 表达式树中应有的公共属性。

查询。

当操作重试了配置的次数后再次失败时引发的异常。

使用无错误消息初始化 类的新实例。

使用指定的错误消息初始化 类的新实例。

描述错误的消息。

初始化 类的新实例。

描述错误的消息。 导致当前异常的异常。

此类的实例用来基于给定的数据库名称或连接字符串创建 SQL Server Compact Edition 的 DbConnection 对象。

使用空的（默认）DatabaseDirectory 和 BaseConnectionString 属性创建新的连接工厂。

应使用指定 SQL Server Compact Edition 版本的提供程序固定名称。

使用给定的 DatabaseDirectory 和 BaseConnectionString 属性创建新的连接工厂。

应使用指定 SQL Server Compact Edition 版本的提供程序固定名称。 用于添加到数据库名称前面的路径，SQL Server Compact Edition 在创建或读取数据库文件时将使用它来构成文件名。空字符串意味着 SQL Server Compact Edition 将其默认位置用作数据库文件位置。 要用于“数据源”之外的数据库的选项的连接字符串。在调用 CreateConnection 时，将基于数据库名称在此字符串前预置数据源。

要用于“数据源”之外的数据库的选项的连接字符串。在调用 CreateConnection 时，将基于数据库名称在此字符串前预置数据源。默认值为空字符串，即表示不使用任何其他选项。

基于给定的数据库名称或连接字符串为 SQL Server Compact Edition 创建连接。如果给定的字符串包含“=”字符，则将其视为一个完整的连接字符串，否则仅将其视为数据库名称。

已初始化的 DbConnection。 数据库名称或连接字符串。

用于添加到数据库名称前面的路径，SQL Server Compact Edition 在创建或读取数据库文件时将使用它来构成文件名。默认值为“|DataDirectory|”，即表示文件将放置在指定的数据目录中。

应使用指定 SQL Server Compact Edition 版本的提供程序固定名称。

此类的实例用来基于给定的数据库名称或连接字符串创建 SQL Server 的 DbConnection 对象。默认情况下，将建立与“.\SQLEXPRESS”的连接。在构造工厂实例时，可通过更改基础连接字符串来更改此设置。

使用默认的 BaseConnectionString 属性“Data Source=\SQLEXPRESS; Integrated Security=True; MultipleActiveResultSets=True;”创建新的连接工厂。

使用给定的 BaseConnectionString 属性创建新的连接工厂。

要用于“初始目录”之外的数据库的选项的连接字符串。在调用 CreateConnection 时，将基于数据库名称在此字符串前预置“初始目录”。

要用于“初始目录”之外的数据库的选项的连接字符串。在调用 CreateConnection 时，将基于数据库名称在此字符串前预置“初始目录”。默认值为“Data Source=.\SQLEXPRESS; Integrated Security=True;”。

基于给定的数据库名称或连接字符串为 SQL Server 创建连接。如果给定的字符串包含“=”字符，则将其视为一个完整的连接字符串，否则仅将其视为数据库名称。

已初始化的 DbConnection。 数据库名称或连接字符串。

此特性可应用于整个派生的 类或该类上的单个 或 属性。应用此特性后，任何发现的 或 属性仍将包含在模型中，但将不再自动进行初始化。

初始化 类的新实例。

当上下文从 Database First 或 Model First 模式中的 模板生成，并在 Code First 模式中使用时引发的异常。

初始化 类的新实例。

初始化 类的新实例。

保存序列化对象数据的对象。 有关源或目标的上下文信息。

初始化 类的新实例。

消息。

初始化 类的新实例。

消息。 内部异常。

表示 要使用的自定义复数形式术语

创建一个新实例

表示单数的非 null 或空字符串。 表示复数的非 null 或空字符串。

获取复数。

获取单数。

要由实体框架使用的默认复数形式服务实现。此复数形式服务基于英文区域设置。

构造实体框架中使用的默认复数形式服务的新实例。

构造实体框架中使用的默认复数形式服务的新实例。

要由此服务使用的用户字典项的集合。这些输入信息可以根据用户需要对服务进行自定义。

返回指定单词的复数形式。

输入参数的复数形式。 要改为复数形式的单词。

返回指定单词的单数形式。

输入参数的单数形式。 要改为单数形式的单词。

要由 EF 运行时使用的复数形式服务实现此接口。默认情况下，使用 ，但是可以在从 派生的类中设置要使用的复数形式服务。

使用服务使单词变为复数形式。

已变为复数形式的单词 要变为复数形式的单词。

使用服务使单词变为单数形式。

已变为单数形式的单词。 要变为单数形式的单词。

基于代码的迁移的基类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 类的新实例。

添加将列添加到现有表的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列将添加到的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要添加的列的名称。 一个指定要添加的列的操作。例如，c =&gt; c.Int(nullable: false, defaultValue: 3) 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加创建新外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 外键列。 包含此外键引用的列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 此外键引用的列。如果未提供任何值，则将引用主体表的主键。 指示是否应针对外键关系配置级联删除的值。如果未提供任何值，则将关闭级联删除。 数据库中的外键约束的名称。如果未提供任何值，则将生成唯一名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加创建新外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 外键列。 包含此外键引用的列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 此外键引用的列。如果未提供任何值，则将引用主体表的主键。 指示是否应针对外键关系配置级联删除的值。如果未提供任何值，则将关闭级联删除。 数据库中的外键约束的名称。如果未提供任何值，则将生成唯一名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加创建新主键的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含主键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 主键列。 数据库中的主键的名称。如果未提供任何值，则将生成唯一名称。 指示此键是否是聚集的主键。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于多列创建新主键的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含主键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 主键列。 数据库中的主键的名称。如果未提供任何值，则将生成唯一名称。 指示此键是否是聚集的主键。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加更改现有列的定义的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列所在的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要更改的列的名称。 一个指定列的新定义的操作。例如，c =&gt; c.String(nullable: false, defaultValue: "none") 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加更改存储过程的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 指定存储过程参数的操作。 存储过程的主体。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数。例如，“new { SampleArgument = "MyValue" }”。 此更改存储过程操作中的参数。无需指定此类型，将根据您提供的 参数推断此类型。

添加更改存储过程的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 存储过程的主体。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数。例如，“new { SampleArgument = "MyValue" }”。

添加在单列上创建索引的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要在其上创建索引的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要在其上创建索引的列的名称。 指示此索引是否是唯一索引的值。如果未提供任何值，则将创建非唯一索引。 用于数据库中的索引的名称。如果未提供任何值，则将生成唯一名称。 指示此索引是否是聚集索引的值。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加在多列上创建索引的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要在其上创建索引的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要在其上创建索引的列的名称。 指示此索引是否是唯一索引的值。如果未提供任何值，则将创建非唯一索引。 用于数据库中的索引的名称。如果未提供任何值，则将生成唯一名称。 指示此索引是否是聚集索引的值。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加创建新存储过程的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 指定存储过程参数的操作。 存储过程的主体。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数。例如，“new { SampleArgument = "MyValue" }”。 此存储过程创建操作中的参数。无需指定此类型，将根据您提供的 参数推断此类型。

添加创建新存储过程的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 存储过程的主体。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数。例如，“new { SampleArgument = "MyValue" }”。

添加创建新表的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

允许进一步配置表创建操作的对象。 表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 指定表中要包含的列的操作。例如，t =&gt; new { Id = t.Int(identity: true), Name = t.String() } 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。 此表中的列创建表操作。无需指定此类型，将根据您提供的 columnsAction 参数推断此类型。

要在降级过程中执行的操作。

添加删除现有列的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要从中删除列的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要删除的列的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于外键约束名称删除外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 数据库中的外键约束的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于外键约束面向的列删除外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 外键列。 包含此外键引用的列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于外键约束面向的列删除外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 外键列。 包含此外键引用的列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 此外键引用的列。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于外键约束面向的列删除外键约束的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含外键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 外键列。 包含此外键引用的列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于索引名称删除索引的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要从中删除索引的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要删除的索引的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加基于索引面向的列删除索引的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要从中删除索引的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 索引面向的列的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加删除使用默认名称创建的现有主键的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含主键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加删除没有默认名称的现有主键的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含主键列的表。架构名称是可选的，如果未指定架构，则将假定 dbo。 要删除的主键的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加一个操作，以删除具有使用指定名称的现有存储过程。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要删除的过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数。例如，“new { SampleArgument = "MyValue" }”。

添加删除表的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要删除的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

确定此实例是否等于指定对象。

如果指定的对象等于当前实例，则为 true；否则为 false。 要与当前实例进行比较的对象。

返回当前对象的哈希函数。

当前对象的哈希函数。

返回当前实例的运行时类型。

当前实例的运行时类型。

创建当前对象的浅表副本。

当前对象的浅表副本。

添加将存储过程移至新架构的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要移动的存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要将存储过程移到其中的架构。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加将表移至新架构的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要移动的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 表将移至的架构。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加重命名列的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

包含要重命名的列的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 要重命名的列的名称。 列的新名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加重命名存储过程的操作。若要更改存储过程的架构，请使用 MoveStoredProcedure 实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要重命名的存储过程的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 存储过程的新名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加重命名表的操作。若要更改表的架构，请使用 MoveTable。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要重命名的表的名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 表的新名称。架构名称是可选的，如果未指定架构，则将假定 dbo。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加执行 SQL 命令的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要执行的 SQL。 指示是否应在用于迁移过程的事务之外执行 SQL 的值。如果未提供任何值，则将在事务内执行 SQL。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

添加迁移操作。

要添加的迁移操作。

返回表示当前对象的字符串。

表示当前对象的字符串。

要在升级过程中执行的操作。

与对给定模型使用迁移相关的配置。通常将创建派生自 的配置类，而不是使用此类。

初始化 DbMigrationsConfiguration 类的新实例。

获取或设置指示是否可接受自动迁移期间的数据丢失的值。如果设置为 false，则将在数据丢失可能作为自动迁移一部分出现时引发异常。

获取或设置指示迁移数据库时是否可使用自动迁移的值。

获取或设置为迁移搭建基架时要使用的代码生成器。

获取或设置在迁移中用于单个命令的超时值。null 值指示将使用基础提供程序的默认值。

获取或设置字符串，它可用于区分属于此配置的迁移和属于其他使用同一数据库的配置的迁移。该属性使来自多个不同模型的迁移能够应用于一个数据库。

获取或设置表示要迁移的模型的派生 DbContext。

存储迁移的默认目录。

获取设置为与给定数据库提供程序结合使用的历史记录上下文工厂。

为数据库提供程序设置的历史记录上下文工厂。 要为其获取工厂的数据库提供程序的名称。

获取设置为用于给定数据库提供程序的 SQL 生成器。

为数据库提供程序设置的 SQL 生成器。 要为之获取 SQL 生成器的数据库提供程序的名称。

获取或设置包含基于代码的迁移的程序集。

获取或设置其中存储基于代码的迁移的子目录。请注意，此属性必须设置为 Visual Studio 项目根目录下子目录的相对路径；它不能设置为绝对路径。

获取或设置用于基于代码的迁移的命名空间。

添加一个新工厂，以便创建要用于给定数据库提供程序的 实例。

要为之设置 SQL 生成器的数据库提供程序的名称。 一个工厂，用于为表示默认架构的给定 和 创建 实例。

添加新的要同于给定数据库提供程序的 SQL 生成器。

为之设置 SQL 生成器的数据库提供程序的名称。 要使用的 SQL 生成器。

获取或设置用于重写要迁移的数据库的连接的值。

与对给定模型使用迁移相关的配置。

表示此配置应用于的模型的上下文。

初始化 DbMigrationsConfiguration 类的新实例。

确定当前配置是否等于指定的对象。

如果当前配置等于指定的对象，则为 true；否则为 false。 要与当前配置进行比较的对象。

获取此实例的哈希函数。

此实例的哈希函数。

返回当前实例的运行时类型。

当前实例的运行时类型。

创建当前对象的浅表副本。

当前对象的浅表副本。

在升级到最新迁移以允许更新种子数据后运行。

要用于更新种子数据的上下文。

返回此配置的字符串表示形式。

此配置的字符串表示形式。

DbMigrator 用于将现有迁移应用于数据库。DbMigrator 可用于升级和降级到任何给定迁移。若要基于对模型的更改为迁移搭建基架，请使用 。

初始化 DbMigrator 类的新实例。

用于迁移过程的配置。

获取要用于迁移过程的配置。

获取已应用于目标数据库的所有迁移。

获取已在配置的迁移程序集中定义的所有迁移。

获取已在程序集中定义但尚未应用于目标数据库的所有迁移。

表示应用任何迁移前数据库的状态的迁移 Id。

将目标数据库更新到给定迁移。

要升级/降级到的迁移。

用于配置列的帮助器类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 类的新实例。

创建新的列定义以存储二进制数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 数组数据的最大允许长度。 指示是否应将所有数据填充至最大长度的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 指示是否应将此列配置为时间戳的值。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储布尔数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储字节数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 指示插入过程中数据库是否会为此列生成值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 DateTime 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 列的精度。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 DateTimeOffset 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 列的精度。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 Decimal 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 列的数值精度。 列的数值刻度。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。 指示插入过程中数据库是否会为此列生成值的值。

创建新的列定义以存储 Double 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

指示指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

创建新的列定义以存储 geography 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 geometry 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

返回此实例的哈希代码。

此实例的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

创建新的列定义以存储 GUID 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 指示插入过程中数据库是否会为此列生成值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 Integer 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 指示插入过程中数据库是否会为此列生成值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 Long 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 指示插入过程中数据库是否会为此列生成值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建当前 的浅表副本。

当前 的浅表副本。

创建新的列定义以存储 Short 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 指示插入过程中数据库是否会为此列生成值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 Single 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储字符串数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 字符串数据的最大允许长度。 指示是否应将所有数据填充至最大长度的值。 指示列是否支持 Unicode 内容的值。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

创建新的列定义以存储 Time 数据。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

新构造的列定义。 指示列是否允许 null 值的值。 列的精度。 用作此列的默认值的常量值。 用作此列的默认值的 SQL 表达式。 列的名称。 用于此列的提供程序特有数据类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

用于进一步配置从 上的 CreateTable 调用创建的表的帮助器类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 TableBuilder 类的新实例。

要进一步配置的表创建操作。 其中创建了表的迁移。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

指定要在表上创建的外键约束。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

对象自身，以便多个调用可以链接在一起。 该外键约束面向的表的名称。 表示外键属性的 lambda 表达式。C#: t =&gt; t.PropertyOne VB.Net: Function(t) t.PropertyOne 如果外键由多个属性组成，则指定包括这些属性的匿名类型。C#: t =&gt; new { t.PropertyOne, t.PropertyTwo } VB.Net: Function(t) New With { t.PropertyOne, t.PropertyTwo } 指示是否应在外键约束上配置级联删除的值。 此外键约束的名称。如果未提供名称，则将计算默认名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取当前对象的哈希代码。

当前对象的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

指定要在表上创建的索引。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

对象自身，以便多个调用可以链接在一起。 表示要编制索引的属性的 lambda 表达式。C#: t =&gt; t.PropertyOne VB.Net: Function(t) t.PropertyOne 如果要将多个属性编入索引，则指定包括这些属性的匿名类型。C#: t =&gt; new { t.PropertyOne, t.PropertyTwo } VB.Net: Function(t) New With { t.PropertyOne, t.PropertyTwo } 指示此索引是否是唯一索引的值。 指示此索引是否是聚集索引的值。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

创建当前 的浅表副本。

当前 的浅表副本。

指定表的主键。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

对象自身，以便多个调用可以链接在一起。 表示要用作主键的属性的 lambda 表达式。C#: t =&gt; t.Id VB.Net: Function(t) t.Id 如果主键由多个属性组成，则指定包括这些属性的匿名类型。C#: t =&gt; new { t.Id1, t.Id2 } VB.Net: Function(t) New With { t.Id1, t.Id2 } 主键的名称。如果未提供，则将生成默认名称。 指示此键是否是聚集的主键。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

返回当前对象的字符串表示形式。

当前对象的字符串表示形式。

为基于代码的迁移生成 C# 代码。

初始化 类的新实例。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成用户可查看和编辑的主代码文件。

生成的代码。 迁移要执行的操作。 其中应生成代码的命名空间。 应生成的类的名称。

生成代码以指定使用 lambda 表达式的一组列名称。

要为之生成代码的列。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以指定 的定义。

要为之生成代码的列定义。 生成的代码要添加到的文本编写器。 指示定义中是否包含列名称的值。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以指定 的定义。

要为之生成代码的参数定义。 生成的代码要添加到的文本编写器。 指示定义中是否包含列名称的值。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定数据类型未知的列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

使用 生成代码隐藏文件。

生成的代码。 迁移的唯一标识符。 要为之生成代码的操作。 要存储在迁移元数据中的源模型。 要存储在迁移元数据中的目标模型。 其中应生成代码的命名空间。 应生成的类的名称。

使用迁移元数据生成代码隐藏文件。

生成的代码。 迁移的唯一标识符。 要存储在迁移元数据中的源模型。 要存储在迁移元数据中的目标模型。 其中应生成代码的命名空间。 应生成的类的名称。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

使用相应的转义将标识符用引号引起来以允许它存储在字符串中。

保存的标识符。 要用引号引起来的标识符。

从数据库体系结构名称中删除所有无效字符。

已擦除的名称。 要擦除的名称。

获取用于给定数据类型的列的类型名称。

要在生成的迁移中使用的类型名称。 要转换的数据类型。

为以 WriteClassStart 开头的类生成结束代码。

生成的代码要添加到的文本编写器。

使用语句和类定义生成命名空间。

其中应生成代码的命名空间。 应生成的类的名称。 生成的代码要添加到的文本编写器。 生成的类的基类。 指示是否应为代码隐藏文件生成此类的值。 将为其添加 using 指令的命名空间。如果为 null，则将使用从 GetDefaultNamespaces 返回的命名空间。

生成属性以在代码隐藏文件中返回源或目标模型。

属性的名称。 要返回的值。 生成的代码要添加到的文本编写器。

为基于代码的迁移生成代码的提供程序的基类。

初始化 类的新实例。

生成应添加到用户项目的代码。

生成的代码。 迁移的唯一标识符。 迁移要执行的操作。 要存储在迁移元数据中的源模型。 要存储在迁移元数据中的目标模型。 其中应生成代码的命名空间。 应生成的类的名称。

为生成的所有代码获取必须输出为“using”或“Imports”指令的默认命名空间。

命名空间名称的有序列表。 指示是否应为代码隐藏文件生成此类的值。

获取必须输出为可处理给定操作生成的代码的“using”或“Imports”指令的命名空间。

命名空间名称的有序列表。 将为其生成代码的操作。

为基于代码的迁移搭建基架以将挂起的模型更改应用于数据库。

初始化 MigrationScaffolder 类的新实例。

要用于搭建基架的配置。

获取或设置迁移生成的代码中使用的命名空间。默认情况下，此命名空间与传入构造函数的迁移配置对象上的 MigrationsNamespace 相同。对于 VB.NET 项目，此命名空间将需要更新为将项目的根命名空间考虑进去。

为基于代码的迁移搭建基架以将挂起的所有模型更改应用于数据库。

已搭建基架的迁移。 要用于已搭建基架的迁移的名称。

为基于代码的迁移搭建基架以将挂起的所有模型更改应用于数据库。

已搭建基架的迁移。 要用于已搭建基架的迁移的名称。 是否包括模型更改。

为与之前运行的数据库初始值设定项对应的基于代码的初始迁移搭建基架。

已搭建基架的迁移。

表示已搭建基架并准备写入文件的基于代码的迁移。

初始化 类的新实例。

获取或设置应存储在代码隐藏文件中的已搭建基架的迁移代码。

获取或设置此迁移应保存在其中的用户项目中的子目录。

获取或设置迁移是否已重新搭建基架。

获取或设置用于此迁移的编程语言。通常用于生成的代码的文件扩展名。

获取或设置此迁移的唯一标识符。通常用于生成的代码的文件名。

获取要添加到迁移资源文件中的字符串资源的字典。

获取或设置用户可编辑的已搭建基架的迁移代码。

设计时工具用于运行需要与正在 Visual Studio 中编辑的应用程序进行交互的迁移相关命令的帮助器类。由于应用程序处于编辑状态，因此需要在单独的 AppDomain 中加载程序集以确保始终加载的是最新版本。还将复制启动项目中的 App/Web.config 文件以确保应用所有配置。

初始化 ToolingFacade 类的新实例。

包含要使用的迁移配置的程序集的名称。 包含要使用的 DbContext 的程序集的名称。 要使用的迁移配置的命名空间限定名称。 包含已编译程序集的工作目录。 启动项目中的配置文件的路径。 启动项目中的应用程序数据目录的路径。通常，App_Data 目录用于 Web 应用程序，或者工作目录用于可执行文件。 与要迁移的数据库的连接。如果未提供，则将使用上下文的默认连接。

释放 类的当前实例所使用的资源。

释放由外观使用的所有资源。

如果为 true，则同时释放托管资源和非托管资源；如果为 false，则仅释放非托管资源。

释放由 facade 使用的所有非托管资源。

获取派生自 的类型的完全限定名。

找到的上下文类型。 上下文类型的名称。如果为 nul，将返回在程序集中找到的单个上下文类型。

获取派生自 的所有类型的完全限定名。

找到的所有上下文类型。

获取已应用于数据库的所有迁移的列表。

已应用迁移的 ID。

获取尚未应用于数据库的所有迁移的列表。

挂起的迁移的 ID。

获取或设置要运行以记录信息的操作。

获取或设置要运行以记录详细信息的操作。

获取或设置要运行以记录警告的操作。

为基于代码的迁移搭建基架以应用所有挂起的模型更改。

已搭建基架的迁移。 生成的迁移的名称。 生成的迁移的编程语言。 迁移将添加到的项目的根命名空间。 是否包括模型更改。

为与之前运行的数据库初始值设定项对应的基于代码的初始迁移搭建基架。

已搭建基架的迁移。 生成的迁移的编程语言。 迁移将添加到的项目的根命名空间。

生成 SQL 脚本以在两个迁移之间进行迁移。

生成的 SQL 脚本。 要从其进行更新的迁移。如果未提供，则将生成更新当前数据库的脚本。 要更新到的迁移。如果未提供，则将生成更新到最新迁移的脚本。 指示是否可接受自动迁移期间的数据丢失的值。

将数据库更新到指定的迁移。

要迁移到的迁移的 ID。如果未提供，则会将数据库更新到最新迁移。 指示是否可接受自动迁移期间的数据丢失的值。

为基于代码的迁移生成 VB.Net 代码。

初始化 类的新实例。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成用户可查看和编辑的主代码文件。

生成的代码。 迁移要执行的操作。 其中应生成代码的命名空间。 应生成的类的名称。

生成代码以指定使用 lambda 表达式的一组列名称。

要为之生成代码的列。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以指定 的定义。

要为之生成代码的列定义。 生成的代码要添加到的文本编写器。 指示定义中是否包含列名称的值。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为其生成代码的参数模型定义。 生成的代码要添加到的文本编写器。 为 true 则在定义中包含列名称；否则为 false。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定数据类型未知的列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

使用迁移元数据生成代码隐藏文件。

生成的代码。 迁移的唯一标识符。 迁移要执行的操作。 要存储在迁移元数据中的源模型。 要存储在迁移元数据中的目标模型。 其中应生成代码的命名空间。 应生成的类的名称。

使用迁移元数据生成代码隐藏文件。

生成的代码。 迁移的唯一标识符。 要存储在迁移元数据中的源模型。 要存储在迁移元数据中的目标模型。 其中应生成代码的命名空间。 应生成的类的名称。

生成代码以指定 列的默认值。

表示默认值的代码。 要用作默认值的值。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

生成代码以执行作为 一部分的 。

要为之生成代码的操作。 生成的代码要添加到的文本编写器。

使用相应的转义将标识符用引号引起来以允许它存储在字符串中。

保存的标识符。 要用引号引起来的标识符。

从数据库体系结构名称中删除所有无效字符。

已擦除的名称。 要擦除的名称。

获取用于给定数据类型的列的类型名称。

要在生成的迁移中使用的类型名称。 要转换的数据类型。

为以 WriteClassStart 开头的类生成结束代码。

生成的代码要添加到的文本编写器。

使用语句和类定义生成命名空间。

其中应生成代码的命名空间。 应生成的类的名称。 生成的代码要添加到的文本编写器。 生成的类的基类。 指示是否应为代码隐藏文件生成此类的值。 将为其添加 Imports 指令的命名空间。如果为 null，则将使用从 GetDefaultNamespaces 返回的命名空间。

生成属性以在代码隐藏文件中返回源或目标模型。

属性的名称。 要返回的值。 生成的代码要添加到的文本编写器。

此类由 Code First 迁移用于读取和写入数据库中的迁移历史记录。要对迁移历史记录表进行自定义，您可以从此类派生并重写 OnModelCreating。派生的实例可以使用 基于每个迁移配置注册，或使用 全局注册。

初始化 HistoryContext 类的新实例。如果要创建派生历史记录上下文，通常将公开一个构造函数，接受这同样的三个参数，然后将其传递给此基构造函数。

要用于新的上下文的现有连接。 要迁移的模型的默认架构。如果未在 OnModelCreating 中配置另一架构，则此架构将用于迁移历史记录表。

获取用于查找以前为此上下文生成的模型的键。这用于避免在每次创建新的上下文实例时处理 OnModelCreating 并计算模型。默认情况下，此属性返回默认架构。在多数情况下，您不需要重写此属性。但是，如果您的 OnModelCreating 实现包含导致为同一数据库提供程序和默认架构生成不同模型的条件逻辑，应重写此属性并计算相应的键。

获取要迁移的模型的默认架构。如果未在 OnModelCreating 中配置另一架构，则此架构将用于迁移历史记录表。

用于迁移历史记录表的默认名称。

获取或设置可用于读取和写入 实例的 。

应用迁移历史记录表的默认配置。如果重写此方法，建议在应用您的自定义配置前调用这个基实现。

定义要创建的上下文的模型的生成器。

此类由 Code First 迁移用于读取和写入数据库中的迁移历史记录。

初始化 类的新实例。

获取或设置一个键，该键表示行应用的上下文。

获取或设置此行表示的迁移的 ID。

获取或设置此迁移应用后模型的状态。

获取或设置创建此条目的实体框架的版本。

表示自动迁移将导致数据丢失时出现的错误。

初始化 AutomaticDataLossException 类的新实例。

初始化 AutomaticDataLossException 类的新实例。

描述错误的消息。

初始化 MigrationsException 类的新实例。

描述错误的消息。 导致当前异常的异常，如果未指定内部异常，则为一个 null 引用（在 Visual Basic 中为 Nothing）。

表示在应用最后一个迁移后仍然存在挂起的模型更改并且禁用了自动迁移时出现的错误。

初始化 AutomaticMigrationsDisabledException 类的新实例。

初始化 AutomaticMigrationsDisabledException 类的新实例。

描述错误的消息。

初始化 MigrationsException 类的新实例。

描述错误的消息。 导致当前异常的异常，如果未指定内部异常，则为一个 null 引用（在 Visual Basic 中为 Nothing）。

由 显式实现，用于防止某些成员在已搭建基架的迁移的 IntelliSense 中出现。

将自定义 添加到迁移中。鼓励自定义操作实现人员在 上创建扩展方法，为添加新操作提供 Fluent 样式的 API。

要添加的操作。

提供有关基于代码的迁移的其他元数据。

获取迁移的唯一标识符。

获取此迁移运行前模型的状态。

获取此迁移运行后模型的状态。

表示 Code First 迁移管道内出现的错误。

初始化 MigrationsException 类的新实例。

使用序列化数据初始化 MigrationsException 类的新实例。

包含有关正在引发的异常的序列化对象数据的 。 包含有关源或目标的上下文信息的 。

初始化 MigrationsException 类的新实例。

描述错误的消息。

初始化 MigrationsException 类的新实例。

描述错误的消息。 导致当前异常的异常，如果未指定内部异常，则为一个 null 引用（在 Visual Basic 中为 Nothing）。

可用于迁移过程的记录器的基类。

初始化 类的新实例。

记录信息性消息。

要记录的消息。

记录只应在用户请求详细输出时呈现给他们的一些其他信息。

要记录的消息。

记录用户应了解的警告。

要记录的消息。

当由于某些现有迁移尚未应用到数据库，导致无法执行操作时引发。

初始化 MigrationsPendingException 类的新实例。

初始化 MigrationsPendingException 类的新实例。

描述错误的消息。

初始化 MigrationsPendingException 类的新实例。

描述错误的消息。 导致当前异常的异常，如果未指定内部异常，则为一个 null 引用（在 Visual Basic 中为 Nothing）。

包装核心 的修饰器的基类

初始化 MigratorBase 类的新实例。

此修饰器将包装的迁移程序。

获取要用于迁移过程的配置。

获取已应用于数据库的迁移的列表。

迁移 Id 的列表

获取程序集中定义的迁移的列表。

迁移 Id 的列表

获取尚未应用于数据库的挂起的迁移的列表。

迁移 Id 的列表

将目标数据库更新到最新迁移。

将目标数据库更新到给定迁移。

要升级/降级到的迁移。

在迁移操作期间提供日志记录的修饰器。

初始化 MigratorLoggingDecorator 类的新实例。

此修饰器将包装的迁移程序。 消息将写入到的记录器。

生成 SQL 脚本而不是将更改应用于数据库的修饰器。使用此修饰器包装 将防止 将任何更改应用于目标数据库。

初始化 MigratorScriptingDecorator 类的新实例。

此修饰器将包装的迁移程序。

生成更新数据库的脚本。

生成的 SQL 脚本。 要从其进行更新的迁移。如果未提供，则将生成更新当前数据库的脚本。 要更新到的迁移。如果未提供，则将生成更新到最新迁移的脚本。

表示将添加到表中的列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 AddColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列应添加到的表的名称。 将添加的列的详细信息。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取将添加的列的详细信息。

获取表示删除已添加列的操作。

获取一个值，该值指示更改是否具有破坏性。

如果更改具有破坏性，则为 true；否则为 false。

获取列应添加到的表的名称。

表示将添加到表中的外键约束。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 AddForeignKeyOperation 类的新实例。还应填充 PrincipalTable、PrincipalColumns、DependentTable 和 DependentColumns 属性。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取或设置指示是否应在外键约束上配置级联删除的值。

获取在外键列上创建索引的操作。

添加索引的操作。

获取删除外键约束的操作。

获取或设置一个值，该值指示此更改是否将导致数据丢失。

如果此更改将导致数据丢失，则为 true；否则为 false。

外键约束应面向的列的名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示向表添加主键。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 AddPrimaryKeyOperation 类的新实例。还应填充 Table 和 Columns 属性。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取删除主键的操作。

获取或设置此键是否为聚集主键。

表示更改现有列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 AlterColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列所属表的名称。 列应更改为的内容的详细信息。 指示此更改是否会导致数据丢失的值。 还原对此列的更改的操作。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

初始化 AlterColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列所属表的名称。 列应更改为的内容的详细信息。 指示此更改是否会导致数据丢失的值。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取列的新定义。

获取表示还原更改的操作。无法自动计算反向，如果未向构造函数提供反向，则此属性将返回 null。

获取一个值，该值指示此更改是否会导致数据丢失。

如果此更改将导致数据丢失，则为 true；否则为 false。

获取列所属表的名称。

表示有关列的信息。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 ColumnModel 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

此列的数据类型。

初始化 ColumnModel 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

此列的数据类型。 有关数据类型的其他详细信息。这些信息包括最大长度、可为空属性等详细信息。

获取与此列的数据库类型对应的 CLR 类型的默认值。

获取与此列的数据库类型对应的 CLR 类型。

获取或设置指示此列的值是否由使用标识模式的数据库生成的值。

确定此列的数据类型是否窄于另一列的。用于确定将提供的列定义更改为此定义是否会导致数据丢失。

如果此列的数据类型更窄，则为 True。 要与之比较的列。 正使用的数据库提供程序的详细信息。

获取或设置指示此列是否可存储 null 值的值。

获取或设置一个值，指示是否应将此属性模型配置为时间戳。

表示创建数据库索引。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 CreateIndexOperation 类的新实例。还应填充 Table 和 Columns 属性。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取删除此索引的操作。

获取或设置此索引是否为聚集索引。

获取或设置一个值，该值指示此更改是否将导致数据丢失。

如果此更改将导致数据丢失，则为 true；否则为 false。

获取或设置指示此索引是否是唯一索引的值。

表示创建表。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 CreateTableOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要创建的表的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取要包含在新表中的列。

获取删除表的操作。

获取指示此操作是否会导致数据丢失的值。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取要创建的表的名称。

获取或设置新表的主键。

表示将从表中删除的列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 DropColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

应从中删除列的表的名称。 要删除的列的名称。 表示还原删除操作的操作。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

初始化 DropColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

应从中删除列的表的名称。 要删除的列的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取表示还原删除列的操作。无法自动计算反向，如果未向构造函数提供反向，则此属性将返回 null。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取要删除的列的名称。

获取应从中删除列的表的名称。

表示将从表中删除的外键约束。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 DropForeignKeyOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示还原删除外键约束的操作。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

初始化 DropForeignKeyOperation 类的新实例。还应填充 PrincipalTable、DependentTable 和 DependentColumns 属性。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取删除外键列上关联的索引的操作。

删除索引的操作。

获取表示还原删除外键约束的操作。无法自动计算反向，如果未向构造函数提供反向，则此属性将返回 null。

获取一个值，该值指示更改是否具有破坏性。

如果更改具有破坏性，则为 true；否则为 false。

表示删除现有索引。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 DropIndexOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示还原删除索引的操作。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

初始化 DropIndexOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取表示还原删除索引的操作。无法自动计算反向，如果未向构造函数提供反向，则此属性将返回 null。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

表示从表中删除主键。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 DropPrimaryKeyOperation 类的新实例。还应填充 Table 和 Columns 属性。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

在更改迁移历史记录表时使用，以便可以重新构建表，而不是简单地删除和添加主键。

用于迁移历史记录表的创建表操作。

获取添加主键的操作。

表示删除现有表。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 DropTableOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要删除的表的名称。 表示还原删除表的操作。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

初始化 DropTableOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要删除的表的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取表示还原删除表的操作。无法自动计算反向，如果未向构造函数提供反向，则此属性将返回 null。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取要删除的表的名称。

影响外键约束的更改的基类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 ForeignKeyOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

外键列的名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取或设置其中存在外键列的表的名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取指示是否为此外键约束提供了特定名称的值。

获取或设置此外键约束的名称。如果未提供名称，则将计算默认名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取或设置外键约束面向的表的名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示对迁移历史记录表的 DML 更改的操作。迁移历史记录表用于存储已应用于数据库的迁移的日志。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 HistoryOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示要应用于历史记录表的操作的命令目录树序列。 使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

表示要应用于历史记录表的操作的命令序列。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

影响索引的操作的常规基类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 IndexOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取已编制索引的列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取指示是否为此索引提供了特定名称的值。

获取或设置此索引的名称。如果未提供名称，则将计算默认名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取或设置此索引所属的表。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示修改数据库架构的操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 MigrationOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取提供程序可能会处理的其他参数。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取将还原此操作的操作。

获取指示此操作是否会导致数据丢失的值。

表示将表从一个架构移至另一个架构。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 MoveTableOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要移动的表的名称。 要将表移至的架构的名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

在更改迁移历史记录表时使用，以便可以将数据移到新表。

模型的上下文键。

在更改迁移历史记录表时使用，以便可以重新构建表，而不是简单地删除和添加主键。

用于迁移历史记录表的创建表操作。

获取将表移回其原始架构的操作。

获取一个值，该值指示此更改是否将导致数据丢失。

如果此更改将导致数据丢失，则为 true；否则为 false。

获取一个指示表是否为系统表的值。

如果表是系统表，则为 true；否则为 false。

获取要移动的表的名称。

获取要将表移至的架构的名称。

用于表示影响主键的操作的常规基类。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 PrimaryKeyOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取组成主键的列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取指示是否为此主键提供了特定名称的值。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取或设置此主键的名称。如果未提供名称，则将计算默认名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取或设置包含主键的表的名称。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

表示重命名现有列。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 RenameColumnOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

列所属表的名称。 要重命名的列的名称。 列的新名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取还原重命名的操作。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取要重命名的列的名称。

获取列的新名称。

获取列所属表的名称。

表示重命名现有表。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 RenameTableOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要重命名的表的名称。 表的新名称。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取还原重命名的操作。

获取一个值，该值指示更改是否具有破坏性。

如果更改具有破坏性，则为 true；否则为 false。

获取要重命名的表的名称。

获取表的新名称。

表示要直接对目标数据库执行的提供程序特定 SQL 语句。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 SqlOperation 类的新实例。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

要执行的 SQL。 提供程序可能会处理的其他参数。使用匿名类型语法指定参数，例如“new { SampleArgument = "MyValue" }”。

获取一个值，该值指示此操作是否会导致数据丢失。

如果此操作会导致数据丢失，则为 true；否则为 false。

获取要执行的 SQL。

获取或设置指示是否应在用于进行迁移过程事务的事务范围外执行此语句的值。如果设置为 true，则在迁移过程失败时，不会回滚此操作。

将提供程序不可知的迁移操作转换为数据库提供程序特定 SQL 命令的提供程序的常规基类。

初始化 类的新实例。

将一组迁移操作转换为数据库提供程序特定 SQL。

为执行迁移操作而要执行的 SQL 语句的列表。 要转换的操作。 表示将面向的数据库版本的标记。

为存储过程生成 SQL 主体。

存储过程的 SQL 主体。 表示针对插入、更新或删除操作的命令的命令目录树。 影响了参数名称的行。 提供程序清单标记。

表示已转换为 SQL 语句的迁移操作。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

初始化 类的新实例。

为数据库提供程序获取或设置批处理终止符。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

数据库提供程序的批处理终止符。

获取或设置为执行此迁移操作而要执行的 SQL。实体框架迁移 API 未被设计为接受不可信源（例如应用程序的最终用户）提供的输入。如果接受来自此类源的输入，则应该首先对其进行验证，然后传递给这些 API，以便防止 SQL 注入攻击之类的威胁。

获取或设置指示是否应在用于进行迁移过程事务的事务范围外执行此语句的值。如果设置为 true，则在迁移过程失败时，不会回滚此操作。

与 相同，但以部分信任模式运行，添加所生成缩进字符串的显式缓存，同时将仅包含 \r\n 或 \n 的字符串的写入识别为写入行，以确保在下一行正确缩进。

使用指定的文本编写器和默认 Tab 字符串，初始化 IndentedTextWriter 类的新实例。请注意，传递到此构造函数的编写器必须使用 属性指定的 。

用于输出的 。

使用指定的文本编写器和 Tab 字符串，初始化 IndentedTextWriter 类的新实例。请注意，传递到此构造函数的编写器必须使用 属性指定的 。

用于输出的 。 用于缩进的 Tab 字符串。

关闭正在向其写入的文档。

指定将由基础 TextWriter 使用的区域性。此静态属性为只读。请注意，传递到 的构造函数之一的任何编写器都必须使用此相同的区域性。区域性为 。

生成表示当前新行缩进级别的字符串。

一个空字符串，或者是包含所指定 Tab 字符串 .Indent 级别值的字符串。

指定默认 Tab 字符串。此字段为常数。

获取供文本编写器使用的编码。

指示供文本编写器使用的编码的 。

刷新流。

获取或设置要缩进的空格数。

要缩进的空格数。

获取要使用的 。

要使用的 。

获取或设置要使用的换行符。

要使用的换行符。

根据 属性为每个缩进级别输出一次 Tab 字符串。

将 Boolean 值的文本表示形式写入文本流。

要写入的 Boolean 值。

将字符写入文本流。

要写入的字符。

将字符数组写入文本流。

要写入的字符数组。

将字符的子数组写入文本流。

要从中写出数据的字符数组。 在缓冲区中开始索引。 要写入的字符数。

将 Double 的文本表示形式写入文本流。

要写入的 double。

将整数的文本表示形式写入文本流。

要写入的整数。

将 8 字节整数的文本表示形式写入文本流。

要写入的 8 字节整数。

将对象的文本表示形式写入文本流。

要写入的对象。

将 Single 的文本表示形式写入文本流。

要写入的 single。

将指定的字符串写入文本流。

要写入的字符串。

使用与指定语义相同的语义写出已格式化的字符串。

格式化字符串。 要写入已格式化字符串的对象。

使用与指定语义相同的语义写出已格式化的字符串。

要使用的格式化字符串。 第一个要写入已格式化字符串的对象。 第二个要写入已格式化字符串的对象。

使用与指定语义相同的语义写出已格式化的字符串。

要使用的格式化字符串。 要输出的参数数组。

写入一个行结束符。

将后跟行结束符的 Boolean 的文本表示形式写入文本流。

要写入的 Boolean。

将后跟行结束符的字符写入文本流。

要写入的字符。

将后跟行结束符的字符数组写入文本流。

要写入的字符数组。

将后跟行结束符的字符子数组写入文本流。

要从中写出数据的字符数组。 在缓冲区中开始索引。 要写入的字符数。

将后跟行结束符的 Double 的文本表示形式写入文本流。

要写入的 double。

将后跟行结束符的整数的文本表示形式写入文本流。

要写入的整数。

将后跟行结束符的 8 字节整数的文本表示形式写入文本流。

要写入的 8 字节整数。

将后跟行结束符的对象的文本表示形式写入文本流。

要写入的对象。

将后跟行结束符的 Single 的文本表示形式写入文本流。

要写入的 single。

将后跟行结束符的指定字符串写入文本流。

要写入的字符串。

使用与指定语义相同的语义写出后跟行结束符的已格式化字符串。

格式化字符串。 要写入已格式化字符串的对象。

使用与指定语义相同的语义写出后跟行结束符的已格式化字符串。

要使用的格式化字符串。 第一个要写入已格式化字符串的对象。 第二个要写入已格式化字符串的对象。

使用与指定语义相同的语义写出后跟行结束符的已格式化字符串。

要使用的格式化字符串。 要输出的参数数组。

将后跟行结束符的 UInt32 的文本表示形式写入文本流。

要输出的 UInt32。

将指定字符串写入无制表符的行。

要写入的字符串。

允许为模型中的复杂类型执行配置。可以通过对 使用 ComplexType 方法来获取 ComplexTypeConfiguration，也可以通过对 使用 Configurations 属性来注册从 ComplexTypeConfiguration 派生的自定义类型。

要配置的复杂类型。

初始化 ComplexTypeConfiguration 的一个新实例

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与指定对象进行比较的对象。

用作特定类型的哈希函数。

特定类型的哈希函数。

获取当前实例的类型。

当前实例的准确运行时类型。

从模型中排除某个属性，使该属性不会映射到数据库。

一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要忽略的属性的类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

允许为模型中的实体类型执行配置。可以通过对 使用 Entity 方法来获取 EntityTypeConfiguration，也可以通过对 使用 Configurations 属性来注册从 EntityTypeConfiguration 派生的自定义类型。

初始化 EntityTypeConfiguration 的一个新实例

返回指定的配置模型是否等于当前配置模型。

如果指定的配置模型等于当前配置模型，则为 true；否则为 false。 要与当前对象进行比较的模型。

返回指定配置模型的哈希函数。

指定模型生成器的哈希函数。

获取当前模型配置的类型。

当前模型配置的类型。

配置要用于此实体类型的实体集名称。只能为每个集中的基类型配置实体集名称。

同一个 EntityTypeConfiguration 实例，以便多个调用可以链接在一起。 实体集的名称。

配置此实体类型的主键属性。

同一个 EntityTypeConfiguration 实例，以便多个调用可以链接在一起。 表示要用作主键的属性的 lambda 表达式。C#: t =&gt; t.Id VB.Net: Function(t) t.Id 如果主键由多个属性组成，则指定包括这些属性的匿名类型。C#: t =&gt; new { t.Id1, t.Id2 } VB.Net: Function(t) New With { t.Id1, t.Id2 } 键的类型。

从此实体类型配置一对多关系。

可用于进一步配置关系的配置对象。 表示关系的导航属性的 lambda 表达式。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 关系另一端的实体的类型。

从此实体类型配置可选关系。实体类型的实例将能保存到数据库，而无需指定此关系。数据库中的外键可为 null。

可用于进一步配置关系的配置对象。 表示关系的导航属性的 lambda 表达式。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 关系另一端的实体的类型。

通过此实体类型配置必需关系。除非指定此关系，否则实体类型的实例将无法保存到数据库。数据库中的外键不可为 null。

可用于进一步配置关系的配置对象。 表示关系的导航属性的 lambda 表达式。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 关系另一端的实体的类型。

从模型中排除某个属性，使该属性不会映射到数据库。

一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要忽略的属性的类型。

允许与派生的实体类型映射到数据库架构的方式相关的高级配置。Map 调用是累加性的，后续调用不会重写已通过 Map 执行的配置。

同一个 EntityTypeConfiguration 实例，以便多个调用可以链接在一起。 对 执行配置的操作。 要配置的派生实体类型。

允许与此实体类型映射到数据库架构的方式相关的高级配置。默认情况下，任何配置都还会应用于从此实体类型派生的任何类型。可以使用配置派生类型的 Map 的重载，或使用派生类型的 EntityTypeConfiguration，来配置派生类型。可以使用多个 Map 调用，在多个表之间拆分实体的属性。Map 调用是累加性的，后续调用不会重写已通过 Map 执行的配置。

同一个 EntityTypeConfiguration 实例，以便多个调用可以链接在一起。 对 执行配置的操作。

将此类型配置为使用插入、更新和删除的存储过程。将使用过程名称和参数名称的默认约定。

同一个配置实例，以便可以链接多个调用。

将此类型配置为使用插入、更新和删除的存储过程。

同一个配置实例，以便可以链接多个调用。 用于重写过程名称和参数名称默认约定的配置。

返回模型配置的字符串表示形式。

模型生成器的字符串表示形式。

配置此实体类型映射到的表名。

表的名称。

配置此实体类型映射到的表名。

表的名称。 表的数据库架构。

在模型创建过程中，生成无效模型时，由 引发的异常。

初始化 ModelValidationException 的一个新实例

使用序列化信息和流下文初始化 类的新实例。

序列化信息。 流上下文。

初始化 ModelValidationException 的一个新实例

异常消息。

初始化 ModelValidationException 的一个新实例

异常消息。 内部异常。

用于执行关系配置的基类。通过 Code First Fluent API 可使用此配置功能，请参见 。

初始化 类的新实例。

用于配置实体类型或复杂类型的 属性。通过 Code First Fluent API 可使用此配置功能，请参见 。

配置用于存储属性的数据库列的名称。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 列的名称。

配置用于存储属性的数据库列的顺序。如果实体类型具有组合键，则此方法还用于指定键顺序。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置用于存储属性的数据库列的数据类型。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

配置数据库如何生成属性的值。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 用于在数据库中生成属性值的模式。设置“null”将从属性中移除数据库生成的模式方面。设置“null”将导致与指定“None”相同的运行时行为。

将属性配置为具有指定的最大长度。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 属性的最大长度。设置“null”将从属性中移除任何最大长度限制。

将属性配置为用作开放式并发标记。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置属性是否要用作开放式并发标记。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。 指示属性是否为并发标记的值。指定“null”将从属性中移除并发标记方面。指定“null”将导致与指定“false”相同的运行时行为。

将属性配置为固定长度。使用 HasMaxLength 可设置属性的固定长度。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为允许使用数据库提供程序支持的最大长度。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为可选属性。用于存储此属性的数据库列将可以为 null。默认情况下， 属性是可选的。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为必需属性。用于存储此属性的数据库列将不可以为 null。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为数据库中的行版本。实际数据类型将因使用的数据库提供程序而异。将属性设置为行版本会自动将属性配置为开放式并发标记。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为可变长度。默认情况下， 属性为可变长度。

同一个 BinaryPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置可以支持级联删除功能的关系。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

将级联删除配置为对关系启用。

配置是否对关系启用级联删除。

指示是否启用级联删除的值。

允许实体和复杂类型的派生配置类向 注册。

将 添加到 中。只能为模型中的每个类型添加一个 。

同一个 ConfigurationRegistrar 实例，以便多个调用可以链接在一起。 要添加的复杂类型配置 要配置的复杂类型。

将 添加到 中。只能为模型中的每个类型添加一个 。

同一个 ConfigurationRegistrar 实例，以便多个调用可以链接在一起。 要添加的实体类型配置。 要配置的实体类型。

发现从给定的程序集中的 或 继承的所有类型并将每个发现的类型的实例添加到此注册器。

同一个 ConfigurationRegistrar 实例，以便多个调用可以链接在一起。 包含要添加的模型配置的程序集。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

允许自定义 实例使用的约定。可在 System.Data.Entity.ModelConfiguration.Conventions 命名空间中找到默认约定。

启用 的约定。

要启用的约定类型。

启用 的一个或多个约定。

要启用的约定。

启用 的约定。在指定一个约定后将运行此约定。

要启用的约定。 在其之后将运行启用的约定的约定类型。

启用 的配置约定。在指定一个约定前将运行此约定。

要启用的约定。 在其之前将运行启用的约定的约定类型。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 一个对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

禁用 的约定。可在 System.Data.Entity.ModelConfiguration.Conventions 命名空间中找到可移除的默认约定。

要禁用的约定的类型。

禁用 的一个或多个约定。

要禁用的约定。

返回表示当前对象的字符串。

表示当前对象的字符串。

用于配置实体类型或复杂类型的 属性。通过 Code First Fluent API 可使用此配置功能，请参见 。

配置用于存储属性的数据库列的名称。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 列的名称。

配置用于存储属性的数据库列的顺序。如果实体类型具有组合键，则此方法还用于指定键顺序。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置用于存储属性的数据库列的数据类型。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

配置数据库如何生成属性的值。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 用于在数据库中生成属性值的模式。设置“null”将从属性中移除数据库生成的模式方面。设置“null”将导致与指定“None”相同的运行时行为。

配置属性的精度。如果数据库提供程序不支持列的数据类型的精度，则忽略该值。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 属性的精度。

将属性配置为用作开放式并发标记。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。

配置属性是否要用作开放式并发标记。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。 指示属性是否为并发标记的值。指定“null”将从属性中移除并发标记方面。指定“null”将导致与指定“false”相同的运行时行为。

将属性配置为可选属性。用于存储此属性的数据库列将可以为 null。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为必需属性。用于存储此属性的数据库列将不可以为 null。默认情况下， 属性是必需的。

同一个 DateTimePropertyConfiguration 实例，以便多个调用可以链接在一起。

用于配置实体类型或复杂类型的 属性。通过 Code First Fluent API 可使用此配置功能，请参见 。

配置用于存储属性的数据库列的名称。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 列的名称。

配置用于存储属性的数据库列的顺序。如果实体类型具有组合键，则此方法还用于指定键顺序。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置用于存储属性的数据库列的数据类型。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

配置数据库如何生成属性的值。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 用于在数据库中生成属性值的模式。设置“null”将从属性中移除数据库生成的模式方面。设置“null”将导致与指定“None”相同的运行时行为。

配置属性的精度和小数位数。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 属性的精度。 属性的小数位数。

将属性配置为用作开放式并发标记。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置属性是否要用作开放式并发标记。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。 指示属性是否为并发标记的值。指定“null”将从属性中移除并发标记方面。指定“null”将导致与指定“false”相同的运行时行为。

将属性配置为可选属性。用于存储此属性的数据库列将可以为 null。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为必需属性。用于存储此属性的数据库列将不可以为 null。默认情况下， 属性是必需的。

同一个 DecimalPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置可以支持在对象模型中公开的外键属性的关系。通过 Code First Fluent API 可使用此配置功能，请参见 。

从属实体类型。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

将关系配置为使用在对象模型中公开的外键属性。如果未在对象模型中公开外键属性，则使用 Map 方法。

可用于进一步配置关系的配置对象。 表示要用作外键的属性的 lambda 表达式。如果外键由多个属性组成，请指定包括这些属性的匿名类型。在使用多个外键属性时，指定这些属性的顺序必须与为主体实体类型配置主键属性的顺序相同。 键的类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置实体类型或实体类型中属性子集的表和列映射。通过 Code First Fluent API 可使用此配置功能，请参见 。

要映射的实体类型。

初始化 类的新实例。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

重新映射从基类型继承的所有属性。当将派生类型配置为映射到单独的表时，这会使所有属性都包含在该表中，而不仅仅是非继承的属性。这称为“每个具体类型一张表”(TPC) 映射。

配置将包含在此映射片段中的属性。如果未调用此方法，则将配置尚未包含在映射片段中的所有属性。

针对包含要映射的属性的匿名类型的 lambda 表达式。C#: t =&gt; new { t.Id, t.Property1, t.Property2 } VB.Net: Function(t) New With { p.Id, t.Property1, t.Property2 } 包含要映射的属性的匿名类型。

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要配置的属性的类型。

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置将包含在此映射片段中的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要配置的属性的类型。

配置用于区分继承层次结构中各个类型的鉴别器条件。

用于进一步配置鉴别器条件的配置对象。 表示要用于鉴别各个类型的属性的 lambda 表达式。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要用于鉴别各个类型的属性的类型。

配置用于区分继承层次结构中的各个类型的鉴别器列。

用于进一步配置鉴别器列和值的配置对象。 鉴别器列的名称。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置要映射到的表名。

表的名称。

配置要映射到的表名和架构。

表的名称。 表的架构。

配置未在对象模型中公开外键属性的关系的表和列映射。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

配置外键的列名。

同一个 ForeignKeyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 外键列名。在使用多个外键属性时，必须按照为目标实体类型配置主键属性的顺序来指定这些属性。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置外键列所在表的名称。指定的表必须已针对实体类型进行映射。如果要外键位于其自己的表中，则对 使用 Map 方法来执行实体拆分，以创建只有主键属性的表。然后可以使用此方法将外键添加到表。

同一个 ForeignKeyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 表的名称。

配置外键列所在表的名称和架构。指定的表必须已针对实体类型进行映射。如果要外键位于其自己的表中，则对 使用 Map 方法来执行实体拆分，以创建只有主键属性的表。然后可以使用此方法将外键添加到表。

同一个 ForeignKeyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 表的名称。 表的架构。

配置只能支持未在对象模型中公开的外键属性的关系。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象比较的对象

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

将关系配置为使用未在对象模型中公开的外键属性。可通过指定配置操作来自定义列和表。如果指定了空的配置操作，则约定将生成列名。如果在对象模型中公开了外键属性，则使用 HasForeignKey 方法。并非所有关系都支持在对象模型中公开外键属性。

可用于进一步配置关系的配置对象。 配置外键列和表的操作。

返回表示当前对象的字符串。

表示当前对象的字符串。

用于为实体类型或复杂类型配置具有长度方面的列。此配置功能由 Code First Fluent API 公开，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 一个对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

将列配置为具有指定的最大长度。

同一个 实例，以便多个调用可以链接在一起。 列的最大长度。将值设置为 null 将从列中移除任何最大长度限制，并且会将默认长度用于数据库列。

将列配置为固定长度。

同一个 实例，以便多个调用可以链接在一起。

将列配置为允许使用数据库提供程序支持的最大长度。

同一个 实例，以便多个调用可以链接在一起。

将列配置为可变长度。

同一个 实例，以便多个调用可以链接在一起。

返回表示当前对象的字符串。

表示当前对象的字符串。

通过实体类型配置多关系。

关系源自的实体类型。 作为关系目标的实体类型。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

将关系配置为 many:many，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 many:many，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 many:optional，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 many:optional，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 many:required，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 many:required，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置 many:many 关系的表和列映射。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

配置左外键的列名。左外键指向在 HasMany 调用中指定的导航属性的父实体。

同一个 ManyToManyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 外键列名。在使用多个外键属性时，必须按照为目标实体类型配置主键属性的顺序来指定这些属性。

配置右外键的列名。右外键指向在 WithMany 调用中指定的导航属性的父实体。

同一个 ManyToManyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 外键列名。在使用多个外键属性时，必须按照为目标实体类型配置主键属性的顺序来指定这些属性。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置关系的联接表名。

同一个 ManyToManyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 表的名称。

配置关系的联接表名和架构。

同一个 ManyToManyAssociationMappingConfiguration 实例，以便多个调用可以链接在一起。 表的名称。 表的架构。

配置 many:many 关系。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

配置用于存储关系的外键列和表。

配置外键列和表的操作。

配置将用于修改此关系的存储过程。将使用过程名称和参数名称的默认约定。

同一个 实例，以便多个调用可以链接在一起。

配置将用于修改此关系的存储过程。

同一个 实例，以便多个调用可以链接在一起。 用于重写过程名称和参数名称默认约定的配置。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置一个条件，该条件用于基于赋给属性的值来区分继承层次结构中的各个类型。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

将条件配置为属性中需要值。对于未向存储此属性的列赋值的行，假定这些行属于此实体类型的基类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

通过实体类型配置可选关系。

关系源自的实体类型。 作为关系目标的实体类型。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 一个对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

将关系配置为 optional:many，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 optional:many，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 optional:optional，且在关系的另一端无导航属性。要配置的实体类型将成为依赖对象，且包含主体的外键。作为关系目标的实体类型将成为关系中的主体。

可用于进一步配置关系的配置对象。

将关系配置为 optional:optional，且在关系的另一端有导航属性。要配置的实体类型将成为依赖对象，且包含主体的外键。作为关系目标的实体类型将成为关系中的主体。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 optional:optional，且在关系的另一端无导航属性。要配置的实体类型将成为关系中的主体。作为关系目标的实体类型将成为依赖对象，且包含主体的外键。

可用于进一步配置关系的配置对象。

将关系配置为 optional:optional，且在关系的另一端有导航属性。要配置的实体类型将成为关系中的主体。作为关系目标的实体类型将成为依赖对象，且包含主体的外键。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。

将关系配置为 optional:required，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 optional:required，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

通过实体类型配置基元列。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

配置用于存储属性的基元列的顺序。如果实体类型具有组合键，则此方法还用于指定键顺序。

同一个 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置用于存储属性的基元列的数据类型。

同一个 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

将基元列配置为可选列。

同一个 实例，以便多个调用可以链接在一起。

将基元列配置为必需列。

同一个 实例，以便多个调用可以链接在一起。

返回表示当前对象的字符串。

表示当前对象的字符串。

允许基于模型中的属性为轻型约定执行配置。

允许此约定应用到的属性的配置。

对 执行配置的操作。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

返回此实例的哈希代码。

此实例的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

在配置期间捕获以后要使用的值时基于谓词筛选此约定应用到的属性。

一个 实例，以便多个调用可以链接在一起。 用于为每个属性捕获值的函数。如果值为 null，则筛选掉该属性。 捕获的值的类型。

返回表示当前对象的字符串。

当前对象。

基于谓词筛选此约定应用到的属性。

一个 实例，以便多个调用可以链接在一起。 用于测试每个属性是否满足条件的函数。

允许基于模型中实体类型的属性和捕获的值为轻型约定执行配置。

允许此约定应用到的属性的配置。

使用捕获的值对 执行配置的操作。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

通过实体类型配置必需关系。

关系源自的实体类型。 作为关系目标的实体类型。

指定指定的对象是否与当前对象相同。

如果指定的对象与当前对象相同，则为 true；否则为 false。 要比较的对象。

获取与当前对象关联的哈希代码。

与当前对象关联的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

返回当前对象的字符串表示形式。

当前对象的字符串表示形式。

将关系配置为 required:many，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 required:many，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 required:optional，且在关系的另一端无导航属性。

可用于进一步配置关系的配置对象。

将关系配置为 required:optional，且在关系的另一端有导航属性。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 required:required，且在关系的另一端无导航属性。要配置的实体类型将成为依赖对象，且包含主体的外键。作为关系目标的实体类型将成为关系中的主体。

可用于进一步配置关系的配置对象。

将关系配置为 required:required，且在关系的另一端有导航属性。要配置的实体类型将成为依赖对象，且包含主体的外键。作为关系目标的实体类型将成为关系中的主体。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

将关系配置为 required:required，且在关系的另一端无导航属性。要配置的实体类型将成为关系中的主体。作为关系目标的实体类型将成为依赖对象，且包含主体的外键。

可用于进一步配置关系的配置对象。

将关系配置为 required:required，且在关系的另一端有导航属性。要配置的实体类型将成为关系中的主体。作为关系目标的实体类型将成为依赖对象，且包含主体的外键。

可用于进一步配置关系的配置对象。 一个 lambda 表达式，表示关系另一端的导航属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置用于存储字符串值的数据库列。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 一个对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的类型。

当前实例的准确运行时类型。

配置数据库列的顺序。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置数据库列的数据类型。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

将属性配置为具有指定的最大长度。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。 属性的最大长度。如果设置为“null”，将对此列使用默认长度。

将列配置为固定长度。使用 HasMaxLength 可设置属性的固定长度。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

将列配置为允许使用数据库提供程序支持的最大长度。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

将列配置为可选列。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

将列配置为必需。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

将列配置为支持 Unicode 字符串内容。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

配置列是否支持 Unicode 字符串内容。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。 指示列是否支持 Unicode 字符串内容的值。指定“null”将从列中移除 Unicode 方面。指定“null”将导致与指定“false”相同的运行时行为。

将列配置为可变长度。列在默认情况下为可变长度。

同一个 StringColumnConfiguration 实例，以便多个调用可以链接在一起。

返回表示当前对象的字符串。

表示当前对象的字符串。

用于配置实体类型或复杂类型的 属性。通过 Code First Fluent API 可使用此配置功能，请参见 。

配置用于存储属性的数据库列的名称。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 列的名称。

配置用于存储属性的数据库列的顺序。如果实体类型具有组合键，则此方法还用于指定键顺序。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 此列应在数据库表中出现的顺序。

配置用于存储属性的数据库列的数据类型。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 特定于数据库提供程序的数据类型的名称。

配置数据库如何生成属性的值。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 用于在数据库中生成属性值的模式。设置“null”将从属性中移除数据库生成的模式方面。设置“null”将导致与指定“None”相同的运行时行为。

将属性配置为具有指定的最大长度。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 属性的最大长度。设置为“null”将从属性中移除任何最大长度限制，并且会将默认长度用于数据库列。

将属性配置为用作开放式并发标记。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置属性是否要用作开放式并发标记。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 指示属性是否为并发标记的值。指定“null”将从属性中移除并发标记方面。指定“null”将导致与指定“false”相同的运行时行为。

将属性配置为固定长度。使用 HasMaxLength 可设置属性的固定长度。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为允许使用数据库提供程序支持的最大长度。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为可选属性。用于存储此属性的数据库列将可以为 null。默认情况下， 属性是可选的。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为必需属性。用于存储此属性的数据库列将不可以为 null。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

将属性配置为支持 Unicode 字符串内容。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

配置属性是否支持 Unicode 字符串内容。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。 指示属性是否支持 Unicode 字符串内容的值。指定“null”将从属性中移除 Unicode 方面。指定“null”将导致与指定“false”相同的运行时行为。

将属性配置为可变长度。默认情况下， 属性为可变长度。

同一个 StringPropertyConfiguration 实例，以便多个调用可以链接在一起。

允许为模型中的类型执行配置。

要配置的类型。

初始化 类的新实例。

确定指定的对象是否等于当前对象。

如果指定的对象等于当前对象，则为 true；否则为 false。 要与当前对象进行比较的对象。

用作特定类型的哈希函数。

当前对象的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要配置的属性的类型。

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty

配置在此类型上定义的 属性。

可用于配置属性的配置对象。 一个 lambda 表达式，表示将要配置的属性。C#: t =&gt; t.MyProperty VB.Net: Function(t) t.MyProperty 要配置的属性的类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

配置用于区分继承层次结构中各个类型的鉴别器列。通过 Code First Fluent API 可使用此配置功能，请参见 。

确定指定的对象是否等于当前对象。

如果对象相等，则为 true；否则为 false。 一个对象。

用作特定类型的哈希函数。

当前类型的哈希代码。

获取当前实例的 。

当前实例的准确运行时类型。

配置用于标识通过继承层次结构中其他类型配置的实体类型的鉴别器值。

用来配置用于存储鉴别器值的列的配置对象。 用于标识实体类型的值。 鉴别器值的类型。

配置用于标识通过继承层次结构中其他类型配置的实体类型的鉴别器值。

用来配置用于存储鉴别器值的列的配置对象。 用于标识实体类型的值。

配置用于标识通过继承层次结构中其他类型配置的实体类型的鉴别器值。

用来配置用于存储鉴别器值的列的配置对象。 用于标识实体类型的值。 鉴别器值的类型。

返回表示当前对象的字符串。

表示当前对象的字符串。

用于在相关类型之间只存在一对导航属性时，将导航属性检测为相互反向的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定

初始化 类的新实例。

用于应用通过 或 API 指定的列顺序的约定。

初始化 类的新实例。

验证为列提供的排序配置。此基实现是一个空操作。

列所属表的名称。 表的定义。

用于应用通过 或 API 指定的列顺序的约定。如果检测重复配置的列顺序，则此约定引发。

初始化 类的新实例。

验证为列提供的排序配置，以确保没有为两个列提供相同的序号。

列所属表的名称。 表的定义。

用于处理在模型中类型上发现的 实例的约定。

初始化 类的新实例。

用于在类型没有主键、没有映射的基类型且没有导航属性的情况下将其配置为复杂类型的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于为小数属性将精度设置为 18 并将小数位数设置为 2 的约定。

使用默认精度和小数位数初始化 类的新实例。

使用指定的精度和小数位数初始化 类的新实例。

精度 小数位数

用于移动主键属性使其首先出现的约定。

初始化 类的新实例。

用于基于外键属性的 CLR 可空性区分可选和必需关系的约定。

初始化 类的新实例。

用于发现外键属性的约定的基类。

初始化 类的新实例。

如果被重写，并且 应该是外键的一部分，则返回 true。

如果 dependentProperty 应该是外键的一部分，则为 true；否则为 false。 所配置的关联类型。 依赖端。 依赖端的候选属性。 主体端实体类型。 主体端的键属性，该键属性是外键的候选目标。

如果约定支持在实体类型对之间定义多个关联，则返回 true。

用于处理在模型中导航属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中的外键属性上发现的 的实例的约定。

初始化 类的新实例。

标识可以添加到 实例或从该实例中移除的约定。

用于检测主键属性的约定。可识别的命名模式为（按优先级顺序）为：1.''Id' 2。[type name]Id。主键检测不区分大小写。

初始化 类的新实例。

要匹配 类的约定。

要匹配的 类。 实体类型。 基元属性的集合。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于发现主键属性的约定的基类。

初始化 类的新实例。

如果被重写，则返回将成为主键一部分的属性子集。

应成为主键一部分的属性。 实体类型。 实体的基元类型

用于将级联删除从多对多关系中涉及的两个表添加到联接表的约定。

初始化 类的新实例。

确保在映射继承的属性时不创建无效/不支持的映射的约定

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于发现名称是从属导航属性名称和主体类型主键属性名称组合的外键属性的约定。

初始化 类的新实例。

匹配依赖的实体模型的键。

返回 。 关联类型元数据对象。 依赖的关联的端。 依赖的属性。 主体实体类型 主体键属性。

获取或设置一个值，该值指示约定是否支持多个关联。

如果约定支持多个关联，则为 true；否则为 false。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中类型上发现的 实例的约定。

初始化 类的新实例。

用于为任何必需关系启用级联删除的约定。

初始化 类的新实例。

用于将从属实体类型的主键配置为一对一关系中的外键的约定。

初始化 类的新实例。

用于将实体集名称设置为实体类型名称的复数版本的约定。

初始化 类的新实例。

用于将表名设置为实体类型名称的复数版本的约定。

初始化 类的新实例。

用于发现名称与主体类型主键属性名称匹配的外键属性的约定。

初始化 类的新实例。

匹配与约定关联的依赖键属性。

匹配的依赖键属性。 关联类型。 依赖的关联端。 依赖的属性。 主体实体类型。 主体键属性。

用于为其类型支持长度方面的属性设置最大长度的约定。默认值为 128。

使用默认长度初始化 类的新实例。

使用指定长度初始化 的新实例。

用于处理在模型中导航属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中基元属性上发现的 实例的约定。

初始化 类的新实例。

为其类型在 SqlCe 为提供程序时支持长度方面的属性设置默认最大长度为 4000 的约定。

初始化 类的新实例。

用于将整数主键配置为标识的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中类型上发现的 实例的约定。

初始化 类的新实例。

用于处理在模型中属性上发现的 实例的约定。

初始化 类的新实例。

用于发现名称是主体类型名称和主体类型主键属性名称组合的外键属性的约定。

初始化 类的新实例。

确定依赖键的属性是否与当前键匹配。

如果依赖键的属性与当前键匹配，则为 true；否则为 false。 关联类型。 端上依赖的关联。 依赖的属性。 主体实体类型。 主体键属性。

表示大地（圆地球）坐标系中的数据。

获取指示此 DbGeography 值面积的可为 null 的双精度值，如果此值不表示面，则可能为 null。

指示此 DbGeography 值的面积、可以为 null 的双精度值。

生成此 DbGeography 值的已知二进制表示形式。

此 DbGeography 值的已知二进制表示形式。

生成此 DbGeography 值的地理标记语言 (GML) 表示形式。

包含此 DbGeography 值的 GML 表示形式的字符串。

生成此 DbGeography 值的已知文本表示形式。仅包含点的经度和纬度。

包含此 DbGeography 值的已知文本表示形式的字符串。

返回一个表示点并集的地理对象，该并集中所有点与地理实例的距离都小于或等于指定的值。

一个地理对象，表示所有点的并集 距离。

获取与坐标系关联的标识符。

与坐标系关联的标识符。

获取地理值 (WGS 84) 的默认坐标系 ID (SRID)

地理值 (WGS 84) 的默认坐标系 ID (SRID)

计算此 DbGeography 值和另一 DbGeography 值的差异。

一个新 DbGeography 值，表示此地理值与其他地理值之间的差异。 应计算它与此值的差异的地理值。

获取给定 值的维度（如果值为集合）或最大的元素维度。

给定 值的维度。

确定此 DbGeography 在空间上是否与指定的 DbGeography 参数不相交。

如果其他地理值不与此地理值相交，则为 true；否则为 false。 应与此地理值比较不相交性的地理值。

计算此 DbGeography 值和另一 DbGeography 值中两个最接近的点之间的距离。

一个双精度值，指定此地理值和其他地理值中，最接近两点之间的距离。 应计算与此值的距离的地理值。

如果表示地理集合，则从特定位置返回此 DbGeography 值的元素。&amp;lt;param name="index"&amp;gt;此地理值中，应采用该处元素的位置。&amp;lt;/param&amp;gt;&amp;lt;returns&amp;gt;如果此地理值表示其他地理值的集合，则为它当中指定位置处的元素；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值在特定位置处的元素 索引。

如果此 DbGeography 值表示地理集合，则获取它当中的元素个数。&amp;lt;returns&amp;gt;如果此地理值表示其他地理值的集合，则为它当中的元素个数；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值中的元素数目。

如果此 DbGeography 值表示点，则获取它的海拔（Z 坐标）值。&amp;lt;returns&amp;gt;如果此地理值表示点，则为它的海拔（Z 坐标）值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值的海拔（Z 坐标）。

获取表示此值起始点的 DbGeography 值，如果 DbGeography 值不表示曲线，此值可能是 null。

表示此值起点的 DbGeography 值。

基于指定的已知二进制值创建新的 值。

使用默认的地理坐标系标识符 (SRID) ()、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的地理标记语言 (GML) 值创建新的 值。

使用默认的地理坐标系标识符 (SRID) ()、由 GML 值定义的新 DbGeography 值。 包含地理值的地理标记语言 (GML) 表示形式的字符串。

基于指定的地理标记语言 (GML) 值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由 GML 值定义的新 DbGeography 值。 包含地理值的地理标记语言 (GML) 表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知文本值创建新的 值。

使用默认的地理坐标系标识符 (SRID) ()、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 集合值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 集合值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

计算此 DbGeography 值和另一 DbGeography 值的交集。

一个新 DbGeography 值，表示此地理值与其他地理值之间的交集。 应计算与此值的交集的地理值。

确定此 DbGeography 值在空间上是否和指定的 DbGeography 参数相交。

如果其他地理值与此地理值相交，则为 true；否则为 false。 应与此地理值比较相交性的地理值。

获取指示此 DbGeography 值是否为闭合的可为 null 的布尔值，如果此值不表示曲线，则可能为 null。

如果此 DbGeography 值为闭合值，则为 true；否则为 false。

获取一个可为 null 的布尔值，它指示此 DbGeography 值是否为空。

如果此 DbGeography 值为空，则为 true；否则为 false。

如果此 DbGeography 值表示点，则获取它的纬度坐标。&amp;lt;returns&amp;gt;如果此地理值表示点，则为它的纬度坐标值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值的纬度坐标。

获取指示此 DbGeography 值长度的可为 null 的双精度值，如果此值不表示曲线，则可能为 null。

指示此 DbGeography 值的长度、可以为 null 的双精度值。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 线值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 线值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

如果此 DbGeography 值表示点，则获取它的经度坐标。&amp;lt;returns&amp;gt;如果此地理值表示点，则为它的经度坐标值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值的经度坐标。

如果此 DbGeography 值表示点，则获取它的 M（度量值）坐标。&amp;lt;returns&amp;gt;如果此地理值表示点，则为它的 M（度量值）坐标值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值的 M（度量值）坐标。

返回二进制值中的多线值。

二进制值中的多线值。 已知的二进制值。 坐标系标识符。

返回已知文本值中的多线值。

已知文本值中的多线值。 已知的文本。 坐标系标识符。

返回已知二进制值中的多点值。

已知二进制值中的多点值。 已知的二进制值。 坐标系标识符。

返回已知文本值中的多点值。

已知文本值中的多点值。 已知的文本值。 坐标系标识符。

返回已知二进制值的多多边形值。

已知二进制值中的多多边形值。 多多边形已知二进制值。 坐标系标识符。

返回已知文本值中的多多边形值。

已知文本值中的多多边形值。 多多边形已知文本值。 坐标系标识符。

如果表示行字符串或线性环，则从特定位置返回此 DbGeography 值的元素。&amp;lt;param name="index"&amp;gt;此地理值中，应采用该处元素的位置。&amp;lt;/param&amp;gt;&amp;lt;returns&amp;gt;如果此地理值表示行字符串或线性环，则为它当中指定位置处的元素；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值在特定位置处的元素 索引。

如果表示行字符串或线性环，则获取此 DbGeography 值中的点数。&amp;lt;returns&amp;gt;如果此地理值表示行字符串或线性环，则为它当中的元素个数；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值中的点数。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 点值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 点值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 多边形值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeography 值。 包含地理值的已知二进制表示形式的字节数组。 新 DbGeography 值应使用的坐标系的标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 多边形值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeography 值。 包含地理值的已知文本表示形式的字符串。 新 DbGeography 值应使用的坐标系的标识符。

获取将用于此空间类型的操作的空间提供程序。

获取此 DbGeography 值的表示形式，它对于构造它的基础提供程序是特定的。

此 DbGeography 值的表示形式。

确定此 DbGeography 在空间上是否与指定的 DbGeography 参数相等。

如果其他地理值在空间上与此地理值相等，则为 true ；否则为 false。 应与此地理值比较相等性的地理值。

获取 DBGeography 的空间类型名称。

DBGeography 的空间类型名称。

获取表示此值起始点的 DbGeography 值，如果 DbGeography 值不表示曲线，此值可能是 null。

表示此值起点的 DbGeography 值。

计算此 DbGeography 值和另一 DbGeography 值的对称差异。

一个新 DbGeography 值，表示此地理值与其他地理值的对称差异。 应计算与此值的对称差异的地理值。

返回地理值的字符串表示形式。

地理值的字符串表示形式。

计算此 DbGeography 值和另一 DbGeography 值的并集。

一个新 DbGeography 值，表示此地理值与其他地理值之间的并集。 应计算与此值的并集的地理值。

获取或设置此 DbGeography 值的数据协定的可序列化已知表示形式。

此 DbGeography 值的数据协定的可序列化的已知表示形式。

值的数据协定的可序列化表示形式。

初始化 类的新实例。

获取或设置此值的坐标系标识符 (SRID)。

获取或设置此值的已知二进制表示形式。

获取或设置此值的已知文本表示形式。

表示几何形状。

获取指示此 DbGeometry 值面积的可为 null 的双精度值，如果此值不表示面，则可能为 null。

一个可以为 null 的双精度值，指示此 DbGeometry 值的面积。

生成此 DbGeometry 值的已知二进制表示形式。

此 DbGeometry 值的已知二进制表示形式。

生成此 DbGeometry 值的地理标记语言 (GML) 表示形式。

包含此 DbGeometry 值的 GML 表示形式的字符串。

生成此 DbGeometry 值的已知文本表示形式。仅包含点的 X 和 Y 坐标。

包含此 DbGeometry 值的已知文本表示形式的字符串。

获取 DbGeometry 对象的边界。

DbGeometry 对象的边界。

返回一个表示所有点并集的几何对象，该并集中所有点与几何实例的距离都小于或等于指定的值。

一个几何对象，表示所有点的并集。 距离。

获取表示此 DbGeometry 值的形心的 DbGeometry 值，如果此值不表示面，则可能为 null。

一个 DbGeometry 值，表示此 DbGeometry 值的形心。

确定此 DbGeography 值在空间上是否包含指定的 DbGeography 参数。

如果此几何值包含其他几何值，则为 true；否则为 false。 应与此几何值比较包含关系的几何值。 其他

获取此 DbGeometry 值的凸包作为另一 DbGeometry 值。

用作另一 DbGeometry 值的此 DbGeometry 值的凸包。

获取此 DbGeometry 对象的坐标系统标识符。

此 DbGeometry 对象的坐标系统标识符。

确定此 DbGeometry 值在空间上是否与指定的 DbGeometry 参数相交。

如果其他几何值与此几何值相交，则为 true；否则为 false。 应与此几何值比较的几何值。 其他

获取几何值的默认坐标系 ID (SRID)。

此几何值的默认坐标系 ID (SRID)。

计算此 DbGeometry 值和另一 DbGeometry 值的差异。

一个新 DbGeometry 值，表示此几何值与其他几何值的差异。 应计算与此值的差异的几何值。 其他

获取给定 值的维度（如果该值为一个集合）或其中最大元素的维度。

给定 值的维度。

确定此 DbGeometry 在空间上是否与指定的 DbGeometry 参数不相交。

如果其他几何值与此几何值不相交，则为 true；否则为 false。 应与此几何值比较不相交性的几何值。 其他

计算此 DbGeometry 值和另一 DbGeometry 值中两个最接近的点之间的距离。

一个双精度值，指定此几何值和其他几何值中最接近的两点之间的距离。 应计算与此值的距离的几何值。 其他

如果表示几何集合，则从特定位置返回此 DbGeometry 值的元素。&amp;lt;param name="index"&amp;gt;此几何值中，应采用该处元素的位置。&amp;lt;/param&amp;gt;&amp;lt;returns&amp;gt;如果此几何值表示其他几何值的集合，则为它当中指定位置处的元素；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值在特定位置处的元素。 索引。

如果表示几何集合，则获取此 DbGeometry 值中的元素数。&amp;lt;returns&amp;gt;如果此几何值表示其他几何值的集合，则为它当中的元素个数；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值中的元素个数。

如果此 DbGeometry 值表示点，则获取它的海拔（Z 坐标）值。&amp;lt;returns&amp;gt;如果此几何值表示点，则为它的海拔（Z 坐标）值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值的海拔（Z 坐标）值。

获取表示此值起始点的 DbGeometry 值，如果 DbGeometry 值不表示曲线，此值可能为 null。

表示此值起点的 DbGeometry 值。

获取此 DbGeometry 值的包络线（最小边界框）作为几何值。

此 DbGeometry 值的包络线（最小边界框）。

获取表示此 DbGeometry 值的外部环的 DbGeometry 值，如果此值不表示多边形，则可能为 null。

一个 DbGeometry 值，表示此 DbGeometry 值的外部环。

基于指定的已知二进制值创建新的 值。

使用默认的几何坐标系标识符 ()、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 wellKnownBinary

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 新 DbGeometry 值应使用的坐标系的标识符。 wellKnownBinary coordinateSystemId

基于指定的地理标记语言 (GML) 值创建新的 值。

使用默认的几何坐标系标识符 (SRID) ()、由 GML 值定义的新 DbGeometry 值。 包含几何值的地理标记语言 (GML) 表示形式的字符串。 geometryMarkup

基于指定的地理标记语言 (GML) 值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由 GML 值定义的新 DbGeometry 值。 包含几何值的地理标记语言 (GML) 表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 geometryMarkup coordinateSystemId

基于指定的已知文本值创建新的 值。

使用默认的几何坐标系标识符 (SRID) ()、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 wellKnownText

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 wellKnownText coordinateSystemId

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 集合值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 新 DbGeometry 值应使用的坐标系的标识符。 geometryCollectionWellKnownBinary coordinateSystemId

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 集合值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 geometryCollectionWellKnownText coordinateSystemId

如果表示多边形，则从此 DbGeometry 值返回位于特定位置的内部环。&amp;lt;param name="index"&amp;gt;此几何值中，应采用该处内部环的位置。&amp;lt;/param&amp;gt;&amp;lt;returns&amp;gt;如果此几何值表示多边形，则为它当中指定位置处的内部环；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值特定位置处的内部环。 索引。

如果表示多边形，则获取此 DbGeometry 值中的内部环数。&amp;lt;returns&amp;gt;如果此几何值表示多边形，则为它当中的元素个数；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值中内部环的个数。

计算此 DbGeometry 值和另一 DbGeometry 值的交集。

一个新 DbGeometry 值，表示此几何值与其他几何值的交集。 应计算与此值的交集的几何值。 其他

确定此 DbGeometry 在空间上是否与指定的 DbGeometry 参数相交。

如果其他几何值与此几何值相交，则为 true；否则为 false。 应与此几何值比较相交性的几何值。 其他

获取指示此 DbGeometry 值是否为闭合的可为 null 的布尔值，如果此值不表示曲线，则可能为 null。

如果此 DbGeometry 值为闭合值，则为 true；否则为 false。

获取一个可以为 null 的布尔值，该值指示此 DbGeometry 值是否为空；如果此值不表示曲线，则可能为 null。

如果此 DbGeometry 值为空，则为 true；否则为 false。

获取指示此 DbGeometry 值是否为环的可为 null 的布尔值，如果此值不表示曲线，则可能为 null。

如果此 DbGeometry 值是一个环，则为 true；否则为 false。

获取一个可以为 null 的布尔值，该值指示此 DbGeometry 值是否为简单值。

如果此 DbGeometry 值是简单值，则为 true；否则为 false。

获取一个可以为 null 的布尔值，该值指示此 DbGeometry 值是否有效。

如果此 DbGeometry 值有效，则为 true；否则为 false。

获取指示此 DbGeometry 值长度的可为 null 的双精度值，如果此值不表示曲线，则可能为 null。

此 DbGeometry 值的长度。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 线值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 新 DbGeometry 值应使用的坐标系的标识符。 lineWellKnownBinary coordinateSystemId

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 线值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 lineWellKnownText coordinateSystemId

如果此 DbGeometry 值表示点，则获取它的度量值（M 坐标）。&amp;lt;returns&amp;gt;如果此几何值表示点，则为它的度量值（M 坐标）；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeography 值的测量值（M 坐标）。

返回二进制值中的多线值。

二进制值中的多线值。 已知的二进制值。 坐标系标识符。

返回已知文本值中的多线值。

已知文本值中的多线值。 已知的文本。 坐标系标识符。

返回已知二进制值中的多点值。

已知二进制值中的多点值。 已知的二进制值。 坐标系标识符。

返回已知文本值中的多点值。

已知文本值中的多点值。 已知的文本值。 坐标系标识符。

返回已知二进制值的多多边形值。

已知文本值中的多点值。 多多边形已知文本值。 坐标系标识符。

返回已知二进制值的多多边形值。

已知二进制值中的多多边形值。 多多边形已知文本值。 坐标系标识符。

确定此 DbGeometry 值在空间上是否与指定的 DbGeometry 参数重叠。

如果此几何值与其他几何值重叠，则为 true；否则为 false。 应与此几何值比较重叠的几何值。 其他

如果此 DbGeometry 值表示行字符串或线性环，则返回它特定位置处的元素。&amp;lt;param name="index"&amp;gt;此几何值中，应采用该处元素的位置。&amp;lt;/param&amp;gt;&amp;lt;returns&amp;gt;如果此几何值表示行字符串或线性环，则为它当中指定位置处的元素；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值在特定位置处的元素。 索引。

如果此 DbGeometry 值表示行字符串或线性环，则获取它当中的点数。&amp;lt;returns&amp;gt;如果此几何值表示行字符串或线性环，则为它当中的点数；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值中的点数。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 点值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 新 DbGeometry 值应使用的坐标系的标识符。 pointWellKnownBinary coordinateSystemId

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 点值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 pointWellKnownText coordinateSystemId

获取此 DbGeometry 值面上的点，如果此值不表示面，则可能为 null。

此 DbGeometry 值面上的点。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 多边形值。

使用指定的坐标系标识符、由已知二进制值定义的新 DbGeometry 值。 包含几何值的已知二进制表示形式的字节数组。 新 DbGeometry 值应使用的坐标系的标识符。 polygonWellKnownBinary coordinateSystemId

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 多边形值。

使用指定的坐标系标识符、由已知文本值定义的新 DbGeometry 值。 包含几何值的已知文本表示形式的字符串。 新 DbGeometry 值应使用的坐标系的标识符。 polygonWellKnownText coordinateSystemId

获取将用于此空间类型的操作的空间提供程序。

获取此 DbGeometry 值的表示形式，它对于构造它的基础提供程序是特定的。

此 DbGeometry 值的表示形式。

根据给定的维度扩展的 9 交集模型 (DE-9IM) 交集模式来确定此 DbGeometry 值在空间上是否与指定的 DbGeometry 参数相关。

如果按照指定的交集样式矩阵，此几何值与其他几何值相关，则为 true；否则为 false。 应与此几何值比较相关性的几何值。 包含定义了相关性的 (DE-9IM) 交集模式的文本表示形式的字符串。 othermatrix

确定此 DbGeometry 在空间上是否与指定的 DbGeometry 参数相等。

如果其他几何值在空间上与此几何值相等，则为 true ；否则为 false。 应与此几何值比较相等性的几何值。 其他

获取此 DbGeometry 值的空间类型名称表示形式。

此 DbGeometry 值的空间类型名称表示形式。

获取表示此值起始点的 DbGeometry 值，如果 DbGeometry 值不表示曲线，此值可能为 null。

表示此值起点的 DbGeometry 值。

计算此 DbGeometry 值和另一 DbGeometry 值的对称差异。

一个新 DbGeometry 值，表示此几何值与其他几何值的对称差异。 应计算与此值的对称差异的几何值。 其他

返回几何值的字符串表示形式。

此几何值的字符串表示形式。

确定此 DbGeometry 值在空间上是否与指定的 DbGeometry 参数接触。

如果其他几何值与此几何值相接，则为 true；否则为 false。 应与此几何值比较的几何值。 其他

计算此 DbGeometry 值和另一 DbGeometry 值的并集。

一个新 DbGeometry 值，表示此几何值与其他几何值的并集。 应计算与此值的并集的几何值。 其他

获取或设置此 DbGeometry 值的数据协定的可序列化已知表示形式。

此 DbGeometry 值的数据协定的可序列化的已知表示形式。

确定此 DbGeometry 值在空间上是否在指定的 DbGeometry 参数内。

如果此几何值在其他几何值中，则为 true；否则为 false。 应与此几何值比较包含关系的几何值。 其他

如果此 DbGeometry 值表示点，则获取它的 X 坐标。&amp;lt;returns&amp;gt;如果此几何值表示点，则为它的 X 坐标值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值的 X 坐标。

如果此 DbGeometry 值表示点，则获取它的 Y 坐标。&amp;lt;returns&amp;gt;如果此几何值表示点，则为它的 Y 坐标值；否则为 null。&amp;lt;/returns&amp;gt;

此 DbGeometry 值的 Y 坐标。

值的数据协定的可序列化表示形式。

初始化 类的新实例。

获取或设置此值的坐标系标识符 (SRID)。

获取或设置此值的已知二进制表示形式。

获取或设置此值的已知文本表示形式。

与提供程序无关的服务 API，用于支持地理空间（几何/地理）类型。

初始化 类的新实例。

当在派生类型中实现时，从指定列序号的列读取 的实例。

位于指定列值处的 DbGeography 实例 包含地理值的列序号

从位于指定的列序号的列异步读取 的实例。

表示异步操作的任务。任务结果包含位于指定列值处的 实例。 包含地理值的列序号。 等待任务完成期间要观察的 。

当在派生类型中实现时，从指定列序号的列读取 的实例。

位于指定列值处的 DbGeometry 实例 包含提供程序专用几何数据的数据记录列的序号

从位于指定的列序号的列异步读取 的实例。

表示异步操作的任务。任务结果包含位于指定列值处的 实例。 包含提供程序特定的几何数据的数据记录列的序号。 等待任务完成期间要观察的 。

返回位于指定的列序号的列是否为地理类型

如果位于指定的列序号的列为地理类型，则为 true；否则为 false。

返回位于指定的列序号的列是否为几何类型

如果位于指定的列序号的列为几何类型，则为 true；否则为 false。

与提供程序无关的服务 API，用于支持地理空间（几何/地理）类型。

初始化 类的新实例。

获取给定 值的已知二进制表示形式。

给定 值的已知二进制表示形式。 应为其生成已知二进制的地理值。 为 null。 与此空间服务实现不兼容。

获取给定 值的已知二进制表示形式。

给定 值的已知二进制表示形式。 应为其生成已知二进制的几何值。 为 null。 与此空间服务实现不兼容。

生成此 值的地理标记语言 (GML) 表示形式。

包含此 DbGeography 值的 GML 表示形式的字符串。 应生成 GML 的地理值。 为 null。 与此空间服务实现不兼容。

生成此 值的地理标记语言 (GML) 表示形式。

包含此 DbGeometry 值的 GML 表示形式的字符串。 应生成 GML 的几何值。 为 null。 与此空间服务实现不兼容。

获取给定 值的已知文本表示形式。此值仅应包含点的经度和纬度。

一个字符串，包含 geographyValue 的已知文本表示形式。 应为其生成已知文本的地理值。 为 null。 与此空间服务实现不兼容。

获取给定 值的已知文本表示形式，仅包含点的 X 和 Y 坐标。

一个字符串，包含 geometryValue 的已知文本表示形式。 应为其生成已知文本的几何值。 为 null。 与此空间服务实现不兼容。

返回 带有海拔和测量值的文本表示形式。

的文本表示形式。 地理值。 为 null。 与此空间服务实现不兼容。

返回 带有海拔和测量值的文本表示形式。

带有海拔和测量值的文本表示形式。 几何值。 为 null。 与此空间服务实现不兼容。

创建一个地理值，该值表示所有距离小于或等于所给定 值的点。

一个新 DbGeography 值，表示所有距离小于或等于 geographyValue 的点。 地理值。 一个双精度值，指定从 geographyValue 到缓冲区的距离。 为 null。 与此空间服务实现不兼容。

创建一个几何值，该值表示所有距离小于或等于所给定 的点。

一个新 DbGeometry 值，表示所有距离小于或等于 geometryValue 的点。 几何值。 一个双精度值，指定从 geometryValue 到缓冲区的距离。 为 null。 与此空间服务实现不兼容。

确定一个 值是否在空间上包含另一个值。

如果 geometryValue 包含 otherGeometry，则为 true；否则为 false。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

在进行指定提供程序值的合适验证后，此方法主要由 的派生实现使用，以确保其适用于派生实现。

一个新的 实例，包含指定的 providerValue，使用指定的 spatialServices 作为其空间实现。 返回的 值将依赖它实现空间功能的空间服务实例。 提供程序值。

在进行指定提供程序值的合适验证后，此方法主要由 的派生实现使用，以确保其适用于派生实现。

一个新的 实例，包含指定的 providerValue，使用指定的 spatialServices 作为其空间实现。 返回的 值将依赖它实现空间功能的空间服务实例。 提供程序值。

基于指定的已知 表示形式，创建一个兼容此空间服务实现的提供程序特定值。

一个提供程序特定值，它按照兼容此空间服务实现的方式，对 wellKnownValue 中包含的信息进行编码。 一个 实例，包含地理值的此已知表示形式。

基于指定的已知 表示形式，创建一个兼容此空间服务实现的提供程序特定值。

一个提供程序特定值，它按照兼容此空间服务实现的方式，对 wellKnownValue 中包含的信息进行编码。 一个 实例，包含几何值的此已知表示形式。

使用其中一个或这两个标准已知空间格式，创建表示所指定 值的 实例。

geographyValue 的已知表示形式，用作新 。 地理值。 为 null。 与此空间服务实现不兼容。

使用其中一个或这两个标准已知空间格式，创建表示指定 值的 实例。

geometryValue 的已知表示形式，用作新 。 几何值。 为 null。 与此空间服务实现不兼容。

确定两个给定的 值是否在空间上相交。

如果 geometryValue 与 otherGeometry 相交，则为 true；否则为 false。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

为 获取默认服务。

默认服务。

计算两个 值的差异。

一个新 DbGeography 值，表示 geographyValue 和 otherGeography 的差异。 第一个地理值。 第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的差异。

一个新 DbGeometry 值，表示 geometryValue 和 otherGeometry 的差异。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值是否在空间上不相交。

如果 geographyValue 不与 otherGeography 相交，则为 true；否则为 false。 用来比较不相交性的第一个地理值。 用来比较不相交性的第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值是否在空间上不相交。

如果 geometryValue 与 otherGeometry 不相交，则为 true；否则为 false。 用来比较不相交性的第一个几何值。 用来比较不相交性的第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值中最接近的点之间的距离。

一个双精度值，表示 geographyValue 和 otherGeography 中，最接近两点之间的距离。 第一个地理值。 第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值中最接近的点之间的距离。

一个双精度值，指定 geometryValue 和 otherGeometry 中，最接近两点之间的距离。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

如果表示地理集合，则返回给定 值的元素。

如果此 geographyValue 表示其他地理值的集合，则为它在位置索引处的元素；否则为 null。 不需要表示地理集合的地理值。 在地理值中应提取元素的位置。 为 null。 与此空间服务实现不兼容。

如果表示几何集合，则返回给定 值的元素。

如果此 geometryValue 表示其他几何值的集合，则为它在位置索引处的元素；否则为 null。 不需要表示几何集合的几何值。 在几何值中应提取元素的位置。 为 null。 与此空间服务实现不兼容。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 集合值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 集合值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含地理值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值创建新的 值。

一个新 值，由已知二进制值使用默认 坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的地理标记语言 (GML) 值创建新的 值。

一个新 值，由 GML 值使用默认 坐标系统标识符 (SRID) () 进行定义。 包含地理值的几何标记语言 (GML) 表示形式的字符串。

基于指定的地理标记语言 (GML) 值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由 GML 值使用指定的坐标系标识符 (SRID) 进行定义。 包含地理值的几何标记语言 (GML) 表示形式的字符串。 新 值应使用的坐标系标识符。

基于与此空间服务实现兼容的提供程序特定的值创建新的 值。

一个新 DbGeometry 值，它受此空间服务实现和指定提供程序值的支持。 此空间服务实现可将其解释为地理值的提供程序特定的值。 为 null。 与此空间服务实现不兼容。

基于指定的已知文本值创建新的 值。

一个新 值，由已知文本值使用默认 坐标系标识符 (SRID) 进行定义。 一个字符串，包含地理值的已知文本表示形式。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含地理值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 线值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 线值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含地理值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多线值。

新 多线值。 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新的 多线值。

新 多线值。 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多点值。

新 多点值。 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新 多点值。

新 多点值。 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多多边形值。

新 多多边形值。 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新的 多多边形值。

新 多多边形值。 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 点值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 点值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含地理值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 多边形值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含地理值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 多边形值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含地理值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 集合值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 集合值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含几何值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值创建新的 值。

一个新 值，由已知二进制值使用默认 坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的地理标记语言 (GML) 值创建新的 值。

一个新 值，由 GML 值使用默认 坐标系统标识符 (SRID) () 进行定义。 包含几何值的地理标记语言 (GML) 表示形式的字符串。

基于指定的地理标记语言 (GML) 值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由 GML 值使用指定的坐标系标识符 (SRID) 进行定义。 包含几何值的地理标记语言 (GML) 表示形式的字符串。 新 值应使用的坐标系标识符。

基于与此空间服务实现兼容的提供程序特定的值创建新的 值。

一个新 DbGeometry 值，它受此空间服务实现和指定提供程序值的支持。 此空间服务实现可将其解释为几何值的提供程序特定的值。 为 null。 与此空间服务实现不兼容。

基于指定的已知文本值创建新的 值。

一个新 值，由已知文本值使用默认 坐标系标识符 (SRID) 进行定义。 一个字符串，包含几何值的已知文本表示形式。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含几何值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 线值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 线值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含几何值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多线值。

新 多线值 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新的 多线值。

新 多线值 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多点值。

新 多点值。 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新的 多点值。

新 多点值。 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符，创建一个新的 多多边形值。

新 多多边形值。 已知的二进制值。 坐标系标识符。

基于指定的已知文本值和坐标系标识符，创建一个新的 多多边形值。

新 多边形值。 已知的文本值。 坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 点值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 点值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含几何值的已知文本表示形式。 新 值应使用的坐标系标识符。

基于指定的已知二进制值和坐标系标识符 (SRID) 创建新的 多边形值。

一个新 值，由已知二进制值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字节数组，包含几何值的已知二进制表示形式。 新 值应使用的坐标系标识符。

基于指定的已知文本值和坐标系标识符 (SRID) 创建新的 多边形值。

一个新 值，由已知文本值使用指定的坐标系标识符 (SRID) () 进行定义。 一个字符串，包含几何值的已知文本表示形式。 新 值应使用的坐标系标识符。

返回一个指示给定 值的面积、可以为 null 的双精度值，如果该值不表示面则可能为 null。

一个可以为 null 的双精度值，指示给定的 值的面积。 不需要表示面的地理值。 为 null。 与此空间服务实现不兼容。

返回一个指示给定 值的面积、可以为 null 的双精度值，如果该值不表示面则可能为 null。

一个可以为 null 的双精度值，指示给定的 值的面积。 不需要表示面的几何值。 为 null。 与此空间服务实现不兼容。

返回一个指示给定 值的边界、可以为 null 的双精度值。

给定 值的边界。 几何值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeometry 值形心的 值，如果该值不表示面则可能为 null。

如果此 geometryValue 表示面，则为它的形心；否则为 null。 不需要表示面的几何值。 为 null。 与此空间服务实现不兼容。

返回一个指示给定 值的凸包、可以为 null 的双精度值。

给定 值的凸包。 几何值。 为 null。 与此空间服务实现不兼容。

返回给定 值的坐标系标识符。

给定 值的坐标系标识符。 地理值。 为 null。 与此空间服务实现不兼容。

返回给定 值的坐标系标识符。

给定 值的坐标系标识符。 几何值。 为 null。 与此空间服务实现不兼容。

获取给定 值的维度（如果值为集合）或最大的元素维度。

geographyValue 的维度；如果 是一个集合，则为最大元素维度。 应检索维度值的地理值。 为 null。 与此空间服务实现不兼容。

获取给定 值的维度（如果值为集合）或最大的元素维度。

geometryValue 的维度；如果 是一个集合，则为最大元素维度。 应检索维度值的几何值。

如果表示地理集合，则返回给定 值的元素数目。

如果此 geographyValue 表示其他地理值的集合，则为它当中的元素个数；否则为 null。 不需要表示地理集合的地理值。 为 null。 与此空间服务实现不兼容。

如果表示几何集合，则返回给定 值的元素数目。

如果此 geometryValue 表示其他几何值的集合，则为它当中的元素个数；否则为 null。 不需要表示几何集合的几何值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的海拔（Z 坐标）。

如果此 geographyValue 表示点，则为它的海拔（Z 坐标）；否则为 null。 不需要表示点的地理值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的海拔 (Z)。

如果此 geometryValue 表示点，则为它的海拔（Z 坐标）；否则为“null”。 不需要表示点的几何值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeography 值终点的 值，如果该值不表示曲线则可能为 null。

如果此 geographyValue 表示曲线，则为它的终点；否则为 null。 不需要表示曲线的地理值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeometry 值终点的 值，如果该值不表示曲线则可能为 null。

如果此 geometryValue 表示曲线，则为它的终点；否则为 null。 不需要表示曲线的几何值。 为 null。 与此空间服务实现不兼容。

获取给定的 值的包络线（最小边界框）作为几何值。

geometryValue 的包络线，用作 值。 应检索包络线值的几何值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeometry 值外部环的 值，如果该值不表示多边形则可能为 null。

如果此 geometryValue 表示多边形，则为表示它的 DbGeometry 值；否则为 null。 不需要表示多边形的几何值。 为 null。 与此空间服务实现不兼容。

如果表示多边形，则返回给定 值中的内部环数。

如果此 geometryValue 表示多边形，则为它当中的元素个数；否则为 null。 不需要表示多边形的几何值。 为 null。 与此空间服务实现不兼容。

返回可以为 null 的布尔值，该值指示给定的 值是否闭合；如果该值不表示曲线则可能为 null。

如果给定的 值为闭合值，则为 true；否则为 false。 不需要表示曲线的地理值。 为 null。 与此空间服务实现不兼容。

返回可以为 null 的布尔值，该值指示给定的 值是否闭合；如果该值不表示曲线则可能为 null。

如果给定的 值为闭合值，则为 true；否则为 false。 不需要表示曲线的几何值。 为 null。 与此空间服务实现不兼容。

返回一个可以为 null 的布尔值，该值指示给定的 值是否为空。

如果给定的 值为空，则为 true；否则为 false。 地理值。 为 null。 与此空间服务实现不兼容。

返回一个可以为 null 的布尔值，该值指示给定的 值是否为空。

如果给定的 值为空，则为 true；否则为 false。 几何值。 为 null。 与此空间服务实现不兼容。

返回可以为 null 的布尔值，该值指示给定的 值是否是环；如果该值不表示曲线则可能为 null。

如果给定的 值为空，则为 true；否则为 false。 不需要表示曲线的几何值。 为 null。 与此空间服务实现不兼容。

返回一个可以为 null 的布尔值，该值指示给定的 值是否很简单。

如果给定的 值为简单值，则为 true；否则为 false。 几何值。 为 null。 与此空间服务实现不兼容。

返回一个可以为 null 的布尔值，该值指示给定的 值是否有效。

如果给定的 值有效，则为 true；否则为 false。 几何值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的纬度坐标。

给定 值的维度坐标。 不需要表示点的地理值。 为 null。 与此空间服务实现不兼容。

返回一个指示给定 值的长度、可以为 null 的双精度值，如果该值不表示曲线则可能为 null。

给定 值的长度。 不需要表示曲线的地理值。 为 null。 与此空间服务实现不兼容。

返回一个指示给定 值的长度、可以为 null 的双精度值，如果该值不表示曲线则可能为 null。

给定 值的长度。 不需要表示曲线的几何值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的经度坐标。

给定的 值的经度坐标。 不需要表示点的地理值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的 M（度量值）坐标。

给定 值的 M（测量值）坐标。 不需要表示点的地理值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的 M（度量值）坐标。

给定 值的 M（测量值）坐标。 不需要表示点的几何值。 为 null。 与此空间服务实现不兼容。

如果表示行字符串或线性环，则返回给定 值中的点数。

给定 值中的点数。 不需要表示行字符串或线性环的地理值。 为 null。 与此空间服务实现不兼容。

如果表示行字符串或线性环，则返回给定 值中的点数。

给定 值中的点数。 不需要表示行字符串或线性环的几何值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeometry 值面上点的 值，如果该值不表示面则可能为 null。

一个 值，表示给定 DbGeometry 值面上的点。 不需要表示面的几何值。 为 null。 与此空间服务实现不兼容。

返回指示给定 值的空间类型名称的值。

给定的 值的空间类型名称。 地理值。 为 null。 与此空间服务实现不兼容。

返回指示给定 值的空间类型名称的值。

给定的 值的空间类型名称。 几何值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeography 值起点的 值，如果该值不表示曲线则可能为 null。

给定 值的起始点。 不需要表示曲线的地理值。 为 null。 与此空间服务实现不兼容。

返回表示给定 DbGeometry 值起点的 值，如果该值不表示曲线则可能为 null。

给定 值的起始点。 不需要表示曲线的几何值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的 X 坐标。

给定 值的 X 坐标。 不需要表示点的几何值。 为 null。 与此空间服务实现不兼容。

如果表示点，则返回给定 值的 Y 坐标。

给定 值的 Y 坐标。 不需要表示点的几何值。 为 null。 与此空间服务实现不兼容。

如果表示多边形，则返回给定 值中的内部环。

如果此 geometryValue 表示多边形，则为它当中的内部环；否则为 null。 不需要表示多边形的几何值。 在几何值中应提取元素的位置。 为 null。 与此空间服务实现不兼容。

计算两个 值的交集。

一个新 值，代表 geographyValue 和 otherGeography 的交集。 第一个地理值。 第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的交集。

一个新 值，代表 geometryValue 和 otherGeometry 的交集。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值是否在空间上相交。

如果 geographyValue 与 otherGeography 相交，则为 true；否则为 false。 用来比较相交性的第一个地理值。 用来比较相交性的第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值是否在空间上相交。

如果 geometryValue 与 otherGeometry 相交，则为 true；否则为 false。 用来比较相交性的第一个几何值。 用来比较相交性的第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

重写此属性，以允许空间提供程序在其正常运行所需的本机类型或其他资源不可用时更快失败。默认值为 true，这意味着 EF 将在假定提供程序具有所需的类型/资源而非更快失败的情况下继续运行。

确定两个给定的 值是否在空间上重叠。

如果 geometryValue 与 otherGeometry 重叠，则为 true；否则为 false。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

如果表示行字符串或线性环，则返回给定 值的点元素。

如果此 geographyValue 表示行字符串或线性环，则为它当中位置索引处的点；否则为 null。 不需要表示行字符串或线性环的地理值。 在地理值中应提取元素的位置。 为 null。 与此空间服务实现不兼容。

如果表示行字符串或线性环，则返回给定 值的点元素。

如果此 geometryValue 表示行字符串或线性环，则为它当中位置索引处的点；否则为 null。 不需要表示行字符串或线性环的几何值。 在几何值中应提取元素的位置。 为 null。 与此空间服务实现不兼容。

根据给定的维度扩展的 9 交集模型 (DE-9IM) 交集模式来确定两个给定的 值在空间上是否相关。

如果根据指定的交集样式矩阵，此 geometryValue 与 otherGeometry 相关，则为 true；否则为 false。 第一个几何值。 应与第一个几何值比较相关性的几何值。 包含定义了相关性的 (DE-9IM) 交集模式的文本表示形式的字符串。 、 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值在空间上是否相等。

如果此 geographyValue 与 otherGeography 在空间上相等，则为 true；否则为 false。 要比较是否相等的第一个地理值。 要比较是否相等的第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值在空间上是否相等。

如果此 geometryValue 与 otherGeometry 在空间上相等，则为 true；否则为 false。 要比较是否相等的第一个几何值。 要比较是否相等的第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的对称差异。

一个新 值，表示此 geographyValue 和 otherGeography 的对称差异。 第一个地理值。 第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的对称差异。

一个新 值，表示 geometryValue 和 otherGeometry 的对称差异。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

确定两个给定的 值在空间上是否接触。

如果此 geometryValue 与 otherGeometry 相接，则为 true；否则为 false。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的并集。

一个新 值，代表 geographyValue 和 otherGeography 的并集。 第一个地理值。 第二个地理值。 或 为 null。 或 与此空间服务实现不兼容。

计算两个 值的并集。

一个新 值，代表 geometryValue 和 otherGeometry 的并集。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

确定一个 值在空间上是否在另一几何值内。

如果此 geometryValue 在 otherGeometry 中，则为 true；否则为 false。 第一个几何值。 第二个几何值。 或 为 null。 或 与此空间服务实现不兼容。

在验证实体失败时，从 引发的异常。

初始化 DbEntityValidationException 的一个新实例。

初始化 DbEntityValidationException 的一个新实例。

异常消息。

初始化 DbEntityValidationException 的一个新实例。

异常消息。 验证结果。

初始化 DbEntityValidationException 的一个新实例。

异常消息。 验证结果。 内部异常。

初始化 DbEntityValidationException 的一个新实例。

异常消息。 内部异常。

验证结果。

表示单个实体的验证结果。

创建 类的实例。

应用结果的实体项。绝不会为 null。 实例的列表。绝不会为 null。可以为空意味着实体有效。

获取应用结果的 的实例。

获取指示实体是否有效的指示器。

获取验证错误。绝不会为 null。

在从验证代码引发异常时，从 引发的异常。

初始化 DbUnexpectedValidationException 的新实例。

用指定的序列化信息和上下文初始化 DbUnexpectedValidationException 的新实例。

序列化信息。 流上下文。

初始化 DbUnexpectedValidationException 的新实例。

异常消息。

初始化 DbUnexpectedValidationException 的新实例。

异常消息。 内部异常。

验证错误。可以是实体级别或属性级别验证错误。

创建 的实例。

无效属性的名称。可以为 null。 验证错误消息。可以为 null。

获取验证错误消息。

获取无效属性的名称。