System.IdentityModel

默认 X.509 证书验证模式下， 。

默认颁发者名称注册表类型; 的 类。

默认最大时钟偏差;5 分钟。

默认 X.509 吊销模式; .

默认的服务名称;一个空字符串。

证书; 因此，默认的受信任存储区位置 .

配置部分定义通过 Windows Identity Foundation (WIF); 的名称system.identityModel。

一个字符串常量，它定义了语言特性，"xml: lang"。

一个字符串常量，它定义的本地语言名称，"lang"。

一个字符串常量，它定义语言命名空间 URI"http://www.w3.org/XML/1998/namespace"。

一个字符串常量，它定义了语言前缀，"xml"。

一个 URI，表示的非对称密钥的类型;http://schemas.System.com/idfx/keytype/asymmetric。

一个 URI，表示所持有者的密钥类型;http://schemas.System.com/idfx/keytype/bearer。

一个 URI，表示对称的密钥类型;http://schemas.System.com/idfx/keytype/symmetric。

一个字符串常量，它表示 WS 信任取消请求的协议不可知 URIhttp://schemas.System.com/idfx/requesttype/cancel。

一个字符串常量，它表示 WS 信任 GetMetadata 请求; 的协议不可知 URIhttp://schemas.System.com/idfx/requesttype/getMetadata。

一个字符串常量，它表示 WS 信任问题请求的协议不可知 URIhttp://schemas.System.com/idfx/requesttype/issue。

一个字符串常量，它表示一个协议不可知的 WS 信任 IssueCard 请求;http://schemas.System.com/idfx/requesttype/issueCard。

一个字符串常量，它表示 WS 信任续订请求的协议不可知 URIhttp://schemas.System.com/idfx/requesttype/renew。

一个字符串常量，它表示 WS 信任验证的请求; 的协议不可知 URIhttp://schemas.System.com/idfx/requesttype/validate。

使用硬件令牌中，身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/hardwaretoken。

使用 Kerberos 协议身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/kerberos。

对于众所周知的身份验证方法中，命名空间 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/。

使用密码身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/password。

通过使用密钥进行身份验证信任的 PGP web 身份验证 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/pgp。

通过使用安全远程密码协议的身份验证 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/secureremotepassword。

使用 XML 数字签名，身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/signature。

使用智能卡身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/smartcard。

使用智能卡的 PKI，身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/smartcardpki。

对密钥使用 SPKI PKI 身份验证的身份验证 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/spki。

通过使用基于证书的客户端身份验证，使用 SSL 或 TLS 协议的身份验证 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/tlsclient。

使用未指定的方法，身份验证的 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/unspecified。

Windows 身份验证、 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/windows。

对密钥使用 X.509 PKI 身份验证的身份验证 http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/x509。

身份验证，对密钥进行身份验证使用 XKMS 信任服务，http://schemas.microsoft.com/ws/2008/06/identity/authenticationmethod/xkms。

P SHA1 哈希算法; URIhttp://schemas.microsoft.com/idfx/computedkeyalgorithm/psha1。

为解决 X.509 证书的默认存储位置。

默认解决 X.509 证书的存储。

获取空的 URI 引用。 可能使用的引用来设置 属性。 使用时，它指定当前文档的起始点。

SAML 2.0 断言 Id，由 OASIS Web 服务安全 SAML 令牌配置文件 1.1 的密钥标识符的值类型。 这是一个 URI。

SAML 命名空间前缀。 此字段为常数。

urn: oasis︰ 名称︰ tc: saml: 1.0 assertion

urn: oasis︰ 名称︰ tc: SAML:1.0:cm:bearer

urn: oasis︰ 名称︰ tc: SAML:1.0

urn:oasis:names:tc:SAML:1.0:am:unspecified

指定指向用于加密 XML 的 128 位 AES 加密算法的 URI。 此字段为常数。

指定指向用于加密和解密对称密钥 （密钥换行） 的 128 位 AES 加密算法的 URI。 此字段为常数。

指定指向用于加密 XML 的 192 位 AES 加密算法的 URI。 此字段为常数。

指定指向用于加密和解密对称密钥 （密钥换行） 的 192 位 AES 加密算法的 URI。 此字段为常数。

指定一个 URI，该 URI 指向用于加密 XML 的 256 位 AES 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密对称密钥的 256 位 AES 加密算法 (Key Wrap)。 此字段为常数。

指定一个 URI，该 URI 指向用于加密 XML 的 DES 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于对 XML 进行数字签名的 DSA 加密算法。 此字段为常数。

表示 XML 专用无注释规范化算法。 此字段为常数。

表示 XML 专用有注释规范化算法。 此字段为常数。

指定一个 URI，该 URI 指向用于对 XML 进行数字签名的 HMAC 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于对 XML 进行数字签名的 256 位 HMAC 加密算法。 此字段为常数。

表示 P-SHA1 密钥生成算法。 此字段为常数。

表示 P-SHA1 密钥生成算法的 2007 年 12 月版本。 此字段为常数。

指定一个 URI，该 URI 指向 RIPEMD-160 加密摘要算法。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密非对称密钥的 RSAES-OAEP-ENCRYPT 加密算法 (Key Wrap)。 此字段为常数。

指定一个 URI，该 URI 指向用于对 XML 进行数字签名的 RSA-SHA1 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于对 XML 进行数字签名的 RSA-SHA256 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密非对称密钥的 RSAES-PKCS1-v1_5 加密算法 (Key Wrap)。 此字段为常数。

指定指向 160 位 sha-1 摘要算法的 URI。 此字段为常数。

指定指向 256 位 sha-256 的摘要算法的 URI。 此字段为常数。

指定一个 URI，该 URI 指向 512 位 SHA-512 摘要算法。 此字段为常数。

表示安全令牌的引用的转换 （STR 转换） 算法。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密对称密钥的传输层安全 (TLS) 算法 (Key Wrap)。 此字段为常数。

指定一个 URI，该 URI 指向用于加密 XML 的三重 DES 加密算法。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密对称密钥的三重 DES 加密算法 (Key Wrap)。 此字段为常数。

指定一个 URI，该 URI 指向用于加密和解密 Kerberos 票证会话密钥的 GSS-API 加密算法 (Key Wrap)。 此字段为常数。

用于引用 ActAs 元素处理的处理程序的集合。

用于引用处理程序的默认集合。

用于引用的处理程序通过使用 OnBehalfOf 元素处理的集合。

指定默认 X.509 证书验证模式。

指定默认 X.509 证书验证程序实例。

指定一个值，确定是否检测重播的令牌; , ，不会检测重播的令牌。

指定的默认颁发者名称注册表实例;基于配置的颁发者名称注册表的实例。

指定默认颁发者令牌解析程序实例。

指定默认最大时钟偏差。

指定默认 X.509 证书吊销模式。

指定是否将保存启动令牌; , 、 引导令牌不会保存。

指定默认的令牌重放缓存过期时间。

指定默认 X.509 受信任的证书存储区位置。

一个只读列出的默认转换应用于 cookie 的集合 和 。

一个常量，它指定 cookie 的默认生存期十个小时。

基本身份验证。

联合身份验证。

Kerberos 身份验证。

协商的身份验证。

用户名和密码 authenticiation。

使用数字签名的身份验证。

Windows 身份验证。

使用 X.509 证书的身份验证。

声明属性的命名空间。

SAML 显示名称属性。

SAML 名称格式属性。

SAML 名称标识符格式。

一个常量，它定义了一个键 saml SAML 属性 元素。 属性指定的安全或管理域的限定名称。

一个常量，用于定义 SAML 元素 特性的键。 特性指定用于进一步限定名称的服务提供程序的名称或提供程序的附属关系。

一个常量，用于定义 SAML 元素 特性的键。 如果不同于主名称标识符， 特性指定由服务提供程序或实体提供程序的从属建立的名称标识符。

初始化 类的新实例。

新实例初始化 使用系统提供的错误消息和对导致此异常的内部异常的引用。

导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

从在派生类的实例进行初始化的构造函数调用 没有回调委托或状态对象的类。

从在派生类的实例进行初始化的构造函数调用 具有回调委托和状态对象的类。

异步操作完成时调用的方法。 一个用户定义的对象，限定或包含有关异步操作的信息。

从在派生类的实例进行初始化的构造函数调用 没有回调委托，但确实有一个状态对象的类。

一个用户定义的对象，限定或包含有关异步操作的信息。

在异步操作完成，且未遇到异常，则调用此版本的完成。 它将更新操作的状态，并通知回调。

如果异步操作完成同步进行;否则为 。

如果引发处理过程中发生异常，则调用此版本的完成。 除了通知回调，它会捕获的异常并存储在调用期间引发 方法。

如果异步操作完成同步进行;否则为 。 在异步操作的处理期间发生的异常。

释放 类的当前实例使用的资源。

由 和 方法调用，以释放 类的当前实例所占用的托管资源和非托管资源。

若要释放托管资源和非托管的资源，则为 ；若要仅释放非托管资源，则为 。 指示这是对 Dispose 的显式调用。

调用此方法时 End 函数的异步操作已完成。 它可以确保异步操作已完成，并且执行一些常见的验证。

表示异步操作的状态。

允许 对象尝试释放资源并在垃圾回收回收之前执行其他清理操作。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

使用指定的类型、资源和权限初始化 类的新实例。

表示声明类型的统一资源标识符 (URI)。 与新声明关联的对象。 与声明关联的权限的 URI。 为 。 - 或 - 为 。 的长度为零。 - 或 - 的长度为零。

创建一个表示指定的 deny-only 安全标识符 (SID) 的 对象。

一个表示 deny-only SID 的 。 一个表示 参数中指定的 SID 的 。 为 。

创建一个表示指定域名系统 (DNS) 名称的 对象。

与声明关联的实体的 DNS 名称。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定哈希值的 对象。

指定哈希值的字节值数组。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定电子邮件地址的 对象。

一个指定此声明所表示的电子邮件地址的 。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定名称的 对象。

与声明关联的实体的名称。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定 RSA 密钥的 对象。

一个表示 RSA 加密密钥的 对象。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定服务主要名称 (SPN) 的 对象。

与此声明关联的实体的 SPN。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定指纹的 对象。

一个字节值数组，指定与声明关联的实体的指纹。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定通用主要名称 (UPN) 的 对象。

与此声明关联的实体的 UPN。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定统一资源定位符 (URL) 的 对象。

一个表示与此声明关联的实体的 URL 的 。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

创建一个表示指定安全标识符 (SID) 的 对象。

一个表示 SID 的 。 一个表示 参数中指定的 SID 的 。 为 。

创建一个表示指定 X.500 可分辨名称的 对象。

一个指定与声明关联的实体的 X.500 可分辨名称的 。 此参数不能为 。 如果此参数为 ，此方法将引发 异常。 此方法创建的 对象。 参数为 。

确定指定对象是否表示与当前 对象相同的声明。

将与当前 进行比较的对象。 如果 表示与当前 相同的声明，则为 ；否则为 。

返回当前声明的哈希代码。

声明的哈希代码。

返回此 对象的字符串表示形式。

此 对象。

初始化 类的新实例。

确定 是否包含指定的 。

要搜索的 。 如果 中包含指定的声明，则为 ；否则为 。

通过使用指定的 对象来确定 是否包含指定的 。

要搜索的 。 用于进行比较的 对象。 如果 中包含指定的声明，则为 ；否则为 。

在派生类中重写时，搜索 中与指定的声明类型和权限匹配的 对象。

声明类型的统一资源标识符 (URI)。 有几个声明类型是以 类的静态属性的形式提供的。 与新声明关联的权限的 URI。 有几个权限是以 类的静态属性的形式提供的。 类型为 的 ，可用于枚举符合指定条件的声明。

在派生类中重写时，获取一个 ，它可用于枚举 中的 对象。

一个 ，可用于枚举 中的 对象。

获取一个 ，它可用于枚举 中的 对象。

一个 ，可用于枚举 中的 对象。

使用指定的声明初始化 类的新实例。

一个类型为 的 ，包含要添加到此声明集中的声明。 为 。

使用指定的声明初始化 类的新实例。

一个 数组，表示要添加到此声明集中的声明。 为 。

使用指定的声明初始化 类的新实例。

一个 对象，指定在 参数中指定的 的颁发者。 一个类型为 的 ，包含要添加到此声明集中的声明。 为 。 - 或 - 为 。

使用指定的声明初始化 类的新实例。

一个 对象，指定在 参数中指定的 的颁发者。 一个 数组，表示要添加到此声明集中的声明。 为 。 - 或 - 为 。

确定指定的声明是否包含在此声明集中。

要确定是否存在于此集合中的 。 如果声明包含在此声明集中，则为 ；否则为 。 为 。

搜索 中与指定的声明类型和权限匹配的 对象。

声明类型的统一资源标识符 (URI)。 有几个声明类型是以 类的静态属性的形式提供的。 与新声明关联的权限的 URI。 有几个权限是以 类的静态属性的形式提供的。 一个类型为 的 ，可用来枚举与指定条件相符的声明。

获取一个 ，它可用于枚举 中的 对象。

一个 ，可用于枚举 中的 。

使用指定的声明初始化 类的实例。

对象，该对象颁发 参数中指定的 。 要包含在此声明集中的一组 对象。 为 。 - 或 - 为 。

返回此 对象。

此 对象。

使用由 对象指定的 Windows 用户标识初始化 类的新实例。

一个指定 Windows 标识的 。

使用由 对象指定的 Windows 用户标识初始化 类的新实例。

一个指定 Windows 标识的 。 如果包含表示此用户所属 Windows 组的声明，则为 ；否则为 。

使用由 对象指定的 Windows 用户标识初始化 类的新实例。

一个指定 Windows 标识的 。 如果包含此用户所属的 Windows 组，则为 ；否则为 。 一个 ，指定声明集的过期时间。

使用由 对象指定的 Windows 用户标识初始化 类的新实例。

一个指定 Windows 标识的 。 一个 ，指定声明集的过期时间。

使用由 对象指定的 Windows 用户标识初始化 类的新实例。

一个指定 Windows 标识的 。 Windows 标识的身份验证类型。 如果包含此用户所属的 Windows 组，则为 ；否则为 。 一个 ，指定声明集的过期时间。

释放由 使用的所有资源。

搜索 中与指定的声明类型和权限匹配的声明。

声明类型的统一资源标识符 (URI)。 与新声明关联的权限的 URI。 一个 对象，可用于枚举符合指定条件的声明。

获取一个 ，可用于枚举 中的 Windows 声明。

可用于枚举 中的 Windows 声明的 。

返回此 对象。

此 对象。

使用指定的 X.509 证书初始化 类的新实例。

要添加到声明集中的 X.509 证书。

释放由 使用的所有资源。

搜索 中与指定的声明类型和权限匹配的声明。

声明类型的统一资源标识符 (URI)。 与新声明关联的权限的 URI。 一个 对象，可用于枚举符合指定条件的声明。

获取一个 ，可用于枚举 中的 Windows 声明。

可用于枚举 中的 Windows 声明的 。

获取此 对象中的 X.509 证书声明数。

此 对象中的 X.509 证书声明数。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

从配置文件读取 XML。

用于读取配置文件的 。 如果只序列化集合键属性，则为 ；否则为 。

获取一个值，该值指示反序列化过程中是否遇到未知属性。 始终返回 。

无法识别的属性的名称。 无法识别的属性的值。 始终返回 , ，指示已遇到无法识别的特性。

获取一个值，该值指示反序列化过程中是否遇到未知元素。 始终返回 。

未知子元素的名称。 要使用反序列化的 XML 读取器。 始终返回 , ，指示已遇到未识别的元素。

重置 对象的内部状态，包括锁和属性集合。

配置元素的父节点。

初始化 类的新实例。

尝试解析指定的某个对象的自定义类型元素 。

要解决的自定义类型元素。 对其进行解析的自定义类型元素。 对象 。

从 XML 加载自定义配置。 重写此方法以提供自定义处理的配置元素。

包含自定义配置的 XML 节点。 在列表中的每个节点属于类型 。

初始化 类的新实例。 如果它存在，将从默认配置中，加载设置。

新实例初始化 类通过使用一个值，指定是否应从默认配置中加载设置。

若要从配置文件，则加载设置否则为 。 是 , ，但没有任何 配置元素。

新实例初始化 类，该类具有指定的服务证书。 设置会根据需要加载默认配置。

若要从配置文件，则加载设置否则为 。 服务证书。 设置 属性。 是 , ，但没有任何 配置元素。

新实例初始化 类，该类具有指定的服务证书。

服务证书。 设置 属性。

初始化 类的新实例。 从命名的配置加载设置。

名称 元素是要加载的设置。 有没有 配置元素。

新实例初始化 类，该类具有指定的服务证书，加载命名的配置。

名称 从哪种配置元素，则会加载 服务证书。 设置 属性。 有没有 配置元素

更新属性 对象 中所含对象 与对此属性值保持一致 实例。

不止一次调用此方法。

加载的设置 从应用程序或 Web 配置文件的实例。

从配置文件。

加载 使用下方指定的元素的 。

要从其中加载设置配置文件中的元素。 加载从配置文件中的元素。

加载到相关的配置元素 。

基 从其继承的默认值。 从配置文件。 从配置文件中的元素加载和 。

加载 为指定的服务定义。

元素，用于将此实例配置。 处理程序集管理器。

初始化 类的新实例。

初始化 类的新实例。

检索 具有指定的名称。

要检索的 identityConfiguration 元素的名称。 这对应于该元素的值 属性。 具有指定的名称的元素或 如果不找到任何匹配元素。 为 。 默认配置中的 name 参数和一个匹配指定 找不到。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。 （可选） 从当前配置中加载的设置。

若要从配置文件，则加载设置否则为 。

新实例初始化 类，该类具有指定的颁发者名称。

颁发者名称中。 设置 属性。

新实例初始化 类，该类具有指定的颁发者名称。 （可选） 从当前配置中加载的设置。

颁发者名称中。 设置 属性。 若要从配置文件，则加载设置否则为 。

新实例初始化 类，该类具有指定的颁发者名称和签名的凭据。

颁发者名称中。 设置 属性。 STS 签名凭据。 设置 属性。 实现活动的安全令牌服务 (STS) 时，将忽略属性。 而是必须将服务证书通过设置 承载您的 STS 服务主机上的属性。 为主动 STS 所用的服务主机由 类。

新实例初始化 类，该类具有指定的颁发者名称和签名的凭据。 （可选） 从当前配置中加载的设置。

颁发者名称中。 设置 属性。 STS 签名凭据。 设置 属性。 实现活动的安全令牌服务 (STS) 时，将忽略属性。 而是必须将服务证书通过设置 承载您的 STS 服务主机上的属性。 为主动 STS 所用的服务主机由 类。 若要从配置文件，则加载设置否则为 。

新实例初始化 类，该类具有指定的颁发者名称和签名的凭据。 从指定的命名配置加载设置。

颁发者名称中。 设置 属性。 STS 签名凭据。 设置 属性。 实现活动的安全令牌服务 (STS) 时，将忽略属性。 而是必须将服务证书通过设置 承载您的 STS 服务主机上的属性。 为主动 STS 所用的服务主机由 类。 名称 为要从中加载该配置元素。

创建安全令牌服务 (STS) 实例从 中指定 属性。

一个实例 中指定 属性。

初始化 类的新实例。

初始化 类的新实例。

初始化 类的新实例。

从构造函数初始化派生类中调用 类。

当在派生类中重写，反转了转换。

Cookie 该编码的格式。 已解码的字节数组中。

当在派生类中重写应用转换。

要进行编码的字节数组。 编码的 cookie。

初始化 类的新实例。

放大的数据。

从以前返回数据 已解码的数据。 为 。 包含零字节。 解压缩后的长度大于指定的最大长度 属性。

压缩数据。

要压缩的数据。 已压缩的数据。 为 。 包含零字节。

初始化 类的新实例。

关闭读取器和更改 为已关闭。

给定索引处获取的属性的值。

属性的索引。 索引是 0 基于的索引。 指定索引处的属性的值。

获取具有给定名称的属性的值。

属性的限定名称。 属性的值。 如果未找到 null 属性将返回。

获取具有给定名称和命名空间 Uri 的属性的值。

属性的本地名称。 该特性的命名空间。 属性的值。 如果未找到 null 属性将返回。

初始化此实例与指定的内部读取器。

是此实例包装读取器。 为 。

解析当前元素范围内的命名空间前缀。

作为 Uri 要解析其命名空间的前缀。 命名空间 Uri 的前缀匹配或如果不找到任何匹配的前缀，则为 null。

移动到具有指定索引的属性。

属性的索引。

移动到具有给定的本地名称的属性。

属性的限定名称。 如果找到该属性，则为 true否则为 false。

移动到具有指定 System.Xml.XmlReader.LocalName 和 System.Xml.XmlReader.NamespaceURI 的属性。

属性的本地名称。 属性的命名空间 URI。 如果找到该属性，则为 true否则为 false。

移动到类型元素的节点。

如果读取器定位在元素上否则为 false，则 true

移动到第一个属性。

如果读取器定位在一个属性，否则为 false，则返回 true。

将读取器移动到下一个属性。

如果读取器定位在某个属性否则为 false，则返回 true。

从流中读取下一个节点。

如果成功读取下一个节点为 true。

将属性值分析为一个或多个 Text、EntityReference 或 EndEntity 节点。

如果没有为 return.false 节点如果读取器未定位在属性节点上进行初始调用时或如果已读取所有属性值为 true。

读取内容并返回 Base64 解码的二进制字节。

结果文本复制到的缓冲区。 此值不能为 null。 缓冲区中的偏移，从这个位置开始将结果复制到缓冲区中。 要复制到缓冲区的最大字节数。 写入缓冲区的字节数。

读取内容并返回 BinHex 解码的二进制字节。

结果文本复制到的缓冲区。 此值不能为 null。 缓冲区中的偏移，从这个位置开始将结果复制到缓冲区中。 要复制到缓冲区的最大字节数。 写入缓冲区的字节数。

读取内容并返回包含的字符串。

返回 。

读取嵌入在 XML 文档中的大量文本流。

作为文本内容写入到的缓冲区的字符数组。 此值不能为 null。 System.Xml.XmlReader 可以开始复制结果的缓冲区内的偏移量。 要复制到缓冲区中的最大字符数。 此方法返回复制的实际字符数。 读取到缓冲区中的字符数。 如果不再有文本内容，则返回值零。

解析 EntityReference 节点的实体引用。

初始化 类的新实例。

关闭基础流。

停止由匹配 调用启动的规范化。

刷新基础流。

初始化此实例与指定的内部编写器。

是此实例包装编写器。

初始化此实例与为将回显的所有调用，并且编写器将编写非规范化的 XML。

编写器将向其回显的所有调用。 如果 , ，不回显调用。

返回在当前命名空间范围中为该命名空间 URI 定义的最近的前缀。

要查找其前缀的命名空间 URI。 在当前范围内找到匹配的前缀或如果没有匹配的命名空间 URI 为 null。

表示规范化的启动。 遵循此规范的任何写入操作将规范化数据，并写入指定流。

应写入规范流的流。 该值表示是否还应规范化写入的注释。 需要包含到规范流的前缀集。 在写入规范流的第一个元素中定义前缀。

将指定的二进制字节编码为 Base64 并写出结果文本。

要进行编码的字节数组。 缓冲区中指示要写入字节的起始位置的位置。 要写入的字节数。

写出包含指定的文本的 CDATA 块。

要放置在 CDATA 块中的文本。

为指定的 Unicode 字符值强制生成字符实体。

为其生成字符实体的 Unicode 字符。

当在派生类中被重写时，以每次一个缓冲区的方式写入文本。

包含要写入的文本的字符数组。 缓冲区中指示要写入文本的起始位置的位置。 要写入的字符数。

写出包含指定的文本的注释。

要放在注释内的文本。

写出具有指定名称和可选属性的 DOCTYPE 声明。

DOCTYPE 的名称。 它必须是非空的。 如果非 null 它还将写入 PUBLIC"pubid""sysid"pubid 和 sysid 替换为给定的参数的值。 如果 pubid 为空且 sysid 不可为 null，则它将写入 SYSTEM"sysid"sysid 将替换该参数的值。 如果非 null，则它写入 [subset]，其中 subset 替换为此自变量的值。

关闭前一个 System.Xml.XmlWriter.WriteStartAttribute(System.String,System.String) 调用。

关闭任何打开的元素或特性并将写入器重新设置为起始状态。

关闭一个元素并弹出相应的命名空间范围。

写出实体引用作为名称。

实体引用的名称。

关闭一个元素并弹出相应的命名空间范围。

写出在名称和文本之间带有空格的处理指令，如下所示︰ &l t;？将命名为文本？ （&a) gt;。

处理指令的名称。 要包括在处理指令中的文本。

当在派生类中被重写时，从字符缓冲区手动写入原始标记。

包含要写入的文本的字符数组。 缓冲区中的位置，指示要写入文本的起始位置。 要写入的字符数。

从字符串手动写入原始标记。

包含要写入的文本的字符串。

写入具有指定本地名称和命名空间 URI 的属性的开头。

属性的命名空间前缀。 属性的本地名称。 属性的命名空间 URI。

当在派生类中被重写时，写入版本为“1.0”的 XML 声明。

当在派生类中被重写时，写入版本为“1.0”的 XML 声明和独立的属性。

如果为 true，则它写入"独立 = yes";如果为 false，则它写入"独立 = no"。

当在派生类中被重写时，写入指定的开始标记并将其与给定的命名空间和前缀关联起来。

元素的命名空间前缀。 元素的本地名称。 与元素关联的命名空间 URI。

写入给定的文本内容。

要写入的文本。

为代理项字符对生成并写入代理项字符实体。

低代理项。 它必须是介于 0xDC00 和 0xDFFF 之间的值。 高代理项。 它必须是介于 0xD800 和 0xDBFF 之间的值。

写出给定的空白区域。

空格字符的字符串。

作为带前缀的 xml 属性写入的属性 xml:。

该属性的 Localname。 属性值。

写入 xmlns 命名空间声明。

命名空间声明的前缀。 命名空间 Uri 本身。

新实例初始化 类通过使用指定的读取器和安全令牌序列化程序。

指向封装的读取器签名的 XML。 要用于反序列化的令牌序列化程序 的签名。 为 。 - 或 - 为 。

新实例初始化 通过使用指定的读取器、 安全令牌序列化程序和令牌解析程序的类。

指向封装的读取器签名的 XML。 要用于反序列化的令牌序列化程序 的签名。 令牌解析程序用于解决签名令牌。 指定应使用默认安全令牌解析程序。 为 。 - 或 - 为 。

新实例初始化 通过使用指定的读取器、 安全令牌序列化程序、 令牌解析程序和行为的类。

指向封装的读取器签名的 XML。 要用于反序列化的令牌序列化程序 的签名。 令牌解析程序用于解决签名令牌。 指定应使用默认安全令牌解析程序。 如果该签名是必需的;否则为 。 如果应读取签名;否则为 。 如果应解决内部函数的签名密钥;否则为 。 为 。 - 或 - 为 。

从流中读取下一个节点。

如果成功，则读取下一个节点 如果没有更多的节点。

如果读取器当前定位在读取的签名 元素。

如果成功读取签名;否则为 。

初始化 类的新实例。

要包装的编写器。 要用于生成签名的签名凭据。 信封参照 ID。 若要用来序列化签名 KeyInfo 令牌序列化程序。 为 或空。 为 。 - 或 - 为 。 - 或 - 为 。

关闭一个元素并弹出相应的命名空间范围。

关闭一个元素并弹出相应的命名空间范围。

在信封范围内设置的签名位置。 虽然应插入编写以指示这时签名信封，则调用此方法。

写出指定的开始标记并将其与指定的命名空间关联。

元素的命名空间前缀。 元素的本地名称。 （不带前缀的元素的名称。） 与元素关联的命名空间 URI。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

初始化 类的实例。

初始化 类的新实例。

新实例初始化 类具有指定的联系人类型。

联系人类型。

新实例初始化 类，该类具有指定的声明类型。

显示的声明类型声明。 初始化 属性。 为 或空字符串。

新实例初始化 类，该类具有指定声明类型、 显示名称和描述。

显示的声明类型声明。 初始化 属性。 显示的显示名称 （或友好名称） 声明。 初始化 属性。 显示声明说明。 初始化 属性。 为 或空字符串。

新实例初始化 类，该类具有指定声明类型、 显示名称、 显示值和说明。 声明是必需的。

显示的声明类型声明。 初始化 属性。 显示的显示名称 （或友好名称） 声明。 初始化 属性。 显示声明说明。 初始化 属性。 显示声明显示值。 初始化 属性。 为 或空字符串。

新实例初始化 类，该类具有指定声明类型、 显示名称、 显示值、 说明和可选特性。

显示的声明类型声明。 初始化 属性。 显示的显示名称 （或友好名称） 声明。 初始化 属性。 显示声明说明。 初始化 属性。 显示声明显示值。 初始化 属性。 如果声明是可选的，则为 ；否则为 。 初始化 属性。 为 或空字符串。

从指定的声明类型创建一个显示声明。

表示声明类型 URI。 返回 。

新实例初始化 类，该类具有指定的加密算法。

加密算法的 URI。 为 。

初始化 类的新实例。

新实例初始化 类，具有指定的子集合 。

实体描述符集合。 初始化 属性。

新实例初始化 类，具有指定的子集合 。

实体描述符集合。 初始化 属性。

新实例初始化 类，具有指定的子集合 和指定的子集合 。

实体描述符集合。 初始化 属性。 实体描述符集合。 初始化 属性。

初始化 类的新实例。

新实例初始化 类，该类具有指定的实体 id。

实体 id。 初始化 属性。

初始化 类的新实例。

新实例初始化 类，该类具有指定 id。

用于初始化新实例的 ID。 初始化 属性。

初始化 类的新实例。

初始化 类的新实例。

新实例初始化 类，该类具有指定的索引、 绑定和位置。

索引。 绑定。 位置。

初始化 类的新实例。

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

新实例初始化 类通过使用指定的密钥标识符。

此实例键标识符。

初始化 类的新实例。

新实例初始化 为指定区域性的类。

区域性信息。 初始化 属性。

初始化 类的新实例。

获取指定项的键。

关键是要返回的项。 一个表示密钥的 。

初始化 类的新实例。

新实例初始化 类，该类具有指定的名称和区域性 （语言）。

此实例的名称。 初始化 属性。 ，它定义为此实例的语言。 初始化 属性。

初始化 类的新实例。

构造 与 和 。

此实例的 URI。 初始化 属性。 ，它定义为此实例的语言。 初始化 属性。

从构造函数初始化派生类中调用 类。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

新实例初始化 类，具有默认的令牌序列化程序。

新实例初始化 类，该类使用指定的令牌序列化程序。

令牌序列化程序用于序列化安全令牌。 为 。

创建应用程序服务描述符。

应用程序服务描述符。

创建联系人的人员。

联系人。

创建实体描述符。

实体描述符中。

创建实体描述符。

实体描述符。

创建 IDPSSO 描述符。

IDPSSO 描述符中。

创建索引的终结点。

索引的终结点。

创建的密钥的说明符。

密钥的描述符。

创建具有本地化的名称。

本地化的名称。

创建一个本地化的 URI。

本地化的 URI。

创建一个组织。

组织。

创建一个终结点。

终结点。

创建一个安全令牌服务描述符。

安全令牌服务描述符。

创建 SPSSO 描述符。

SPSSO 描述符中。

获取由指定的密钥标识符的 X.509 证书。

从中创建 X.509 证书的密钥标识符。 从指定的密钥标识符创建 X.509 证书。 为 。 找不到类型的密钥标识符子句 中 。 强制执行默认行为，可以重写此方法以支持其他密钥标识符子句。

读取应用程序服务描述符。

XML 读取器。 应用程序服务描述符。 为 。

读取 < saml:Attribute > 元素。

XML 读取器。 Saml2 属性中。 为 。

读取掌握的人员联系。

XML 读取器。 联系人。 为 。

用于读取自定义属性的扩展点。

XML 读取器。 一个 类型的对象。 表示正在读取; 的元数据元素的类型例如， 。

用于读取自定义元素扩展点。 默认情况下，返回 。

XML 读取器。 一个 类型的对象。 表示正在读取; 的元数据元素的类型例如， 。 如果类型的元素 读取; 否则为 。

用于读取自定义 RoleDescriptors 扩展点。

Xsi 类型 XML 读取器。 添加角色描述符实体描述符

读取显示声明。

XML 读取器。 显示声明中。 为 。 当 XML 格式不正确时引发。

读取实体描述符。

XML 读取器。 安全令牌解析器。 实体描述符中。 为 。 当 XML 格式不正确时引发。

读取实体描述符。

XML 读取器。 安全令牌解析器。 实体描述符。 为 。

将读取 IDPSSO 说明符。

XML 读取器。 IDPSSO 描述符中。 为 。

读取索引终结点。

XML 读取器。 一个索引的终结点。 为 。

读取密钥说明符。

XML 读取器。 密钥的描述符。 为 。

读取具有本地化的名称。

XML 读取器。 本地化的名称。 为 。

读取一个本地化的 URI。

XML 读取器。 本地化的 URI。 为 。

读取指定的流进行反序列化实体描述符或实体描述符。

要读取的流。 描述符。 一个实例 或 类。 为 。

读取指定的 XML 读取器反序列化实体描述符或实体描述符。

要读取的 XML 读取器。 描述符。 一个实例 或 类。 为 。

读取给定的从其中进行反序列化实体描述符或实体描述符。

要读取的 XML 读取器。 用来解析签名令牌令牌解析器。 描述符。 一个实例 或 类。 为 。 - 或 - 为 。

读取实体描述符或实体描述符。

XML 读取器。 安全令牌解析器。 描述符。 一个实例 或 类。 为 。 - 或 - 为 。 读取器未定位在 或 元素。

读取组织。

XML 读取器。 一个组织。 为 。

读取终结点。

XML 读取器。 一个终结点。 为 。

读取角色描述符属性。

XML 读取器。 角色描述符中。 为 。 - 或 - 是。 - 或 - 的 属性为 。

读取角色描述符元素。

XML 读取器。 角色描述符中。 如果元素为只读;否则为 。 为 。 - 或 - 是。 - 或 - 的 属性为 。 的 属性为 。

读取安全令牌服务描述符。

XML 读取器。 安全令牌服务描述符。 为 。

将读取 SPSSO 说明符。

XML 读取器。 SPSSO 描述符。 为 。 XML 无效。

读取 SSO 描述符属性。

XML 读取器。 SSO 角色描述符。 为 。 - 或 - 是。

读取 SSO 描述符元素。

XML 读取器。 SSO 描述符中。 如果元素为只读;否则为 。 为 。 - 或 - 是。

读取 web 服务描述符属性。

XML 读取器。 Web 服务描述符。 为 。 - 或 - 是。

读取 web 服务描述符元素。

XML 读取器。 Web 服务描述符。 如果元素为只读;否则为 。 为 。 - 或 - 是。 - 或 - 的 属性为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。 参数 reader/roleDescriptor/roleDescriptor.TargetScopes/roleDescriptor.TargetScopes/roleDescriptor.TokenTypesOffered 为 null。

验证 X.509 证书签名的针对指定的受信任的颁发者列表的元数据文档 属性。 通过调用此方法 方法。

签名证书。

验证元数据文档的签名凭据。

已使用元数据文档进行签名的凭据。 为 。

写入应用程序服务描述符。

XML 编写器。 应用程序服务描述符。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

写入 < saml:Attribute > 元素。

XML 编写器。 Saml2 属性中。 为 。 - 或 - 为 。

写入某一联系人。

XML 编写器。 联系人。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

要编写自定义特性的可扩展点。

XML 编写器。 类型的源元素 。 表示在写入其属性的元素的类型。 例如，。

要编写自定义元素的可扩展点。

XML 编写器。 类型的源元素 。 表示正在写入的元素的类型。

将显示声明。

XML 编写器。 若要编写显示声明。

写入实体描述符。

XML 编写器。 实体描述符中。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

写入实体描述符。

XML 编写器。 实体描述符。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

写入 IDPSSO 描述符。

XML 编写器。 IDPSSO 描述符中。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

写入的索引的终结点。

XML 编写器。 索引的终结点。 XML 限定的元素。 为 。 - 或 - 为 。 - 或 - 为 。

将写入密钥说明符。

XML 编写器。 密钥的描述符。 为 。 - 或 - 为 。

写入具有本地化的名称。

XML 编写器。 本地化的名称。 Xml 限定的名。 为 。 - 或 - 为 。 - 或 - 为 。

写入本地化的 URI

XML 编写器。 本地化的 URI。 Xml 限定的名。 为 。 - 或 - 为 。 - 或 - 为 。

将联合身份验证元数据写入到指定的流。

若要将联合身份验证元数据写入到的流。 要写入的元数据。 为 。 - 或 - 为 。

联合身份验证元数据写入指定的 XML 编写器。

要向其写入联合身份验证元数据的 XML 编写器 要写入的元数据。 为 。 - 或 - 为 。

写入的元数据。

XML 编写器。 基 SAML 元数据。 一个实例 或 类。 为 。 - 或 - 为 。 不能从分配 或 。

写入一个组织。

XML 编写器。 组织。 为 。 - 或 - 为 。

写入某个终结点。

XML 编写器。 终结点。 Xml 限定的名元素。 为 。 - 或 - 为 。 - 或 - 为 。

编写角色描述符属性。

XML 编写器。 角色描述符中。 为 。 - 或 - 是。 - 或 - 的 属性为 。

写入角色描述符元素。

XML 编写器。 角色描述符中。 为 。 - 或 - 是。 - 或 - 的 属性为 。 的 属性为 。

写入安全令牌服务描述符。

XML 编写器。 安全令牌服务描述符。 为 。 - 或 - 为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。

写入 SPSSO 描述符。

XML 编写器。 SPSSO 描述符中。 为 。 - 或 - 为 。 - 或 - 的 属性为 。

编写 SSO 描述符属性。

XML 编写器。 SSO 描述符中。 为 。 - 或 - 是。

写入 SSO 描述符元素。

XML 编写器。 SSO 描述符中。 为 。 - 或 - 是。

编写 web 服务描述符属性。

XML 编写器。 Web 服务描述符。 为 。 - 或 - 是。

写入一个 web 服务描述符元素。

XML 编写器。 Web 服务描述符。 为 。 - 或 - 是。 - 或 - 的 属性为 。 - 或 - 的 属性为 。 - 或 - 的 属性为 。 参数 reader/roleDescriptor/roleDescriptor.TargetScopes/roleDescriptor.TargetScopes/roleDescriptor.TokenTypesOffered 为 null。

初始化 类的新实例。

新实例初始化 具有指定的名称的集合类的显示名称和 Uri。

一套 ，其中包含此实例的名称。 一套 ，其中包含此实例的显示名称。 一套 ，其中包含此实例的 Url。 如果任何输入的参数为 null。

初始化 类的新实例。

新实例初始化 类，该类具有指定的绑定和位置。

一个 URI，表示新实例的绑定。 初始化 属性。 一个 URI，表示新实例的位置。 初始化 属性。

初始化 类的新实例。

新实例初始化 类，该类具有的集合支持的协议。

支持的协议集合中。 初始化 属性。

初始化 类的新实例。

初始化 类的新实例。

新实例初始化 类，该类具有指定索引的终结点的字典。

此实例对象。 初始化 属性。

初始化 类的新实例。

初始化 类的新实例。

从派生类来初始化调用 类。

初始化 类的新实例。

对所有指定的授权策略进行评估并创建一个 。

一个类型为 的 ，它包含授权策略集。 一个 ，它包含对所有指定授权策略进行评估的结果。

初始化 类的新实例。

将一个声明集添加到评估上下文中。

一个 ，表示正将声明添加到评估上下文的授权策略。 一个包含一个声明集的 。

设置此 不再有效的日期和时间。

一个 值，指示此 对象不再有效的日期和时间。

评估用户是否符合此授权策略的需求。

一个 ，其中包含授权策略所评估的声明集。 一个 ，由表示此授权策略的自定义状态的引用传递。 如果在其他授权策略向 中添加其他声明时必须调用此授权策略的 方法，则为 ；否则为 ，表示此授权策略不需要任何其他评估。

创建 类的新实例。

验证数据保护，并返回解密后的数据。

从以前返回数据 方法。 最初用于保护解密的数据。 为 。 包含零字节。

保护 （加密） 指定的数据。

要保护 （加密） 数据。 受保护 （加密） 的数据。 为 。 包含零字节。

初始化 类的新实例。

新实例初始化 与指定的上下文项的类。

对象的 。 为 。

创建的新实例 类使用指定的数据和值类型的 URI。

交换的二进制数据。 一个 表示二进制数据的值类型。 为 。 - 或 - 为 。 不是一个绝对 URI。

创建的新实例 使用指定的数据、 ValueType URI 和 EncodingType URI。

交换的二进制数据。 一个 表示二进制数据的值类型。 一个 ，它指定要用于编码的二进制数据的编码类型。 为 。 - 或 - 为 。 - 或 - 为 。 不是一个绝对 URI。 - 或 - 不是一个绝对 URI。

新实例初始化 类具有指定名称的 URI。

一个 ，该值指示上下文项名称。 为 。 不是一个绝对 URI。

新实例初始化 类，具有指定名称的 URI 和值。

一个 ，该值指示上下文项名称。 上下文项值。 可以为 。 为 。 不是一个绝对 URI。

新实例初始化 类，具有指定名称的 URI、 值和范围 URI。

一个 ，该值指示上下文项名称。 上下文项值。 可以为 。 上下文项的作用域。 可以为 。 为 。 不是一个绝对 URI。 - 或 - 不是 并不是绝对 URI。

用指定的 URI 初始化 类的新实例。

绝对 URI，指定的终结点引用的地址。 初始化 属性。 不是绝对 URI。 为 。

从指定的 XML 字典读取器读取 wsa:EndpointReference 元素。

从中进行读取的终结点引用 XML 字典读取器。 从 XML 字典读取器读取终结点引用或 如果无法读取 wsa:EndpointReference 元素。

从指定的 XML 读取器读取 wsa:EndpointReference 元素。

从中进行读取的终结点引用的 XML 读取器。 从 XML 字典读取器读取终结点引用或 如果无法读取 wsa:EndpointReference 元素。

写入 作为 < wsa:EndpointReference > 元素指定的 XML 编写器。

要向其写入的终结点引用的 XML 编写器。

新实例初始化 机密的二进制格式发送平均信息量的类。

包含密钥材料的字节数组。

新实例初始化 用于加密密钥的格式发送平均信息量的类。

包含密钥材料的字节数组。 表示用于加密的密钥材料的凭据。

新实例初始化 类与指定受保护的密钥。

一个 表示受保护的密钥可以是二进制或者机密或加密的密钥。

新实例初始化 类随机生成的字节数。

密钥材料内平均信息量的 entropySizeInBits。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

新实例初始化 类，具有指定的创建和过期时间。

一个 ，表示令牌的创建时间以 utc 为单位。 一个 ，它表示令牌的过期时间以 utc 为单位。 指定的时间 之前指定的时间发生 。

新实例初始化 类，具有指定的创建和过期时间。

一个 ，指定的令牌创建时间以 utc 为单位。 可以为 。 一个 ，指定令牌的过期时间以 utc 为单位。 可以为 。 指定的时间 之前指定的时间发生 。

初始化 类的新实例。

新实例初始化 未加密的类。

一个数组 ，包含要保护的密钥材料。

新实例初始化 类使用指定的加密凭据。

一个数组 ，包含要保护的密钥材料。 ，其中包含用于加密的密钥材料的凭据。

获取密钥材料。

一个数组 包含密钥材料。

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

新实例初始化 类具有指定值。

如果允许续订;否则为 。 如果可以续订请求的令牌，过期; 后否则为 。

新实例初始化 与指定的声明类型的类。

表示声明类型 URI。

新实例初始化 类具有指定的声明类型和值，该值指示声明是否可选。

表示声明类型 URI。 如果声明是可选的响应中;否则为 。

新实例初始化 用指定的声明类型、 声明值和一个值，该值指示声明是否可选。

表示声明类型 URI。 如果声明是可选的响应中;否则为 。 声明的值。

初始化 类的新实例。

新实例初始化 类使用指定的密钥材料。

一个数组 包含密钥材料。

新实例初始化 类使用指定的密钥材料和加密凭据。

一个数组 包含密钥材料。 一个 表示用于加密的密钥材料的凭据。

使用指定的 对象初始化 类的新实例。

一个 ，表示的键，可以是二进制密钥或加密的密钥。 为 。

新实例初始化 类使用指定的计算密钥算法。

一个字符串，包含一个 URI，指示用于计算组合的平均信息量用例中的会话密钥的算法。 为 。

新实例初始化 类使用颁发的令牌。

一个 表示请求的安全令牌。 为 。

新实例初始化 类使用令牌的 XML。

，其中包含的 XML 表示形式的请求的安全令牌。 为 。

初始化 类的新实例。

新实例初始化 与指定的请求类型的类。

一个包含请求类型 URI 的字符串。

新实例初始化 与指定的请求类型的类。

一个包含请求类型 URI 的字符串。 一个包含密钥类型 URI 的字符串。 这应该是一个定义的常量 类。

初始化 类的新实例。

新实例初始化 类根据指定的请求消息 (RST)。

一个 该对象表示请求 (RST)。 为 。

新实例初始化 类使用指定的状态代码和原因。

一个字符串，包含状态代码的 URI。 一个字符串，包含用户可读的原因。 原因是可选的;可以是 。 为 。

初始化 类的新实例。

新实例初始化 类使用指定的安全密钥标识符。

一个 ，表示应使用的现有键。

新实例初始化 类使用指定的安全密钥标识符和安全令牌。

一个 ，表示应使用的现有键。 一个 ，表示应使用的现有键。

新实例初始化 类使用的指定的安全令牌。

一个 ，表示应使用的现有键。

初始化 类的新实例。

检查给定的读取器是否定位在 命名空间"http://docs.oasis-open.org/ws-sx/ws-trust/200512"元素。

从中进行读取的对象。 如果读取器定位在命名空间"http://docs.oasis-open.org/ws-sx/ws-trust/200512"; 的 RequestSecurityToken 元素否则为 。 为 。

以进行读取的特例 WS 信任 1.3 RST 中。

对象，将光标指向 内 RST 元素。 一个 ，其中包含当前序列化上下文。 一个 ，其中包含在 RST 中找到 SecondaryParameters。 为 。 - 或 - 为 。 一个内部 处理外部时找到的元素 元素。

反序列化从 RST 对象传递给 对象。

通过 RST XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。 为 。 - 或 - 为 。 分析 RST 出错。

读取 RST 中的子元素。 基类方法的重写。

对象位于要读取 RST 内的元素。 正在从读取器填充的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 无法反序列化当前的参数。

将受支持的元素写入上 写入流的对象。

对象被序列化。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将序列化为指定 对象插入 对象。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将指定的 RST 参数写入到传出流。 基类方法的重写。

对象传递给该序列 RST。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 为 或空字符串。

初始化 类的新实例。

检查指定的 XML 读取器是否定位在 RequestSecurityTokenResponse 或命名空间"http://docs.oasis-open.org/ws-sx/ws-trust/200512"的 RequestSecurityTokenResponseCollection 元素。

从中进行读取的对象。 如果读取器定位在 RequestSecurityTokenResponse 或命名空间"http://docs.oasis-open.org/ws-sx/ws-trust/200512"; 的 RequestSecurityTokenResponseCollection 元素否则为 。 为 。

反序列化从 RSTR 对象传递给 对象。

通过 RSTR XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。 为 。 - 或 - 为 。

读取 RSTR 中的特定子元素。

对象位于要读取 RSTR 内的元素。 正在填充从读取器的元素。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 无法反序列化当前的参数。

将受支持的元素写入上 对象传递给传出流。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将序列化为指定 对象插入 对象。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将指定的 RSTR 元素写入到传出流。 基类方法的重写。

RSTR 正在序列化成对象。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 elementname 或空字符串。

初始化 类的新实例。

检查给定的读取器是否定位在命名空间"http://schemas.xmlsoap.org/ws/2005/02/trust"的 RequestSecurityToken 元素。

从中进行读取的对象。 如果读取器定位在命名空间"http://schemas.xmlsoap.org/ws/2005/02/trust"; 的 RequestSecurityToken 元素否则为 。 为 。

反序列化从 RST 对象传递给 对象。

通过 RST XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。 为 。 - 或 - 为 。 分析 RST 出错。

读取 RST 中的子元素。 基类方法的重写。

对象位于要读取 RST 内的元素。 正在从读取器填充的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 无法反序列化当前的参数。

将受支持的元素写入上 写入流的对象。

对象被序列化。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将序列化为指定 对象插入 对象。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将指定的 RST 参数写入到传出流。 基类方法的重写。

对象传递给该序列 RST。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 为 或空字符串。

初始化 类的新实例。

检查指定的 XML 读取器是否定位在命名空间"http://schemas.xmlsoap.org/ws/2005/02/trust"的 RequestSecurityTokenResponse 元素。

从中进行读取的对象。 如果读取器定位在命名空间"http://schemas.xmlsoap.org/ws/2005/02/trust"; 的 RequestSecurityTokenResponse 元素否则为 。 为 。

反序列化从 RSTR 对象传递给 对象。

通过 RSTR XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。 为 。 - 或 - 为 。

重写读取 RSTR 中的特定子元素的基类。

对象位于要读取 RSTR 内的元素。 正在填充从读取器的元素。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 无法反序列化当前的参数。

将受支持的元素写入上 对象传递给传出流。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将序列化为指定 对象插入 对象。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。

将指定的 RSTR 元素写入到传出流。 基类方法的重写。

RSTR 正在序列化成对象。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。 为 。 - 或 - 为 。 - 或 - 为 。 elementname 或空字符串。

初始化 类的新实例。

初始化 类的新实例。

当在派生类中重写，检查指定的 XML 读取器是否定位在 WS 信任 RequestSecurityToken 元素。

从中进行读取的对象。 如果读取器定位在序列化程序可读，则 RST 元素否则为 。

创建的一个实例 此类可以序列化或反序列化的类。

一个 对象。

当在派生类中重写，将读取自定义元素。

定位在当前元素上的对象。 一个 ，其中包含当前序列化上下文。

当在派生类中重写，反序列化从 RST 对象传递给 对象。

通过 RST XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。

当在派生类中重写，将读取 RST 中的子元素。

对象位于要读取 RST 内的元素。 正在从读取器填充的对象。 一个 ，其中包含当前序列化上下文。

验证 消息反序列化的对象。

要验证对象。 为 。 非对称密钥的 WS 信任问题请求未指定 UseKey 元素。

当在派生类中重写时写入受支持的元素上 写入流的对象。

对象被序列化。 要写入的 对象。 一个 ，其中包含当前序列化上下文。

当在派生类中重写序列化指定 对象插入 对象。

要序列化对象。 要写入的 对象。 一个 ，其中包含当前序列化上下文。

当在派生类中重写时写入 RST 中的子元素。

对象传递给该序列 RST。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。

初始化 类的新实例。

当在派生类中重写，检查指定的 XML 读取器是否定位在 WS 信任 RequestSecurityTokenResponse 元素。

从中进行读取的对象。 如果读取器定位在此序列化程序可以读取; RSTR 元素否则为 。

创建的一个实例 此类可以序列化或反序列化的类。

一个 对象。

当在派生类中重写，反序列化从 RSTR 对象传递给 对象。

通过 RSTR XML 读取器。 一个 ，其中包含当前序列化上下文。 一个 对象反序列化是否成功。

当在中重写派生的类读取 RSTR 中的子元素。

对象位于要读取 RSTR 内的元素。 正在填充从读取器的元素。 一个 ，其中包含当前序列化上下文。

验证 消息反序列化的对象。

要验证对象。 为 。

当在派生类中重写时写入受支持的元素上 对象传递给传出流。

要序列化对象。 要向其中进行写入的 。 一个 ，其中包含当前序列化上下文。

当在派生类中重写序列化指定 对象插入 对象。

要序列化对象。 要向其中进行写入的 。 一个 ，其中包含当前序列化上下文。

当在派生类中重写时写入 RSTR 中的子元素。

RSTR 正在序列化成对象。 要写入的元素本地名称。 元素的值。 正在序列化的对象。 一个 ，其中包含当前序列化上下文。

初始化 类的新实例。

新实例初始化 类与指定 对象。

对象，其中包含的一套 WS 信任消息中找到要用于序列化和验证令牌的对象。 为 。

新实例初始化 类与指定 , ，, ，和 对象。

对象，其中包含的一套 WS 信任消息中找到要用于序列化和验证令牌的对象。 对象，用于解决在 WS 信任消息的大多数元素中找到的安全令牌引用。 要用来解决在 RST 消息的 wst:UseKey 元素，以及在 RST 消息中找到的 wst:RenewTarget 元素中找到的令牌的引用的安全对象。 为 。 - 或 - 为 。 - 或 - 为 。

初始化 的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

新实例初始化 类，该类使用指定的密钥进行加密和解密。

要用作默认加密和解密密钥的密钥。 初始化 和 属性。 为 。

新实例初始化 类，该类使用指定的 X.509 证书的私钥进行加密和解密。

使用其私钥进行加密和解密证书。 证书的私钥将用作默认加密和解密密钥。 初始化 和 属性。 为 。 没有私钥。 - 或 - 私钥不是 RSA。

对指定的数据进行解密通过使用提供的 RSA 密钥进行解密 AES 密钥，对 cookie 进行解密。

编码的数据 已解码的数据 为 。 包含零字节。 该平台不支持请求的算法。 没有任何解密密钥或所有键都不都匹配。

对指定的数据进行编码。 对数据进行加密使用的默认加密算法 (aes-256)，然后使用 RSA 加密的 AES 密钥，并追加的 RSA 公钥。

要编码的数据 编码的数据 为 。 包含零字节。 为 。

新实例初始化 类通过使用指定的 RSA 密钥。

RSA 密钥将用作默认签名和验证密钥。 为 。

新实例初始化 类通过使用指定的证书的私钥。

证书的私钥是可用于签名和验证。 为 。 没有私钥 - 或 - 私匙 不是 RSA 密钥。

验证指定的签名，并返回原始的未签名数据。

从以前返回数据 方法。 原始数据 （无符号）。 为 。 包含零字节。 该签名无效。 在格式不正确的数据。 没有任何验证密钥。 该平台不支持指定的算法。

指定的数据进行签名。

要签名的数据。 已签名的数据。 为 。 包含零字节。 属性为 。 - 或 - 由指定的密钥 属性不能作为分配 。 - 或 - 由指定的密钥 属性不包含私钥。 操作系统不支持指定的算法。

初始化 类的新实例。

新实例初始化 类，具有指定的 appliesTo 地址。

信赖方 appliesTo 地址。 这通常是一个 URI。

新实例初始化 类具有指定的 appliesTo 地址和加密凭据。

信赖方 appliesTo 地址。 这通常是一个 URI。 信赖方的加密的凭据。

新实例初始化 类具有指定的 appliesTo 地址和签名的凭据。

信赖方 appliesTo 地址。 这通常是一个 URI。 信赖方的签名的凭据。

新实例初始化 类，具有指定的 appliesTo 地址，签名凭据和加密凭据。

信赖方 appliesTo 地址。 这通常是一个 URI。 信赖方的签名的凭据。 信赖方的加密的凭据。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

从派生类来初始化调用 类使用指定的配置设置。

一个 包含 STS 的设置。 为 。

当在派生类中重写，开始异步 WS 信任取消请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 可接收异步取消操作完成通知的委托。 一个包含与异步取消操作关联的状态信息的对象。 引用异步取消操作的 。

当在派生类中重写，开始异步调用 方法。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 ，包含有关与请求关联的信赖方信息。 可接收异步操作完成通知的委托。 一个包含与异步操作关联的状态信息的对象。 引用异步操作的 。

当在派生类中重写，开始异步调用的 方法。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 可接收异步操作完成通知的委托。 一个包含与异步操作关联的状态信息的对象。 引用异步取消操作的 。

当在派生类中重写，开始一个异步 Ws-trust 发出请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 可接收异步问题操作完成通知的委托。 一个包含与异步问题操作相关联的状态信息的对象。 引用异步问题操作。

当在派生类中重写，开始异步 WS 信任续订请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 可接收的异步完成通知的委托的续订操作。 一个对象，包含与异步相关联的状态信息的续订操作。 引用异步续订操作。

当在派生类中重写，开始异步 WS 信任验证请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 委托，它接收的异步完成通知的验证操作。 包含与异步相关联的状态信息的对象验证操作。 引用异步验证操作。

当在派生类中重写，处理 Ws-trust 取消请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 一个 表示 RSTR 以返回到调用方。

创建的一个实例 。

传入的令牌请求。 从返回的对象 。 。 为 。 - 或 - 为 。

当在派生类中重写，完成异步 WS 信任取消请求。

，由对 方法的调用返回。 一个 表示 RSTR 以返回到调用方。

当在派生类中重写时完成的异步调用 方法。

，由对 方法的调用返回。 一个 包含将被放置在颁发的安全令牌的声明的集合。

当在派生类中重写时完成的异步调用 方法。

，由对 方法的调用返回。 一个 封装与对的调用中指定的请求 (RST) 关联的信赖方 (RP) 信息 方法。

当在派生类中重写，完成异步 Ws-trust 发出请求。

，由对 方法的调用返回。 一个 表示 RSTR 以返回到调用方。

当在派生类中重写，完成异步 WS 信任续订请求。

，由对 方法的调用返回。 一个 表示 RSTR 以返回到调用方。

当在派生类中重写，完成异步 WS 信任验证请求。

，由对 方法的调用返回。 一个 表示 RSTR 以返回到调用方。

新实例初始化 类指定令牌的请求 (RST) 令牌请求者和 对象。

令牌请求。 请求者的标识。 表示异步调用的状态。 为 。 - 或 - 为 。

新实例初始化 类从指定 对象。 此构造函数中有效地创建指定的实例的副本。

实例，将创建新实例。 为 。

获取安全令牌服务 (STS) 的名称。

颁发者名称中。

当在派生类中重写此方法将返回输出者颁发的令牌中包含的集合。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 ，包含有关与请求关联的信赖方信息。 这是 返回的对象 方法。 一个 包含将被放置在颁发的安全令牌的声明的集合。

获取要包括在响应 (RSTR) 的证明令牌。

一个 该对象表示传入的令牌请求 (RST)。 封装有关信赖方的信息的实例。 一个 ，表示新创建的证明描述符。 证明描述符可以是一个非对称证明的描述符对称校验描述符中，或 在持有者令牌的情况下。 为 。 - 或 - 为 。

获取加密凭据的请求者的证明。

一个 该对象表示传入的令牌请求 (RST)。 对象，表示请求程序的加密凭据。 为 。

创建使用指定的请求 (RST) 和令牌的安全描述符包含已颁发的令牌的响应 (RSTR)。

包含令牌请求 RST。 令牌描述符，其中包含要使用已颁发的令牌的信息。 响应 (RSTR) 或 如果响应不能创建从指定的请求和令牌描述符。 默认实现返回 如果 参数是 。

获取 对象，其中包含有关与指定的请求 (RST) 相关联的信赖方 (RP) 的信息。 必须在您的实现重写此方法 类。

一个 ，表示客户端发出请求。 一个 该对象表示传入的请求 (RST)。 一个 封装与请求关联的 RP 信息。

颁发安全令牌的指定类型获取适当的安全令牌处理程序。

一个包含请求的令牌类型 URI 的字符串。 一个 ，表示要用于创建已颁发的安全令牌的令牌处理程序。 返回 如果不支持请求的令牌类型 （没有处理程序配置为指定的令牌类型）。

获取已颁发的令牌的生存期。

一个 ，表示请求的生存期。 一个 ，表示授予的生存期。

颁发安全令牌。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 一个 包含颁发的安全令牌。

当在派生类中重写处理 Ws-trust 续订请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 一个 表示 RSTR 以返回到调用方。

当在派生类中重写处理 WS 信任验证的请求。

一个 ，表示令牌的请求者的标识。 一个 ，表示安全令牌请求。 这包括请求消息以及其他客户端相关的信息，如授权上下文。 一个 表示 RSTR 以返回到调用方。

安全令牌对请求进行验证 (RST) 中的此实例。

一个 表示的请求。 为 。 - 或 - 请求的属性未设置为 。 - 或 - 请求的属性不是 或中定义的常量之一 类。 - 或 - 请求的是 和 元素存在，但其值不等于零。 STS 不支持请求的令牌类型 (基于值的 请求的属性)。

获取一个值，指示指定 的值是否有效。

要验证其有效性的 。 如果 为 、 或 ，则为 ；否则为 。

使用指定的验证程序来初始化 类的新实例。

一个 ，它使用自定义身份验证方案对用户名和密码进行身份验证。 为 。

对指定的用户名和密码进行身份验证，并返回 安全令牌的授权策略集。

与安全令牌相关联的用户名。 与安全令牌相关联的密码。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。 为 。 和 的组合无效。

初始化 类的新实例。

通过指定是否在对 Windows 用户进行身份验证时获取该用户所属的组，初始化 类的新实例。

如果获取 Windows 用户所属的组，则为 ；否则为 。

获取一个值，指示此安全令牌身份验证器是否可以验证指定的安全令牌。

要进行身份验证的 。 如果 为 安全令牌，则为 ；否则为 。

使用指定的服务主体名称初始化 类的新实例。

要为其获取 安全令牌的服务主体名称。 为 。

通过使用指定的服务主体名称以及有关客户端是否允许 安全令牌的接收方模拟客户端的凭据的信息，初始化 类的新实例。

要为其获取 安全令牌的服务主体名称。 一个 ，它指定 安全令牌的接收方可在多大程度上代表客户端执行操作。 不是 或 。 为 。

通过使用指定的服务主体名称、客户端标识以及有关客户端是否允许 安全令牌的接收方模拟客户端的凭据的信息，初始化 类的新实例。

要为其获取 安全令牌的服务主体名称。 一个 ，它指定 安全令牌的接收方可在多大程度上代表客户端进程执行操作。 一个 ，它表示 的标识。 不是 或 。 为 。

获取 安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 表示要获取的安全令牌的 。

初始化 类的新实例。

获取一个值，该值指示指定的安全令牌是否可由该安全令牌身份验证器进行验证。

进行验证。 如果 为 安全令牌，则为 ；否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

使用指定的身份验证器集初始化 类的新实例。

的一个 ，它包含对颁发者的 安全令牌进行身份验证的身份验证器。

使用指定的身份验证器集以及发送方和接收方时钟之间允许的最大偏差来初始化 类的新实例。

的一个 ，它包含对颁发者的 安全令牌进行身份验证的身份验证器。 一个 ，表示发送方和接收方时钟之间允许的最大偏差。

获取一个值，指示此安全令牌身份验证器是否可以验证指定的安全令牌。

要验证的 。 如果 为 安全令牌，则为 ；否则为 。

使用在创建 实例时提供的支持安全身份验证器解析与指定密钥标识符关联的标识，并将其作为 返回。

一个要获取其标识的 。 一个 ，表示指定的密钥标识符的标识。

使用在创建 实例时提供的支持令牌身份验证器解析与指定安全令牌关联的标识，并将其作为 返回。

一个要获取其标识的 。 一个 ，表示指定的安全令牌的标识。

使用在创建 实例时提供的支持安全令牌身份验证器解析与指定密钥标识符关联的标识，并将其作为 返回。

一个要获取其标识的 。 一个 ，表示指定的密钥标识符的标识。

使用在创建 实例时提供的支持安全令牌身份验证器解析与指定安全令牌关联的标识，并将其作为 返回。

一个要获取其标识的 。 一个 ，表示指定的安全令牌的标识。

验证 安全令牌是否针对此 Web 服务。

一个 ，指定 安全令牌针对的目标 Web 服务集。 如果 参数的 属性位于 集合中，则为 ，否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含安全令牌身份验证产生的授权策略集。

初始化 类的新实例。

获取一个值，该值指示指定的安全令牌是否可由该安全令牌身份验证器进行验证。

要验证的 。 如果可以验证令牌，则为 ；否则为 。 为 。

在派生类中重写时，获取一个值，指示此安全令牌身份验证器是否可以验证指定的安全令牌。

要验证的 。 如果可以验证 ，则为 ；否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。 为 。 此安全令牌身份验证器无法对 进行身份验证 - 或 - 未通过身份验证。

在派生类中重写时，对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

初始化 类的新实例。

获取符合指定安全令牌需求的安全令牌身份验证器。

一个 ，指定安全令牌要求。 一个 ，确定符合指定安全令牌要求的安全令牌。 一个 ，对传入 SOAP 消息中符合指定要求的安全令牌进行身份验证。

获取符合指定安全令牌需求的安全令牌提供程序。

一个 ，指定安全令牌要求。 一个 ，为传出 SOAP 消息提供符合指定要求的安全令牌。

获取 XML 序列化程序，它可以按指定的 WS-* 规范版本序列化安全令牌。

一个 ，指定安全令牌所遵循的 WS-* 规范版本。 一个用于序列化安全令牌的 。

初始化 类的新实例。

开始异步操作以取消安全令牌。

一个 ，它为取消安全令牌的消息指定超时值。 要取消的 。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步取消操作的 。

开始异步操作以取消安全令牌。

一个 ，它为取消安全令牌的消息指定超时值。 要取消的 。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步取消操作的 。

开始异步操作以获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步关闭操作的 。

开始异步操作以获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步操作的 。

开始异步操作以续订安全令牌。

一个 ，它为续订安全令牌的消息指定超时值。 要续订的 。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步操作的 。

开始异步操作以续订安全令牌。

一个 ，它为续订安全令牌的消息指定超时值。 要续订的 。 接收异步关闭操作完成通知的 委托。 一个由应用程序指定的对象，它包含与异步关闭操作相关联的状态信息。 引用异步操作的 。

取消安全令牌。

一个 ，它为取消安全令牌的消息指定超时值。 要取消的 。

取消安全令牌。

一个 ，它为取消安全令牌的消息指定超时值。 要取消的 。

完成异步操作以取消安全令牌。

，由对 方法的调用返回。

完成异步操作以取消安全令牌。

，由对 方法的调用返回。

完成异步操作以获取安全令牌。

，由对 方法的调用返回。 ，表示安全令牌。

完成异步操作以获取安全令牌。

，由对 方法的调用返回。 ，表示安全令牌。

完成异步操作以续订安全令牌。

，由对 方法的调用返回。 表示所续订的安全令牌的 。

完成异步操作以续订安全令牌。

，由对 方法的调用返回。 表示所续订的安全令牌的 。

获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 表示要获取的安全令牌的 。

获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 表示要获取的安全令牌的 。

续订安全令牌。

一个 ，它为续订安全令牌的消息指定超时值。 要续订的 。 表示所续订的安全令牌的 。

续订安全令牌。

一个 ，它为续订安全令牌的消息指定超时值。 要续订的 。 表示所续订的安全令牌的 。

创建 的新实例。

利用其初始化 的安全令牌 要在异步操作完成时调用的回调方法。 作为异步方法调用的最后一个参数提供的对象。

使用指定的结果完成异步操作。

异步操作的结果。 返回 。

初始化 类的新实例。

获取当前 实例的指定属性。

要获取的属性的名称。 要获取的属性的类型。 要获取的属性的值。 为 。

获取当前 实例的指定属性。

要获取的属性的名称。 属性中指定的属性的值。 要在 参数中返回的属性的类型。 如果 属性包含在 属性中指定的属性的属性值，则为 ；否则为 。 属性具有 参数中指定的名称，但其类型与 参数中指定的类型不同。

初始化 类的新实例。

为指定的安全令牌创建默认安全令牌解析程序。

一个类型为 的 ，它包含此安全令牌解析程序可以将密钥标识符和密钥标识符子句解析到其中的安全令牌集。 如果对所引用的安全密钥位于 SOAP 消息中其他某个位置的 密钥标识符子句进行解析，则为 ；否则，为 。 一个 ，它解析与 参数中指定的安全令牌相匹配的密钥标识符和子句。

在派生类中重写，当从 XML 加载自定义配置。

自定义配置元素中。

获取在指定的密钥标识符子句中引用的密钥。

要为其检索密钥的 。 一个 ，它是指定的密钥标识符子句中引用的密钥。 为 。 无法为 参数中指定的密钥标识符子句检索密钥。

检索与指定的密钥标识符中包含的安全密钥标识符子句之一相匹配的安全令牌。

要为其创建安全令牌的 。 一个 ，它表示指定的密钥标识符。 为 。 无法为指定的密钥标识符创建安全令牌。

检索与指定的密钥标识符子句相匹配的安全令牌。

要为其创建安全令牌的 。 一个 ，它表示指定的密钥标识符子句。

尝试检索在指定的密钥标识符子句中引用的密钥。

要为其检索密钥的 。 当此方法返回时，包含一个 ，其中包含在指定的密钥标识符子句中引用的密钥。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索密钥，则为 ；否则为 。 为 。

尝试检索在指定的密钥标识符子句中引用的密钥。

要为其检索密钥的 。 当此方法返回时，包含一个 ，其中包含在指定的密钥标识符子句中引用的密钥。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索密钥，则为 ；否则为 。

尝试检索与指定的密钥标识符中包含的密钥标识符子句之一相匹配的安全令牌。

要为其创建安全令牌的 。 当此方法返回时，包含一个 ，它表示指定的密钥标识符。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符检索安全令牌，则为 ；否则为 。 为 。

尝试检索与指定的密钥标识符子句相匹配的安全令牌。

要为其创建安全令牌的 。 当此方法返回时，包含一个 ，它表示指定的密钥标识符子句。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索安全令牌，则为 ；否则为 。 为 。

当在派生类中重写时，尝试检索至少与指定的密钥标识符中包含的密钥标识符子句之一相匹配的安全令牌。

要为其创建安全令牌的 。 当此方法返回时，包含一个 ，它表示指定的密钥标识符。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符检索安全令牌，则为 ；否则为 。

当在派生类中重写时，尝试解析与指定的密钥标识符子句相匹配的安全令牌。

要为其创建安全令牌的 。 当此方法返回时，包含一个 ，它表示指定的密钥标识符子句。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索安全令牌，则为 ；否则为 。

初始化 类的新实例。

确定此序列化程序是否可读取由指定的 XML 读取器引用的 元素。

读取密钥标识符的 。 如果可以读取指定的 XML 元素，则为 ；否则为 。 为 。

确定此序列化程序是否可读取中的子句 由指定的 XML 读取器引用元素。

读取密钥标识符子句的 。 如果可以读取指定的密钥标识符子句，则为 ；否则为 。 为 。

确定此序列化程序是否可读取由指定的 XML 读取器引用的 元素。 供基类调用。

读取密钥标识符子句的 。 如果可以读取指定的 元素，则为 ；否则为 。 为 。

确定此序列化程序是否可读取由指定的 XML 读取器引用的 元素。 供基类调用。

读取密钥标识符的 。 如果可以读取指定的密钥标识符子句，则为 ；否则为 。 为 。

确定此序列化程序是否可读取由指定的 XML 读取器指向的安全令牌。

读取安全令牌的 。 如果可以读取安全令牌，则为 ；否则为 。 为 。

确定此序列化程序是否可读取由指定的 XML 读取器指向的安全令牌。 供基类调用。

读取安全令牌的 。 如果可以读取安全令牌，则为 ；否则为 。 为 。

确定此序列化程序是否可以编写指定的密钥标识符。

表示要编写的密钥标识符的 。 如果此序列化程序可以编写指定的密钥标识符，则为 ；否则为 。 为 。

确定此序列化程序是否可以编写指定的密钥标识符子句。

表示要编写的密钥标识符子句的 。 如果此序列化程序可以编写指定的密钥标识符子句，则为 ；否则为 。 为 。

确定此序列化程序是否可以编写指定的密钥标识符子句。 供基类调用。

表示要编写的密钥标识符子句的 。 如果此序列化程序可以编写指定的密钥标识符子句，则为 ；否则为 。 为 。

确定此序列化程序是否可以编写指定的密钥标识符。 供基类调用。

表示要编写的密钥标识符的 。 如果此序列化程序可以编写指定的密钥标识符，则为 ；否则为 。 为 。

确定此序列化程序是否可以将指定的安全令牌编写为 XML。

要转换为 XML 的 。 如果可以编写安全令牌，则为 ；否则为 。 为 。

确定此序列化程序是否可以将指定的安全令牌编写为 XML。 供基类调用。

要转换为 XML 的 。 如果可以编写安全令牌，则为 ；否则为 。 为 。

使用指定的 XML 读取器读取密钥标识符。

读取密钥标识符的 。 表示所读取的密钥标识符的 。 为 。

使用指定的 XML 读取器读取密钥标识符子句。

读取密钥标识符的 。 表示所读取的密钥标识符的 。 为 。

使用指定的 XML 读取器读取密钥标识符子句。 供基类调用。

读取密钥标识符的 。 表示所读取的密钥标识符的 。 为 。

使用指定的 XML 读取器读取密钥标识符子句。 供基类调用。

读取密钥标识符的 。 表示所读取的密钥标识符的 。 为 。

读取由指定的 XML 读取器指向的安全令牌。

读取安全令牌的 。 确定安全令牌类型的 。 表示所读取的安全令牌的 。 为 。 - 或 - 为 。

读取由指定的 XML 读取器指向的安全令牌。 供基类调用。

读取安全令牌的 。 确定安全令牌类型的 。 表示所读取的安全令牌的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的密钥标识符。

编写密钥标识符的 。 表示要编写的密钥标识符的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的密钥标识符子句。

编写密钥标识符子句的 。 表示要编写的密钥标识符子句的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的密钥标识符子句。 供基类调用。

编写密钥标识符子句的 。 表示要编写的密钥标识符子句的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的密钥标识符。 供基类调用。

编写密钥标识符的 。 表示要编写的密钥标识符的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的安全令牌。

编写安全令牌的 。 表示要编写的安全令牌的 。 为 。 - 或 - 为 。

使用指定的 XML 编写器编写指定的安全令牌。 供基类调用。

编写安全令牌的 。 表示要编写的安全令牌的 。 为 。 - 或 - 为 。

初始化 类的新实例。

获取受支持的安全规范的集合。

一个类型为 的 ，它包含受支持的安全规范集。

初始化 类的新实例。

获取 的实例，它使用指定的成员资格提供程序来验证用户名和密码。

一个验证用户名和密码的 。 一个使用 来验证用户名和密码的 。

当在派生类中重写时，验证指定的用户名和密码。

要验证的用户名。 要验证的密码。

初始化 类的新实例。

获取一个值，该值指示指定的安全令牌是否可由该安全令牌身份验证器进行验证。

要验证的 。 如果 为 安全令牌，则为 ；否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

如果在派生类中重写，则对指定的用户名和密码进行身份验证，并且返回 安全令牌的授权策略集。

与安全令牌相关联的用户名。 与安全令牌相关联的密码。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

使用指定的用户名和密码初始化 类的新实例。

要为其获取 安全令牌的用户的用户名。 要为其获取 安全令牌的用户的密码。

根据构造函数中指定的用户名和密码获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 表示要获取的安全令牌的 。

初始化 类的新实例。

通过指定是否在对 Windows 用户进行身份验证时将该用户所属的组添加到 属性，初始化 类的新实例。

如果获取 Windows 用户所属的组，则为 ；否则为 。

获取一个值，该值指示指定的安全令牌是否可由该安全令牌身份验证器进行验证。

进行验证。 如果 为 安全令牌，则为 ；否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

初始化 类的新实例。

通过指定在对用户进行身份验证时，是否起初将标识用户所属 Windows 组的声明添加到 属性，以此来初始化 类的新实例。

如果获取 Windows 用户所属的组，则为 ；否则为 。

对指定的用户名和密码进行身份验证，并返回 安全令牌的授权策略集。

与安全令牌相关联的用户名。 与安全令牌相关联的密码。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。 包含多个反斜杠 (\) 字符。

初始化 类的新实例。

获取一个验证程序，它通过指定用于构建和验证信任链的上下文和链策略来验证 X.509 证书。

如果为 ，则使用计算机上下文；如果为 ，则使用当前用户上下文。 一个 ，它指定用于构建和验证信任链的策略。 一个 ，它使用信任链来验证 X.509 证书。

获取一个验证程序，它验证证书是否位于 证书存储区中，或通过指定用于构建证书信任链的上下文和链策略来验证证书。 如果证书通过任一验证方法，就是受信任的。

如果为 ，则使用计算机上下文；如果为 ，则使用当前用户上下文。 一个 ，它指定用于构建信任链的策略。 一个 ，它通过验证证书是否位于 证书存储区中来验证证书，或通过构建证书信任链来验证证书。

在派生类中重写，当从 XML 加载自定义配置。

自定义配置元素中。

当在派生类中重写时，验证 X.509 证书。

表示要验证的 X.509 证书的 。

初始化 类的新实例。

使用指定的证书验证程序初始化 类的新实例。

一个 ，用于验证证书是否有效。

使用指定的证书验证方法初始化 类的新实例，并指示是否将证书标识映射到 Windows 标识。

一个 ，用于验证证书是否有效。 若要将证书标识映射到 Windows 标识，则为 ；否则为 。

使用指定的证书验证方法初始化 类的新实例，并指示是否将证书标识映射到 Windows 标识以及用户所属的 Windows 组。

一个 ，用于验证证书是否有效。 若要将证书标识映射到 Windows 标识，则为 ；否则为 。 若要在整个身份验证过程中将 Windows 用户所属的组包括在构造的 属性中，则为 ；否则为 。

获取一个值，指示此安全令牌身份验证器是否可以验证指定的安全令牌。

要验证的 。 如果 是 安全令牌或从 中派生的类，则为 ；否则为 。

对指定的安全令牌进行身份验证，并返回该安全令牌的授权策略集。

要验证的 。 一个类型为 的 ，它包含对此应用程序生效的授权策略集。

通过从指定的证书存储条件中获取 X.509 证书来初始化 类的新实例。

值之一，该值指定了证书存储位置。 值之一，该值指定了证书存储名称。 值之一，该值指定了如何搜索证书存储区。 用于在证书存储区中查找 X.509 证书的值。 为 。 没有与指定的条件匹配的证书。 - 或 - 有多个证书与指定的条件匹配。

使用指定的 X.509 证书初始化 类的新实例。

要为其获取安全令牌的 。 为 。

释放由 使用的所有资源。

使用构造函数中指定的 X.509 证书获取安全令牌。

一个 ，它为获取安全令牌的消息指定超时值。 表示要获取的安全令牌的 。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。

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

解释异常原因的错误消息。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

新实例初始化 类通过使用指定的令牌解析程序列表。

安全令牌解析程序要包装的此实例的列表。 为 。

尝试检索在指定的密钥标识符子句中引用的密钥。

要检索的密钥的密钥标识符子句。 此方法返回时，包含指定的密钥标识符子句中引用的密钥。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索密钥，则为 ；否则为 。 为 。

尝试检索至少指定的密钥标识符中包含的密钥标识符子句之一相匹配的安全令牌。

要检索的令牌的安全密钥标识符。 此方法返回时，包含表示指定的密钥标识符的标记。 此参数未经初始化即被传递。 当一个令牌可检索为指定的密钥标识符;否则为 。 为 。

尝试解析与指定的密钥标识符子句相匹配的安全令牌。

若要创建安全令牌的密钥标识符子句。 此方法返回时，包含表示指定的密钥标识符子句的安全令牌。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索安全令牌，则为 ；否则为 。 为 。

初始化 类的新实例。

新实例初始化 类根据密钥标识符。

在其构造证明令牌的密钥标识符。

新实例初始化 类基于 RSA 算法。

RSA 算法构造证明令牌。

适用于 RSTR 请求证明令牌的证明描述符。

要将该说明符应用于 RSTR。

初始化 类的新实例。

在派生类中重写时，获取指定的非对称加密算法。

要创建的非对称算法。 如果需要使用私钥来创建算法，则为 ；否则为 。 一个 ，表示指定的非对称加密算法。 通常将 传递到 参数中，因为解密通常需要使用私钥。

在派生类中重写时，获取一个用于生成数字签名的哈希值的加密算法。

哈希算法。 一个 ，它生成数字签名的哈希值。

在派生类中重写时，获取数字签名的反格式化程序算法。

数字签名的反格式化程序算法。 一个 ，它表示数字签名的反格式化程序算法。

在派生类中重写时，获取数字签名的格式化程序算法。

数字签名的格式化程序算法。 一个 ，它表示数字签名的格式化程序算法。

在派生类中重写时，获取一个值，指示私钥是否可用。

如果私钥可用，则为 ；否则为 。

初始化 类的新实例。

用指定的模式初始化 类的新实例。

指定在其中应用了受众 URI 限制的模式的枚举值之一。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

初始化 类的新实例。

使用指定的密钥标识符子句类型、二进制数据以及一个指示是否必须克隆二进制数据的值来初始化 类的新实例。

密钥标识符子句类型。 设置 属性的值。 一个 数组，包含表示密钥标识符的二进制数据。 如果要克隆传入 参数的数组，则为 ；否则为 。 为 。 的长度为零。

使用指定的密钥标识符子句类型、二进制数据、一个指示是否必须克隆二进制数据的值、一个 Nonce 和密钥长度来初始化 类的新实例。

密钥标识符子句类型。 设置 属性的值。 一个 数组，包含表示密钥标识符的二进制数据。 设置 方法所返回的二进制数据。 如果要克隆传入 参数的数组，则为 ；否则为 。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。 为 。 的长度为零。

获取表示密钥标识符的二进制数据。

一个 数组，包含表示密钥标识符的二进制数据。

获取表示密钥标识符的二进制数据。

一个 数组，包含表示密钥标识符的二进制数据。

返回一个值，该值指示当前实例的二进制数据是否与指定的二进制数据相匹配。

要进行比较的 数组。 如果 等效于 方法所返回的二进制数据，则为 ；否则为 。

返回一个值，该值指示当前实例的二进制数据是否与指定偏移处的指定二进制数据等效。

要进行比较的 数组。 数组中的索引，从此处开始比较。 如果从 参数中指定的索引处开始，参数中的二进制数据与 方法（从索引零开始）所返回的二进制数据等效，则为 ；否则为 。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 为 类型并且 方法所返回的二进制数据对于 参数和当前实例是相同的，则为 ；否则为 。

新实例初始化 类通过使用指定的数组。

一个数组，表示令牌。 为 。

新实例初始化 类通过使用指定的安全令牌和令牌处理程序。

要序列化的安全令牌。 用于序列化令牌处理程序。 为 。 - 或 - 为 。

新实例初始化 从流的类。

序列化数据。 序列化的上下文。 为 null。

新实例初始化 类通过使用指定的字符串。

一个表示令牌的字符串。 为 。

填充 所需数据来序列化当前 对象。

要填充数据的对象。 此序列化的目标。 可以为 。 为 。

初始化 类的新实例。

将颁发者添加到受信任的颁发者的字典。

ASN.1 编码形式的颁发者的证书指纹。 颁发者的名称。 为 或空。 - 或 - 为 或空。 通过指定的颁发者 已配置。 (颁发者中已存在 字典。)

返回与指定关联的颁发者名称 通过映射到受信任的颁发者字典中的名称的证书指纹。

安全令牌为其请求的颁发者名称。 应该是可赋值为 。 如果该令牌的证书指纹的条目中存在的颁发者名称 字典; 否则为 。 为 。

从配置中加载的受信任的颁发者。

表示配置文件中指定的受信任的颁发者的映射的 XML。 为 。 配置包含无法识别的一个或多个元素。

初始化 类的新实例。

使用指定的上下文初始化 类的新实例。

用于提供一个提示，在需要时将一个空的子句解析为某个特定键。 对于具有而无需签名的 SAML11 和 SAML2 令牌 元素，该属性将包含当前正在处理的断言。

新实例初始化 类根据指定 对象、 密钥大小和加密算法。

包装用于加密会话密钥凭据密钥。 已包装的会话密钥的密钥的大小。 一个 URI，表示加密算法时使用会话密钥。 这应该是对称密钥算法。 为 。

新实例初始化 类根据指定的 X.509 证书。

使用密钥进行加密的证书。

新实例初始化 类根据指定的 X.509 证书，换行算法、 密钥大小和加密算法。

使用密钥进行加密的证书。 一个 URI，表示密钥包装算法。 这应该是非对称算法。 已包装的会话密钥的密钥的大小。 一个 URI，表示加密算法时使用会话密钥。 这应该是对称密钥算法。

使用指定的加密密钥和用于加密密钥的加密算法初始化 类的新实例。

包含加密密钥的 数组。 设置 方法所返回的值。 用于加密密钥的加密算法。 设置 属性的值。 为 。 - 或 - 为 。 的长度为零。

使用指定的加密密钥、用于加密密钥的加密算法和加密密钥的密钥标识符初始化 类的新实例。

包含加密密钥的 数组。 设置 方法所返回的值。 用于加密密钥的加密算法。 设置 属性的值。 一个 ，表示 参数中指定的加密密钥的密钥标识符。 设置 属性的值。 为 。 - 或 - 为 。 的长度为零。

使用指定的加密密钥、用于加密密钥的加密算法、加密密钥的密钥标识符和用户可读名称初始化 类的新实例。

包含加密密钥的 数组。 设置 方法所返回的值。 用于加密密钥的加密算法。 设置 属性的值。 一个 ，表示 参数中指定的加密密钥的密钥标识符。 设置 属性的值。 与 参数中指定的密钥相关联的用户可读名称。 设置 属性的值。 为 。 - 或 - 为 。 的长度为零。

使用指定的加密密钥、用于加密密钥的加密算法、密钥的密钥标识符和用户可读名称初始化 类的新实例。

包含加密密钥的 数组。 设置 方法所返回的值。 用于加密密钥的加密算法。 设置 属性的值。 一个 ，表示 参数中指定的密钥的密钥标识符。 设置 属性的值。 与 参数中指定的密钥相关联的用户可读名称。 设置 属性的值。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。 为 。 - 或 - 为 。 的长度为零。

获取加密密钥。

包含加密密钥的 数组。

返回一个值，该值指示此实例的密钥标识符是否与指定的加密密钥、加密方法和用户可读名称相同。

包含加密密钥的 数组。 用于加密密钥的加密算法。 与加密密钥相关联的用户可读名称。 如果 、 和 参数分别具有 方法以及 和 属性所返回的值，则为 ；否则为 。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 的类型为 ，并且具有与当前实例相同的加密密钥、加密方法和用户可读名称，则为 ；否则为 。 为 。

返回表示当前对象的字符串。

当前对象。

新实例初始化 通过使用指定的加密凭据指定的标记的类。

要加密的令牌。 要使用对令牌进行加密的凭据。

获取一个值，该值指示令牌是否可以创建指定类型的密钥标识符子句。

密钥标识符子句的类型。 如果令牌可以创建密钥标识符子句指定的类型;否则为 。

创建指定类型的令牌的密钥标识符子句。

若要创建的密钥标识符子句的类型。 指定类型的密钥标识符子句。

返回一个值，该值指示此实例的密钥标识符能否解析为指定的密钥标识符。

要与此实例进行比较的密钥标识符子句。 如果指定的密钥标识符子句可以解析的此实例;否则为 。

为指定的密钥标识符子句获取密钥。

若要获取密钥的密钥标识符子句。 键。

初始化 类的新实例。

返回一个值，该值指示当前的 XML 元素是否正指向 可以反序列化到元素 此实例。

XML 读取器的开始元素处。 读取器不应将前移。 如果 XML 读取器定位在 元素，如在部分 3.5.1 (http://www.w3.org/TR/2002/REC-xmlenc-core-20021210); 中的 XML 加密语法和处理规范中定义，否则为 。 为 。

返回一个值，该值指示读取器是否正指向 元素。

读取器定位在安全令牌 ( 元素。) 如果读取器定位在 元素; 否则为 。

获取由当前实例的令牌类型标识符的 Uri。

默认情况下，返回具有单个数组 由于没有与之关联的特定的令牌类型标识符的字符串 类型。

读取 从 XML 流。

XML 读取器定位在 元素，作为 http://www.w3.org/TR/2002/REC-xmlenc-core-20021210 中的定义; 否则为 。 类型的密钥标识符子句 。 为 。 未置于 元素。

读取加密的安全令牌。

从中进行读取的标记读取器。 类型的安全令牌 。 为 。 没有任何配置的服务令牌解析程序。 (或者 属性或 被引用的标记处理程序配置的属性是 。 要获得解密密钥，需要服务令牌解析程序。 - 或 - 通过引用 属性是找不到 ，可以读取已解密的 XML，并返回 。 一个 找不到的内部指向的 XML 读取器。 - 或 - 不是 。 找到的内部配置的服务令牌解析程序为无法解析 XML 。

编写使用 XML 编写器加密的安全令牌。

要向其写入加密的令牌的 XML 编写器。 加密的安全令牌，必须是实例 。 为 。 - 或 - 为 。 不能作为赋值 。 属性为 。 此属性是需要获取密钥进行加密。 - 或 - 返回的令牌处理程序集合 属性找不到 ，可以编写 返回 属性。 属性不能作为分配 。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

初始化 类的新实例。

新实例初始化 用指定的加密密钥、 密钥标识符和加密算法。

一个 ，包含用于加密的加密密钥。 一个 ，指定表示用于加密的密钥的标识符。 一个 URI，表示用于加密的加密算法。 为 。 - 或 - 为 。 - 或 - 为 。

新实例初始化 类通过使用指定的 XML 元素。

XML 元素，表示密钥标识符子句。 设置 属性的值。 为 。

新实例初始化 类通过使用指定的 XML 元素、 nonce 和派生长度。

XML 元素，表示密钥标识符子句。 设置 属性的值。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。 为 。

返回一个值，该值指示指定的密钥标识符子句是否与当前实例相匹配。

要与当前实例进行比较的密钥标识符子句。 如果指定的密钥标识符子句与当前实例相匹配否则为 。

初始化 类的新实例。

一个 ，表示与安全令牌相关联的 XML。 设置 属性。 一个 ，表示安全令牌的证明令牌。 设置 属性。 一个 ，表示此安全令牌有效的最初时刻。 设置 属性。 一个 ，表示此安全令牌有效的最后时刻。 设置 属性。 一个 ，表示安全令牌包含在引用它的 SOAP 消息内时对此安全令牌的引用。 设置 属性。 一个 ，表示安全令牌未包含在引用它的 SOAP 消息内时对此安全令牌的引用。 设置 属性。 一个类型为 的 ，包含此安全令牌的授权策略集。 为 。 - 或 - 为 。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 如果 不为 ，并且与 或 属性值的类型相同，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是 安全令牌的密钥标识符子句。 不为 ，并且与 或 属性值不是同一类型。

返回一个值，该值指示此实例的密钥标识符是否等于指定的密钥标识符。

一个要与此实例进行比较的 。 如果 不为 ，并且与 或 属性值匹配，则为 ；否则为 。

返回当前对象。

当前对象。

使用指定的对称密钥初始化 类的新实例。

包含对称密钥的 数组。 为 。 的长度为零。

使用指定的对称密钥和一个指示是否必须克隆二进制数据的值来初始化 类的新实例。

包含对称密钥的 数组。 如果要克隆传入 参数的数组，则为 ；否则为 。 为 。 的长度为零。

对指定的加密密钥进行解密。

用于对密钥进行加密的加密算法。 包含加密密钥的 数组。 包含解密密钥的 数组。 不支持 。 支持的算法包括 、、 和 。

加密指定的密钥。

用于对密钥进行加密的加密算法。 包含密钥的 数组。 包含加密密钥的 数组。 不支持 。 受支持的算法包括 、、 和 。

使用指定的加密算法和当前密钥的参数生成派生密钥。

一个 URI，表示用于生成派生密钥的加密算法。 一个 数组，它包含加密算法的标签参数。 一个 数组，它包含用于创建派生密钥的 Nonce。 派生密钥的大小。 派生密钥在从此方法返回的字节数组中的位置。 包含派生密钥的 数组。 不支持 。 受支持的算法为 。

获取一种使用指定的加密算法对密码文本进行解密的转换。

一种对密码文本（例如加密的 XML）进行解密的加密算法。 一个 数组，它包含指定算法的初始化向量 ()。 一个表示解密转换的 。 不支持 。 支持的算法包括 、、 和 。

获取一种使用指定的加密算法对 XML 进行加密的转换。

一个对 XML 进行加密的加密算法。 一个 数组，它包含指定算法的初始化向量 ()。 一个表示加密转换的 。 不支持 。 支持的算法包括 、、 和 。

获取指定加密算法所需的初始化向量 () 的大小（以位为单位）。

用于获取初始化向量 () 的大小的加密算法。 参数中指定的加密算法所需的初始化向量 () 的大小（以位为单位）。 不支持 。 支持的算法包括 、、 和 。

获取指定的加密哈希算法的实例。

要获取其实例的加密哈希算法。 一个表示加密哈希算法的 。 不支持 。 受支持的算法为 。

获取指定对称算法的实例。

要获取其实例的对称算法。 一个表示对称算法的 。 不支持 。 受支持的算法包括 、、、、、、 和 。

获取表示对称密钥的字节。

包含对称密钥的 数组。

获取一个值，该值指示指定的算法是否使用非对称密钥。

加密算法。 如果指定的算法使用非对称密钥，则为 ；否则为 。

获取一个值，该值指示此类是否支持指定的算法。

加密算法。 如果此类支持指定的算法，则为 ；否则为 。

获取一个值，该值指示指定的算法是否使用对称密钥。

加密算法。 如果指定的算法使用对称密钥，则为 ；否则为 。

初始化 类的新实例。

当在派生类中重写，则返回指定的安全令牌的颁发者的名称。

要为其返回的颁发者名称的安全令牌。 颁发者名称中。

当在派生类中重写，则返回指定的安全令牌的颁发者的名称。 指定颁发者名称可能会被视为在确定颁发者名称返回。

要为其返回的颁发者名称的安全令牌。 在请求时需要考虑一个颁发者名称。 颁发者名称中。

返回要用于 Windows 声明的默认颁发者名称。

Windows 声明默认颁发者名称。

在派生类中重写，当从 XML 加载自定义配置。

配置 XML 元素。 在列表中的每个节点属于类型 。

初始化 类的新实例。

新实例初始化 通过使用指定的令牌解析程序的类。

安全令牌解析程序要包装的此实例。 集 属性中的新实例。

尝试检索在指定的密钥标识符子句中引用的密钥。 （重写基类方法。）

若要检索的密钥的密钥标识符子句。 此方法返回时，包含指定的密钥标识符子句中引用的密钥。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句检索密钥，则为 ；否则为 。

尝试检索至少指定的密钥标识符中包含的密钥标识符子句之一相匹配的安全令牌。 （重写基类方法。）

要创建的安全令牌的密钥标识符。 当此方法返回时，包含一个 ，它表示指定的密钥标识符。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符; 检索安全令牌否则为 。

当在派生类中重写时，尝试解析与指定的密钥标识符子句相匹配的安全令牌。 （重写基类方法。）

若要创建安全令牌的密钥标识符子句。 当此方法返回时，包含一个 ，它表示指定的密钥标识符子句。 此参数未经初始化即被传递。 如果可以为指定的密钥标识符子句; 中检索安全令牌否则为 。

使用指定的 Kerberos 票证初始化 类的新实例。

包含 Kerberos 票证的 数组。

使用指定的 Kerberos 票证和唯一标识符初始化 类的新实例。

包含 Kerberos 票证的 数组。 安全令牌的唯一标识符。 设置 属性的值。

创建 的新实例。

包含 Kerberos 票证的字节数组。 安全令牌的唯一标识符。 描述值类型的 URI。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符的类型。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符的类型。 一个 ，它是安全令牌的密钥标识符子句。

获取 Kerberos 票证。

包含 Kerberos 票证的 数组。

返回一个值，该值指示此实例的密钥标识符是否与指定的密钥标识符相匹配。

要与此实例进行比较的 。 如果 的类型为 并且 Kerberos 票证匹配，则为 ；否则为 。

使用与指定的服务主体名称关联的服务来初始化 类的新实例。

安全令牌的服务主体名称。 设置 属性。 为 。 无法为当前用户获取 Kerberos 票证。

初始化 类的新实例。

安全令牌的服务主体名称。 设置 属性。 值之一，它指定客户端允许在何种级别上模拟 安全令牌。 一个 ，它指定要为其获取 安全令牌的用户。 安全令牌的唯一标识符。 设置 属性的值。 为 。 - 或 - 为 。 不为 且不等于 ，而 属性为空或 。 无法为指定用户获得 Kerberos 票证。 不是 或 。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是安全令牌的密钥标识符子句。

获取 Kerberos 票证请求。

一个 数组，它包含 Kerberos 票证请求的结果。

返回一个值，该值指示此实例的密钥标识符是否与指定的密钥标识符相匹配。

要与此实例进行比较的 。 如果 的类型为 并且 Kerberos 票证请求的结果匹配，则为 ；否则为 。

初始化 类的新实例。

获取 Ws-security Kerberos 安全令牌的配置文件中定义的 Kerberos 安全令牌类型。

Kerberos 安全令牌类型 URI。 默认情况下，值 属性。

验证指定的 Kerberos 安全令牌。

要验证的安全令牌。 这必须是实例 类。 令牌中包含的标识。 为 。 指定的标记不能作为分配 。

使用 Kerberos 服务票证的指定 SHA-1 哈希值来初始化 类的新实例。

一个 数组，它包含 Kerberos 服务票证的 SHA-1 哈希值。 为 。

使用指定的 Kerberos 票证、Nonce 和密钥长度来初始化 类的新实例。

一个 数组，它包含 Kerberos 服务票证的 SHA-1 哈希值。 一个 数组，包含用于创建派生密钥的 Nonce。 派生密钥的大小。 为 。 的长度为零。

获取 Kerberos 服务票证的 SHA-1 哈希值。

一个 数组，它包含 Kerberos 服务票证的 SHA-1 哈希值。

返回当前对象。

一个表示当前对象的 。

使用指定的标识符和类型数组初始化 类的新实例。

当前 SOAP 消息中 XML 元素的 属性值。 设置 属性的值。 为 。 为空。

使用指定的标识符、Nonce、派生密钥长度和所有者安全令牌类型初始化 类的新实例。

当前 SOAP 消息中 XML 元素的 属性值。 设置 属性的值。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。 一个 ，它是 参数所引用的安全令牌的类型。 设置 属性的值。 为 。 为空。

使用指定的标识符和所有者安全令牌类型初始化 类的新实例。

当前 SOAP 消息中 XML 元素的 属性值。 设置 属性的值。 一个 ，它是 参数所引用的安全令牌的类型。 设置 属性的值。 为 。 为空。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 为 类型并且 和 属性的值与当前实例相匹配，则为 ；否则为 。 有关详细信息，请参见备注。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的引用和类型。

当前 SOAP 消息中 XML 元素的 属性值。 一个 ，它是 参数所引用的安全令牌的类型。 如果 和 参数与 和 属性的值相匹配，则为 ；否则为 。 有关详细信息，请参见备注。

返回表示当前对象的字符串。

一个表示当前对象的 。

从构造函数初始化派生类中调用 类。

设置在 RSTR 根据当前的证明描述符实例的属性的相应属性。

要修改此证明说明符的 RSTR 对象。

使用指定的 RSA 算法初始化 类的新实例。

一个表示 RSA 算法的 。 设置 属性的值。 为 。

使用 RSA 算法创建密钥。

一个 ，它是使用构造函数中所指定的 RSA 算法创建的密钥。

获取 RSA 算法的 参数。

一个 数组，包含 RSA 算法的 参数。

获取 RSA 算法的 参数。

一个 数组，包含 RSA 算法的 参数。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 为 类型并且 和 方法对于 参数返回的数组与当前实例相同，则为 ；否则为 。

返回一个值，该值指示此实例的密钥标识符是否与指定的 RSA 算法相匹配。

一个表示 RSA 算法的 。 如果 参数的 和 字段与当前实例的 和 方法所返回的值相匹配，则为 ；否则为 。

返回表示当前对象的字符串。

一个表示当前对象的 。

将 RSA 算法的 Base64 编码的 参数写入指定的 XML 序列化程序。

一个 ，它用于写入 RSA 算法的 Base64 编码的 参数。 为 。

将 RSA 算法的 Base64 编码的 参数写入指定的 XML 序列化程序。

一个 ，它用于写入 RSA 算法的 Base64 编码的 参数。 为 。

使用指定的 RSA 算法初始化 类的新实例。

一个表示 RSA 算法的 。 为 。

对指定的加密密钥进行解密。

用于对密钥进行加密的加密算法。 支持的算法为 和 。 包含加密密钥的 数组。 包含解密密钥的 数组。 不支持 。 支持的算法为 和 。 为 。

使用指定的算法加密指定的密钥。

用于对密钥进行加密的加密算法。 包含密钥的 数组。 包含加密密钥的 数组。 不支持 。 支持的算法为 和 。 为 。

获取指定的非对称加密算法。

要创建的非对称算法。 如果需要使用私钥来创建算法，则为 ；否则为 。 一个 ，表示指定的非对称加密算法。 为 ，而私钥不可用。

获取用于生成数字签名的哈希值的加密算法。

哈希算法。 支持的算法为 。 一个 ，它生成数字签名的哈希值。 不支持。 支持的算法为 。

获取数字签名的反格式化程序算法。

要获取其实例的数字签名的反格式化程序算法。 支持的算法为 。 一个 ，它表示数字签名的反格式化程序算法。 不支持。 支持的算法为 。

获取数字签名的格式化程序算法。

要获取其实例的数字签名的格式化程序算法。 支持的算法为 。 一个 ，它表示数字签名的格式化程序算法。 不支持。 支持的算法为 。

获取一个值，该值指示私钥是否可用。

如果私钥可用，则为 ；否则为 。

获取一个值，该值指示指定的算法是否使用非对称密钥。

加密算法。 如果指定的算法使用非对称密钥，则为 ；否则为 。

获取一个值，该值指示此类是否支持指定的算法。

加密算法。 如果指定的算法为 、 或 ，则为 ；否则为 。

获取一个值，该值指示指定的算法是否使用对称密钥。

加密算法。 如果指定的算法使用对称密钥，则为 ；否则为 。

使用指定的 RSA 算法初始化 类的新实例。

一个 ，表示能够创建非对称密钥的 RSA 算法。 设置 属性的值。 为 。

使用指定的 RSA 算法和唯一标识符初始化 类的新实例。

一个 ，表示能够创建非对称密钥的 RSA 算法。 设置 属性的值。 安全令牌的唯一标识符。 设置 属性的值。 为 。 - 或 - 为 。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符的类型。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是安全令牌的密钥标识符子句。

允许 在垃圾收集器销毁资源之前将这些资源释放。

返回一个值，该值指示此实例的密钥标识符是否与指定的密钥标识符相匹配。

要与此实例进行比较的 。 如果 为 类型并且密钥匹配，则为 ；否则为 。

初始化 类的新实例。

指示是否可以为读取当前 XML 元素 。

XML 读取器定位在开始元素。 读取器不应将前移。 如果读取器指向 ; 否则为 。 为 。

获取 WS 安全令牌的配置文件中定义的 RSA 安全令牌的类型 (URI)。

RSA 安全令牌类型 URI。

将 RSA 安全令牌从 XML 反序列化。

XML 读取器定位标记的开始元素处。 从 XML 进行反序列化的 RSA 安全令牌。 为 。 未定位在 RSA 令牌。

验证指定的安全令牌。

安全令牌进行验证;必须是实例 类。 令牌中包含的标识。 为 。 不能从分配 。 属性为此处理程序 。

序列化到 XML 的 RSA 安全令牌。

要用来序列化令牌的 XML 编写器。 要序列化的 RSA 安全令牌。 为 。 - 或 - 为 。 不能从分配 。

新实例初始化 与指定的命名空间和操作的类。

要执行的操作。 表示在其中指定操作的名称将被解释的命名空间 URI。 为 。 - 或 - 为 或空字符串。 不是绝对 URI。

初始化 类的新实例。

新实例初始化 类，具有指定的颁发者。

一个 ，它指定 SAML 授权机构进行索赔断言中。 [Saml2Core，2.3.3]。 为 。

如果可用，请将源数据。

用来写入源的数据。 没有源数据

新实例初始化 类以获取指定的 id。

用于定义要创建的子句的 ID。 为 或空字符串。

新实例初始化 指定 ID 的类、 nonce，和密钥大小。

用于定义要创建的子句的 ID。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。 为 或空字符串。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 是与当前实例相同的实例，则为 ；否则为 。

返回一个值，该值指示断言的密钥标识符是否等效于指定的密钥标识符子句。

断言的 ID。 要进行比较的 。 如果 匹配 属性 ; 否则为 。 为 或空字符串。

返回一个字符串，表示当前实例。

当前实例的字符串表示形式。

用指定的名称初始化 类的新实例。

属性名。 为 。

新实例初始化 类具有指定的名称和值。

属性名。 包含属性值的字符串集合。 为 。 - 或 - 为 。

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

属性名。 属性的值。 为 。 - 或 - 为 。

新实例初始化 不具有任何属性的类。

初始化 类的新实例。

类型的集合 ，其中包含此语句中包含的属性元素。 为 。 - 或 - 指定的集合的元素之一 是 。

初始化 类的新实例。

一个 ，表示此语句中包含的单个属性元素。 为 。

新实例初始化 不含任何受众元素的类。

新实例初始化 类具有指定的 Uri。

集合 ，其中包含此限制中包含的受众元素。

初始化 类的新实例。

一个 ，表示包含在此限制的 Audience 元素的内容。

初始化 类的新实例。

新实例初始化 类具有指定的类引用。

身份验证上下文类引用。 不是 并不是绝对 URI。

新实例初始化 类，具有指定的类引用和声明的引用。

身份验证上下文类引用。 身份验证上下文声明参考 不是 并不是绝对 URI。 - 或 - 不是 并不是绝对 URI。

新实例初始化 带有指定的身份验证上下文和当前时间作为即时身份验证的类。

此语句的身份验证上下文。 为 。

新实例初始化 使用指定的身份验证的上下文和身份验证时的类。

此语句的身份验证上下文。 身份验证的时间。 为 。

新实例初始化 类与指定的资源指定决定。

的授权决定应用哪些资源。 设置 属性。 一个 值，该值指示此决定。 设置 属性。 为 。 不是绝对 URI 或一个空的相对 URI。 不是有效的 值。

新实例初始化 类，具有指定的资源上指定的操作的指定决定。

的授权决定应用哪些资源。 设置 属性。 一个 值，该值指示此决定。 设置 属性。 一套 ，它指定要为其授权对资源的操作。 设置 属性。 为 。 不是绝对 URI 或一个空的相对 URI。 不是有效的 值。

初始化 类的新实例。

初始化 类的新实例。

新实例初始化 类，具有指定的断言。

一个 包含的证据。 为 。

新实例初始化 类具有引用断言的 ID。

一个 引用断言。 为 。

新实例初始化 类引用声明的 URI。

一个 ，它引用一个断言。 为 。

新实例初始化 类，具有由系统生成的值。

新实例初始化 类具有指定值。

ID 值中。 不是有效的 NCName。 为 或空字符串。

确定此实例是否等于指定的对象。

具有要与此实例进行比较的对象。 如果对象相等，则否则为 。

返回此实例的哈希代码。

一个包含哈希代码的整数。

返回此实例的字符串表示。

的字符串表示形式。

用指定的名称初始化 类的新实例。

名称标识符中。 为 。

新实例初始化 类具有指定名称，并设置格式的 URI。

名称标识符中。 一个 指定标识符的格式。 为 。 尝试设置 值不是到 并且不是绝对 URI 发生。

初始化 类的新实例。

初始化 类的新实例。

当前正在处理的断言。 设置 属性的值。

使用指定的 SAML 断言初始化 类的新实例。

一个 ，表示此安全令牌的 SAML 断言。

新实例初始化 类使用指定的 SAML 断言、 加密密钥和颁发者令牌。

一个 ，表示此安全令牌的 SAML 断言。 与此安全令牌相关联的密钥集。 此安全令牌的颁发者的令牌。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是 SAML 安全令牌的密钥标识符子句。 的类型不是 。

返回一个值，该值指示此实例的密钥标识符与指定的密钥标识符是否相等。

一个要与此实例进行比较的 。 如果 为 ，并且具有与 属性相同的唯一标识符，则为 ；否则为 。

新实例初始化 类，具有默认安全令牌要求。

新实例初始化 指定的安全令牌要求类。

若要在验证令牌时，此实例使用。 设置 属性。 为 。

将所有与主题关联到属性集合的委托添加。

此委托 对象序列化到 。 类型的集合 。 令牌的描述符。 为 。 - 或 - 为 。

指示当前的 XML 元素是否正指向进行序列化此实例的密钥标识符子句。

XML 读取器的开始元素处。 如果 方法可以读取元素; 否则为 。

指示是否可以处理此实例的类型的令牌作为读取当前 XML 元素。

XML 读取器定位在开始元素。 读取器不应将前移。 如果 方法可以读取元素; 否则为 。

指示指定的密钥标识符子句是否可以序列化此实例。

要序列化的 。 如果可以序列化指定的密钥标识符子句。否则为 。

收集到单个属性具有多个值具有公用声明类型、 声明值类型和原始颁发者的属性。

类型的集合 包含声明从生成的特性。 一套 ，它包含从输入集合中派生的属性。 共享通用声明类型，输入集合中的属性声明值，并与其他属性的原始颁发者都合并到单个属性具有多个输出集合中的值。 输入集合中与其他属性不能共享声明类型、 声明值或原始的颁发者的属性将出现在输出集合中未更改。

创建 断言的对象。

令牌的描述符。 一个 对象。 默认值为 。

创建 声明中的对象。

从中生成 SAML 属性。 令牌的描述符。 一个 ，其中包含转换后的声明。 为 。

创建 从令牌描述符的对象。

对象，其中包含将被转换为 SAML 属性的声明。 令牌的描述符。 一个 ，包含已转换的声明。

创建从指定的身份验证信息的 SAML 2.0 身份验证语句。

对象，其中包含要包装为的状态 对象。 令牌的描述符。 一个 将添加到正在创建的断言或 忽略 对象 （并不创建 SAML 2.0 身份验证语句）。 为 。 - 或 - 属性 是 。 主题的 ( 属性) 包含使用的声明类型的声明 或 ，但不包含至少一个声明的每个类型。 - 或 - 指定的使用者的身份验证方法 无法解析为绝对 URI。

创建基于 SAML 2.0 令牌的声明。

一个 ，它表示从中创建声明的安全令牌。 ，包含从令牌提取的声明。 为 。 属性 是 。 该处理程序未配置或颁发者名称注册表未配置为处理程序。 ( 属性是 ，或者设置为 与 属性都 。 返回配置的颁发者名称注册表中是否有安全令牌的颁发者名称 () 是 或为空。

创建断言的条件。

令牌的生存期。 为其创建该令牌终结点地址。 该地址都建模为 AudienceRestriction 条件。 令牌的描述符。 一个 对象，其中包含断言的条件。

创建一个用于标识断言颁发者的名称标识符。

从其创建的名称标识符令牌的描述符。 一个 ，它表示名称标识符。 为 。

创建 SAML 2.0 断言的主题。

从中创建使用者的安全令牌描述符。 一个 表示断言的主题。 为 。

令牌未附加到消息时，请创建安全令牌引用。

SAML 令牌中。 一个值，该值指示是否应创建一个附加或未附加引用。 一个 ，表示令牌的引用。 (实例 实际返回。) 为 。

创建要包括在断言的 SAML 2.0 语句。

从中创建语句令牌描述符。 枚举 包含的语句。 为 。

创建基于令牌的描述符的安全令牌。

从其创建安全令牌的令牌描述符。 一个 ，它表示 SAML 2.0 安全令牌。 (返回的标记是实际的实例 。) 为 。

创建 对象使用指定用户主体名称 (UPN)。

要用于创建标识的 UPN。 已创建的 Windows 标识。 为 或空字符串。

生成 XML 格式字符串，从代表参与者的 SAML 2.0 属性的集合。

类型的枚举 它包含的特性。 格式正确的 XML 字符串构造使用的特性。

返回 匹配 SAML 身份验证上下文类引用的标准的值的值。

已标准化的值。 一个字符串，包含之一 常量。

如果指定的标记已存在于令牌重放缓存，则将引发异常否则该令牌添加到缓存中。

一个 ，它表示 SAML 2.0 安全令牌 (该令牌的类型应为 ) 进行检查。 为 。 属性为 。 - 或 - 有没有 下配置 属性处理程序配置 (通过访问 属性)。 不能强制转换为的一个实例 。 与令牌相关联的断言的 ID 是 或为空。 ( 令牌的引用属性 具有 属性，引用 与 属性都 或为空。) 中已存在该令牌 。

UPN 声明中指定的值开始查找 对象用于将标识映射到 对象。

包含所需的 UPN 声明的声明标识对象。 一个字符串，包含 UPN 声明找到的值。

获取加密凭据的令牌。 重写此方法以更改加密凭据的令牌。

检索加密凭据的作用域对象从某些作用域。 表示加密凭据的令牌。 为 。 加密令牌描述符从检索到凭据不对称。

获取对断言进行签名的凭据。

令牌的描述符。 一个 表示断言进行签名的凭据。 为 。

返回在令牌重放缓存中应截止持有令牌的时间。

要为其返回的过期时间标记。 一个 ，表示过期时间。 为 。

获取支持此处理程序的令牌类型标识符。

包含令牌的字符串的数组类型支持此处理程序的标识符。

从 XML 加载自定义配置。

，它指定 SAML 令牌身份验证要求。 为 。 中指定的配置 无效。

返回已标准化的值匹配的 SAML 身份验证上下文类引用。

其中一个 常量。 一个字符串，包含已标准化的值。

从 SAML 2.0 属性语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。 - 或 - 为 。

从 SAML 2.0 身份验证语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。 - 或 - 为 。

从 SAML 2.0 授权决策语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。

从 SAML 2.0 主题创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。 - 或 - 为 。

从一组 SAML 2.0 语句创建声明并将它们添加到指定的主题。

一套 从其声明的创建。 声明被添加到的主题。 颁发者。 为 。

读取 < saml:Action > 元素。

位于要读取的元素。 一个 ，表示所读取的操作元素。 为 。

读取 < saml:Advice > 元素。

位于要读取的元素。 一个 ，表示所读取的建议元素。 为 。

读取 < saml:Assertion > 元素。

位于要读取的元素。 一个 表示读取了 Assertion 元素。 为 。

读取 < saml:Attribute > 元素。

位于要读取的元素。 一个 表示读取了 Assertion 元素。 为 。

读取了 < saml:AttributeStatement > 元素或指定的 saml:AttributeStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取属性值。

位于要读取的元素。 所读取的属性。 一个字符串，包含的属性值。 为 。

读取 < saml:AudienceRestriction > 元素或指定的 saml:AudienceRestrictionType xsi: type 的 < saml:Condition > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取 < saml:AuthnContext > 元素。

位于要读取的元素。 一个 ，它表示读取 AuthnContext 元素。 为 。

读取 < saml:AuthnStatement > 元素或指定的 saml:AuthnStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取 < saml:AuthzDecisionStatement > 元素或指定的 saml:AuthzDecisionStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取 < saml:Conditions > 元素。

位于要读取的元素。 一个 ，它表示读取条件元素。 为 。 未定位在 Conditions 元素。

读取 < saml:EncryptedId > 元素。

指向 EncryptedId 元素。 一个 ，表示所读取 EncryptedId 元素。 为 。 未置于 EncryptedID 元素。

读取 < saml:Evidence > 元素。

位于要读取的元素。 一个 ，它表示读取证据元素。 为 。

读取 < saml:Issuer > 元素。

位于要读取的元素。 一个 ，表示所读取的颁发者元素。 为 。

读取 SecurityKeyIdentifierClause。

用来读取。 一个 ，表示安全密钥标识符子句。 为 。

读取 < saml:NameID > 元素。

位于 NameID 元素。 一个 表示已读取的 NameID 元素。 为 。

这两个 < 颁发者 > 和 < NameID > NameIDType 的。 此方法读取任一这些元素的内容。

定位在 NameID 类型。 一个 从 XML 构造。 为 。

读取了 < saml:ProxyRestriction > 元素或指定的 saml:ProxyRestrictionType xsi: type 的 < saml:Condition > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

反序列化签名 KeyInfo 的 SAML。

可以位于 ds:KeyInfo 元素 XmlReader。 具有签名检查断言。 ，表示的键要用来检查签名。 为 。

读取 < saml:Statement > 元素。

位于要读取的元素。 一个 表示已读取的语句元素。 为 。

读取 < saml:Subject > 元素。

位于要读取的元素。 一个 ，表示已读取的主题元素。 为 。

读取 < SubjectConfirmation > 元素。

位于要读取的元素。 一个 ，表示所读取 SubjectConfirmation 元素。 为 。

读取 < saml:SubjectConfirmationData > 元素。

位于要读取的元素。 一个 ，表示所读取 SubjectConfirmationData 元素。 为 。

此方法可处理 < 主体 > 中使用的构造和 < SubjectConfirmation > 元素的 id。

定位在使用者 ID XML。 父元素中包含此使用者 id。 一个 从 XML 构造。 为 。

反序列化 SAML 主题 < ds:KeyInfo > 元素。

位于 < ds:KeyInfo > 元素。 一个 表示 < ds:KeyInfo > 元素的内容。 为 。

读取 < saml:SubjectLocality > 元素。

位于要读取的元素。 一个 ，表示所读取 SubjectLocality 元素。 为 。

从指定的流中读取 SAML 2.0 令牌。

一个 流式传送到 SAML 2.0 安全令牌。 的一个实例。 属性为 。 - 或 - 属性所指定的配置 属性是 。 - 或 - 属性所指定的配置 属性是 。

解析到的签名密钥标识符 。

要为其颁发者令牌进行解析。 当前 与此处理程序相关联。 一个 表示解析的令牌。 为 。 该处理程序无法解析令牌。

解析集合的 中引用 。

要处理的 。 解析使用 对象。 类型的集合 ，包含的键。 为 。 该处理程序无法解析的密钥。

当一种特殊类型的调用此方法，获取 检测到。 中包装传递 ，其中包含属性值的集合 (在 属性)，其中每个将会映射到一个声明。 在将返回的所有声明 与指定的颁发者。

要使用的 。 此令牌的主题。 声明颁发者。 不包含任何有效的属性的值。

将签名的密钥标识符解析为 SecurityToken。

要为其颁发者令牌进行解析。 当前 与此处理程序相关联。 此方法返回时，如果令牌已成功解析包含解析的安全令牌。 如果该令牌将被解析。

验证指定 对象。

要验证的 SAML 2.0 条件。 若要检查的受众限制条件。

验证指定 对象。

SAML 2.0 主题确认数据。

验证令牌数据并返回其声明。

要验证的 SAML 2.0 令牌。 在令牌中包含的标识。

写入 < saml:Action > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Advice > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将指定的 SAML 断言指定的 XML 编写器序列化。

用于序列化。 一个 ，它表示要序列化的断言。 为 。 - 或 - 为 。 指定的断言 同时具有 和 属性设置为 。 - 或 - 有没有语句和由指定的断言中没有主题 。 (同时 属性和 属性 。) 如果断言不包含语句，它必须包含一个使用者。 - 或 - 指定的断言 包含的身份验证 （attribute) 或授权决策语句和无主题 — 这些语句需要一个使用者。 ( 属性包含的声明类型的 , ，, ，或 和 属性是 )。 令牌加密凭据没有指定的对称密钥。

写入 < saml:Attribute > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AttributeStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 saml:Attribute 值。

用其进行写。 一个字符串，包含要写入的属性值。 一个 ，表示正在写入其值的特性。 为 。

写入 < saml:AudienceRestriction > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AuthnContext > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AuthnStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AuthzDecisionStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Conditions > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Evidence > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Issuer > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将序列化为 到指定的 XML 编写器。

要序列化密钥标识符子句。 一个 ，表示要进行序列化密钥标识符子句。 为 。 - 或 - 为 。

写入 < saml:NameID > 元素。

用来序列化 。 要序列化的 。 为 。 - 或 - 为 。 Saml2NameIdentifier 加密凭据必须具有指定的对称密钥。

这两个 < 颁发者 > 和 < NameID > NameIDType 的。 此方法将任一这些元素的内容。

与其 NameID 类型进行序列化。 要写入的 。 为 。 - 或 - 为 。

写入 < saml:ProxyRestriction > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入使用指定的 XML 编写器签名 < ds:KeyInfo > 元素。

用来序列化密钥标识符。 ，它表示要编写的密钥标识符。 为 。 - 或 - 为 。 该处理程序无法将指定的密钥标识符序列化为 。

写入 Saml2Statement。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Subject > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:SubjectConfirmation > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:SubjectConfirmationData > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将序列化为指定的 XML 编写器的主题 < ds:KeyInfo > 元素。

用来序列化密钥标识符。 ，它表示要编写的密钥标识符。 为 。 - 或 - 为 。

写入 < saml:SubjectLocality > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将写入指定的 XML 编写器的 Saml2 令牌。

用来写入数据。 要写入的标记。 为 。 - 或 - 为 。 不是 对象。

从构造函数初始化派生类中调用 类。

初始化 类的新实例。

新实例初始化 类与指定 对象。

一个 ，它表示名称标识符。

新实例初始化 类与指定 对象。

一个 ，它包含确认信息。 为 。

新实例初始化 类指定的 confirmation 方法。

，该值指示 confirmation 方法。 为 。 不是绝对 URI。

新实例初始化 带有指定的 confirmation 方法和额外的确认信息的信息的类。

，该值指示 confirmation 方法。 ，其中包含进一步确认信息。 为 。 不是绝对 URI。

初始化 类的新实例。

初始化 类的新实例。

新实例初始化 从地址和 DNS 名称的类。

一个字符串，包含的地址。 一个字符串，包含的 DNS 名称。

初始化 类的新实例。

使用指定的操作初始化 类的新实例。

安全令牌的主题试图对指定资源执行的操作。 为 。 - 或 - 为 。

使用指定的操作初始化 类的新实例。

安全令牌的主题试图对指定资源执行的操作。 在其中定义 参数的 XML 命名空间。 为 。 - 或 - 为 。

将此实例设置为只读的。

使用指定的 XML 读取器读取 元素。

一个 读取 XML 元素。 一个 ，它能够读取 SAML 断言中已在 SAML 规范内定义的 XML 元素。 一个 ，它能够读取 子句。 一个 ，它确定为 XML 元素所引用的 SAML 断言创建数字签名的安全令牌。 为 。 - 或 - 为 。

将 作为 元素写入指定的 XML 编写器。

一个用于写入 元素的 。 一个 ，它能够写入 SAML 规范中定义的 元素及其子元素和属性。 一个 ，它能够写入 子句。 为 。 - 或 - 为 。

初始化 类的新实例。

使用指定的 SAML 断言集合初始化 类的新实例。

一个类型为 的 ，包含提供 SAML 断言附加信息的 SAML 断言。 包含一个 元素。

初始化 类的新实例。

一个类型为 的 ，包含对提供 SAML 断言附加信息的 SAML 断言的引用集合。 包含一个 元素。

使用指定的 SAML 断言集合和 SAML 断言引用集合初始化 类的新实例。

一个类型为 的 ，包含对提供 SAML 断言附加信息的 SAML 断言的引用集合。 一个类型为 的 ，包含提供 SAML 断言附加信息的 SAML 断言。 包含一个 元素。 - 或 - 包含一个 元素。

将此实例设置为只读的。

使用指定的 XML 读取器读取 XML 元素。

一个用于读取 XML 元素的 。 一个 ，它能够读取 SAML 断言中已在 SAML 规范内定义的 XML 元素。 一个 ，它能够读取 子句。 一个 ，它确定为包含此 XML 元素的 SAML 断言创建数字签名的安全令牌。 为 - 或 - 为 元素不符合 元素的 XML 架构。

将此 作为一个 元素写入指定的 XML 编写器。

一个用于写入 元素的 。 一个 ，它能够写入 SAML 规范中定义的 元素及其子元素和属性。 一个 ，它能够写入 子句。 为 - 或 - 为

初始化 类的新实例。

使用指定的 SAML 断言标识符、断言颁发者、断言的颁发日期和时间、一组处理条件、附加信息和一个 SAML 语句集合来初始化 类的新实例。

断言的标识符。 颁发此 SAML 断言的 SAML 授权机构。 一个 ，它指定 SAML 断言的颁发时间。 一个 ，它指定在评估 SAML 断言的有效性时可能考虑的一组条件。 一个 ，它指定由 SAML 授权机构提供的、有助于处理 SAML 断言的附加信息。 一个包含 SAML 语句的、类型为 的 。 为 - 或 - 为 - 或 - 不是以字母或“_”字符开头。 - 或 - 为 - 或 - 为 - 或 - 为 - 或 - 不包含任何元素 - 或 - 包含一个 元素

将此实例设置为只读的。

从 XML 读取器读取 SAML 断言的数字签名。

一个用来读取数字签名的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 ，它能够读取 SAML 规范中定义的 XML 元素。 为 - 或 - 为 - 或 - 尚未从 SAML 断言中读取数字签名。

从指定的 XML 读取器读取 SAML 断言。

一个 ，它用来读取 SAML 断言。 一个 ，它能够读取 SAML 断言中已在 SAML 规范内定义的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 先前已经调用过 方法且 SAML 断言已进行数字签名。 不引用遵循 SAML 1.1 规范的 SAML 断言。

如果可用，请将源数据。

与要将源数据写入 XML 编写器。 没有源数据

将 SAML 断言作为 元素写入指定的 XML 编写器。

一个 ，它用于写入 SAML 断言。 一个 ，它能够将 中的对象写为 XML。 一个 ，它能够写入 子句。 为 - 或 - 为 的配置方式使得在将它序列化为 XML 时，将导致不符合 SAML v1.1 规范。

使用指定的 SAML 断言标识符来初始化 类的新实例。

包含密钥标识符的 的标识符 为 。

使用指定的 SAML 断言标识符、Nonce 和密钥长度来初始化 类的新实例。

包含密钥标识符的 的标识符。 一个 数组，包含用于创建派生密钥的 Nonce。 派生密钥的大小。 为 。

确定指定的密钥标识符是否与当前实例相同。

要进行比较的 。 如果指定的密钥标识符与当前实例相同，则为 ；否则为 。

确定指定的 SAML 断言标识符是否与当前实例相同。

要进行比较的 SAML 断言标识符。 如果 与当前实例的 属性具有相同值，则为 ；否则为 。

返回一个 ，它包含表示当前密钥标识符子句的 SAML 断言标识符。

一个 ，它包含表示当前 实例的 SAML 断言标识符。

初始化 类的新实例。

使用指定的声明初始化 类的新实例。

一个 ，它表示 安全令牌的主题的属性。 为 。 的 属性的类型不是 。 - 或 - 的 属性不是 。 - 或 - 的 属性不含有“/”字符，或者它位于第一个或最后一个索引位置。

使用指定的属性名称、XML 命名空间和属性值来初始化 类的新实例。

在其中定义 参数的 XML 命名空间。 SAML 属性的名称。 一个 ，它包含 SAML 属性的值。 为 。 - 或 - 为 。 - 或 - 为 。 的 属性的类型不是 。 - 或 - 的 属性不是 。 - 或 - 的 属性不含有“/”字符，或者它位于第一个或最后一个索引位置。

获取该 SAML 属性表示的声明的集合。

一个类型为 的 ，它包含该 SAML 属性表示的声明集。

将此实例设置为只读的。

从指定的 XML 读取器读取 SAML 属性。

一个用于读取 SAML 属性的 。 一个 ，它能够读取 SAML 规范中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 。 - 或 - 为 。 引用不具有 和 属性的 XML 元素。

将 SAML 属性写入指定的 XML 序列化程序。

一个用于写入 SAML 属性的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 。 - 或 - 为 。

初始化 类的新实例。

使用指定的主题以及与该主题关联的属性集来初始化 类的新实例。

一个 ，它指定声明的主题。 一个类型为 的 ，它包含一组与主题关联的属性。 为 。 包含一个为 的成员。 - 或 - 不包含成员。

将指定的声明集作为属性添加到此 SAML 语句中。

一个类型为 的 ，它包含要添加到 SAML 语句中的声明集。

将此实例设置为只读的。

从指定的 XML 读取器读取 SAML 属性语句。

用于读取 SAML 属性语句的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 属性语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 引用不包含 元素的 XML 元素。 - 或 - 引用一个 XML 元素，该元素包含的 元素不具有属性值。

将 SAML 属性语句写入指定的 XML 序列化程序。

一个用于写 SAML 属性语句的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 - 或 - 为

初始化 类的新实例。

使用 SAML 断言的指定目标受众集初始化 类的新实例。

一个 类型的 ，包含一个目标受众集。 为 。

将此实例设置为只读的。

从指定的 XML 读取器读取 元素。

一个用于读取 元素的 。 一个 ，它能够读取 SAML 断言中已在 SAML 规范内定义的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 。 - 或 - 为 。 元素具有一个没有值的子 元素。

将 元素写入指定的 XML 序列化程序。

一个用于写入 元素的 。 一个 ，它能够在 SAML 规范中定义的 SAML 断言中写入 XML 元素。 一个 ，它能够写入 子句。 为 。 - 或 - 为 。

使用指定的时刻、身份验证方法、DNS 域名以及 IP 地址初始化 类的新实例。

一个 ，它指定对主题进行身份验证的时刻。 一个 URI 引用，它指定如何对主题进行身份验证。 对主题进行身份验证的计算机所在的 DNS 域名。 对主题进行身份验证的计算机的 IP 地址。

使用指定的时刻、身份验证方法、DNS 域名、IP 地址以及对附加信息的引用来初始化 类的新实例。

一个 ，它指定对主题进行身份验证的时刻。 一个 URI 引用，它指定如何对主题进行身份验证。 对主题进行身份验证的计算机所在的 DNS 域名。 对主题进行身份验证的计算机的 IP 地址。 一个类型为 的 ，它包含关于主题的附加信息。 包含一个为 的成员。

使用指定的时刻、身份验证方法、DNS 域名、IP 地址以及对附加信息的引用来初始化 类的新实例。

一个 ，它指定对主题进行身份验证的时刻。 一个 URI 引用，它指定如何对主题进行身份验证。 对主题进行身份验证的计算机所在的 DNS 域名。 对主题进行身份验证的计算机的 IP 地址。 一个类型为 的 ，它包含关于主题的附加信息。 包含一个为 的成员。

返回一个值，该值指示该实例是否与指定的对象相等。

要与此实例进行比较的对象。 如果 为 且拥有与此实例相等的值，则为 ；否则为 。

返回 的哈希代码。

的哈希代码。

初始化 类的新实例。

使用指定的身份验证详细信息初始化 类的新实例。

一个表示声明主题的 。 一个 URI 引用，它指定如何对主题进行身份验证。 一个 ，它指定对主题进行身份验证的时刻。 对主题进行身份验证的计算机所在的 DNS 域名。 对主题进行身份验证的计算机的 IP 地址。 一个类型为 的 ，它包含关于主题的附加信息。 包含一个为 的成员。

根据此实例的属性将声明添加到指定的声明集合。

一个类型为 的 ，包含添加操作的目标声明集。 为 。

将此实例设置为只读的。

从指定的 XML 读取器读取 SAML 身份验证语句。

读取 SAML 身份验证语句的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 身份验证语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 引用不包含 和 属性的 XML 元素。 - 或 - 引用不包含 子元素的 XML 元素。

将 SAML 身份验证语句写入指定的 XML 序列化程序。

用于写入 SAML 身份验证语句的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 - 或 - 为 。

初始化 类的新实例。

使用指定的查询类型、协议绑定和 SAML 授权机构位置初始化 类的新实例。

一个 ，表示具有主题附加信息的 SAML 授权机构所响应的查询类型。 一个 URI 引用，标识与具有主题附加信息的 SAML 授权机构通信时所使用的 SAML 协议绑定。 一个 URI 引用，描述如何找到并与具有主题附加信息的 SAML 授权机构进行通信。

将此实例设置为只读的。

从指定的 XML 读取器读取 元素。

一个用于读取 元素的 。 一个 ，它能够读取 SAML 断言中已在 SAML 规范内定义的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 不引用 SAML 断言。 元素不具有 、 或 属性。

将 元素写入指定的 XML 序列化程序。

一个用于写入 元素的 。 一个 ，它能够在 SAML 规范中定义的 SAML 断言中写入 XML 元素。 一个 ，它能够写入 子句。 为 - 或 - 为

使用该主题正试图访问的指定资源、与该资源有关的授权决定、试图对该资源执行的操作以及在其中定义该操作的 XML 命名空间来初始化 类的新实例。

该主题正试图访问的资源。 由 SAML 授权机构做出的、与该主题访问资源有关的授权决定。 XML 命名空间，在其中定义了 参数中指定的操作。 该主题试图对 参数中指定的资源执行的操作。 为 。 - 或 - 为 。

返回一个值，该值指示该实例是否与指定的对象相等。

要与此实例进行比较的对象。 如果 为 且拥有与此实例相等的值，则为 ；否则为 。

返回 的哈希代码。

的哈希代码。

初始化 类的新实例。

初始化 类的新实例。 。

一个表示声明主题的 。 设置 属性。 一个 URI 引用，它标识要试图访问的资源。 设置 属性。 一个 ，它指定由 SAML 授权机构做出的、与主题访问指定资源有关的授权决定。 设置 属性。 一个类型为 的 ，它指定该主题有权对资源执行的操作集。 设置 属性。 为 。 - 或 - 包含一个为 的成员。 - 或 - 为 。 包含一个为 的成员。 - 或 - 为 或空。

初始化 类的新实例。 。

一个表示声明主题的 。 设置 属性。 一个 URI 引用，它标识要试图访问的资源。 设置 属性。 一个 ，它指定由 SAML 授权机构做出的、与主题访问指定资源有关的授权决定。 设置 属性。 一个类型为 的 ，它指定该主题有权对资源执行的操作集。 设置 属性。 一个 ，它包含 SAML 授权机构在做出授权决定时所依赖的一组 SAML 断言。 设置 属性。

将基于此实例的属性的声明添加指定的声明集合。

一个类型为 的 ，包含添加操作的目标声明集。 为 。

将此实例设置为只读的。

从指定的 XML 读取器读取 SAML 授权语句。

一个用于读取 SAML 授权语句的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 授权语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 。 - 或 - 为 。 引用不包含 和 属性的 XML 元素。 - 或 - 引用不具有 、 和 子元素的 XML 元素。

将 SAML 授权语句写入指定的 XML 序列化程序。

一个用于写 SAML 授权语句的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 。 - 或 - 为 。

初始化 类的新实例。

在派生类中重写时，使此实例为只读。

在派生类中重写时，从指定的 XML 读取器读取条件。

一个用来读取条件的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 授权语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。

在派生类中重写时，将条件写入指定的 XML 序列化程序。

一个用于写入条件的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。

初始化 类的新实例。

使用 SAML 断言有效的指定时间范围来初始化 类的新实例。

一个 ，指定 SAML 断言有效的最初时刻。 设置 属性。 一个 ，指定 SAML 断言过期的时刻。 设置 属性。

使用 SAML 断言有效的指定时间范围和条件来初始化 类的新实例。

一个 ，指定 SAML 断言有效的最初时刻。 设置 属性。 一个 ，指定 SAML 断言过期的时刻。 设置 属性。 一个类型为 的 ，它指定条件集，即在评估断言有效性时必须考虑的 SAML 断言的某个接收方。 设置 属性。 包含一个为 的成员。

将此实例设置为只读的。

从指定的 XML 读取器读取 元素。

读取 元素的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 授权语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 。

将 元素写入指定的 XML 序列化程序。

一个用于写入 元素的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 - 或 - 为 。

初始化 类的新实例。

将此实例设置为只读的。

从指定的 XML 读取器读取 元素。

用于读取 的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 授权语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 - 或 - 为 不指向 元素。

将 元素写入指定的 XML 序列化程序。

一个用于写入 元素的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 - 或 - 为

初始化 类的新实例。

使用指定的 SAML 断言集初始化 类的新实例。

一个类型为 的 ，它包含 SAML 授权机构呈现授权决定时所依赖的证据。 设置 属性。 包含一个为 的成员。

使用指定的 SAML 断言引用集初始化 类的新实例。

一个类型为 的 ，它包含一个 SAML 断言的标识符，该断言指定 SAML 授权机构呈现授权决定时所依赖的证据。 设置 属性。 包含一个为 或空的成员。

使用一组指定的 SAML 断言引用和 SAML 断言初始化 类的新实例。

一个类型为 的 ，它包含一个 SAML 断言的标识符，该断言指定 SAML 授权机构呈现授权决定时所依赖的证据。 设置 属性。 一个类型为 的 ，它包含 SAML 授权机构呈现授权决定时所依赖的证据。 设置 属性。 包含一个为 或空的成员。 - 或 - 包含一个为 的成员。 - 或 - 和 均为 。

将此实例设置为只读的。

从指定的 XML 读取器读取证据。

用于读取证据的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 授权语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 。 - 或 - 为 。 引用未包含至少一个 或 子元素的 XML 元素。

将证据写入指定的 XML 序列化程序。

用于写入证据的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。 为 。 - 或 - 为 。

使用指定的名称、该名称所在的域以及该名称的格式初始化 类的新实例。

主题名称。 设置 属性。 参数所在的域。 设置 属性。 一个 URI 引用，表示 参数所使用的格式。 设置 属性。 为 或 。

返回一个值，该值指示该实例是否与指定的对象相等。

要与此实例进行比较的对象。 如果 为 且拥有与此实例相等的值，则为 ；否则为 。

返回 的哈希代码。

的哈希代码。

初始化 类的新实例。

当前正在处理的断言。 设置 属性的值。

初始化 类的新实例。

使用指定的 SAML 断言初始化 类的新实例。

一个 ，表示此安全令牌的 SAML 断言。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是 SAML 安全令牌的密钥标识符子句。 的类型不是 。

使用指定的 SAML 断言初始化 类的属性。

一个 ，表示此安全令牌的 SAML 断言。 为 。

返回一个值，该值指示此实例的密钥标识符与指定的密钥标识符是否相等。

一个要与此实例进行比较的 。 如果 为 ，并且具有与 属性相同的唯一标识符，则为 ；否则为 。

新实例初始化 类，具有默认安全令牌要求。

新实例初始化 指定的安全令牌要求类。

若要在验证令牌时，此实例使用。 设置 属性。 为 。

将所有与 ActAs 主题关联到属性集合的委托添加。

此委托 对象序列化到 。 通过指定委托 属性。 ActAs 令牌将被序列化到的特性集合。 令牌的描述符。 为 。 - 或 - 为 。

指示是否可以处理此实例的类型的令牌作为读取当前 XML 元素。

XML 读取器定位在开始元素。 读取器不应将前移。 如果 方法可以读取元素; 否则为 。

收集到单个属性具有多个值具有公用声明类型、 声明值类型和原始颁发者的属性。

类型的集合 包含声明从生成的特性。 一套 ，它包含从输入集合中派生的属性。 共享通用声明类型，输入集合中的属性声明值，并与其他属性的原始颁发者都合并到单个属性具有多个输出集合中的值。 输入集合中与其他属性不能共享声明类型、 声明值或原始的颁发者的属性将出现在输出集合中未更改。

当在派生类中重写创建 断言的对象。

令牌的描述符。 一个 对象。 默认值为 。

创建 通过使用指定的颁发者、 条件、 建议和语句对象。 您可以重写此方法以自定义用于创建该断言的参数。

断言的颁发者。 将添加到该断言。 将添加到该断言。 集合 将添加到该断言。 创建 SAML 断言。

创建 声明中的对象。

从中生成 SAML 属性。 令牌的描述符。 一个 ，其中包含转换后的声明。 为 。

创建 从令牌描述符的对象。

用于 ，它创建。 对象，其中包含将被转换为 SAML 属性的声明。 令牌的描述符。 一个 ，包含已转换的声明。

从指定的身份验证信息创建 SAML 1.1 验证语句。

在 SamlSubject 的语句。 从中生成 SAML 身份验证语句。 包含使用在令牌颁发的所有其他信息。 已创建的 SAML 身份验证语句。 为 。 - 或 - 为 。

创建从 SAML 1.1 令牌的声明。

一个 ，它表示从中创建声明的安全令牌。 一个 ，包含从令牌提取的声明。 为 。 属性 是 。 该处理程序未配置或颁发者名称注册表未配置为处理程序。 ( 属性是 ，或者设置为 与 属性都 。 返回配置的颁发者名称注册表中是否有安全令牌的颁发者名称 () 是 或为空。

创建断言的条件。

令牌的生存期。 为其创建该令牌终结点地址。 该地址都建模为 AudienceRestriction 条件。 令牌的描述符。 一个 对象，其中包含断言的条件。

创建 SAML 1.1 断言的主题。

从中创建使用者的安全令牌描述符。 一个 表示断言的主题。 为 。

令牌未附加到消息时，请创建安全令牌引用。

SAML 令牌中。 一个值，该值指示是否应创建一个附加或未附加引用。 一个 ，表示令牌的引用。 (实例 实际返回。) 为 。

创建要包括在断言的 SAML 1.1 语句。

从中创建语句令牌描述符。 枚举 包含的语句。 为 。

创建基于令牌的描述符的安全令牌。

从其创建安全令牌的令牌描述符。 一个 ，它表示 SAML 1.1 安全令牌。 (返回的标记是实际的实例 。) 为 。

创建 对象使用指定用户主体名称 (UPN)。

要用于创建标识的 UPN。 已创建的 Windows 标识。 为 或空字符串。

生成 XML 格式字符串，从代表参与者的 SAML 1.1 特性的集合。

类型的枚举 它包含的特性。 格式正确的 XML 字符串构造使用的特性。

返回与匹配的 SAML 身份验证方法为指定的规范化的值的 SAML11 身份验证方法标识符。

已标准化的值。 值之一。 SAML11 身份验证方法标识符 (URI) 指定的规范化的标识符相匹配。 如果不找到任何匹配的 SAML11 身份验证方法，则 URI 将返回未更改。

如果指定的标记已存在于令牌重放缓存，则将引发异常否则该令牌添加到缓存中。

一个 ，它表示 SAML 1.1 安全令牌 (该令牌的类型应为 ) 进行检查。 为 。 属性为 。 - 或 - 属性处理程序配置 (通过访问 属性) 是 。 不能强制转换为的一个实例 。 与令牌相关联的断言的 ID 是 或为空。 ( 令牌的引用属性 具有 属性，引用 与 属性都 或为空。) 中已存在该令牌 。

UPN 声明中指定的值开始查找 对象用于将标识映射到 对象。

包含所需的 UPN 声明的声明标识对象。 一个字符串，包含 UPN 声明找到的值。

获取加密凭据的令牌。 重写此方法以更改加密凭据的令牌。

检索加密凭据的作用域对象从某些作用域。 表示加密凭据的令牌。 为 。 加密令牌描述符从检索到凭据不对称。

获取对断言进行签名的凭据。

令牌的描述符。 一个 表示断言进行签名的凭据。 为 。

返回在令牌重放缓存中应截止持有令牌的时间。

要为其返回的过期时间标记。 一个 ，表示过期时间。 为 。

获取支持此处理程序的令牌类型标识符。

包含令牌的字符串的数组类型支持此处理程序的标识符。

从 XML 加载自定义配置。

，它指定 SAML 令牌身份验证要求。 为 。 中指定的配置 无效。

返回与 SAML 1.1 身份验证方法标识符相匹配的规范化的值。

SAML 1.1 身份验证方法标识符 (URI) 进行规范化。 已标准化的值，这是其中之一的 值。 如果没有匹配值存在， 返回，不变。

从 SAML 1.1 属性语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。 - 或 - 为 。

从 SAML 1.1 验证语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。 - 或 - 为 。

从 SAML 1.1 授权决策语句创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。

从 SAML 1.1 主题创建声明并将它们添加到指定的主题。

从其声明的创建。 声明被添加到的主题。 颁发者。 为 。

从一组 SAML 1.1 语句创建声明并将它们添加到指定的主题。

从中创建声明的 SAML 语句。 声明被添加到的主题。 颁发者。 为 。

读取 < saml:Action > 元素。

位于要读取的元素。 一个 ，表示所读取的操作元素。 为 。

读取 < saml:Advice > 元素。

位于要读取的元素。 一个 ，表示所读取的建议元素。 为 。

读取 < saml:Assertion > 元素。

位于要读取的元素。 一个 表示读取了 Assertion 元素。 为 。

读取 < saml:Attribute > 元素。

位于要读取的元素。 一个 表示读取了 Assertion 元素。 为 。

读取了 < saml:AttributeStatement > 元素或指定的 saml:AttributeStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取属性值。

位于要读取的元素。 所读取的属性。 一个字符串，包含的属性值。 为 。

从指定的 XML 读取器读取 < saml:AudienceRestrictionCondition > 元素。

XML 读取器位于 < saml:AudienceRestrictionCondition > 元素来读取。 一个 ，表示所读取的元素。 为 。

读取 < saml:AuthnStatement > 元素或指定的 saml:AuthnStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

读取 < saml:AuthorityBinding > 元素。

XML 读取器位于 < saml:AuthorityBinding > 元素 读取的 。 为 。 未置于 saml:AuthorityBinding 元素或包含一个无法识别的子元素或不是有效的子元素。

读取 < saml:AuthzDecisionStatement > 元素或指定的 saml:AuthzDecisionStatementType xsi: type 的 < saml:Statement > 元素。

位于要读取的元素。 一个 ，表示所读取的元素。 为 。

从指定的读取器读取 saml:AudienceRestrictionCondition 或 saml:DoNotCacheCondition

从其中读取元素读取器。 从 XML 中读取。 为 。 将位于未知元素。

读取 < saml:Conditions > 元素。

位于要读取的元素。 一个 ，它表示读取条件元素。 为 。 未定位在 Conditions 元素。

从指定的 XML 读取器读取 saml:DoNotCacheCondition 元素。

XML 读取器定位在 saml:DoNotCacheCondition 元素 读取的 。 为 。 未置于 saml:DoNotCacheCondition 元素。

读取 < saml:Evidence > 元素。

位于要读取的元素。 一个 ，它表示读取证据元素。 为 。

反序列化签名 KeyInfo 的 SAML。

可以位于 ds:KeyInfo 元素 XmlReader。 具有签名检查断言。 ，表示的键要用来检查签名。 为 。

读取 < saml:Statement > 元素。

位于要读取的元素。 一个 表示已读取的语句元素。 为 。

读取 < saml:Subject > 元素。

位于要读取的元素。 一个 ，表示已读取的主题元素。 为 。

反序列化 SAML 主题 < ds:KeyInfo > 元素。

位于 < ds:KeyInfo > 元素。 一个 表示 < ds:KeyInfo > 元素的内容。 为 。

从指定的流中读取 SAML 1.1 令牌。

一个 流式传送到 SAML 1.1 安全令牌。 的一个实例。 属性为 。 - 或 - 属性所指定的配置 属性是 。 - 或 - 属性所指定的配置 属性是 。

解析到的签名密钥标识符 。

要为其颁发者令牌进行解析。 当前 与此处理程序相关联。 一个 表示解析的令牌。 为 。 该处理程序无法解析令牌。

解析 saml:Subject 元素中指定。

要将解析为密钥的密钥标识符。 从密钥标识符解析键。

当一种特殊类型的调用此方法，获取 检测到。 中包装传递 ，其中包含属性值的集合 (在 属性)，其中每个将会映射到一个声明。 在将返回的所有声明 与指定的颁发者。

要使用的 。 此令牌的主题。 声明颁发者。 不包含任何有效的属性的值。

将签名的密钥标识符解析为 SecurityToken。

要为其颁发者令牌进行解析。 当前 与此处理程序相关联。 此方法返回时，如果令牌已成功解析包含解析的安全令牌。 如果该令牌将被解析。

验证指定 对象。

要验证的 SAML 1.1 条件。 若要检查的受众限制条件。

验证令牌数据并返回其声明。

要验证的 SAML 1.1 令牌。 在令牌中包含的标识。

写入 < saml:Action > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Advice > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将指定的 SAML 断言指定的 XML 编写器序列化。

用于序列化。 一个 ，它表示要序列化的断言。 为 。 - 或 - 为 。 指定的断言 同时具有 和 属性设置为 。 - 或 - 有没有语句和由指定的断言中没有主题 。 (同时 属性和 属性 。) 如果断言不包含语句，它必须包含一个使用者。 - 或 - 指定的断言 包含的身份验证 （attribute) 或授权决策语句和无主题 — 这些语句需要一个使用者。 ( 属性包含的声明类型的 , ，, ，或 和 属性是 )。 令牌加密凭据没有指定的对称密钥。

写入 < saml:Attribute > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AttributeStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 saml:Attribute 值。

用其进行写。 一个字符串，包含要写入的属性值。 一个 ，表示正在写入其值的特性。 为 。

写入 < saml:AudienceRestriction > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。 属性 中指定 是 或为空集合。

写入 < saml:AuthnStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AuthorityBinding > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:AuthzDecisionStatement > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将序列化为指定 对象。

用来写入数据。 要写入的数据。 默认情况下，仅 和 支持。 为 。 - 或 - 为 。 不支持 。 。 默认情况下，仅 和 支持。

写入 < saml:Conditions > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:DoNotCacheCondition > 元素。

用来将数据写入 XML 编写器。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Evidence > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入使用指定的 XML 编写器的签名 < ds:KeyInfo > 元素。

用来序列化密钥标识符。 ，它表示要编写的密钥标识符。 为 。 - 或 - 为 。 该处理程序无法将指定的密钥标识符序列化为 。

写入 SamlStatement。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

写入 < saml:Subject > 元素。

用来写入数据。 要写入的数据。 为 。 - 或 - 为 。

将序列化为指定的 XML 编写器的主题 < ds:KeyInfo > 元素。

用来序列化密钥标识符。 ，它表示要编写的密钥标识符。 为 。 - 或 - 为 。

将 Saml 令牌写入指定的 XML 编写器。

用来写入数据。 要写入的标记。 为 。 - 或 - 为 。 不是 对象。

新实例初始化 类为默认值。

新实例初始化 从指定的 XML 类。

为要加载该实例的 XML 元素。

返回一个值，该值指示是否对于指定的令牌基于此项的设置，需要访问群体强制检查 。

定义访问群体要求的枚举值之一。 要测试受众实施的安全令牌。 如果应该应用访问群体强制;否则为 。 为 。

检查与 AllowedAudienceUri 列表指定的受众 Uri 列表。

AudienceUris 的集合。 受众 Uri 令牌应用到的集合。 为 。 - 或 - 为 。 为空集合。 - 或 - 为空集合。 - 或 - 验证将失败。

初始化 类的新实例。

使用指定 XML 读取器读取 SAML 断言的 元素中 SAML 授权机构所提供的附加信息。

一个 ，它读取 SAML 授权机构所提供的附加信息。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 ，包含 SAML 断言的 元素中 SAML 授权机构所提供的附加信息。 为

从指定的 XML 读取器读取 SAML 断言。

一个读取 SAML 断言的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个表示 SAML 断言的 。 为

使用指定的 XML 阅读器读取 SAML 安全令牌主题的属性。

一个读取属性的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 ，它表示一个声明，而该声明是 SAML 安全令牌主题的一个属性。

使用指定的 XML 读取器读取评估 SAML 断言有效性时必须考虑的条件。

一个读取 SAML 条件的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 ，它指定评估 SAML 断言有效性时必须考虑的条件。 为 。

使用指定的 XML 读取器读取评估 SAML 断言有效性时必须考虑的条件集。

一个读取 SAML 条件的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 ，它指定评估 SAML 断言有效性时必须考虑的条件集。 为 。

使用指定的 XML 读取器读取 SAML 语句。

一个读取 SAML 语句的 。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个表示 SAML 语句的 。 为 。

将此序列化程序能识别的 XML 元素和属性默认集替换为指定的元素和属性字典。

一个 ，包含 XML 元素和属性集。

从指定的 XML 读取器读取 SAML 安全令牌。

一个 ，它读取 安全令牌。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 一个 安全令牌。 为 引用不包含数字签名的 XML 元素。

将指定的 SAML 安全令牌写入指定的 XML 序列化程序。

要写入的 。 一个 ，它写入 SAML 授权语句。 一个 ，它能够写入 子句。 为 - 或 - 为

初始化 类的新实例。

为 安全令牌创建授权策略。

一个 ，表示 安全令牌的颁发者。 一个用来对 安全令牌进行身份验证的 。 一个 ，表示 安全令牌的授权策略。

将此实例设置为只读的。

在派生类中重写时，从指定的 XML 读取器读取 SAML 语句。

读取 SAML 语句的 。 一个 ，它能够读取 SAML 规范中定义的 SAML 语句中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。

将 SAML 语句写入指定的 XML 序列化程序。

一个用于写入 SAML 语句的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。

初始化 类的新实例。

使用指定的名称、该名称所在的域以及该名称的格式初始化 类的新实例。

一个 URI 引用，表示 参数所使用的格式。 设置 属性。 参数所在的域。 设置 属性。 主题名称。 设置 属性。 为 或 。

使用指定的名称、该名称所在的域、该名称的格式、身份验证协议、附加身份验证信息和密钥标识符初始化 类的新实例。

一个 URI 引用，表示 参数所使用的格式。 设置 属性。 参数所在的域。 设置 属性。 主题名称。 设置 属性。 一个类型为 的 ，包含多个 URI 引用，这些引用标识用来验证主题身份的协议。 设置 属性。 可供身份验证协议使用的附加身份验证信息。 设置 属性。 一个 ，提供对 安全令牌的主题所持有的加密密钥的访问。 设置 属性。 为 或 。 包含一个 或 成员。 - 或 - 不包含任何成员，并且 为 或为 。 - 或 - 不包含任何成员，并且 或 不为 。

使用此类的属性获取一个声明集。

一个类型为 的 ，包含此 实例所表示的声明集。

使用此类的属性和指定的 SAML 安全令牌验证器获取一个声明集。

一个 ，它对 安全令牌中对应于 元素的部分进行验证。 一个 ，包含此 实例所表示的声明集。 为 。

将此实例设置为只读的。

从指定的 XML 读取器读取 元素。

一个用于读取 元素的 。 一个 ，它能够读取 SAML 断言中的 XML 元素。 一个 ，它读取数字签名的 子句。 一个 ，它确定是哪个安全令牌创建了数字签名。 为 。 - 或 - 为 。 引用符合以下任一条件的 XML 元素： 包含没有值的 元素。 - 或 - 包含没有值的 元素。 - 或 - 包含一个 元素，但该元素连一个 子元素都没有。 - 或 - 连一个 或 元素都不包含。 引用一个 XML 元素，该元素包含的某个 元素没有可检索的密钥。

将 元素写入指定的 XML 序列化程序。

一个用于写入 元素的 。 一个 ，它能够写入 SAML 断言中的 XML 元素。 一个 ，它能够写入 子句。

初始化 类的新实例。

使用指定的主题初始化 类的新实例。

一个 ，它标识 安全令牌的主题。 设置 属性。

根据此实例的属性将声明添加到指定的声明集合。

一个类型为 的 ，包含添加操作的目标声明集。 为 。

为 安全令牌创建授权策略。

一个 ，表示 安全令牌的颁发者。 一个用来对 安全令牌进行身份验证的 。 一个 ，表示 安全令牌的授权策略。

将此实例设置为只读的。

设置 安全令牌的主题。

一个 ，它标识 安全令牌的主题。 为 。

初始化 类的新实例。

在派生类中重写时，解密指定的加密密钥。

用于对密钥进行加密的加密算法。 包含加密密钥的 数组。 包含解密密钥的 数组。

在派生类中重写时，加密指定的密钥。

用于对密钥进行加密的加密算法。 包含密钥的 数组。 包含加密密钥的 数组。

在派生类中重写时，获取一个值，该值指示指定的算法是否使用非对称密钥。

加密算法。 如果指定的算法使用非对称密钥，则为 ；否则为 。

在派生类中重写时，获取一个指示此类是否支持指定算法的值。

加密算法。 如果此类支持指定的算法，则为 ；否则为 。

在派生类中重写时，获取一个指示指定的算法是否使用对称密钥的值。

加密算法。 如果指定的算法使用对称密钥，则为 ；否则为 。

新实例初始化 类从指定的密钥标识符。

一个表示密钥标识符 。 令牌解析程序可被解析为 。 为 。

新实例初始化 类从指定的密钥标识符子句。

表示一个密钥标识符子句 。 令牌解析程序可被解析为 。 为 。

通过使用指定的算法解密指定的密钥。

要使用密钥进行解密的算法。 一个数组，包含加密的密钥。 一个数组，包含解密的密钥。

通过使用指定的算法加密指定的密钥。

要使用密钥进行解密的算法。 一个数组，包含要加密的密钥。 一个数组，包含加密的密钥。

返回一个值，该值指示指定的算法是不对称。

要检查的算法。 如果该算法将处理由运行时作为非对称;否则为 。

返回一个值，该值指示该项是否支持指定的算法。

要检查的算法。 如果该算法支持的此项;否则为 。

返回一个值，该值指示指定的算法是否对称。

要检查的算法。 如果该算法将处理由对称; 运行时否则为 。

初始化 类的新实例。

使用指定的密钥标识符子句初始化 类的新实例。

一个包含密钥标识符子句的 数组。 为 。

在列表末尾添加密钥标识符子句。

一个要添加到列表末尾的 。 为 。 属性的值为 。

为密钥标识符子句之一创建密钥。

一个表示已创建的密钥的 。 无法为任何密钥标识符子句创建密钥。

搜索指定类型的密钥标识符子句，并返回整个集合中的第一个匹配项。

一个 ，表示要在集合中搜索的密钥标识符子句的类型。 集合中第一个具有 参数中指定的类型的 。 为 。 集合不包含具有 参数中指定的类型的密钥标识符子句。

返回一个枚举数，它循环访问密钥标识符子句集合。

集合的一个 类型 。

将此实例设置为只读的。

返回一个枚举数，它循环访问密钥标识符子句集合。

一个可用于循环访问集合的 。

返回当前对象。

当前对象。

搜索指定类型的密钥标识符子句，并返回一个值，指示是否可以找到该类型的子句。 如果找到一个类型，则在 参数中返回它。

当此方法返回时，包含一个具有在 参数中指定的类型的 ，但前提是可以在集合中找到该类型的子句。 此参数未经初始化即被传递。 一个 ，表示要在集合中搜索的密钥标识符子句的类型。 如果集合中存在具有 参数中指定的类型的密钥标识符子句，则为 ；否则为 。

使用指定的密钥标识符子句类型初始化 类的新实例。

密钥标识符子句类型。 设置 属性的值。

使用指定的密钥标识符子句类型、Nonce 和派生密钥长度来初始化 类的新实例。

密钥标识符子句类型。 设置 属性的值。 一个 数组，包含用于创建派生密钥的 Nonce。 设置 方法所返回的值。 派生密钥的大小。 设置 属性的值。

基于传入构造函数的参数创建密钥。

一个包含已创建的密钥的 。

获取用于生成派生密钥的 Nonce。

一个 数组，包含用于生成派生密钥的 Nonce。

返回一个值，该值指示此实例的密钥标识符是否等效于指定的密钥标识符子句。

要进行比较的 。 如果 是与当前实例相同的实例，则为 ；否则为 。 为 。

初始化 类的新实例。

当在派生类中重写，则返回一个值，指示作为密钥标识符子句由处理程序是否可以读取指定的读取器所在的元素。

密钥标识符子句的开始元素处 XML 读取器。 如果 XML 可以反序列化为一个密钥标识符子句由处理程序;否则为 。

当在派生类中重写时返回一个值，该值指示指定的密钥标识符子句是否可以序列化由处理程序。

要检查的密钥标识符子句。 如果处理程序，否则为可序列化密钥标识符子句 。

当在派生类中重写，使用反序列从一个密钥标识符子句指定的 XML 读取器。

XML 读取器的密钥标识符子句的开始元素处读取。 从 XML 进行反序列化密钥标识符子句。

当在派生类中重写序列化指定的密钥标识符子句。

要使用的 XML 编写器序列化密钥标识符子句。 要序列化密钥标识符子句。

在派生类中初始化的构造函数调用 类。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符。 如果 的类型为 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是安全令牌的密钥标识符子句。

返回一个值，该值指示此实例的密钥标识符能否解析为指定的密钥标识符。

要与此实例进行比较的 。 如果 为 ，并且具有与 属性相同的唯一标识符，则为 ；否则为 。

为指定的密钥标识符子句获取密钥。

要为其获取密钥的 。 一个表示密钥的 。

初始化 类的新实例。

将指定的身份验证方法声明添加到当前实例的主题。 即时身份验证设置为当前时间。

一个 URI，指定身份验证方法。

将指定的身份验证类型和即时身份验证的声明添加到当前实例的使用者。

一个 URI，指定身份验证方法。 Utc 格式的即时身份验证。 如果时间不是 utc 格式，它将转换为 UTC。

基于当前实例的属性集指定 RSTR 的相应属性。

要对其应用的当前实例的设置 RSTR。 为 。

新实例初始化 类通过使用 对象。

安全令牌表示的新实例。

新实例初始化 通过使用指定的 XML 表示形式的安全令牌的类。

安全令牌 XML 表示形式。 用于读取和验证新的实例包装的安全令牌的默认令牌处理程序集合。

获取包装令牌中包含的标识。

令牌中包含的标识。

获取由当前实例表示的安全令牌。

当前实例表示安全令牌。

反序列化 从指定的 XML 表示形式。

安全令牌 XML 表示形式。 要用于读取令牌的令牌处理程序集合。 从 XML 进行反序列化安全令牌。

创建指定的 XML 表示形式的安全令牌中包含的标识。

安全令牌 XML 表示形式。 要用于读取令牌的令牌处理程序集合。 令牌中包含的标识。 为 。 - 或 - 为 。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

从构造函数初始化派生类中调用 类。

返回一个值，该值指示指定的 XML 读取器是否由 XML 元素引用可以反序列化此实例的密钥标识符子句。

XML 读取器的开始元素处。 不应将读取器前移此方法。 如果 方法可以读取元素; 否则为 。 默认值为 。

返回一个值，该值指示指定的字符串是否可以反序列化为此实例处理的类型的令牌。

要读取的令牌字符串。 如果 方法可以读取元素; 否则为 。 默认值为 。

返回一个值，该值指示是否可以处理此实例的类型的令牌作为读取由指定的 XML 读取器引用的 XML 元素。

XML 读取器定位在开始元素。 不应将读取器前移此方法。 如果 方法可以读取元素; 否则为 。 默认值为 。

返回一个值，该值指示指定的密钥标识符子句是否可以序列化此实例。

要检查的密钥标识符子句。 如果可以序列化密钥标识符子句。否则为 。 默认值为 。

当在派生类中重写创建处理由该类的令牌的安全令牌引用。 此方法通常由安全令牌服务 (STS) 调用。

引用要为其创建标记。 如果应创建附加的引用; ，如果应创建的未附加的引用。 引用指定的令牌的密钥标识符子句。

当在派生类中重写，创建使用指定的令牌描述符的安全令牌。 由安全令牌服务 (STS) 调用此方法。

是要创建令牌的安全令牌描述符。 调用此方法之前，是设置令牌描述符的属性。 与令牌描述符的属性匹配安全令牌。

当在派生类中重写，如果作为在重播检测到指定的标记，则引发异常。

要检查的重播的标记。

当在派生类中重写时返回的一套所使用 Uri 中标识处理由派生类类型的令牌的请求。

用于标识此处理程序支持的令牌类型 Uri 集。

在派生类中重写，当从 XML 加载自定义配置。

配置 XML 元素。 在列表中的每个节点属于类型 。

当在派生类中重写，反序列化到引用的派生类中处理的令牌的密钥标识符子句指定的 XML 读取器引用的 XML。

XML 读取器的 XML 进行反序列化到的密钥标识符子句的开始元素处。 从 XML 进行反序列化密钥标识符子句。

当在派生类中重写，反序列化对处理由派生类类型的令牌的指定的字符串。

要进行反序列化的字符串。 从指定的字符串进行反序列化安全令牌。

当在派生类中重写，反序列化到的派生类中处理类型的令牌指定的 XML 读取器引用的 XML。

XML 读取器定位标记的开始元素处。 从 XML 进行反序列化安全令牌。

当在派生类中重写，反序列化指定的 XML 读取器为通过使用指定的令牌解析程序处理的派生类的类型的标记所引用的 XML。

XML 读取器定位标记的开始元素处。 包含带外和缓存标记令牌解析器。 从 XML 进行反序列化安全令牌。

当启用跟踪时的安全令牌验证期间跟踪故障事件。

正在验证安全令牌。 要写入跟踪的消息。

跟踪成功验证的安全令牌事件时启用了跟踪。

验证令牌。

当在派生类中重写，验证指定的安全令牌。 令牌必须由派生类中处理的类型。

要验证的标记。 在令牌中包含的标识。

当在派生类中重写序列化到 XML 的指定的密钥标识符子句。 由派生类所支持必须是类型的密钥标识符子句。

XML 编写器。 要序列化密钥标识符子句。

当在派生类中重写序列化指定的安全令牌的字符串。 令牌必须由派生类中处理的类型。

要序列化的标记。 序列化的令牌。

当在派生类中重写序列化到 XML 指定的安全令牌。 令牌必须由派生类中处理的类型。

XML 编写器。 要序列化的标记。

初始化 类的新实例。

新实例初始化 类，具有指定的令牌处理程序。

令牌处理程序用来初始化新实例。

新实例初始化 类与指定的令牌处理程序和配置。

令牌处理程序用来初始化新实例。 要将与集合相关联的基本配置。

新实例初始化 类，具有指定的配置。

要将与集合相关联的基本配置。

将指定的令牌处理程序添加到此集合。 如果具有相同标记处理程序类型标识符，因为集合中已存在指定的处理程序，用指定的处理程序代替它。

要添加到集合的令牌处理程序。

返回一个值，指示是否可以读取指定的密钥标识符子句，通过此集合中的处理程序之一或基 。

XML 读取器的开始元素处。 读取器不应将前移。 如果可以读取密钥标识符子句。否则为 。

返回一个值，该值指示由一个集合中的处理程序或由基类是否可以读取指定的密钥标识符子句 。

XML 读取器的开始元素处。 读取器不应将前移。 如果可以读取密钥标识符子句。否则为 。

返回一个值，该值指示是否可以通过此集合中的处理程序之一读取标记的指定的字符串表示。

字符串形式表示的标记。 如果集合包含的令牌处理程序可以读取指定的标记;否则为 。 为 或空字符串。

返回一个值，该值指示是否可以通过在此集合中的处理程序之一读取指定的标记。

XML 读取器的开始元素处。 读取器不应将前移。 如果可以读取令牌。否则为 。

通过此集合中的处理程序之一返回一个值，该值指示是否可以序列化指定的标记。

要进行序列化的安全令牌。 如果令牌可以序列化一个处理程序;否则为 。

清除所有此集合中的处理程序。 （重写基类方法。）

创建系统默认集合的基本的安全令牌处理程序，每个都有系统默认配置。 此集合中的令牌处理程序必须使用服务特定的数据配置，然后才能使用。

一个包含默认情况下，基本的安全令牌处理程序的安全令牌处理程序集合。

创建基本的安全令牌处理程序的系统默认集合，并将指定的配置与新集合相关联。 每个处理程序都有系统默认配置。 此集合中的令牌处理程序必须使用服务特定的数据配置，然后才能使用。

要将与处理程序集合相关联的配置。 一个包含默认情况下，基本的安全令牌处理程序的安全令牌处理程序集合。

从指定的令牌说明符创建一个令牌。

是要创建令牌的令牌描述符。 调用此方法之前，是设置令牌描述符的属性。 与令牌描述符的属性匹配安全令牌。

在此集合中指定索引处插入指定的令牌处理程序。 （重写基类方法。）

从零开始的索引，应在该位置插入该处理程序。 要插入的令牌处理程序。

反序列化从指定的 XML 读取器读取密钥标识符子句。

XML 读取器的 XML 进行反序列化到的密钥标识符子句的开始元素处。 从 XML 反序列化密钥标识符子句。

反序列化从指定的 XML 读取器读取密钥标识符子句。

XML 读取器的 XML 进行反序列化到的密钥标识符子句的开始元素处。 从 XML 反序列化密钥标识符子句。

反序列化指定字符串中的安全令牌。

从其反序列化令牌的字符串。 从指定的字符串进行反序列化令牌。

反序列化指定的 XML 读取器的安全令牌。

XML 读取器定位标记的开始元素处。 从 XML 反序列化安全令牌。

从此集合中移除指定索引处的处理程序。 （重写基类方法。）

要删除的处理程序的从零开始的索引。

集合中的指定索引处的令牌处理程序替换为指定的处理程序。

待替换元素的从零开始的索引。 新令牌处理程序中指定索引处的元素。

验证指定的安全令牌。

要验证的标记。 令牌中包含的标识。

序列化到 XML 的指定的密钥标识符子句。

XML 编写器。 要序列化密钥标识符子句。

序列化到 XML 的指定的密钥标识符子句。

XML 编写器。 要序列化密钥标识符子句。

将序列化为指定的安全令牌的字符串。

要序列化的标记。 从使用令牌序列化字符串。 为 。 集合不包含能够序列化指定的标记处理程序。

将指定的安全令牌提供给 XML 序列化。

XML 编写器。 要序列化的标记。 为 。 - 或 - 为 。 集合不包含能够序列化指定的标记处理程序。

新实例初始化 为指定的类名为 service。

关联的服务的名称。 属性设置为此名称。

确定此实例是否包含指定的使用情况的安全令牌处理程序集合。

若要查找令牌处理程序集合的用法。 如果此实例包含一个标记处理程序集合，以便指定用法;否则为 。

创建一个令牌处理程序集合管理器包含令牌处理程序的一组默认的处理程序集合。

包含一个带默认令牌处理程序的集合管理器。

创建一个空的令牌处理程序集管理器。

收集管理器，其中包含不具有处理程序。

初始化 类的新实例。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

初始化 类的新实例。

使用指定的 XML 序列化数据和有关序列化流的源和目标的上下文数据来初始化 类的新实例。

一个 ，包含在序列化和反序列化过程中使用的值。 一个 ，包含有关序列化流的源和目标的数据。

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

一个标识异常发生原因的消息。

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

一个标识异常发生原因的消息。 一个 ，表示异常的根源。

用序列化数据初始化 类的新实例。

序列化的对象数据中。 有关源的上下文信息。

从指定的主体初始化 类的新实例。

从其初始化标记所声明的主体。 为 。 - 或 - 的 属性为 。

新实例初始化 从指定的主体和引导令牌的类。

从对启动令牌生成所声明的主体。 一个可选的、 特定于应用程序的上下文的字符串。 为 。 - 或 - 的 属性为 。

新实例初始化 类从指定的主体和引导令牌; 并使用指定开始时间和过期时间。

从对启动令牌生成所声明的主体。 一个可选的、 特定于应用程序的上下文的字符串。 令牌生效时间即时。 若要指定 时间点之后该令牌将不再有效。 若要指定应通过添加值来确定值 属性设置为指定的时间 参数。 为 。 - 或 - 的 属性为 。 和 无法验证参数; 例如， 指定发生的时间早于 。

新实例初始化 类从指定的主体和引导令牌; 并使用指定开始时间和过期时间。 新令牌的作用范围是指定的终结点。

从对启动令牌生成所声明的主体。 一个可选的、 特定于应用程序的上下文的字符串。 此令牌绑定到的终结点。 一个空字符串创建一个未区分范围的令牌。 令牌生效时间即时。 若要指定 。 时间点之后该令牌将不再有效。 若要指定应通过添加值来确定值 属性设置为指定的时间 参数。 为 。 - 或 - 的 属性为 。 - 或 - 为 。 和 无法验证参数; 例如， 指定发生的时间早于 。

从指定的主体初始化 类的新实例。 新令牌的有效期从 通过指定的生存期。

从其初始化标记所声明的主体。 从当前令牌的有效期的时间段。 属性将设置为 和 属性将设置为 加上指定此参数的时期。 为 。 - 或 - 的 属性为 。 小于或等于 。

新实例初始化 类通过使用指定的主体、 上下文 ID、 上下文、 终结点、 有效的时间戳、 生存期和密钥。

与此会话关联所声明的主体。 与此令牌关联的上下文标识符。 一个可选的、 特定于应用程序的上下文的字符串。 此令牌绑定到的终结点。 一个空字符串创建一个未区分范围的令牌。 令牌生效的时间。 会话令牌的生存期。 属性将设置为 加上指定此参数的时期。 一个可选的对称会话密钥。 为 。 - 或 - 的 属性为 。 - 或 - 为 。 - 或 - 为 。 小于或等于 。

新实例初始化 类通过使用指定的主体、 上下文 ID、 上下文、 终结点、 开始时间、 到期时间和密钥。

与此会话关联所声明的主体。 与此令牌关联的上下文标识符。 一个可选的、 特定于应用程序的上下文的字符串。 此令牌绑定到的终结点。 一个空字符串创建一个未区分范围的令牌。 令牌生效时间即时。 若要指定 时间点之后该令牌将不再有效。 若要指定应通过添加值来确定值 属性设置为指定的时间 参数。 一个可选的对称会话密钥。 为 。 - 或 - 的 属性为 。 - 或 - 为 。 大于或等于 。 - 或 - 小于当前时间。

新实例初始化 类通过使用指定的主体、 上下文 ID、 上下文、 终结点、 生存期和密钥。

与此会话关联所声明的主体。 与此令牌关联的上下文标识符。 一个可选的、 特定于应用程序的上下文的字符串。 此令牌绑定到的终结点。 一个空字符串创建一个未区分范围的令牌。 会话令牌的生存期。 属性将设置为 和 属性将设置为 加上指定此参数的时期。 一个可选的对称会话密钥。 为 。 - 或 - 的 属性为 。 - 或 - 为 。 - 或 - 为 。 小于或等于 。

集 会话安全令牌序列化所需的信息。

序列化的对象数据中。 关于来源和目标的上下文信息

从构造函数初始化派生类中调用 类。

当在派生类中重写，尝试向缓存中添加项或更新现有。

要添加或更新的项的键。 与此项关联的令牌。 项的过期时间。

当在派生类中重写，尝试从缓存中检索一个项。

要检索的项的键。 与键关联的会话令牌或 , ，如果未找到匹配。

当在派生类中重写，检索所有与键关联的令牌。

要搜索的终结点 ID。 要搜索的上下文 ID。 与键关联的会话令牌的集合。

在派生类中重写，当从 XML 加载自定义配置。

自定义配置元素中。

当在派生类中实现，尝试从缓存中移除一个项。

要移除的条目的键。

当在派生类中实现，尝试从缓存中删除具有匹配的终结点 ID 的所有项。

要删除的条目终结点 ID。

当在派生类中实现，尝试从缓存中删除所有匹配项。

要删除的条目终结点 ID。 要删除的条目上下文 ID。

初始化 类的新实例。

为作用域的缓存项的终结点 ID。 这是应为的值 缓存的令牌属性。 缓存项的上下文 ID。 这是应为的值 缓存的令牌属性。 缓存项密钥生成。 这是应为的值 缓存的令牌属性。 当续订令牌后，此值才可用。 它将 缓存新的令牌时。

确定指定的对象是否与当前的缓存密钥相同。

要与当前的缓存键进行比较的对象。 应可从赋值 。 如果指定的对象等同于当前的缓存项;否则为 。

返回当前的缓存密钥的哈希代码。

当前的缓存密钥哈希代码。

实现的相等运算符 类。

要比较的第一个缓存键。 要比较的第二个缓存键。 如果缓存键是否相等。否则为 。

实现的相等运算符 类。

要比较的第一个缓存键。 要比较的第二个缓存键。 如果缓存键是否不相等;否则为 。

重写 提供唯一标识符。

字符串形式中的键。

新实例初始化 类，该类使用默认 cookie 转换和令牌生存期。

新实例初始化 类，该类使用指定的 cookie 转换。

若要在编码或解码 cookie 时应用转换。 设置 属性。 为 。

新实例初始化 类，该类使用指定的 cookie 转换和令牌生存期。

若要在编码或解码 cookie 时应用转换。 设置 属性。 获取令牌默认生存时间。 设置 属性。 为 。 小于或等于 。

将应用指定的转换 属性进行编码或解码指定的 cookie。

要转换的 cookie。 如果该 cookie 应进行编码; 如果 cookie 应进行解码。 已编码或解码的 cookie。 属性为 。

返回一个值，该值指示读取器定位在 元素。

通过传入 。 读取器应位于 元素。 如果读取器指向 元素; 否则为 。 为 。

创建 基于令牌的有效期的指定的声明主体和时间范围。

声明主体中。 一个调用方定义的上下文的字符串。 终结点的范围限定该令牌的标识符。 令牌生效时间即时。 时间点之后该令牌将不再有效。 已创建的会话安全令牌。 根据指定的参数设置新的会话令牌上的属性。 为 。 属性为 。

创建基于指定的令牌描述符的安全令牌。

从中创建令牌令牌描述符。 创建安全令牌。 这将是实例 。 为 。 属性为 。

获取可由该处理程序处理的令牌类型的令牌类型 Uri。

可通过此处理程序处理的令牌类型的标记类型标识符 Uri。

从 XML 加载自定义配置。

自定义配置元素中。 为 。 通过指定的配置 无效。 例如，它不包含 元素，它包含多个 元素、 一个有效 不能从读取值 属性中，或 属性指定的值是小于比 。

读取 从通过使用指定的令牌解析程序的字节流。

包含标记的字节流中。 若要使用令牌解析器。 读取的 。

读取 使用指定的 XML 读取器。

通过传入 。 已读取的一个实例的会话安全令牌 。 为 。 读取器未定位在 或 无法读取。

读取 使用指定的 XML 读取器和令牌解析程序。

通过传入 。 一个 可用于解析 。 已读取的一个实例的会话安全令牌 。 为 。 - 或 - 为 。 读取器未定位在 或 无法读取。

设置将应用于 cookie 的转换。

要使用的转换。

确定与指定标记关联的会话是否仍有效。 通过检查来确定有效性 和 属性指定的标记。 如果在会话不再有效，将引发异常。

要检查的标记。 为 。 属性为 。 令牌的属性是否晚于 。 令牌的属性是早于 。

验证指定的标记并返回其声明。

要验证的标记。 必须可从 。 令牌中包含的标识。 . 不能从分配 。

对指定的会话令牌进行验证，并返回其声明。

要验证的标记。 必须可从 。 终结点的范围限定该令牌的标识符。 令牌中包含的标识。 为 。 - 或 - 为 。 不能从分配 。 指定标记的属性不是 或空且其值比指定的不同 参数。

将指定的令牌序列化到字节数组。

要写入的标记。 编码的字节数组。 为 。

通过使用指定的 XML 编写器序列化指定的标记。

用于序列化令牌的 XML 编写器。 要序列化的标记。 的一个实例。 为 。 - 或 - 为 。 不能从分配 。 - 或 - 的令牌指定该处理程序不支持的 Ws-secure Conversation 的版本。

初始化 类的新实例。

一个 ，它包含用于生成数字签名的加密密钥。 一个 URI，表示用于生成数字签名的加密算法。 一个表示加密算法的 URI，该加密算法用于计算要进行数字签名的 SOAP 消息部分的摘要。

初始化 类的新实例。

一个 ，它包含用于生成数字签名的加密密钥。 一个 URI，表示用于生成数字签名的加密算法。 一个表示加密算法的 URI，该加密算法用于计算要进行数字签名的 SOAP 消息部分的摘要。 一个 ，指定表示用于创建数字签名的密钥的标识符。

新实例初始化 类，具有指定的密钥材料。

在已颁发令牌使用对称密钥。 为信赖方加密凭据密钥。 为 。

新实例初始化 类，具有指定的加密凭据。

要使用。

新实例初始化 类，具有自动生成的密钥。

对称密钥的大小。 密钥加密凭据的请求的目标。

新实例初始化 类，具有自动生成的密钥。

对称密钥的大小。 密钥加密凭据的请求的目标。 为请求者加密凭据密钥。 小于或等于零。

新实例初始化 用来发送类结合使用平均信息量。

对称密钥的大小。 密钥加密凭据的请求的目标。 请求者使用平均信息量或证明令牌进行加密的加密凭据。 请求者的平均信息量。 是 或一个空数组。 小于零。

新实例初始化 用来发送类结合使用平均信息量。

对称密钥的大小。 信赖方用来加密 SecurityKeyIdentifier 属性中的密钥的加密凭据。 请求程序用来加密平均信息量或证明令牌加密凭据。 请求者的平均信息量。 要使用加密校验密钥的算法的 URI。 小于或等于零。 是 或一个空数组。

使用此构造函数有 STS 自动生成密钥并将其发送作为加密密钥的证明令牌。 两种情况下都是涵盖此处 1。 客户端发送平均信息量，但服务器会拒绝它 2。 客户端没有未发送平均信息量，所以只需使用服务器的平均信息量

对称密钥的大小。 为信赖方加密凭据密钥。 为请求者加密凭据密钥。 中指定的算法 (URI) RST 中的元素。 小于或等于零。

修改指定的 RSTR 基于此证明描述符中的设置。

要对其应用证明描述符 RSTR。 为 。

获取密钥材料。

一个包含密钥材料的字节数组。

获取源平均信息量以普通字节为单位。

一个字节数组，其中包含源平均信息量。

获取用纯字节表示的目标平均信息量

一个字节数组，其中包含目标平均信息量。

初始化 类的新实例。

在派生类中重写时，使用指定的加密算法和参数生成当前密钥的派生密钥。

一个 URI，表示用于生成派生密钥的加密算法。 一个 数组，它包含加密算法的标签参数。 一个 数组，它包含用于创建派生密钥的 Nonce。 派生密钥的大小。 派生密钥在从此方法返回的字节数组中的位置。 包含派生密钥的 数组。

在派生类中重写时，获取一个使用指定的加密算法解密密码文本的转换。

一种对密码文本（例如加密的 XML）进行解密的加密算法。 一个 数组，它包含指定算法的初始化向量 ()。 一个表示解密转换的 。

在派生类中重写时，获取一个使用指定的加密算法加密 XML 的转换。

一个对 XML 进行加密的加密算法。 一个 数组，它包含指定算法的初始化向量 ()。 一个表示加密转换的 。

在派生类中重写时，获取指定的加密算法所需的初始化向量 () 的大小（以位为单位）。

用于获取初始化向量 () 的大小的加密算法。 参数中指定的加密算法所需的初始化向量 () 的大小（以位为单位）。

在派生类中重写时，获取指定的加密哈希算法的实例。

要获取其实例的加密哈希算法。 一个表示加密哈希算法的 。

在派生类中重写时，获取指定的对称算法的实例。

要获取其实例的对称算法。 一个表示对称算法的 。

在派生类中重写时，获取表示对称密钥的字节。

包含对称密钥的 数组。

从构造函数初始化派生类中调用 类。

在派生类中重写，当尝试添加新项或更新和现有条目。

要在添加项时使用的键。 若要添加到缓存中，该标记会 。 项的过期时间。

当在派生类中重写时返回一个值，该值指示是否在缓存中存在一个匹配项。

要搜索的键。 匹配的项是否位于缓存中;否则为 。

当在派生类中重写，尝试获取指定的项。

要搜索的键。 与键匹配的标记或 如果不找到任何标记。

当在派生类中重写，则从指定的 XML 加载自定义配置。

自定义配置 XML 元素。

当在派生类中重写，尝试从缓存中移除一个项。

标识要移除的项的键。

使用指定的用户名和密码初始化 类的新实例。

用户名。 设置 属性。 用户名的密码。 设置 属性。 为 。 - 或 - 为 。

使用指定的用户名、密码和唯一标识符来初始化 类的新实例。

用户名。 设置 属性。 用户名的密码。 设置 属性。 安全令牌的唯一标识符。 设置 属性。 为 。 - 或 - 为 。 - 或 - 为 。

从构造函数初始化派生类中调用 类。

指示是否可以为读取当前 XML 元素 。

XML 读取器定位在开始元素。 读取器不应将前移。 如果读取器指向 ; 否则为 。

返回包含 Uri 用于在请求中标识此处理程序可以处理的类型的令牌。

用于标识此处理程序支持的令牌类型 Uri 集。

读取 从指定的读取器。

XML 读取器定位标记的开始元素处。 从 XML 进行反序列化对用户名安全令牌。 为 。 无法读取令牌。 密码不是以纯文本格式。 安全令牌中发现一个未知的元素或未指定用户名。

将序列化为指定 为 XML。

要用来序列化令牌的 XML 编写器。 要序列化的标记。 为 。 - 或 - 为 。 不能从分配 。

初始化 类的新实例。

使用 Windows 用户初始化 类的新实例。

一个表示 Windows 用户的 。 为 。

使用 Windows 用户初始化 类的新实例。

一个表示 Windows 用户的 。 安全令牌的唯一标识符。 为 。 - 或 - 为 。

创建 的新实例。

一个表示 Windows 用户的 。 安全令牌的唯一标识符。 安全令牌的身份验证类型。

释放由 使用的所有资源。

使用指定的唯一标识符、Windows 用户以及安全令牌有效的最初时刻和最后时刻来初始化 类的新实例。

安全令牌的唯一标识符。 设置 属性的值。 一个 ，表示此安全令牌有效的最初时刻。 请设置 属性的值。 一个 ，表示此安全令牌有效的最后时刻。 设置 属性的值。 一个表示 Windows 用户的 。 设置 属性的值。 若要创建与 参数相同的 对象并将其分配给 属性，则为 ；否则，将 参数的值分配给 属性。 为 。 - 或 - 为 。

初始化 类的新实例。

安全令牌的唯一标识符。 安全令牌的身份验证类型。 一个 ，表示此安全令牌有效的最初时刻。 一个 ，表示此安全令牌有效的最后时刻。 表示 Windows 用户。 若要创建与 参数相同的 对象并将其分配给 属性，则为 ；否则，将 参数的值分配给 属性。

如果已为此实例调用了 方法，则会引发异常。

已为此实例调用了 方法。

初始化 类的新实例。

验证指定的标记并返回其声明。

要验证的标记。 的一个实例。 令牌中包含的标识。 为 。 不能从分配 。 - 或 - 属性指定的标记不是窗体的 user\domain。 属性为 。 使用指定的标记的 LogonUser 失败。

使用指定的 X.509 证书初始化 类的新实例。

表示 X.509 证书的 。 为 。

使用指定的加密算法解密指定的加密密钥。

用于解密密钥的加密算法。 包含加密密钥的 数组。 包含解密密钥的 数组。 构造函数中指定的 X.509 证书不具有私钥。 - 或 - X.509 证书具有私钥，但它不是使用 算法生成的。 - 或 - X.509 证书具有私钥，并且是使用 算法生成的，但是 属性为 。 - 或 - 不支持 参数。 支持的算法为 和 。

使用指定的加密算法加密指定的加密密钥。

用于加密密钥的加密算法。 包含要加密的密钥的 数组。 包含加密密钥的 数组。 构造函数中指定的 X.509 证书所具有的公钥不是使用 算法生成的。 - 或 - 不支持 参数。 支持的算法为 和 。

获取指定的非对称加密算法。

要创建的非对称算法。 如果需要使用私钥来创建算法，则为 ；否则为 。 一个 ，表示指定的非对称加密算法。 为 ，并且构造函数中指定的 X.509 证书不具有私钥。 - 或 - 为 ，并且构造函数中指定的 X.509 证书的公钥或私钥类型不是 。 - 或 - 为 、、 或 ，并且构造函数中指定的 X.509 证书的公钥或私钥类型不是 。 - 或 - 不支持 。 支持的算法为 、、、 和 。

获取用于生成数字签名的哈希值的加密算法。

哈希算法。 一个 ，它生成数字签名的哈希值。 不支持 。 支持的算法为 、 和 。

获取数字签名的反格式化程序算法。

要获取其实例的数字签名的反格式化程序算法。 一个 ，它表示数字签名的反格式化程序算法。 为 ，并且构造函数中指定的 X.509 证书的公钥类型不是 。 - 或 - 为 或 ，并且构造函数中指定的 X.509 证书的公钥类型不是 。 - 或 - 不支持 。 支持的算法为 、 和 。

获取数字签名的格式化程序算法。

要获取其实例的数字签名的格式化程序算法。 一个 ，它表示数字签名的格式化程序算法。 构造函数中指定的 X.509 证书不具有私钥。 - 或 - 为 ，并且构造函数中指定的 X.509 证书的私钥类型不是 。 - 或 - 为 或 ，并且构造函数中指定的 X.509 证书的私钥类型不是 。 - 或 - 不支持 。 支持的算法为 、 和 。

获取一个值，该值指示该私钥是否可用。

如果私钥可用，则为 ；否则为 。

获取一个值，该值指示指定的算法是否使用非对称密钥。

加密算法。 如果指定的算法为 、、、 或 ，则为 ；否则为 。

获取一个值，该值指示此类是否支持指定的算法。

加密算法。 如果指定的算法为 、、、 或 ，并且公钥的类型是正确的，则为 ；否则为 。 有关详细信息，请参见备注。

获取一个值，该值指示指定的算法是否使用对称密钥。

加密算法。 如果指定的算法为 、、、、、、、、 或 ，则为 ；否则为 。

新实例初始化 类，具有默认 X.509 证书存储区。

新实例初始化 类，该类使用 X.509 证书存储与指定的位置和名称解析标记。

存储指定的 X.509 证书的名称的枚举值之一。 存储指定的 X.509 证书的位置的枚举值之一。

新实例初始化 类，该类使用 X.509 证书存储与指定的位置和名称解析标记。

X.509 证书存储区的名称。 存储指定的 X.509 证书的位置的枚举值之一。 为 或空字符串。

尝试将指定的密钥标识符子句解析为安全密钥。

要在其中解析安全密钥的密钥标识符子句。 此方法返回时，包含已从密钥标识符子句解析安全密钥。 该参数未经初始化即被处理。 如果密钥标识符子句，则成功解析;否则为 。 为 。

将指定的密钥标识符解析为安全令牌。

要解析的密钥标识符。 此方法返回时，包含从密钥标识符已得到解决的安全令牌。 该参数未经初始化即被处理。 如果密钥标识符是否成功解析;否则为 。 为 。

将指定的密钥标识符子句解析为安全令牌。

若要解决的密钥标识符子句。 此方法返回时，包含已从密钥标识符子句解析的安全令牌。 该参数未经初始化即被处理。 如果密钥标识符子句，则成功解析;否则为 。 为 。

初始化 类的新实例。

返回一个值，该值指示是否指定的读取器定位在 元素。

密钥标识符子句的开始元素处 XML 读取器。 如果读取器指向 元素; 否则为 。 为 。

返回一个值，该值指示指定的密钥标识符子句是否可以序列化此处理程序。

要检查的密钥标识符子句。 如果密钥标识符子句支持此处理程序;否则为 。 为 。

使用指定的 XML 读取器反序列 XML 中的密钥标识符子句。

XML 读取器的密钥标识符子句的开始元素处读取。 从 XML 进行反序列化的密钥标识符子句或 如果无法读取密钥标识符子句。 为 。 未置于 元素。 ( 方法将返回 。)

将序列化为指定的密钥标识符子句。

要用来序列化密钥标识符子句的 XML 编写器。 要序列化密钥标识符子句。 为 。 - 或 - 为 。 不受支持的子句类型。

新实例初始化 类根据指定的 X.509 证书。

X.509 证书。

新实例初始化 类根据指定 X.509 证书和安全的密钥标识符。

X.509 证书。 安全密钥标识符。

新实例初始化 类根据指定的 X.509 证书、 密钥换行算法和安全密钥标识符。

X.509 证书。 安全密钥标识符。 密钥包装算法。

新实例初始化 类根据指定的 X.509 证书和密钥包装算法。

X.509 证书。 密钥包装算法。

使用指定的 X.509 证书初始化 类的新实例。

一个包含 X.509 证书的 。 为 。

使用指定的证书颁发者可分辨名称和 X.509 证书的序列号初始化 类的新实例。

颁发 X.509 证书的证书颁发机构的可分辨名称。 设置 属性的值。 X.509 证书的序列号。 设置 属性的值。 为 。 - 或 - 为 。

返回一个值，该值指示此实例的密钥标识符是否与指定的密钥标识符相匹配。

要与此实例进行比较的 。 如果 为 类型，并且密钥标识符子句匹配，则为 ；否则为 。

返回一个值，该值指示此实例的密钥标识符是否与指定的 X.509 证书相匹配。

一个 ，包含要进行比较的 X.509 证书。 如果 具有与当前实例相同的颁发者名称和颁发者序列号，则为 ；否则为 。

返回一个值，该值指示此实例的密钥标识符是否与指定的颁发者名称和颁发者序列号相同。

颁发 X.509 证书的证书颁发机构的可分辨名称。 X.509 证书的序列号。 如果 和 参数与 和 属性匹配，则为 ；否则为 。

返回当前对象。

一个表示当前对象的 。

初始化 类的新实例。

初始化 类的新实例。

使用本地计算机上下文来构建证书链中;否则为 。 生成 X.509 证书链时要使用链策略。

验证指定的 X.509 证书。

要验证的 X.509 证书。 为 。 X.509 证书验证失败。

使用指定的 X.509 证书原始数据初始化 类的新实例。

包含 X.509 证书的原始数据的 数组。 为 。 的长度为零。

使用指定的 X.509 证书初始化 类的新实例。

一个包含 X.509 证书的 。 为 。

从 X.509 证书的原始数据或从构造函数中指定的字节数组创建密钥。

一个 ，它包含与 X.509 证书相关联的密钥。

获取与 X.509 证书相关联的原始数据。

包含与 X.509 证书相关联的原始数据的 数组。

返回一个值，该值指示此实例的密钥标识符是否与指定的 X.509 证书相等。

一个 ，包含要进行比较的 X.509 证书。 如果 具有与当前实例相匹配的原始数据，则为 ；否则为 。 为 。

返回当前对象。

一个表示当前对象的 。

使用指定的 X.509 证书初始化 类的新实例。

一个包含 X.509 证书的 。 设置 属性。 为 。

使用指定的 X.509 证书和唯一标识符初始化 类的新实例。

一个包含 X.509 证书的 。 设置 属性。 安全令牌的唯一标识符。 设置 属性。 为 。 - 或 - 为 null。

获取一个值，该值指示此安全令牌能否创建指定的密钥标识符。

一个 ，指定要创建的密钥标识符。 如果 的类型为 、、 或 ，则为 ；否则为 。

创建指定的密钥标识符子句。

一个 ，指定要创建的密钥标识符。 一个 ，它是安全令牌的密钥标识符子句。

释放由 使用的所有资源。

返回一个值，该值指示此实例的密钥标识符与指定的密钥标识符是否相等。

一个要与此实例进行比较的 。 如果 为 、、 或 类型之一，并且密钥标识符子句匹配，则为 ；否则为 。

如果已为此实例调用了 方法，则会引发异常。

已为此实例调用方法。

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

新实例初始化 类通过使用一个值，该值指示证书是否应映射到 Windows 帐户。

如果该证书应映射到 Windows 帐户;否则为 。 设置 属性。

新实例初始化 类使用的值，该值指示是否应将证书映射到 Windows 帐户和指定的证书验证程序。

如果该证书应映射到 Windows 帐户;否则为 。 设置 属性。 要使用的证书验证程序。 设置 属性。

新实例初始化 通过使用指定的证书验证程序类。

要使用的证书验证程序。 设置 属性。

返回一个值，该值指示指定的读取器所指 元素。

密钥标识符子句的开始元素处 XML 读取器。 如果读取器指向 元素; 否则为 。 为 。

返回一个值，该值指示在 Ws-security 规范中定义是否将读取器指向的 X.509 安全令牌。

指向将令牌 XML 读取器。 如果读取器指向 X.509 安全令牌。否则为 。 为 。

返回一个值，该值指示指定的密钥标识符子句是否可以序列化此处理程序。

要序列化密钥标识符子句。 如果 支持，如果 属性设置为 ; 否则为 。 为 。

获取 Ws-security X.509 令牌配置文件中定义的 X.509 安全令牌类型。

X.509 令牌类型 URI。 默认情况下，值 属性。

从 XML 加载自定义配置。

包含自定义配置的 XML 元素。 为 。 指定的自定义配置不正确。

反序列化指定的 XML 阅读器引用的密钥标识符子句。

XML 读取器引用的密钥标识符子句。 从 XML 进行反序列化密钥标识符子句。 为 。

反序列化由指定的 XML 阅读器引用的 X.509 安全令牌。

指向一个 X.509 安全令牌 XML 读取器。 从 XML 反序列化安全令牌。 的一个实例。 为 。 没有指向有效的 X.509 安全令牌在 Ws-security X.509 令牌配置文件中定义。 或指定 encodingType Base64 或 HexBinary 以外。

验证指定的 X.509 安全令牌。

要验证的标记。 在令牌中包含的标识。 不能从分配 。 为 。 属性为 。 - 或 - 没有任何颁发者名称注册表 () 配置。 ( 属性 所引用的 属性是 。) 当前 程序无法验证令牌中的证书。 当前 返回 在尝试解析令牌中证书的颁发者。

序列化到 XML 编写器指定的密钥标识符子句。

密钥标识符子句应序列化到 XML 编写器。 要序列化密钥标识符子句。 为 。 - 或 - 为 。 属性为 。

将指定的 XML 编写器指定的 X.509 安全令牌序列化。

令牌应序列化到 XML 编写器。 要序列化的 X.509 安全令牌。 的一个实例。 为 。 - 或 - 为 。 不能从分配 。

新实例初始化 类根据指定的 X.509 证书。

X.509 证书。

新实例初始化 类根据指定 X.509 证书和安全的密钥标识符。

X.509 证书。 安全密钥标识符。

新实例初始化 类根据指定的 X.509 证书、 安全密钥标识符、 签名算法和摘要算法。

X.509 证书。 安全密钥标识符。 签名算法。 摘要算法。

新实例初始化 类根据指定的 X.509 证书、 签名算法和摘要算法。

X.509 证书。 签名算法。 摘要算法。

使用指定的主题密钥标识符初始化 类的新实例。

一个 数组，它包含主题密钥标识符。 为 。

获取一个值，该值指示是否可以为指定的 X.509 证书创建密钥标识符子句。

一个包含 X.509 证书的 。 如果可以为 创建密钥标识符子句，则为 ；否则为 。 为 。

获取主题密钥标识符。

一个 数组，它包含主题密钥标识符。

返回一个值，该值指示此实例的密钥标识符是否与指定 X.509 证书的密钥标识符等效。

一个 ，包含要进行比较的 X.509 证书。 如果 与当前实例具有相同的主题密钥标识符，则为 ；否则为 。 为 。

返回表示当前对象的字符串。

一个表示当前对象的 。

使用指定的 X.509 证书创建密钥标识符子句。

要为其创建密钥标识符子句的 。 当此方法返回时，它包含一个表示密钥标识符子句的 。 此参数未经初始化即被传递。 如果可以为指定的 X.509 证书创建密钥标识符子句，则为 ；否则为 。 为 。

使用 X.509 证书的指定指纹初始化 类的新实例。

一个 数组，包含 X.509 证书的指纹。 为 。 - 或 - 的长度为零。

使用指定的 X.509 证书初始化 类的新实例。

一个包含 X.509 证书的 。 为 。

返回 X.509 证书的指纹。

一个 数组，包含 X.509 证书的指纹。

返回一个值，该值指示此实例的密钥标识符是否等效于指定 X.509 证书的指纹。

一个 ，包含要进行比较的 X.509 证书。 如果 与当前实例含有相同的指纹，则为 ；否则为 。

返回表示当前对象的字符串。

一个表示当前对象的 。

使用指定的 X.509 证书和 Windows 域或计算机帐户来初始化 类的新实例。

一个包含 X.509 证书的 。 一个 ，表示 Windows 域或计算机帐户的标识。

使用指定的 X.509 证书、Windows 域或计算机帐户以及唯一标识符来初始化 类的新实例。

一个包含 X.509 证书的 。 一个 ，表示 Windows 域或计算机帐户的标识。 安全令牌的唯一标识符。

创建 的新实例。

一个包含 X.509 证书的 。 标识 Windows 域或计算机帐户的标识。 令牌的身份验证类型。 安全令牌的唯一标识符。

释放由 使用的所有资源。

新实例初始化 具有回调委托和状态对象的类。

异步操作完成时调用的方法。 一个用户定义的对象，限定或包含有关异步操作的信息。

新实例初始化 具有的状态对象的类。

一个用户定义的对象，限定或包含有关异步操作的信息。

在异步操作完成，且未遇到异常，则调用此版本的完成。 它将更新操作的状态，并通知回调。

要包装的结果。 如果异步操作完成同步进行;否则为 。

如果引发处理过程中发生异常，则调用此版本的完成。 除了通知回调，它会捕获的异常并存储在调用期间引发 方法。

要包装的结果。 如果异步操作完成同步进行;否则为 。 在异步操作的处理期间发生的异常。

完成异步操作的结束函数时，应调用结束。 它可以确保异步操作已完成，并执行一些常见的验证。

表示异步操作的状态。 异步操作的类型化的结果。

初始化 类的新实例。

用序列化数据初始化 类的新实例。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。 为 。

新实例初始化 使用指定的令牌类型的类。

包含令牌类型 URI 的字符串。

使用指定的错误消息和对作为此异常原因的内部异常的引用来初始化 类的新实例。

解释异常原因的错误消息。 导致当前异常。 如果 参数不为 ，则当前异常将在处理内部异常的 块中引发。

集 具有不受支持的令牌类型和其他异常信息的对象。

一个 对象，其中包含序列化的对象数据。 一个 对象，其中包含有关源或目标的上下文信息。 为 。

初始化 类的新实例。

新实例初始化 用指定的主体、 资源声明和操作声明。

为其授权是要检查该主体。 表示为其主体是要为其授权的资源的声明集合。 通常，该集合包含单个元素。 表示要在对资源执行的操作的声明集合。 通常，该集合包含单个元素。 为 。 - 或 - 为 。 - 或 - 为 。

新实例初始化 用指定的主体、 资源名称和操作名称。

为其授权是要检查该主体。 主体未获得授权的资源。 作为一个名称声明的值指定的资源。 要在对资源执行的操作。 作为一个名称声明的值指定的操作。 为 。 - 或 - 为 。 - 或 - 为 。

初始化 类的新实例。

当在派生类中重写返回 对象与 RP 应用程序的要求一致。 默认实现不会修改传入 。

所请求资源的地址。 表示经过身份验证尝试访问该资源的用户所声明的主体。 所声明的主体包含 RP 应用程序所需的任何修改。 默认实现返回未经修改的形式传入声明主体。

在派生类中重写，当从 XML 加载自定义配置。

自定义配置元素中。 在列表中的每个节点属于类型 。

初始化 类的新实例。

派生类中实现时，检查指定的上下文中的主题的授权对指定资源执行指定的操作。

包含使用者、 资源和为其授权是要检查的操作的授权上下文。 如果该主题有权在指定的资源; 上执行指定的操作，否则为 。

在派生类中重写，当从 XML 加载自定义配置。

自定义配置元素中。 在列表中的每个节点属于类型 。

使用指定的密钥初始化 类的新实例。

一个表示密钥的 数组。

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

一个表示密钥的 数组。 若要克隆缓冲区，则为 ；否则为 。

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

一个表示密钥的 数组。 若要克隆缓冲区，则为 ；否则为 。 用于派生密钥的“只用一次的数字”(Nonce)。 要派生的密钥的长度。

创建安全密钥。

新创建的安全密钥。

获取表示密钥的字节数组。

表示密钥的字节数组。

比较指定子句的密钥是否与此实例的密钥相匹配。

要匹配的 。 如果存在匹配项，则为 ；否则为 。

初始化 类的新实例。

密钥名称。

检查 是否与该类的当前实例相匹配。

要进行比较的 。 如果存在匹配项，则为 ；否则为 。

检查指定的密钥名称是否与当前实例的密钥名称相匹配。

安全密钥名称子句。 如果存在匹配项，则为 ；否则为 。

返回一个 ，表示当前的 。 （从 继承）

当前的 。

使用指定的上下文标识符初始化 类的新实例。

安全性上下文的唯一 ID。

使用指定的上下文标识符和生成初始化 类的新实例。

一个 ，表示安全上下文的上下文 ID。 一个 ，表示安全上下文令牌的密钥生成。

用指定的值初始化 类的新实例。

标识符子句的上下文 ID 部分。 标识符子句的生成部分。 用于派生令牌的“只用一次的数字”(Nonce)。 要派生的密钥长度。

将指定的 与 类的当前实例进行比较。

要比较的 。 如果两个实例相等，则为 ；否则为 。

将指定的 与具有指定的上下文标识符和生成部分的 类的当前实例进行比较。

标识符子句的上下文 ID 部分。 标识符子句的生成部分。 如果两个实例相等，则为 ；否则为 。

提供该类实例的文本表示形式。

该类实例的文本表示形式。

初始化 类的新实例。

一个表示密钥的字节数组。

初始化 类的新实例。

密钥的大小（以位为单位）。

初始化 类的新实例。

令牌 ID。 一个表示密钥的字节数组。

初始化 类的新实例。

令牌 ID。 一个表示密钥的字节数组。 一个 ，指出是否允许加密。 为 。

初始化 类的新实例。

令牌 ID。 密钥的大小（以位为单位）。 小于或等于零，或者大于或等于 512，或者不是 8 的倍数。

初始化 类的新实例。

令牌 ID。 密钥的大小（以位为单位）。 一个 ，指出是否允许加密。 小于或等于零，或者大于或等于 512，或者不是 8 的倍数。

获取表示密钥的字节。

键。

初始化 类的新实例。

密钥令牌的 ID。 要包装的密钥。 用于执行包装的算法。 一个表示包装令牌的 。 一个 ，表示对包装令牌的引用。

获取一个值，该值指示令牌是否可以创建密钥标识符子句。

的类型。 如果令牌可以创建密钥标识符子句，则为 ；否则为 。 默认值为 。

创建密钥标识符子句。

的类型。 的类型。

获取已包装的密钥。

已包装的密钥。

比较当前的安全密钥标识符子句和指定的密钥标识符子句是否相等。

指定的安全密钥标识符子句。 如果当前的安全密钥标识符子句与指定的相等，则为 ；否则为 。 默认值为 。

获取一个用户定义的对象，该对象限定或包含有关异步操作的信息。

一个用户定义的对象，限定或包含有关异步操作的信息。

获取 用来等待异步操作以完成。

一个 用来等待异步操作以完成。

获取一个值，该值指示异步操作是否同步完成。

如果异步操作同步完成，则为 ；否则为 。

获取一个值，该值指示异步操作是否已完成。

如果操作已完成，则为 ；否则为 。

获取声明的类型。

表示声明类型的 URI。

获取一个对象，它可以比较两个 对象是否相等。

一个比较两个 对象的 接口实现。

获取与此 对象关联的资源。

与此 对象关联的资源。

指定与此 对象关联的权限的统一资源标识符 (URI) 的字符串表示形式。 预定义权限是以 类的静态属性的形式提供的。

指定与此 对象关联的权限的 URI。

表示系统实体的预定义声明。

一个表示系统实体的 对象。 此 对象具有下表所示的属性值。 属性 值

在派生类中重写时，获取此声明集中的声明数。

此 中的声明数。

在派生类中重写时，获取颁发此 的实体。

颁发此 对象的 对象。

在派生类中重写时，获取指定索引的 。

要检索的声明的索引。 位于指定索引处的 。

获取表示应用程序可信颁发者的 对象。

系统 对象。

获取一组包含 Windows 安全标识符的声明。

一个 ，其中至少包含一个类型为 的声明。

获取声明的 URI，该 URI 指定匿名用户。

声明的 URI，该 URI 指定匿名用户。

获取声明的 URI，该 URI 指定关于标识是否经过身份验证的详细信息。

声明的 URI，该 URI 指定关于标识是否经过身份验证的详细信息。

获取声明的 URI，该 URI 指定对于实体的授权决定。

声明的 URI，该 URI 指定对于实体的授权决定。

获取声明的 URI，该 URI 指定实体所在的国家/地区。

声明的 URI，该 URI 指定实体所在的国家/地区。

获取声明的 URI，该 URI 指定实体的出生日期。

声明的 URI，该 URI 指定实体的出生日期。

获取声明的 URI，该 URI 指定实体的 deny-only 安全标识符 (SID)。

声明的 URI，该 URI 指定实体的 deny-only SID。

获取声明的 URI，该 URI 指定与计算机名称关联的 DNS 名称或者与 X.509 证书的使用者或颁发者的备用名称关联的 DNS 名称。

声明的 URI，该 URI 指定与计算机名称关联的 DNS 名称或者与 X.509 证书的使用者或颁发者的备用名称关联的 DNS 名称。

获取声明的 URI，该 URI 指定实体的电子邮件地址。

声明的 URI，该 URI 指定实体的电子邮件地址。

获取声明的 URI，该 URI 指定实体的性别。

声明的 URI，该 URI 指定实体的性别。

获取声明的 URI，该 URI 指定实体的名字。

声明的 URI，该 URI 指定实体的名字。

获取声明的 URI，该 URI 指定一个哈希值。

声明的 URI，该 URI 指定一个哈希值。

获取声明的 URI，该 URI 指定实体的住宅电话号码。

声明的 URI，该 URI 指定实体的住宅电话号码。

获取声明的 URI，该 URI 指定实体所在的区域。

声明的 URI，该 URI 指定实体所在的区域。

获取声明的 URI，该 URI 指定实体的移动电话号码。

声明的 URI，该 URI 指定实体的移动电话号码。

获取声明的 URI，该 URI 指定实体的名称。

声明的 URI，该 URI 指定实体的名称。

获取声明的 URI，该 URI 指定实体的名称。

声明的 URI，该 URI 指定实体的名称。

获取声明的 URI，该 URI 指定实体的备用电话号码。

声明的 URI，该 URI 指定实体的备用电话号码。

获取声明的 URI，该 URI 指定实体的邮政编码。

声明的 URI，该 URI 指定实体的邮政编码。

获取声明的 URI，该 URI 指定实体的私人标识符 (PPI)。

声明的 URI，该 URI 指定实体的私人标识符 (PPI)。

获取声明的 URI，该 URI 指定一个 RSA 密钥。

声明的 URI，该 URI 指定一个 RSA 密钥。

获取声明的 URI，该 URI 指定一个安全标识符 (SID)。

声明的 URI，该 URI 指定一个安全标识符 (SID)。

获取声明的 URI，该 URI 指定一个服务主体名称 (SPN) 声明。

声明的 URI，该 URI 指定一个服务主体名称 (SPN) 声明。

获取声明的 URI，该 URI 指定实体所在的州或省份。

声明的 URI，该 URI 指定实体所在的州或省份。

获取声明的 URI，该 URI 指定实体的街道地址。

声明的 URI，该 URI 指定实体的街道地址。

获取声明的 URI，该 URI 指定实体的姓氏。

声明的 URI，该 URI 指定实体的姓氏。

获取声明的 URI，该 URI 标识系统实体。

声明的 URI，该 URI 标识系统实体。

获取声明的 URI，该 URI 指定一个指纹。

声明的 URI，该 URI 指定一个指纹。

获取声明的 URI，该 URI 指定一个用户主体名称 (UPN)。

声明的 URI，该 URI 指定 UPN。

获取声明的 URI，该 URI 指定一个 URI。

声明的 URI，该 URI 指定一个 URI。

获取声明的 URI，该 URI 指定实体的网页。

声明的 URI，该 URI 指定实体的网页。

获取一个字符串，其中包含 X.509 证书的可分辨名称声明的 URI。

X.509 证书的可分辨名称声明的 URI。

获取此声明集中包含的 对象数。

此声明集中包含的 对象数。

获取颁发此声明集的 对象。

颁发此声明集的 对象。

获取指定索引的 。

要检索的声明的索引。 索引指定的 。

获取一个字符串，该字符串指定权限表示标识。

表示标识的权限。

获取一个字符串，该字符串指定权限表示一个与声明关联的实体所拥有的属性。

一个权限，表示与 对象关联的实体所拥有的属性。

获取此集合中的声明数。

此集合中的声明数。

获取此 的过期时间。

此 过期的 。

获取此 的颁发者。

一个 ，表示此声明集的颁发者。

获取指定索引的声明。

要检索的 Windows 声明的索引。 指定索引的声明。

获取此声明集的 Windows 标识。

此声明集的 。

获取此 对象中的 X.509 证书声明数。

此 对象中的 X.509 证书声明数。

获取此 的过期时间。

此 的过期时间。

获取此 的颁发者。

此 的颁发者。

获取指定索引的声明。

要检索的声明的索引。 指定索引的声明。

获取与此声明集关联的 X.509 证书。

与此声明集关联的 X.509 证书。

获取或设置受众 URI。

受众 URI。

获取或设置的受众限制模式。

访问群体限制模式。 默认值为 。

获取此元素的节点的子级。

子节点的集合。 如果此元素没有任何子节点。

获取此实例所表示的 XML 元素。

XML 元素。

获取一个值，该值指示是否已使用非默认值的配置元素。

如果该元素已配置为使用非默认值;否则为 。

当前实例表示的。

此实例所表示的类型。

获取或设置已配置 。

已配置 。

获取或设置已配置 。

配置的缓存。

获取或设置处理程序用来验证颁发者证书的证书验证模式。

证书验证模式。

获取或设置处理程序用来验证颁发者证书的证书验证程序。

证书验证程序。

获取或设置声明身份验证管理器。 默认值是实例 类。

声明身份验证管理器。 尝试将该属性设置为 时发生。

获取或设置声明授权管理器。

声明授权管理器。 尝试将该属性设置为 时发生。

获取或设置一个值，该值指示是否处理程序应检测重播的令牌的默认处理程序配置中。

如果处理程序应检测，重播令牌;否则为 。

获取或设置一个值，该值指示是否 调用方法。

如果 方法已被调用; 否则为 。

获取或设置颁发者名称注册表使用颁发者名称解析。

颁发者名称注册表。 尝试将该属性设置为 时发生。

获取或设置颁发者令牌解析程序。

颁发者令牌解析器。 尝试将该属性设置为 时发生。

获取或设置通信双方的系统时钟之间允许的最大时间差异。

最大时钟偏差。

获取此配置的服务名称。

服务名称。

获取或设置处理程序用于验证颁发者证书的吊销模式。

吊销模式。

获取或设置一个值，该值指示令牌验证后 对象是否保存在 和会话中。

如果保存了 bootstrap 上下文，则为 ，否则为 。

获取 包含的一套 WS 信任消息中找到用于序列化和验证令牌的对象。

处理程序集管理器。

获取 对象的集合，这些对象用于序列化和验证 WS-Trust 消息中发现的令牌。

令牌处理程序的集合。

获取或设置服务证书。

要用作服务证书的 X.509 证书。

获取或设置服务令牌解析程序。

服务令牌解析器。 尝试将该属性设置为 时发生。

获取或设置项放入的过期期限 。

项的过期期限放置到令牌重放缓存中。

获取或设置处理程序用来验证颁发者证书的受信任存储区位置。

受信任存储区位置。

获取 此标识配置元素与该键相关联。

受众 Uri 配置为此标识配置元素的集合。

获取或设置 此标识配置元素与该键相关联。

配置令牌的元素重播缓存和会话安全令牌缓存此标识配置元素。

获取或设置 此标识配置元素与该键相关联。

配置的证书验证程序并将其属性为此标识配置元素的元素。

获取或设置与此标识配置元素相关联的声明身份验证管理器。

一个指定的自定义类型元素 的声明身份验证管理器。 该类型必须派生自 。

获取或设置与此标识配置元素相关联的声明授权管理器。

一个指定的自定义类型元素 声明授权管理器。 该类型必须派生自 。

获取或设置 此标识配置元素与该键相关联。

配置颁发者名称注册表中的有此标识配置元素的元素。

获取或设置与此标识配置元素相关联的颁发者令牌解析器。

一个指定的自定义类型元素 的颁发者令牌解析程序。 该类型必须派生自 。

获取或设置最大时钟偏差被配置为此标识配置元素。

最大时钟偏差。

获取或设置标识配置元素的名称。

标识配置的名称。

获取或设置一个值，该值指示是否声明标识和配置此标识集合中的处理程序创建的会话安全令牌中保存的启动上下文。

若要保存 ; 否则为 。

获取或设置 此标识配置元素与该键相关联。

为此标识配置元素配置的安全令牌处理程序集合...

获取或设置与此标识配置元素相关联的服务令牌解析器。

一个指定的自定义类型元素 的服务令牌解析程序。 该类型必须派生自 。

获取或设置 此标识配置元素与该键相关联。

指定是否启用令牌重放检测，以及指定令牌的最大有效期令牌重放缓存中的元素。

获取或设置 用于缓存 。

配置的会话令牌缓存。 尝试将该属性设置为 时发生。

获取或设置 用于确定是否重放令牌。

已配置的令牌重放缓存中。 尝试将该属性设置为 时发生。

获取一个值，该值指示是否配置了此元素。

如果该元素已配置;否则为 。

获取或设置 会话令牌缓存。

会话令牌缓存的类型。 该类型必须派生自 。

获取或设置 的令牌重放缓存。

令牌重放缓存的类型。 该类型必须派生自 。

获取或设置的字符串表示形式 的颁发者名称注册表。

字符串表示形式 的颁发者名称注册表。 该类型必须派生自 类。

获取 此令牌处理程序配置元素与该键相关联。

受众 Uri 配置此令牌处理程序配置元素的集合。

获取或设置 此令牌处理程序配置元素与该键相关联。

配置令牌的元素重播缓存和会话安全令牌缓存此令牌处理程序配置元素。

获取或设置 此令牌处理程序配置元素与该键相关联。

配置的证书验证程序和其属性进行此令牌处理程序配置元素的元素。

获取或设置 此令牌处理程序配置元素与该键相关联。

配置颁发者名称注册表中的有此令牌处理程序配置元素的元素。

获取或设置与此令牌处理程序配置元素相关联的颁发者令牌解析器。

一个指定的自定义类型元素 的颁发者令牌解析程序。 该类型必须派生自 。

获取或设置最大时钟偏差配置此令牌处理程序配置元素。

最大时钟偏差。

获取或设置令牌处理程序配置元素的名称。

标识配置的名称。

获取或设置一个值，该值指示是否声明标识和配置此标识集合中的处理程序创建的会话安全令牌中保存的启动上下文。

若要保存 ; 否则为 。

获取或设置与此令牌处理程序配置元素相关联的服务令牌解析器。

一个指定的自定义类型元素 的服务令牌解析程序。 该类型必须派生自 。

获取或设置 此令牌处理程序配置元素与该键相关联。

指定是否启用令牌重放检测，以及指定令牌的最大有效期令牌重放缓存中的元素。

获取或设置集合的名称。

集合的名称。

获取或设置集合中的处理程序的默认设置。

集合中的处理程序默认设置。

获取一个值，该值指示是否已使用非默认值配置此元素。

如果该元素已配置为使用非默认值;否则为 。

获取或设置默认的密钥大小限制在使用位检查，如果 KeySize 请求中指定在此限制内。

默认的密钥大小限制，以位为单位。 默认值为 1024年。

获取或设置默认的密钥大小，以使用已颁发令牌中的位数。

在已颁发令牌中，以位为单位使用的密钥大小。 默认值为 256。

获取或设置已颁发的令牌中使用的默认生存期。

要在中使用的默认生存期已颁发的令牌。 默认值为 1 天。

获取或设置令牌颁发中使用的默认令牌类型。

返回一个字符串，包含默认令牌类型。 指定的值是 或为空。 令牌处理程序中未定义指定的值。

获取或设置一个值，指定是否应为安全令牌服务 (STS) 启用 WSDL 生成。

若要启用 sts; WSDL 生成否则为 。 默认值为 。

获取或设置已颁发的令牌的最大令牌生存期。

最大令牌生存期为已颁发令牌的。 默认值为 1 天。

获取或设置 的安全令牌服务 (STS)。

安全令牌服务的类型。 该类型必须派生自 类。 指定的值不能作为分配 。 指定的值是 。

获取或设置的签名凭据。

签名的凭据。

获取或设置颁发者名称，以便可以在已颁发的令牌对其进行设置。

颁发者名称中。 尝试将该属性设置为 或空字符串的出现。

获取或设置 WS 信任 1.3 请求 (RST) 序列化程序。

WS 信任 1.3 请求 (RST) 序列化程序。 指定的值是 。

获取或设置 WS 信任 1.3 响应 (RSTR) 序列化程序。

WS 信任 1.3 响应 (RSTR) 序列化程序。 指定的值是 。

获取或设置 Ws-trust 2005 年 2 月请求 (RST) 序列化程序。

Ws-trust 2005 年 2 月请求 (RST) 序列化程序。 指定的值是 。

获取或设置 Ws-trust 2005 年 2 月响应 (RSTR) 序列化程序。

Ws-trust 2005 年 2 月响应 (RSTR) 序列化程序。 指定的值是 。

获取当前 引用。

当前 引用。

获取默认值 （未命名） 从配置文件。

默认值 （未命名） 元素。

获取 从配置文件。

一个包含的所有集合 中的元素 部分。

获取或设置一个值，该值指示是否应执行重播检测。

若要执行重播检测。否则为 。

获取或设置最长时间之前的项被视为过期并从缓存中删除。

最长时间被视为一个项之前过期，从缓存中删除。

获取或设置证书验证模式。

证书验证模式。 默认值为 。

获取或设置 的 X.509 证书验证程序。

一个包装的 X.509 证书验证程序类型的元素。

获取或设置吊销模式。

吊销模式。 默认值为 。

获取或设置 X.509 证书的受信任存储区位置。

X.509 证书存储区位置。 默认值为 。

获取或设置最大大小，以字节为单位，以解压缩的 cookie。

以字节为单位，解压缩 cookie 的最大大小。

获取位于当前读取器位置的属性数。

属性数目。

获取当前节点的基 URI。

基 URI。

获取当前节点的深度。

深度。

获取一个值，该值指示读取器定位在流的末尾。

如果用户是该流，则末尾否则为 。

获取一个值，该值指示当前节点是否可以具有 。

如果当前节点可以具有 ; 否则为 。

获取此实例包装内部读取器。

内部读取器。

获取一个值，该值指示当前节点是否是从 DTD 或架构中定义的默认值生成的属性。

如果当前节点生成的默认值;否则为 。

获取一个值，该值指示当前节点是否为空元素。

如果当前节点是一个空的元素;否则为 。

获取具有指定索引的属性的值。

属性的索引。 指定索引处的属性值。

获取具有指定名称的属性的值 (如返回 从包装读取器的属性)。

属性的限定名称。 指定的属性的值。 如果未找到该属性，则返回 。

获取具有指定的本地名称和命名空间 URI 的属性的值 (如返回 属性和 从包装读取器的属性。

属性的本地名称。 属性的命名空间 URI。 指定的属性的值。 如果未找到该属性，则返回 。

获取当前节点的本地名称。

移除了前缀的当前节点的名称。

获取当前节点的限定名称。

当前节点的限定名称。

获取当前节点的 URI 的命名空间。

命名空间 URI 在当前节点的...

获取与此实例关联的 。

，它使你能够获取该节点内字符串的原子化版本。

获取当前节点的类型。

值之一，表示当前节点的类型。

获取与当前节点关联的命名空间前缀。

与当前节点关联的命名空间前缀。

获取用于括起属性节点的值的引号字符。 ("或)。

用于括起属性节点的值的引号字符（" 或 '）。

获取读取器的状态。

其中一个 值，该值指定读取器的状态。

获取当前节点的文本值。

当前节点的文本值。 有关详细信息，请参阅 属性

获取当前节点的公共语言运行时 (CLR) 类型。

与节点的类型化值对应的 CLR 类型。 默认值为 。

获取 作用域。

作用域。

获取当前 范围。

值之一。 如果不存在任何 范围，则该属性默认值为 。

返回一个值，该值指示读取器是否支持规范化工作。

如果读取器支持的规范化; 则为 true否则为 false。

获取已包装的编写器。

返回 。

当在派生类中被重写时，获取写入器的状态。

返回 。

获取信封的情况下被用完后以及验证的签名的签名中使用的签名凭据。

签名的凭据。

获取此应用程序服务的终结点。

应用程序服务的终结点的集合。

获取此应用程序服务的被动请求者终结点。

应用程序服务的被动请求者终结点的集合。

获取或设置的公司名称。

公司名称。

获取电子邮件地址的集合。

电子邮件地址的集合。

获取或设置给定的名称。

给定的名称。

获取或设置姓氏。

姓氏。

获取或设置电话号码的集合。

电话号码的集合。

获取或设置联系人类型。

指定联系人的类型的枚举值之一。

获取与显示声明关联的声明类型。

一个表示声明类型的 URI。

获取或设置显示声明的说明。

显示声明说明。

获取或设置显示声明的友好名称。

显示声明友好名称。

获取或设置显示声明一个可显示值。

显示声明可显示值。

获取或设置显示声明的可选属性

如果显示声明是可选的;否则为 。 默认值为 。

获取或设置一个值，该值指示是否将序列化的可选属性。

要序列化的可选属性;否则为 false。 默认值为 。

获取或设置加密方法算法属性。

加密算法的 URI。

获取子 为此实体集合。

子集合 。 默认值为空集合。

获取子 为此实体集合。

子集合 此实体。 默认值为空集合。

获取或设置此实体集合的名称。

实体集合的名称。 默认值为 。

获取的集合 此描述符。

联系人对象的集合。 默认值为空集合。

获取或设置此描述符的实体 ID。

实体 id。 默认值为 。

获取或设置此说明符的联合 ID。

联合 id。 默认值为 。

获取或设置此说明符的组织。

组织。 默认值为 。

获取此说明符角色描述符的集合。

角色描述符的集合。 默认值为空集合。

获取或设置实体 id。

实体 id。 设置实体 ID 长度超过 1024年个字符的尝试时发生。

获取的集合 表示单一登录服务。

表示单一登录服务的协议终结点的集合。 默认值为空集合。

获取支持 集合。

支持的属性的集合。 默认值为空集合。

获取或设置一个值，该值指示是否应签名身份验证请求。

如果应对签名身份验证请求;否则为 。 默认值为 。

获取或设置的索引。 这是必需的元素。

索引。

获取或设置一个值，该值指示这是否为默认终结点。 这是可选项。

如果这是默认的终结点;否则为 。 可以为 。 默认值为 。

获取默认的 。

默认的 。 如果存在无默认值。

获取的集合 此密钥的描述符。

加密方法的集合。 默认值为空集合。

获取或设置此密钥描述符的密钥标识符。

密钥标识符。 默认值为 。

获取或设置 此密钥的描述符。

指定密钥类型的枚举值之一。 默认值为 。

获取或设置的区域性信息。

区域性信息。 尝试将该属性设置为 时发生。

获取或设置名称。

名称。

获取或设置一个 URI。

URI。

获取或设置的签名凭据。

签名的凭据。 默认值为 。

获取或设置用于签署的元数据文档的 X.509 证书验证模式。

指定 X.509 证书验证模式的枚举值之一。 通过指定了默认值 。

获取或设置用于签署的元数据文档的 X.509 证书的证书验证程序。

X.509 证书的证书验证程序。

获取或设置用于签署的元数据文档的 X.509 证书的吊销模式。

指定 X.509 证书吊销模式的枚举值之一。 通过指定了默认值 。

获取当前实例用于序列化安全令牌的令牌序列化程序。

令牌序列化程序的当前实例使用。

获取受信任的元数据对文档进行签名的当前实例的受信任颁发者的列表。

受信任的颁发者的列表。

获取或设置用于签署的元数据文档的 X.509 证书的受信任存储区位置。

存储区位置指定 X.509 证书的枚举值之一。 通过指定了默认值 。

获取与组织关联的显示名称的集合。 这是必需的元素。

显示名称的集合。

获取与组织关联的名称的集合。 这是必需的元素。

名称的集合。

获取与组织相关联的 Url 的集合。 这是必需的元素。

URL 项的集合。

获取或设置的绑定。 这是必需的元素。

一个 URI，表示当前实例的绑定。

获取或设置的位置。 这是必需的元素。

一个 URI，表示当前实例的位置。

获取或设置响应的位置。 这是可选元素。

用于表示当前实例的响应位置的 URI。 默认值为 。

获取的集合 。

为此角色描述符的联系人的集合。

获取或设置错误 URL。

此角色描述符错误 URL。

获取的集合 。

为此角色描述符密钥描述符的集合。

获取或设置 。

此角色描述符的组织。

获取受支持的协议的集合。

受支持协议的此角色描述符的集合。

获取或设置的过期时间。

此角色描述符到期时间。

获取的集合 表示被动请求者终结点。

被动请求者的终结点的集合。

获取的集合 ，表示安全令牌服务的终结点。

终结点的集合。

获取 ，其中包含支持 [SAMLProf] 中定义的身份验证请求的协议的配置文件的索引终结点。

此实例的 。

获取或设置一个值，该值指示是否将签名由服务提供商发送的请求。

如果发送针对服务提供商的身份验证请求将进行签名;否则为 。 默认值为 。

获取或设置一个值，该值指示是否应签名，服务提供程序接收的断言。

如果断言收到的服务提供程序应进行签名则否则为 。 默认值为 。

获取 对象，其中包含对项目解析服务的索引终结点。

，其中包含对项目解析服务的索引终结点。

获取表示支持的名称标识符格式的 Uri 的集合。

表示支持的名称标识符格式的 Uri 的集合。

获取服务终结点的单一注销的集合。

单一注销服务终结点的集合。

获取一套 ，它表示提供的声明类型。

提供的声明类型的集合。

获取一套 ，表示请求的声明类型。

请求的声明类型的集合。

获取或设置服务说明。

服务说明。

获取或设置服务显示名称。

服务显示名称。

获取一套 表示目标作用域。

目标作用域的集合。

获取提供的令牌类型的集合。

提供的令牌类型的集合。

获取属性包可以扩展对象。

属性包，可以扩展对象。

获取与授权策略关联的声明集。

一个类型为 的 ，它包含声明集。

获取此 对象不再有效的日期和时间。

一个 值，指示此 对象不再有效的日期和时间。

获取此 对象的唯一标识符。

一个 对象。

获取与此 对象关联的非声明属性的集合。

一个指定非声明属性集合的 。

获取 对象的只读集合，该集合包含由已经过评估的授权策略添加的声明。

一个 对象，它包含由已经过评估的授权策略添加的声明。

获取已向评估上下文中添加声明的次数。

已向评估上下文中添加声明的次数。

获取与此 关联的非声明属性的集合。

一个指定非声明属性集合的 。

获取标识此授权组件的字符串。

一个标识此授权组件的字符串。

获取一个表示授权策略颁发者的声明集。

一个表示授权策略颁发者的 。

获取此实例的上下文项的集合。

的 作为名称 / 值对的集合 (RST) 请求提供上下文的对象。 默认值为空列表。

获取与 BinaryExchange 元素关联的二进制数据。

一个数组 ，包含二进制数据。

获取 EncodingType URI。

一个 ，其中包含的编码类型。 这是 BinaryExchange 元素的 EncodingType 属性的值。

获取 ValueType URI。

一个 ，其中包含的值类型。 这是 BinaryExchange 元素的 ValueType 属性的值。

获取或设置名称 URI。

一个 包含名称属性的值。

获取或设置范围 URI。

一个 ，其中包含作用域属性的值。 可以为 。 尝试设置一个值，不是 并不是绝对 URI。

获取或设置的上下文项的值。

ContextItem 元素的值。 可以为 。

获取终结点引用中包含的 XML 元素的集合。 集合中不包括 wsa:Address 元素。

终结点引用中包含的 XML 元素的集合。

获取指定的终结点引用的地址的 URI。

终结点引用的地址。

获取的令牌创建时间以 UTC 时间。

一个 ，它表示在其中创建该令牌的 UTC 时间。 可以为 。

获取令牌的过期时间的 UTC 时间。

一个 ，它表示令牌过期时的 UTC 时间。 可以为 。

获取可以使用该令牌的参与者的列表。

参与者的列表。 在列表中的每个项都包含 wst:Participant 元素的内容。

获取或设置已颁发令牌的主要用户。

包含令牌的主要用户的地址。 这是 wst:Primary 元素的内容。

获取密钥的加密凭据。

一个 ，表示用来加密密钥的凭据。 指示该密钥不加密。

获取或设置一个值，该值指示是否可以续订令牌。

如果允许续订;否则为 。

获取或设置一个值，该值指示是否可以过期后续订令牌。

如果可以续订请求的令牌，过期; 后否则为 。

获取请求的声明的类型。

表示声明类型 URI。

获取或设置一个值，该值指示请求声明是否可选在响应中。

如果声明是可选的响应中;否则为 。

获取或设置请求的声明值。

声明的值。

获取或设置的方言属性。

一个字符串，其中包含标识方言的 URI。 默认值是 , ，这指示 集合中的对象对应于信息卡配置文件。

获取计算所得的密钥算法用于计算组合的平均信息量用例中的会话密钥。

一个字符串，包含一个 URI，指示该计算的密钥算法。

在这种情况中获取的密钥，当 wst:RequestedProofToken 元素包含一个键。

一个 ，表示的键，可以为加密或清除文本。

获取已颁发的安全令牌时 使用该令牌本身创建的实例。

一个 表示已颁发的安全令牌。 如果 使用令牌的 XML 创建实例。

获取的 XML 表示形式已颁发的安全令牌时 使用令牌的 XML 创建实例。

，其中包含的 XML 表示形式的安全令牌。 如果 实例使用创建 对象。

获取或设置请求程序尝试充当标识的安全令牌。

一个 ，表示请求程序尝试使其作为的标识。 可以为 。

获取或设置请求的附加上下文信息。

包含请求的附加上下文信息。 可以为 。

获取或设置要采用 WS 信任取消请求取消的标记。

一个 ，包含要取消的标记。

获取客户端 （请求程序） 发出请求的声明类型。

一个 ，其中包含请求的声明。 默认值为空集合。

获取一个表示所需的算法在计算的密钥可用于已颁发的令牌时要使用的 URI。

一个字符串，其中包含表示计算所得的密钥算法的 URI。

获取或设置一个值，指定是否应将已颁发的令牌标记为可以进行委派。

如果颁发的令牌是可以进行委派。否则为 。 可以为 。

获取或设置应向其委派颁发的令牌的标识。

一个 ，表示应向其委派颁发的令牌的标识。 可以为 。

获取或设置有关的令牌和密钥在加密时使用的信息。

一个 ，其中包含加密的信息。

获取或设置一个值，指定是否颁发的令牌应标记为票据。

如果颁发的令牌是票据;否则为 。 可以为 。

获取或设置 wst:OnBehalfOf 令牌的颁发者。

一个 ，其中包含颁发者的地址。

获取或设置代表发出请求的标识令牌。

一个 包含在请求发出的标识令牌。

获取或设置有权使用的已颁发的令牌的参与者。

一个 ，其中包含有权使用的已颁发的令牌的参与者。

获取或设置要用于加密的证明令牌的令牌。

一个 包含的令牌。

获取或设置针对 WS 信任续订请求的续订语义。

返回 ，其中包含更新语义。

获取或设置要在 WS 信任环境中续订的令牌续订请求。

一个 ，包含要续订的令牌。

获取或设置为其请求者不是原始发件人的参数。

一个 包含辅助参数的请求; 即，为其请求者不是原始发件人的参数。

获取或设置要在 WS 信任验证的令牌验证请求。

一个 ，包含要验证的令牌。

获取或设置用于确定是否 RSTR 是最后一条消息，并应在这种序列化的标志。

如果 RSTR 是最后一条消息;否则为 。

获取或设置请求的令牌附加到消息时的安全令牌引用。

一个 ，其中包含该引用。

获取或设置用于返回拥有令牌的证明的可选元素。

一个 表示的证明令牌。

获取或设置用来返回请求的安全令牌的可选元素。

一个 表示安全令牌。

获取或设置 wst:RequestedTokenCancelled 元素。

如果该标记已取消;否则为 。

获取或设置请求的令牌未附加到消息的安全令牌引用。

一个 ，其中包含该引用。

获取或设置中 RSTR wst:Status 元素。

一个 ，它包含一个 WS 信任验证申请的状态信息。

获取或设置在 RSTR WS 信任验证绑定的状态代码。

一个字符串，包含状态代码的 URI。

获取或设置在 RSTR WS 信任验证绑定的可选状态原因。

返回一个字符串，包含的原因。

获取安全密钥标识符

一个 ，表示安全密钥标识符。

获取安全令牌，如果序列化程序不能将其转换为安全密钥标识符。

一个 表示的令牌。

获取或设置 wst:AllowPostdating 元素的内容。

如果返回的令牌应允许对远期令牌; 的请求否则为 。

获取或设置 wsp:AppliesTo 元素的内容。

，表示为其所需的安全令牌的终结点地址。

获取或设置 wst:AuthenticationType 元素的内容。

一个字符串，包含一个 URI，指示所需的身份验证的类型。

获取或设置 wst:BinaryExchange 元素的内容。

一个 包含二进制数据交换。 这包括 ValueType 和 EncodingType 属性，以及实际数据的内容。

获取或设置 wst:CanonicalizationAlgorithm 元素的内容。

一个字符串，包含一个 URI，指示的规范化算法。

获取或设置上的 RST 或 RSTR 的上下文属性的内容。

一个字符串，包含一个 URI，标识请求或响应消息的上下文。

获取或设置 wst:EncryptionAlgorithm 元素的内容。

一个字符串，包含一个 URI，指示的加密算法。

获取或设置 wst:EncryptWith 元素的内容。

一个字符串，包含一个 URI，指示所需的加密 algoritm 要用于颁发的安全令牌。 尝试将该属性设置为 或空字符串的出现。

获取或设置 wst:Entropy 元素的内容。

一个 表示平均信息量元素的内容。

获取或设置作为 RequestSecurityToken (RST) 消息内 wst:KeySize 元素的内容。

密钥的大小（以位为单位）。 尝试将设置一个值小于或等于零时发生。

获取或设置作为 RequestSecurityToken (RST) 消息内 wst:KeyType 元素的内容。

一个字符串，其中包含标识所需的键的类型的 URI。

获取或设置 wst:KeyWrapAlgorithm 元素的内容。

一个字符串，其中包含标识该密钥的 URI 换行算法。

获取或设置作为 RequestSecurityToken (RST) 消息内 wst:Lifetime 元素的内容。

一个 ，它表示所需的时间在此期间，返回的令牌才有效。

获取或设置要用于给信赖方答复的地址。

一个字符串，包含的地址。

获取或设置 wst: requesttype 元素。

一个字符串，包含一个 URI，指示所请求的类型;例如，一个中定义的常数 类。

获取或设置 wst:SignatureAlgorithm 元素的内容。

一个字符串，包含一个 URI，指示签名算法。

获取或设置 wst:SignWith 元素的内容。

一个包含标识所需的签名算法的 URI 的字符串。 尝试将值设置为 或空字符串的出现。

获取或设置 wst:TokenType 元素的内容。

一个字符串，包含一个 URI，指示标记的类型。

获取或设置 wst:UseKey 元素的内容。

一个 包含密钥。

获取 ，其中包含的组 WS 信任消息中找到用于序列化和验证令牌的对象。

一个 对象。

获取或设置的集合 WS 信任消息中找到用于序列化和验证安全令牌的对象。

一个 对象。

获取或设置 对象用于解析在 WS 信任消息的大多数元素中找到的安全令牌引用。

一个 对象。

获取或设置 用于解析的安全令牌引用在 RST 消息的 wst:UseKey 元素，以及在 RST 消息中找到的 wst:RenewTarget 元素中找到的对象。

一个 对象。

获取默认情况下，用于解密的密钥此属性返回包含仅加密密钥的列表。

可用于解密密钥。

获取或设置用于加密的 RSA 密钥

用于加密的 RSA 密钥。

获取或设置要使用的哈希算法的名称。

要使用的哈希算法的名称。 默认值为"SHA2566"。

获取或设置要使用的哈希算法的名称。

哈希算法的名称。 默认值为"SHA256"。

获取或设置用于签名的 RSA 密钥。

用于签名 RSA 密钥。

获取用于签名验证的密钥的集合。 默认情况下，此属性返回包含仅签名的密钥的列表。

用于签名验证的键的集合。

获取或设置依赖方的 appliesTo 地址。

信赖方 appliesTo 地址。 这通常是一个 URI。

获取或设置为信赖方的加密凭据。

为信赖方使用的加密凭据。

获取属性包可以扩展对象。

属性包中。

获取或设置依赖方的回复地址。

信赖方 replyTo 地址。 这通常是一个 URI。

获取或设置为信赖方的签名凭据。

为信赖方使用的签名凭据。

获取或设置一个值，该值指示是否必须加密颁发的对称密钥。

如果必须对对称密钥进行加密;，否则为 。 默认值为 。

获取或设置一个值，该值指示是否必须加密颁发的安全令牌。

如果安全令牌必须加密;，否则为 。 默认值为 。

获取与异步调用关联的令牌请求者的标识。

令牌请求者的标识。

获取与异步调用关联的令牌请求 (RST)。

与异步调用关联的令牌请求。

获取 与异步调用关联。

表示异步调用的状态。

获取或设置令牌颁发异步调用过程中将使用的安全令牌处理程序。

将使用令牌处理程序。

获取或设置与当前实例关联的主体。

一个 ，它表示当前的主体。

获取或设置与当前实例关联的安全令牌请求 (RST)。

一个 ，其中包含该请求。

获取或设置与当前实例关联的范围。

一个 表示令牌颁发请求的配置。

获取或设置 与当前实例相关联。

安全令牌说明符与当前实例相关联。 尝试将该属性设置为 时发生。

获取配置实例的所有者。

一个 ，其中包含当前实例的配置。

获取 安全令牌的标识。

一个 ，它表示 的标识。

获取要获取的 安全令牌的服务主体名称。

要获取的 安全令牌的服务主体名称。

获取一个值，该值指定 安全令牌的接收方可在多大程度上代表客户端执行操作。

一个 ，它指定 安全令牌的接收方可在多大程度上代表客户端执行操作。

获取的目标 Uri 集为其 安全令牌可能会成为目标才被视为有效由此 实例。

一个类型为 的 ，它包含 安全令牌的目标 URI 集，只有在使用这些目标 URI 时，此安全令牌身份验证器才会将该令牌视为有效令牌。

获取或设置一个 ，它指定是否应验证 安全令牌的 。

一个 ，指定是否应验证 安全令牌的 。

获取作为异步方法调用的最后一个参数传递的对象。

返回 。

获取封装 Win32 同步句柄的 。

返回 。

返回 调用完成异步; 否则为如果 。

返回 。

返回 如果异步调用的是已完成; 否则为 。

返回 。

获取一个值，该值指示是否可以取消安全令牌。

如果可以取消安全令牌，则为 ；否则为 。 默认值为 。

获取一个值，该值指示是否可以续订安全令牌。

如果可以续订安全令牌，则为 ；否则为 。 默认值为 。

获取令牌的属性的值，如果它是可选的。

令牌的属性的值。

获取或设置与安全令牌相关联的密钥的要求大小。

与安全令牌相关联的密钥的大小（以位为单位）。 默认值为 0。 属性被设置为一个小于 0 的值。

获取一个值，该值指定 属性在 集合中的索引名称。

属性在 集合中的索引名称。

获取或设置与安全令牌相关联的密钥的类型（非对称或对称）。

一个 ，它指定了与安全令牌相关联的密钥的类型（非对称或对称）。 默认值为 。

获取一个值，该值指定 属性在 集合中的索引名称。

属性在 集合中的索引名称。

获取或设置一个值，该值指定与安全令牌相关联的密钥的使用方式。

一个 ，它指定与安全令牌相关联的密钥的使用方式。 默认值为 。

获取一个值，该值指定 属性在 集合中的索引名称。

属性在 集合中的索引名称。

获取用于指定对等身份验证方法的属性在 集合中的索引名称。

用于指定对等身份验证方法的属性在 集合中的索引名称。

获取当前 实例的非静态属性的集合。

一个 ，它包含当前 实例的非静态属性的集合。

获取或设置一个值，该值指示安全令牌是否必须能够执行加密操作（例如加密）。

如果安全令牌必须能够执行加密操作，则为 ；否则为 。 默认值为 。

获取 属性在 集合中的索引名称。

属性在 集合中的索引名称。

获取或设置要求的安全令牌类型。

要求的安全令牌类型。

获取一个值，该值指定 属性在 集合中的索引名称。

属性在 集合中的索引名称。

获取不对用户名和密码执行验证的验证程序。 因此，用户名和密码总是被视为有效。

一个 ，它不对用户名和密码执行验证。

获取使用信任链来验证 X.509 证书的验证程序。

一个 ，它使用信任链来验证 X.509 证书。

获取不对 X.509 证书执行验证的验证程序。 因此，X.509 证书总是被视为有效。

一个 ，它不对 X.509 证书执行验证。

获取一个验证程序，它通过验证证书是否位于 证书存储区中来验证证书，或通过构建证书信任链来验证证书。 如果证书通过任一验证方法，就是受信任的。

一个 ，它通过验证证书是否位于 证书存储区中来验证证书，或通过构建证书信任链来验证证书。

获取一个验证程序，它验证证书是否位于 证书存储区中。

一个 ，它验证证书是否位于 证书存储区中。

获取一个值，指示是否将 X.509 证书映射到 Windows 帐户。

若要将 X.509 证书映射到 Windows 帐户，则为 ；否则为 。

获取与 安全令牌相关联的 X.509 证书。

获取用于表示安全令牌的 X.509 证书的 。

获取此实例包装的令牌解析程序的安全性。

包含此实例包装令牌解析程序的只读集合。

从使用的密钥获取已向请求者的密钥标识符。 它可以回显返回在 SAML 令牌，如有必要。

请求者提供从使用密钥的密钥标识符。

获取允许的受众 Uri 的列表。

允许的受众 Uri 的列表。

获取或设置在其中应用受众 URI 限制的模式。

指定在其中应用了受众 URI 限制的模式的枚举值之一。

获取机构以用于解析的身份验证事件的集合。

颁发机构以用于解析的身份验证事件的集合。

获取或设置要用于解析的身份验证事件的上下文类。

要用于解析的身份验证事件的上下文类。

获取或设置要用于解析的身份验证事件的上下文声明。

要用于解析的身份验证事件的上下文声明。

获取用于初始化上下文的安全令牌。

安全令牌或 。

获取用于初始化上下文的令牌处理程序。

令牌处理程序或 。

获取用于初始化上下文的字符串。

用于初始化上下文的字符串或 。

获取用于初始化上下文的数组。

用于初始化上下文的数组或 。

获取此实例的已配置的受信任颁发者的字典。

一个字典，其中包含受信任的颁发者。

获取用于提供一个提示，当需要解析为某个特定键的对象。

一个对象，需要解析为某个特定键时给出一个提示。

获取包装用于加密会话密钥; 凭据的密钥例如， 。

表示用于加密会话密钥的凭据。

获取与加密密钥相关联的用户可读名称。

与加密密钥相关联的用户可读名称。

获取加密密钥的密钥标识符。

一个 ，表示加密密钥的密钥标识符。

获取用于加密密钥的加密算法。

用于加密密钥的加密算法。

获取要用于加密的凭据。

要用于加密的凭据。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌相关联的加密密钥。

与安全令牌相关联的密钥集。

获取加密的令牌。

加密的令牌。

在安全令牌无效的时间内获取的最初时刻。

中的安全令牌的有效时间瞬间。

获取最后一个时刻的安全令牌无效。

安全令牌无效的时的时刻上一次。

获取一个值，该值指示是否处理程序提供的令牌序列化功能。

如果该处理程序可以序列化令牌;否则为 。 总是为 。

获取或设置 将使用序列化和反序列化密钥标识符从 元素。

将用于读取和写入的令牌序列化程序密钥的密钥标识符。 尝试将该属性设置为 时发生。

获取由当前实例的标记的类型。

处理的当前实例的令牌类型。 默认值是 。

获取或设置加密算法。

一个 URI，表示用来加密校验密钥的加密算法。 尝试将属性设置为 或为空字符串。

获取或设置加密密钥材料。

一个 ，包含用于加密校验密钥的加密密钥。 尝试将属性设置为 。

获取或设置标识加密凭据的标识符。

一个 用于标识用于加密校验密钥的密钥。 尝试将属性设置为 。

获取表示密钥标识符子句的 XML 元素。

XML 元素，表示密钥标识符子句。

获取此安全令牌的授权策略集合。

一个类型为 的 ，包含此安全令牌的授权策略集。

获取当此安全令牌未包含在引用它的 SOAP 消息内时引用此安全令牌的安全密钥标识符子句。

一个 ，表示安全令牌未包含在引用它的 SOAP 消息内时对此安全令牌的引用。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取当此安全令牌包含在引用它的 SOAP 消息内时引用此安全令牌的安全密钥标识符子句。

一个 ，表示安全令牌包含在引用它的 SOAP 消息内时对此安全令牌的引用。

获取安全令牌的证明令牌。

一个 ，表示安全令牌的证明令牌。

获取与证明令牌相关联的加密密钥。

一个类型为 的 ，包含与证明令牌相关联的密钥集。

获取与安全令牌相关联的 XML。

一个 ，表示与安全令牌相关联的 XML。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取密钥的大小（以位为单位）。

密钥的大小（以位为单位）。

获取此实例包装的安全令牌解析。

已包装的令牌解析器。

获取与此安全令牌关联的 Kerberos 票证的对称会话密钥。

一个 ，它包含与此安全令牌关联的 Kerberos 票证的对称会话密钥。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取用于描述值类型的 URI。

返回 。

获取与此安全令牌关联的 Windows 用户。

一个表示 Windows 用户的 。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与此安全令牌关联的 Kerberos 票证的对称会话密钥。

一个 ，它包含与此安全令牌关联的 Kerberos 票证的对称会话密钥。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取 安全令牌的服务主体名称。

安全令牌的服务主体名称。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示当前实例是否可以验证安全令牌。

如果该处理程序可以验证令牌;否则为 。 默认值为 。

获取由当前实例的标记的类型。

由当前实例的标记的类型。 默认情况下，这是一种 类。

获取当前 SOAP 消息中 XML 元素的 属性值。

当前 SOAP 消息中 XML 元素的 属性值。

获取 属性所引用的安全令牌的类型。

一个 ，包含 属性所引用的安全令牌的类型。

派生类中实现时，获取可在已颁发的令牌定义键的键标识符。

密钥标识符。

获取一个值，该值指示是否可以从密钥标识符子句创建密钥。

在所有情况下均为 。

获取与密钥标识符子句关联的 RSA 算法。

一个表示 RSA 算法的 。

获取密钥的大小（以位为单位）。

密钥的大小（以位为单位）。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取能够创建非对称密钥的 RSA 算法。

一个 ，表示能够创建非对称密钥的 RSA 算法。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示此处理程序是否支持验证的类型的令牌 。

如果该处理程序支持的类型的令牌验证 ; 否则为 。 总是为 。

获取一个值，该值指示此处理程序是否可以编写类型的令牌 。

如果该处理程序可以编写类型的令牌 ; 否则为 。 总是为 。

获取 该处理程序处理的令牌。

的类型。

获取或设置表示在其中指定操作的名称将被解释的 XML 命名空间的 URI 引用。

表示的命名空间。 尝试将该属性设置为 时发生。 设置一个值，不是绝对 URI 的尝试时发生。

获取或设置的操作的主题 可以在资源上执行。

该操作的主题的 可以在资源上执行。 尝试设置一个值，该值 或空字符串的出现。

获取所引用的 id。 断言的集合

类型的集合 ，其中包含引用断言的 Id。

获取断言值所指定的集合。

类型的集合 包含的断言。

获取所引用的 URI 断言的集合。

类型的集合 ，其中包含引用声明的 Uri。

获取或设置与断言，可帮助相关的其他信息处理在某些情况下，但这可能会忽略由应用程序不理解的建议或不希望使其使用。 [Saml2Core，2.3.3]

一个 包含断言为相关的其他信息。

获取一个值，该值指示是否从 XML 源进行反序列化此断言，并可以重新发出 XML 数据不变。

如果此断言重新发出 XML 源数据保持不变;否则为 。

获取或设置在评估的有效性和/或使用断言时都必须进行评估的条件。 [Saml2Core 2.3.3]

一个 包含的条件。

获取或设置用于加密该断言的凭据。 使用加密凭据中的密钥标识符为嵌入 中 元素。

返回 表示的凭据。

获取或设置包含指定任何其他加密的密钥的集合外部到 EncryptedData 元素，作为 EncryptedAssertion 元素的子级。

类型的集合 ，包含的键。

获取或设置断言的标识符。 [Saml2Core，2.3.3]

一个 表示的标识符。 尝试将该属性设置为 时发生。

获取或设置即时的问题的时间以 utc 为单位。 [Saml2Core，2.3.3]

一个 ，表示从该处此断言的颁发时间采用 UTC 时间。 默认值为 。

获取或设置正在索赔断言的 SAML 授权机构的标识符。 [Saml2Core，2.3.3]

一个 ，它指定颁发者。 尝试将该属性设置为 时发生。

颁发者用于保护该断言的完整性的凭据。

一个 表示的凭据。

获取包含的语句的集合与有关进行此断言中的主题。

类型的集合 ，它包含断言语句。

获取或设置断言中的语句的主题。 [Saml2Core，2.3.3]

一个 指定的主题。

获取此断言的 SAML 版本。 [Saml2Core，2.3.3]

一个字符串，包含的版本。

获取或设置 SAML 属性中包含的值的 xsi: type。

一个字符串，包含 xsi: type。 默认值为 。 尝试设置一个值，该值 或空发生。 - 或 - 尝试设置一个值的格式不正确，会发生。

获取或设置该属性的用户可读名称。 [Saml2Core，2.7.3.1]

一个字符串，包含该属性的友好名称。

获取或设置属性的名称。 [Saml2Core，2.7.3.1]

一个包含属性名称的字符串。 尝试设置一个值，该值 或空字符串的出现。

获取或设置一个 URI，表示用于解释名称的特性名称的分类。 [Saml2Core，2.7.3.1]

一个 ，它表示该分类。 尝试设置一个值，不是 并且不是绝对 URI 发生。

获取或设置表示该 SAML 属性的 OriginalIssuer 的字符串。

一个字符串，包含该属性的原始颁发者。 尝试设置一个值为空字符串，会发生。

获取包含该属性的值的集合。

包含属性值的字符串集合。

获取属性语句中包含的属性的集合。 这些属性是对断言使用者与相关联。 [Saml2Core，2.7.3]

类型的集合 ，其中包含该语句中的属性。

获取指定给它发送断言受众的 Uri 的集合。 条件为信赖方的任何指定的访问群体成员是否有效。

类型的集合 ，它指定访问者。

获取的零个或多个唯一标识符 (Uri 在 （不包括断言颁发者，假定为已而无需显式包含在集合中所涉及的人员） 的主体进行身份验证过程中涉及的身份验证机构的) 集合。 [Saml2Core，2.7.2.2]

返回类型的集合 ，它标识在主体的身份验证过程中涉及的身份验证机构。

获取或设置标识身份验证上下文类，用于描述遵循的身份验证上下文声明的 URI 引用。 [Saml2Core，2.7.2.2]

一个 标识上下文类。 尝试设置一个值，不是 并且不是绝对 URI 发生。

获取或设置一个 URI 引用，标识的身份验证上下文声明。 [Saml2Core，2.7.2.2]

一个 标识的身份验证上下文声明。 尝试设置一个值，不是 并且不是绝对 URI 发生。

获取或设置使用的最多颁发机构进行身份验证和包括生成此语句在身份验证事件的上下文。 [Saml2Core，2.7.2]

一个 表示的上下文。 尝试设置一个值，该值 时发生。

获取或设置发生身份验证的时间。 [Saml2Core，2.7.2]

一个 ，它表示的时间以 utc 为单位的身份验证。

获取或设置由使用者和身份验证机构标识的主体之间的特定会话的索引。 [Saml2Core，2.7.2]

一个字符串，包含会话索引。

获取或设置即时速率由使用者和 SAML 授权机构发出该语句标识的主体之间的会话，必须考虑结束的时间。 [Saml2Core，2.7.2]

返回一个可以为 null ，表示会话过期时间以 utc 为单位。 一个 值指示未指定的属性。

获取或设置的 DNS 域名和从其对断言使用者进行显然是身份验证系统的 IP 地址。 [Saml2Core，2.7.2]

一个 ，用于指定 DNS 域名和 IP 地址。

获取或设置的一组有权在指定的资源上执行的操作。

类型的集合 ，它指定的授权的操作。

获取或设置由指定资源有关的 SAML 授权机构做出的决定。

值之一，它指定由 SAML 授权机构做出的、与主题访问指定资源有关的授权决定。 尝试设置一个值，不是有效 值的出现。

获取或设置的一套断言的 SAML 授权机构做出的决策中依赖于。 [Saml2Core，2.7.4]

一个 包含的断言。

获取或设置标识要试图访问授权的资源的 URI 引用。

一个 标识的资源。 尝试设置一个值，该值 时发生。 设置一个值，不是绝对 URI 或不是一个空的相对 URI 的尝试时发生。

获取指定给它发送断言的受众的集合。 [Saml2Core，2.5.1]

类型的集合 ，它指定断言的受众。 如果该集合为空的受众没有限制应用。

获取或设置断言无效即时的最早时间。 [Saml2Core，2.5.1]

一个可以为 null ，其中包含即时以 utc 为单位的时间。 一个 值指示该属性不存在。 属性不是 并尝试设置一个值，会发生，或者在指定的时间即时后 属性时发生。

获取或设置即时断言过期的时间。 [Saml2Core，2.5.1]

一个可以为 null ，其中包含即时以 utc 为单位的时间。 一个 值指示该属性不存在。 属性不是 并尝试设置一个值，在指定的时间即时之前发生 属性时发生。

获取一个值，指定是否断言应立即使用，并且必须不会保留供将来使用。 [Saml2Core，2.5.1]

如果应立即; 使用断言否则为 。

获取或设置上希望随后充当断言当事方自己和他们自己根据原始断言中包含的信息的问题断言的信赖方的断言方施加的限制。 [Saml2Core，2.5.1]

一个 ，其中包含在后续的断言方上的限制。

获取所引用的 id。 断言的集合

类型的集合 ，其中包含引用断言的 Id。

获取断言值所指定的集合。

类型的集合 包含的断言。

获取所引用的 URI 断言的集合。

类型的集合 ，其中包含引用声明的 Uri。

获取标识符字符串。

ID 字符串。

获取或设置用于加密 EncryptedID 元素中的名称标识符的凭据。

一个 表示用于加密的名称标识符的凭据。

获取一个集合包含指定的其他加密的密钥作为 EncryptedID 元素的子元素外部到 xenc:EncryptedData 元素。

一个 ，包含的键。

获取或设置一个 URI 引用，表示基于字符串的标识符信息的分类。 [Saml2Core，2.2.2]

。 尝试设置一个值，不是 并且不是绝对 URI 发生。

获取或设置的安全或管理域的限定名称。 [Saml2Core，2.2.2]

该名称限定符。

获取或设置服务提供商的名称或用来进一步限定名称 [Saml2Core，2.2.2] 提供程序的隶属关系。

服务提供程序名称限定符。

获取或设置由服务提供商或提供程序的实体的隶属关系的名称标识符，如果不同于主名称标识符。 [Saml2Core，2.2.2]

一个字符串，其中包含名称标识符。

获取或设置的名称标识符的值。

一个包含名称标识符值的字符串。 尝试设置一个值，该值 时发生。

获取或设置为其断言方允许新的断言，以根据此断言颁发的受众集。

类型的集合 ，其中包含新断言可以颁发哪些实体的地址。

获取或设置断言的参与方允许存在此断言与断言其最终根据它发出之间的间接寻址的最大数目。

可以为 null 的整数。 表示未设置该属性，没有限制设置的间接寻址的数量。 尝试设置一个值，不是 且小于不会出现零。

获取当前与此实例关联 Saml2Assertion。

当前与此实例关联 Saml2Assertion。 可以为 。

获取此安全令牌的 SAML 断言。

一个 ，表示此安全令牌的 SAML 断言。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取安全令牌的颁发者。

安全令牌的颁发者。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示此处理程序可以验证类型的令牌 。

, 指示该处理程序可以验证类型的令牌 。

获取一个值，该值指示此处理程序是否可以序列化类型的令牌 。

;指示该处理程序可以序列化类型的令牌 。

获取或设置当前实例用于验证 X.509 证书的 X.509 证书验证程序。

，它表示该验证程序。

获取或设置的安全令牌序列化程序用于序列化和反序列化密钥标识符。

一个 ，它表示序列化程序。 尝试将值设置为 时发生。

获取或设置此实例的令牌要求的安全。

一个 指定的要求。 尝试将值设置为 时发生。

获取支持此处理程序的令牌类型。

的 类。

获取或设置主题的标识符。 [Saml2Core，2.4.1]

一个 ，包含的标识符。

获取一个集合，其中包含允许使用者进行确认的信息。 [Saml2Core，2.4.1]

类型的集合 。

获取或设置一个 URI 引用，标识协议或机制，以用于确认该主题。 [Saml2Core，2.4.1.1]

一个 表示的引用。 尝试将该属性设置为 时发生。 设置一个值，不是绝对 URI 的尝试时发生。

获取或设置期望能够满足封闭的使用者确认要求的实体的标识符。 [Saml2Core，2.4.1.1]

一个 指定的实体。

获取或设置使用的特定确认方法进一步确认信息。 [Saml2Core，2.4.1.1]

一个 ，包含要用于确认方法的信息。

获取或设置从中 attesting 实体可能会造成断言的网络地址/位置。 [Saml2Core，2.4.1.2]

一个字符串，包含的地址。

获取或设置在响应 attesting 实体可以向其提供该断言的 SAML 协议消息的 ID。 [Saml2Core，2.4.1.2]

一个 ，表示该 id。

获取以某种方式进行身份验证 attesting 实体使用的加密密钥的集合。 [Saml2Core，2.4.1.3]

返回类型的集合 ，包含的键。

获取或设置的时间点不能在其前确认该主题。 [Saml2Core，2.4.1.2]

一个可以为 null ，其中包含即时以 utc 为单位的时间。

获取或设置从该处不再可以确认主题即时的时间。 [Saml2Core，2.4.1.2]

一个可以为 null ，其中包含即时以 utc 为单位的时间。

获取或设置一个 URI，指定的实体或 attesting 实体可以向其提供该断言的位置。 [Saml2Core，2.4.1.2]

一个 指定的实体或位置。 尝试设置一个值，不是 并且不是绝对 URI 发生。

获取或设置从中由使用者标识的主体进行身份验证的系统的网络地址。 [Saml2Core，2.7.2.1]

一个字符串，包含的地址。

获取或设置从中由使用者标识的主体进行身份验证的系统的 DNS 名称。 [Saml2Core，2.7.2.1]

一个字符串，包含的 DNS 名称。

获取或设置 的主题可对指定资源执行的操作。

获取或设置 安全令牌的主题试图对指定资源执行的操作。 属性设置为 。 - 或 - 属性设置为 。 属性的值为 ，同时设置了 属性。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。

获取或设置定义 属性的 XML 命名空间。

在其中定义 属性的 XML 命名空间。 属性为 ，同时设置了 属性。

获取对 SAML 断言的引用集合。

一个类型为 的 ，包含对提供 SAML 断言附加信息的 SAML 断言的引用集合。

获取 SAML 断言的集合。

一个类型为 的 ，包含提供 SAML 断言附加信息的 SAML 断言。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置与 有关的、由 SAML 授权机构提供的、有助于处理 SAML 断言的附加信息。

一个 ，它指定由 SAML 授权机构提供的、有助于处理 SAML 断言的附加信息。 属性设置与 属性是 。

获取或设置断言的标识符。

断言的标识符。 属性的值为 ，且试图设置 属性。 试图将 属性设置为 或空字符串。

获取一个值，该值指示是否从 XML 源进行反序列化此断言，并重新发出 XML 数据不变。

如果此断言可以重新发出 XML 源数据保持不变;否则为 。

获取或设置在评估 SAML 断言的有效性时可能考虑的一组条件。

一个 ，它指定在评估 SAML 断言的有效性时可能考虑的一组条件。 属性是 和尝试设置 属性。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置 SAML 断言的颁发日期和时间。

以协调世界时 (UTC) 表示的 ，它指定 SAML 断言的颁发时间。 属性是 和尝试设置 属性。

获取或设置颁发此 SAML 断言的 SAML 授权机构的名称。

颁发此 SAML 断言的 SAML 授权机构。 属性是 和尝试设置 属性。 试图将 属性设置为 或空字符串。

获取此 SAML 断言所遵循的 SAML 规范的主版本。

此 SAML 断言所遵循的 SAML 规范的主版本。 默认值为 属性的值。

获取此 SAML 断言所遵循的 SAML 规范的次版本。

此 SAML 断言所遵循的 SAML 规范的次版本。 默认值为 属性的值。

获取或设置用于对 SAML 断言进行数字签名的安全凭据。

一个 ，它用于对 SAML 断言进行数字签名。 属性为 ，而试图设置 属性。

获取由数字签名的 SAML 断言包含或引用的安全令牌。

一个由数字签名的 SAML 断言包含或引用的 。

获取与 SAML 断言相关联的 SAML 语句集。

一个类型为 的 ，它包含与 SAML 断言相关联的 SAML 语句。

获取包含密钥标识符的 的标识符。

包含密钥标识符的 的标识符。

获取 SAML 属性的属性值集合。

一个 ，它包含 SAML 属性的属性值集合。

获取或设置 SAML 属性中包含的值的 xsi: type。

一个字符串，包含 xsi: type。 默认值为 。 尝试设置一个值，该值 或空发生。 - 或 - 尝试设置一个值的格式不正确，会发生。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置 SAML 属性的名称。

SAML 属性的名称。 属性设置与 属性是 。 属性设置为 。

获取或设置在其中定义 SAML 属性的名称的 XML 命名空间。

在其中定义 SAML 属性的名称的 XML 命名空间。

获取或设置表示 SAML 属性 OriginalIssuer 的字符串。

SAML 属性的原始颁发者。 尝试设置一个值为空字符串，会发生。

获取与 SAML 断言的主题关联的属性集合。

一个类型为 的 ，它包含一组与主题关联的属性。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取 SAML 断言的目标受众集。

一个 类型的 ，包含一个目标受众集。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。

获取对主题进行身份验证的时刻。

一个 ，它指定对主题进行身份验证的时刻。

获取或设置用于对主题进行身份验证的方法。

用于对主题进行身份验证的方法。

获取关于主题的附加信息。

一个类型为 的 ，它包含关于主题的附加信息。

获取对主题进行身份验证的计算机所在的 DNS 域名。

对主题进行身份验证的计算机所在的 DNS 域名。

获取或设置对主题进行身份验证的计算机的 IP 地址。

对主题进行身份验证的计算机的 IP 地址。

获取或设置主题进行身份验证的时刻。

一个 ，它指定对主题进行身份验证的时刻。 异常类型 条件 属性设置与 属性是 。

获取或设置用于对主题进行身份验证的方法。

用于对主题进行身份验证的方法。 默认值为 。 属性设置与 属性是 。

获取关于主题的附加信息。

一个类型为 的 ，它包含关于主题的附加信息。

获取安全声明的类型。

指定安全声明类型的 。 总是为 http://schemas.microsoft.com/mb/2005/09/ClaimType/SamlAuthentication。

获取或设置对主题进行身份验证的计算机所在的 DNS 域名。

对主题进行身份验证的计算机所在的 DNS 域名。 属性设置与 属性是 。

获取或设置对主题进行身份验证的计算机的 IP 地址。

对主题进行身份验证的计算机的 IP 地址。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置具有主题附加信息的 SAML 授权机构所响应的查询类型。

一个 ，表示具有主题附加信息的 SAML 授权机构所响应的查询类型。 属性设置与 属性是 。 属性设置为 。

获取或设置与具有主题附加信息的 SAML 授权机构进行通信时所使用的 SAML 协议绑定。

一个 URI 引用，标识与具有主题附加信息的 SAML 授权机构进行通信时所使用的 SAML 协议绑定。 属性设置与 属性是 。 属性设置为 。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置如何找到并与具有主题附加信息的 SAML 授权机构进行通信。

一个 URI 引用，描述如何找到并与具有主题附加信息的 SAML 授权机构进行通信。 属性设置与 属性是 。 属性设置为 。

获取由 SAML 授权机构做出的、与该主题访问资源有关的授权决定。

由 SAML 授权机构做出的、与该主题访问资源有关的授权决定。

获取该主题试图对 属性中指定的资源执行的操作。

该主题试图对 属性中指定的资源执行的操作。

获取在其中定义了 属性中指定的操作的 XML 命名空间。

XML 命名空间，在其中定义了 属性中指定的操作。

获取该主题正试图访问的资源。

一个 URI，它表示该主题正试图访问的资源。

获取或设置由 SAML 授权机构做出的、与主题访问指定资源有关的授权决定。

值之一，它指定由 SAML 授权机构做出的、与主题访问指定资源有关的授权决定。 异常类型 条件 设置了 属性且 属性为 。

获取安全声明的类型。

安全声明的类型。 总是为 http://schemas.microsoft.com/mb/2005/09/ClaimType/SamlAuthorizationDecision。

获取或设置 SAML 授权机构在做出授权决定时所依赖的证据。

一个 ，它包含 SAML 授权机构在做出授权决定时所依赖的一组 SAML 断言。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

安全令牌的主题要试图访问的资源。

一个 URI 引用，它标识要试图访问的资源。

获取该主题有权对资源执行的操作集。

一个类型为 的 ，它指定该主题有权对资源执行的操作集。

在派生类中重写时，获取一个值，指示此实例的属性是否为只读。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取在评估 SAML 断言有效性时必须考虑的条件集。

一个类型为 的 ，它指定条件集，即在评估断言有效性时必须考虑 SAML 断言的某个接收方。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取 SAML 断言有效的最初时刻。

一个 ，指定 SAML 断言有效的最初时刻。

获取 SAML 断言过期的时刻。

一个 ，指定 SAML 断言过期的时刻。

获取用于指定“将 SAML 断言的主题指定为电子邮件地址”的属性的名称。 此字段为常数。

用于指定“将 SAML 断言的主题指定为电子邮件地址”的属性的名称。 此字段为常数。

获取一个 URI，它声明 SAML 断言的主题被指定为电子邮件地址。 此字段为常数。

一个 URI，它声明 SAML 断言的主题被指定为电子邮件地址。

获取一个 URI，它指定 SAML 安全令牌的接收方应使用 元素来确认 SOAP 消息是由 SAML 断言的主题发送的。 此字段为常数。

一个 URI，它指定 安全令牌的接收方应使用 元素来确认 SOAP 消息是由 SAML 断言的主题发送的。

获取 安全令牌所遵循的 SAML 规范的主版本。 此字段为常数。

安全令牌所遵循的 SAML 规范的主版本。 总是为 1。

获取 安全令牌所使用的 SAML 规范的次版本。 此字段为常数。

SAML 规范的次版本。 总是为 1。 和 属性的组合包含 安全令牌所遵循的 SAML 规范的版本。

获取在其中定义 SAML 断言的 XML 命名空间。 此字段为常数。

在其中定义 SAML 断言的 XML 命名空间。

获取一个 URI，它指定 SAML 安全令牌的接收方无法使用附加信息来确认 SOAP 消息是由 SAML 断言的主题发送的。 此字段为常数。

一个 URI，指定 SAML 安全令牌的接收方无法使用附加信息来确认 SOAP 消息是由 SAML 断言的主题发送的。

获取用于指定“将 SAML 断言的主题指定为 Windows 域帐户”的属性的名称。 此字段为常数。

用于指定“将 SAML 断言的主题指定为 Windows 域帐户”的属性的名称。 此字段为常数。

获取一个 URI，它表明 SAML 断言的主题是使用 Windows 域帐户指定的。 此字段为常数。

一个 URI，表明 SAML 断言的主题是使用 Windows 域帐户指定的。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取 SAML 断言的标识符的集合，这些断言指定 SAML 授权机构呈现授权决定时所依赖的证据。

一个类型为 的 ，它包含 SAML 断言的标识符，这些断言指定 SAML 授权机构呈现授权决定时所依赖的证据。

获取 SAML 断言的集合，这些断言包含 SAML 授权机构呈现授权决定时所依赖的证据。

一个类型为 的 ，它包含 SAML 授权机构呈现授权决定时所依赖的证据。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取一个 URI 引用，它表示 SAML 安全令牌的主题名称所采用的格式。

一个 URI 引用，它表示 SAML 安全令牌的主题名称所采用的格式。

获取 SAML 安全令牌的主题名称。

安全令牌的主题名称。

获取 SAML 安全令牌的主题名称所在的域。

SAML 安全令牌的主题名称所在的域。

获取当前与此实例关联的 SamlAssertion。

当前与此实例关联的 SamlAssertion。 可以为 。

获取此安全令牌的 SAML 断言。

一个 ，表示此安全令牌的 SAML 断言。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示此处理程序可以验证类型的令牌 。

, 指示该处理程序可以验证类型的令牌 。

获取一个值，该值指示此处理程序是否可以序列化类型的令牌 。

;指示该处理程序可以序列化类型的令牌 。

获取或设置当前实例用于验证 X.509 证书的 X.509 证书验证程序。

，它表示该验证程序。

获取或设置的安全令牌序列化程序用于序列化和反序列化密钥标识符。

一个 ，它表示序列化程序。 尝试将值设置为 时发生。

获取或设置此实例的令牌要求的安全。

一个 指定的要求。 尝试将值设置为 时发生。

获取支持此处理程序的令牌类型。

的 类。

获取或设置 此令牌要求与该键相关联。

X.509 证书验证程序，此令牌要求与该键关联。 默认值为 。

获取或设置一个值，该值指示令牌处理程序将尝试通过使用唯一的主体名称 (UPN) 声明的 SAML 标识映射到 Windows 标识。

若要尝试 SAML 标识映射到 Windows 标识;否则为 。 默认值为 。

获取或设置将用于生成 FederatedIdentity.Name 属性的声明类型。

声明类型。 默认为 字段的值。

获取或设置用于生成 FederatedIdentity.Roles 属性的声明类型。

角色声明类型。 默认为 字段的值。

在派生类中重写时，获取一个值，该值指示此实例的属性是否为只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取一组 URI 引用，这些引用标识要用于验证主题身份的协议。

一个类型为 的 ，包含一组标识用于验证主题身份的协议的 URI 引用。

获取或设置加密密钥，该密钥用于验证由此 SAML 主题语句标识的数字签名。

一个 ，其中包含用于验证 SAML 安全令牌的数字签名的加密密钥。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置一个密钥标识符，该标识符提供对 SAML 安全令牌的主题所持有的加密密钥的访问。

一个 ，提供对 安全令牌的主题所持有的加密密钥的访问。

获取或设置 SAML 安全令牌的主题名称。

安全令牌的主题名称。

获取用于表示 SAML 安全令牌的主题名称的声明类型。

用于表示 SAML 安全令牌的主题名称的声明类型 ()。

获取或设置一个 URI 引用，它表示 SAML 安全令牌的主题名称所采用的格式。

一个 URI 引用，它表示 SAML 安全令牌的主题名称所采用的格式。

获取或设置 SAML 安全令牌的主题名称所在的域。

SAML 安全令牌的主题名称所在的域。

获取或设置可供身份验证协议使用的附加身份验证信息。

可供身份验证协议使用的附加身份验证信息。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取或设置 安全令牌的主题。

一个 ，它标识 安全令牌的主题。 属性设置与 属性是 。

在派生类中重写时，获取密钥的大小（以位为单位）。

密钥的大小（以位为单位）。

获取密钥的大小，以位为单位。

密钥的大小，以位为单位。

获取一个值，指示是否可以为至少一个密钥标识符子句创建密钥。

如果可以为至少一个密钥标识符子句创建密钥，则为 ；否则为 。

获取密钥标识符子句数。

密钥标识符子句数。

获取一个值，该值指示此实例的属性是否是只读的。

如果此实例的属性是只读的，则为 ；否则为 。 默认值为 。

获取指定索引处的密钥标识符子句。

密钥标识符子句集合中的密钥标识符子句的从零开始的索引。 位于指定索引处的 。 小于 0。 - 或 - 等于或大于 。

获取一个值，该值指示是否可以创建密钥。

如果可以创建密钥，则为 ；否则为 。 默认值为 。

获取密钥标识符子句类型。

密钥标识符子句类型。

获取派生密钥的大小。

派生密钥的大小。

获取或设置密钥标识符子句 id。

密钥标识符子句 id。 默认值为 。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取或设置中的 AppliesTo 属性地址 。

绝对 URI，它表示的地址。 尝试将属性设置为不是绝对 URI 的值时发生。

获取或设置密钥标识符子句，该令牌附加到消息时

指定的密钥标识符子句。

获取或设置令牌的身份验证信息。

令牌身份验证信息。

获取或设置用于对令牌进行加密的凭据。

使用对令牌进行加密的凭据。

获取或设置已颁发令牌的生存期信息。

已颁发令牌的生存期信息。

获取或设置已颁发的令牌，可以用于修改某些字段内 RSTR，如请求的证明令牌的证明描述符。

证明的描述符。

获取已颁发令牌的属性包。

一个字典表示的属性包。

获取或设置 ReplyToAddress 属性中，地址 。

一个 URI，表示的地址。

获取或设置用于对令牌进行签名的凭据。

使用该令牌进行签名的凭据。

获取或设置要颁发的令牌中包含的输出声明。

包含输出声明声明的标识。

获取或设置颁发的安全令牌。

颁发的安全令牌。

获取或设置可能还用在已颁发令牌的颁发者名称。

颁发者名称中。

获取或设置已颁发令牌的令牌类型

令牌类型。

密钥标识符子句时颁发的令牌不附加到消息。

指定的密钥标识符子句。

获取包装令牌的 XML 表示。

令牌的 XML 表示形式。

获取一个值，该值指示该处理程序是否支持验证安全令牌。

如果此类是能够验证安全令牌。否则为 。 默认值为 。

获取一个值，该值指示该处理程序是否可以序列化安全令牌。

如果此类是能够序列化令牌。否则为 。 默认值为 。

获取或设置 对象，它提供当前实例的配置。

当前实例的的配置对象。

获取包含当前实例的标记处理程序集合。

包含当前实例的标记处理程序集合。

当在派生类中重写，获取此实例处理的安全令牌的类型。

此实例处理的安全令牌的类型。

获取和设置此安全令牌处理程序集合的基本配置。

找不到令牌处理程序配置。

从此集合可以处理指定的安全令牌中获取的令牌处理程序。

应为其返回该处理程序的标记。 令牌处理程序可以处理指定的标记的说明。

可以处理指定的类型标识符此集合中获取的令牌处理程序。

一个 URI，标识令牌类型。 令牌处理程序可以处理对应于指定的类型标识符的标记的说明。

该处理程序从集合中获取此可处理指定的令牌类型。

要处理的标记的类型。 令牌处理程序可以处理指定类型的标记的说明。

获取此集合中处理程序处理的令牌的类型标识符的列表。

类型标识符 Uri 的列表。

获取此集合中的处理程序处理的令牌类型的列表。

类型的列表。

获取多的安全令牌处理程序管理的此实例的集合。

管理的此实例的标记处理程序集的数目。

返回使用指定的安全令牌处理程序集合。

找不到令牌处理程序用法的名称。 指定使用情况与关联的标记处理程序集合。

获取的安全令牌处理程序管理的此实例的集合。

管理此实例的标记处理程序集合。

获取服务名称。

与此实例关联的服务的名称。

获取或设置受众限制。

访问群体限制中。

获取或设置用于此配置的缓存。

缓存。

获取或设置处理程序用于验证颁发者证书的 X.509 证书验证模式。

证书验证模式。

获取或设置处理程序用来验证颁发者证书的 X.509 证书验证程序

证书验证程序。

获取或设置一个值，该值指示是否应由在此配置中的处理程序检测重播的令牌。

如果应检测重播的令牌;否则为 。

获取或设置颁发者名称注册表中的有此配置。

颁发者名称注册表。

获取或设置颁发者令牌解析程序为此配置。

颁发者令牌解析器。

获取或设置处理程序使用此配置最大时钟偏差。

最大时钟偏差。

获取或设置此配置的 X.509 吊销模式。

X.509 吊销模式。

获取或设置一个值，该值指示是否将启动上下文 （令牌） 保存在 和令牌验证后的会话。

若要保存对启动令牌;否则为 。

获取或设置安全令牌解析程序用来解析服务令牌。

令牌解析器。

获取或设置将置于令牌重放缓存中的项的过期期限。

过期时间。

获取或设置处理程序用来验证颁发者证书的 X.509 受信任存储区位置。

受信任存储区位置。

获取表示基于 Kerberos 票证的安全令牌的字符串。

一个字符串，它表示基于 Kerberos 票证的安全令牌。

获取表示基于 RSA 密钥的安全令牌的字符串。

一个字符串，它表示基于 RSA 密钥的安全令牌。

获取表示基于 SAML 断言的安全令牌的字符串。

一个字符串，它表示基于 SAML 断言的安全令牌。

获取表示基于用户名和密码的安全令牌的字符串。

一个字符串，它表示基于用户名和密码的安全令牌。

获取表示基于 X.509 证书的安全令牌的字符串。

一个字符串，它表示基于 X.509 证书的安全令牌。

获取声明的主体与会话相关联。

声明主体中。

获取一个用户指定上下文值。

用户指定的上下文值。

获取会话上下文标识符

会话上下文标识符。

获取此令牌的范围限定到的终结点的 ID。

终结点的 ID。

获取此令牌的唯一标识符。

令牌 ID。

获取或设置一个值，该值指示此标记所表示的 cookie 是否持久。

如果该 cookie 出现不一致;否则为 。

获取或设置一个值，该值指示是否在引用模式下操作的会话安全令牌。

如果会话模式，则在运行，该令牌否则为 。

获取此令牌中的键开始生效的即时的时间。

从其即时的时间的关键是有效的。

获取即时之后此令牌中的密钥将不再有效的时间。

该密钥的到期时间即时。

获取密钥生成此令牌中的标识符

此令牌中的键生成唯一标识符。

获取一个 URI，标识用于序列化此会话安全的 Ws-secure Conversation 的版本标记。

标识用于序列化此令牌的 Ws-secure Conversation 的版本的 URI。

获取与此会话相关联的密钥。 这通常是单个密钥。

与会话相关联的密钥。 通常是单个密钥。

该令牌的有效的情况下获取即时的时间。

该令牌的有效时间。

获取即时之后该令牌将不再有效的时间。

此后该令牌将不再有效的时间。

获取缓存密钥的上下文 ID。

缓存键上下文 ID。

获取此缓存条目的范围限定到的终结点 ID。

此缓存条目的范围限定到的终结点 ID。

获取或设置一个值，该值指示在执行索引比较时是否可以忽略密钥生成。

若要忽略密钥生成;否则为 。

获取密钥生成的缓存键

缓存项密钥生成

获取一个值，该值指示此处理程序是否支持验证的类型的令牌 。

如果该处理程序支持的类型的令牌验证 ; 否则为 。 总是为 。

获取一个值，该值指示此处理程序是否可以编写类型的令牌 。

如果该处理程序可以编写类型的令牌 ; 否则为 。 总是为 。

获取 cookie 元素的名称。

Cookie 元素的名称。 默认元素名称为"Cookie"。

获取 cookie 元素的命名空间。

Cookie 元素的命名空间。 默认命名空间为"http://schemas.microsoft.com/ws/2006/05/security"。

获取默认令牌生存期。

默认令牌生存期。 总是为 。

获取或设置令牌生存期。

令牌生存期。 默认值为 。 尝试设置时间跨度，小于或等于零时发生。

获取该处理程序处理的令牌的类型。

的 。

获取将应用于该 cookie 的转换。

将应用于该 cookie 的转换的列表。

获取加密算法，该加密算法用于计算要进行数字签名的 SOAP 消息部分的摘要。

一个表示加密算法的 URI，该加密算法用于计算要进行数字签名的 SOAP 消息部分的摘要。

获取用于生成数字签名的加密算法。

一个 URI，表示用于生成数字签名的加密算法。

获取用于生成数字签名的加密密钥。

一个 ，它包含用于生成数字签名的加密密钥。

获取表示用于创建数字签名的密钥的标识符。

一个 ，指定表示用于创建数字签名的密钥的标识符。

获取可在已颁发的令牌定义键的键标识符。 通常是二进制密钥或加密的密钥;

密钥标识符。

获取请求者的加密凭据，可用于对请求的证明令牌或在响应中的平均信息量进行加密。

请求者的加密凭据。

获取依赖方加密凭据，可能用来加密请求的安全令牌在响应中。

信赖方加密凭据。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌关联的用户名的密码。

与安全令牌关联的用户名的密码。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取与安全令牌关联的用户名。

与安全令牌关联的用户名。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示此处理程序是否可以编写类型的令牌 。

如果该处理程序可以编写类型的令牌 ; 否则为 。 总是为 。

获取或设置一个值，指定是否将附加到对启动令牌中保留该密码 返回 方法。

如果应将密码保留在对启动令牌;否则为 。 默认值为 。

获取 该处理程序处理的令牌。

的类型。

获取令牌的身份验证类型。

返回 。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取与此安全令牌关联的 Windows 用户。

一个表示 Windows 用户的 。

获取一个值，该值指示此处理程序是否支持验证的类型的令牌 。

如果该处理程序支持的类型的令牌验证 ; 否则为 。 总是为 。

获取与 X.509 证书关联的公钥的大小（以位为单位）。

与 X.509 证书关联的公钥的大小（以位为单位）。

获取此令牌解析程序使用的 X.509 证书存储区的位置。

存储指定的 X.509 证书的位置的枚举值之一。

获取此令牌解析程序使用的 X.509 证书存储区的名称。

使用此令牌解析程序的 X.509 证书存储区名称。

获取 X.509 证书。

X.509 证书。

获取颁发 X.509 证书的证书颁发机构的可分辨名称。

颁发 X.509 证书的证书颁发机构的可分辨名称。

获取 X.509 证书的序列号。

X.509 证书的序列号。

获取一个值，该值指示是否可以从 X.509 证书的原始数据或从构造函数中指定的字节数组来创建密钥。

在所有情况下均为 。

获取与安全令牌关联的 X.509 证书。

一个包含 X.509 证书的 。

获取安全令牌的唯一标识符。

安全令牌的唯一标识符。

获取与安全令牌相关联的加密密钥。

一个类型为 的 ，包含与安全令牌相关联的密钥集。

获取此安全令牌有效的最初时刻。

一个 ，表示此安全令牌有效的最初时刻。

获取此安全令牌有效的最后时刻。

一个 ，表示此安全令牌有效的最后时刻。

获取一个值，该值指示此处理程序是否支持验证的类型的令牌 。

如果该处理程序支持的类型的令牌验证 ; 否则为 。 总是为 。

获取一个值，该值指示此处理程序是否可以编写类型的令牌 。

如果该处理程序可以编写类型的令牌 ; 否则为 。 总是为 。

获取或设置 ，它由当前实例。

当前实例使用 X.509 证书验证程序。

获取或设置一个值，该值指示验证令牌是否应映射到 Windows 帐户。

如果验证令牌应映射到 Windows 帐户;否则为 。

获取 该处理程序处理的令牌。

默认情况下的一种 类。

获取或设置用于指定是否为首选 XmlDsig 定义子句类型的值。

如果首选; XmlDsig 定义的子句类型否则为 。

获取或设置 的当前实例在过程中使用证书验证传入的 X.509 证书映射到 Windows 帐户时。

X.509 证书验证程序将验证指定的 X.509 证书，并确认是否要将证书映射到 Windows 帐户，以及是否受信任的证书链。

获取 X.509 证书。

X.509 证书。

获取令牌的身份验证类型。

返回 。

获取 Windows 域或计算机帐户的标识。

一个 ，表示 Windows 域或计算机帐户的标识。

获取已完成的异步操作的类型化的结果。

已完成的异步操作的类型化的结果。

获取和设置不受支持的令牌类型 URI。

一个包含不受支持的令牌类型 URI 的字符串。

获取或设置创建令牌的颁发机构的地址。

地址。

获取 颁发令牌时使用的身份验证机构。

一套 代表授权上下文。

获取或设置创建令牌的颁发机构的 DNS 名称。

颁发机构的 DNS 名称。

获取或设置必须考虑会话索引中引用的会话已结束的时间。

结束会话，必须考虑的时间。

获取或设置描述该颁发机构和客户端之间的会话的会话索引。

会话的索引。

获取为其主体是要为其授权的操作。

表示与请求相关的操作的声明集合。

获取正在请求进行授权的主体 （主题）。

正在为其请求授权主体。

获取的资源的原则是要为其授权。

表示资源的声明集合。

获取一个值，该值指示该类实例是否可以创建安全密钥。

总是为 。

获取密钥名称。

密钥名称。

获取安全上下文 ID。

安全性上下文的唯一 ID。

获取生成。

生成。

获取令牌 ID。

令牌 ID。

获取令牌密钥大小。

令牌密钥大小。

获取安全密钥的集合。

的集合。

获取令牌的有效起始时间。

一个 ，表示令牌的有效起始时间。

获取令牌的有效起始时间。

一个 ，表示令牌的有效起始时间。

获取令牌 ID。

令牌 ID。

获取安全密钥的集合。

的集合。

获取令牌的有效起始日期。

一个 ，表示令牌的有效起始日期。

获取令牌的过期日期。

一个 ，表示令牌的过期日期。

获取包装算法。

一个 ，指定包装算法或用于加密对称密钥的算法。

获取包装令牌。

一个表示包装令牌的 。

获取包装令牌引用。

一个 ，表示对包装令牌的引用。

异步操作期间发生错误时引发的异常。

实现一个抽象基类 接口。 用作从中进行派生的基类 可用于常见异步编程方案的对象。

不为安全令牌服务 (STS) 所理解的令牌请求 (RST) 时，将引发异常。

表示与某个实体关联的声明。

表示与某个实体关联的声明的集合。

表示实体可以声明的预定义声明类型。 此类不能被继承。

提供 类的默认实现。

定义可与 对象关联的预定义权限类型。

表示与某一实体关联的 Windows 声明的集合。

表示从 X.509 证书中提取与某个实体关联的声明的集合。

表示下配置的受众 URI 值 元素。

表示 配置文件中的元素。

有部分用户可以指定任意元素和属性，则 Windows Identity Foundation (WIF) 配置架构例如，当指定的自定义令牌处理程序。 类实现来处理这种情况。

表示元素或属性指定自定义 配置文件中。 此类不能被继承。

定义使类可以加载自定义配置的方法。

定义控制 Windows Identity Foundation 的行为的可配置属性的集合。

表示 配置文件中的元素。 此类不能被继承。

表示集合的 配置文件中的元素。 此类不能被继承。

定义配置来检测重播的令牌并缓存会话令牌的缓存。 此类不能被继承。

表示 配置文件中的元素。 此类不能被继承。

表示 配置文件中的元素。 此类不能被继承。

表示 配置文件中的元素。

表示 配置文件中的元素。 此类不能被继承。

表示的所有组 下的元素 配置文件中的元素。 此类不能被继承。

定义安全令牌服务 (STS) 的配置。 实现 Sts 的类派生自 类。

表示 配置文件中的部分。 此类不能被继承。

表示 配置文件中的元素。 此类不能被继承。

表示 配置文件中的元素。 此类不能被继承。

将可还原的数据转换应用到 cookie 数据的类抽象基类。

提供了 cookie 压缩使用 。

该类包装指定的读取器并委托所有 对已包装的读取器的调用。

该类包装指定的编写器并委托所有 对已包装的编写器的调用。

包装的读取器指向封装签名的 XML，以提供可用于读取内容，而无需处理签名的读取器。 读取信封的最后一个元素时，会自动验证签名。 此类不能被继承。

包装一个编写器，并在完全写入信封时，自动生成的签名。 此类不能被继承。

当超出了配置的限制或配额时引发的异常。

定义应用程序服务描述符和其终结点。

表示 SAML 2.0 元数据中的联系人的人员。

指定联系人的类型。

具有未指定类型的协定。

技术联系人。

支持联系人。

管理联系人。

记帐联系人。

具有非管理、 帐单支持、 技术，或未指定类型的协定。

表示可显示声明对象。

定义的加密方法。

表示实体的集合。

表示实体描述符。

表示实体 id。

标识提供程序单一登录在描述符 (IDPSSODescriptor) 类。

定义索引 。

的已排序列表。

定义密钥描述符。

定义的键类型 属性。

未指定键的类型。

该密钥用于签名。

该密钥用于加密。

用于定义本地化的项抽象基类。

对象的集合。

集合中对象的 。 必须从 类派生。

定义一个本地化的名称。

定义本地化的 URI。

定义的 SAML 元数据基类。

在序列化或反序列化 SAML 元数据过程中发生错误时引发的异常。

提供对元数据序列化的支持

定义一个组织。

此类定义的协议终结点。

定义角色描述符。

定义服务安全令牌服务描述符。

定义一个描述符为服务提供商 SSO (SPSSO)。

定义 SSO 描述符。

定义 web 服务描述符。

一个抽象类，提供了一个通用的属性包的派生类。

可以通过已发送消息中的令牌，以及通过调用 方法获取对所有授权策略进行评估的结果。

当在派生类中重写时，表示已经过评估的授权策略的结果。

表示用于对用户进行授权的组件。

通过给定的声明集，定义一组用于对用户进行授权的规则。

通过使用提供 cookie 的完整性和保密性 类。 此类不能被继承。

表示 WS 信任授权扩展插件中定义的 auth:AdditionalContext 元素。 WS 联合身份验证规范中定义了这些扩展。

表示 WS 信任 BinaryExchange 元素的内容。

表示 WS 信任授权扩展插件中定义的 auth:ContextItem 元素。 WS 联合身份验证规范中定义了这些扩展。

表示一个 wsa:EndpointReference 元素。

表示在令牌请求消息和令牌响应消息中使用的平均信息量。

当请求 (RST) 无效或格式不正确时引发的异常。

在令牌请求 (RST) 或响应 (RSTR)，以指示所需的或所需的密钥类型中定义协议不可知所使用的 Uri。

表示 元素。

表示一个 WS 信任参与者元素。 Wst:Participants 元素是对 wst:RequestSecurityToken 元素的扩展，并用于传递有关哪些参与方有权参与使用令牌的信息。

表示 wst:Entropy 或深入了解 RequestSecurityToken 和 RequestSecurityTokenResponse wst:RequestedProofToken 元素的内容。

表示 wst︰ 续订 WS 信任中的元素续订请求。

表示安全令牌请求 (RST) 中的单个请求的声明。

表示 内 对象的集合。

表示 wst:RequestedProofToken 元素的内容。

表示请求 （发布） 的安全令牌。

表示用于请求安全令牌的 wst:RequestSecurityToken 元素 (RST)。

表示 wst:RequestSecurityTokenResponse 元素，它用来返回安全令牌。

定义了协议不可知 RequestType URI 字符串。

表示 WS 信任验证请求的结果。

表示 wst:UseKey 元素的内容。

用于序列化和反序列化 WS 信任 1.3 RequestSecurityToken (RST) 消息的类。

用于序列化和反序列化 WS 信任 1.3 RequestSecurityTokenResponse (RSTR) 消息的类。

类用于序列化和反序列化 Ws-trust 2005 年 2 月 RequestSecurityToken (RST) 消息。

类用于序列化和反序列化 Ws-trust 2005 年 2 月 RequestSecurityTokenResponse (RSTR) 消息。

RST 和 RSTR 的基类。

定义用于序列化和反序列化版本的 Ws-trust 请求 (RST) 消息的方法的抽象基类。

定义用于序列化和反序列化版本的 WS 信任 (RSTR) 的响应消息的方法的抽象基类。

定义 WS 信任消息的序列化上下文。

在序列化或反序列化 WS 信任消息过程中发生错误时引发的异常。

请求失败，则引发异常的基类。

如果指定的请求 (RST) 由于无法明确确定外部原因而失败，则引发异常。

加密 cookie 使用 。

提供了 cookie 完整性使用 签名。

表示令牌颁发请求的配置。

在序列化一条安全消息时出现错误时引发的异常。

定义的属性和方法的安全令牌服务 (STS) 的抽象基类。

此类用于在安全令牌服务中的异步调用之间维护请求状态。

指定是否应验证 安全令牌的 。

从不。

始终。

只有在安全令牌的密钥类型为 BearerKey 并且安全令牌中没有所有权证明密钥时。

类的一个帮助器类，用于验证是否将 属性设置为有效值。

使用自定义身份验证方案对 安全令牌进行身份验证。

对 安全令牌进行身份验证。

表示为 SOAP 消息发送方提供 安全令牌的安全令牌提供程序。

对 安全令牌进行身份验证。

对 安全令牌进行身份验证。

对安全令牌进行身份验证。

表示安全令牌管理器，它指定如何提供、验证以及序列化安全令牌。

表示为 SOAP 消息发送方处理安全令牌的安全令牌提供程序。

封装对委托的异步操作的结果。

指定安全令牌要求。

表示一个实用工具类，该类可以在您具有密钥标识符或密钥标识符子句时检索安全令牌或密钥。

表示一个类，它可以读写密钥标识符、密钥标识符子句和安全令牌。

表示在其中定义安全令牌的规范，例如 WS-* 规范。

验证用户名和密码。

对 安全令牌进行身份验证。

表示为 SOAP 消息发送方提供 安全令牌的安全令牌提供程序。

使用 Windows 身份验证对 安全令牌进行身份验证。

使用 Windows 身份验证对 安全令牌中的用户名和密码进行身份验证。

验证 X.509 证书。

对 进行身份验证。

表示为 SOAP 消息发送方提供 安全令牌的安全令牌提供程序。

当处理一个签名过程中发生错误时引发的异常

表示安全令牌解析程序，可以换行的多个令牌解析程序，在所有已包装的冲突解决程序解决令牌。

此类可以用于为颁发非对称密钥的基于的令牌。

非对称密钥的基类。

定义 AudienceRestriction 验证设置。

当传入的安全令牌的受众 URI 验证失败时引发的异常。

此类用于指定身份验证事件的上下文。

定义常数的受支持的已知身份验证方法。 定义常数的 SAML 身份验证方法。

表示基于二进制数据的密钥标识符子句的基类。

包含在登录时使用的原始标记的序列化的版本。

在 RST 中用于指示所需的算法用于计算基于组合熵从令牌的请求者和令牌颁发者密钥。

表示颁发者名称注册表中维护从应用程序配置文件中将每个颁发者名称与验证的令牌颁发者所生成的签名所需的 X.509 证书相关联的元素加载的受信任颁发者的列表。

表示空的密钥标识符子句。 使用此类时 或 元素不包含 元素，用于描述解密的数据或检查的签名所需的密钥。

表示加密的密钥加密凭据。 使用这些报告通常作为加密凭据的数据进行加密令牌等内容。

表示标识加密密钥的密钥标识符子句。

包装的令牌处理本身不支持它的令牌的加密。

加密的安全令牌的令牌处理程序。 处理类型的令牌 。

处理加密的安全令牌的过程中发生错误时引发的异常。

表示加密密钥和用于加密校验密钥的加密算法。

表示基于 XML 的密钥标识符子句。

表示基于 XML 的安全令牌。

表示使用对称算法生成、并仅存储在本地计算机的随机存取内存中的密钥。

颁发者名称注册表抽象基类。 颁发者名称注册表用于将关联到生成由相应的颁发者颁发的令牌的签名验证所需的加密材料的助记键名称。 颁发者名称注册表维护信赖方 (RP) 应用程序的受信任的颁发者的列表。

从服务合作伙伴接收到解析颁发者令牌。

表示一个安全令牌，它基于在 SOAP 消息中接收到的 Kerberos 票证。

表示一个安全令牌，它基于在 SOAP 请求中发送的 Kerberos 票证。

表示处理 Kerberos 令牌的安全令牌处理程序。 处理类型的令牌 。

表示一个密钥标识符子句，它标识一个 或 安全令牌。

表示一个密钥标识符子句，它标识在 SOAP 消息的安全标头中指定的安全令牌。

类的基类 和 类。

表示一个标识 安全令牌的密钥标识符子句。

表示一个使用 RSA 算法生成的安全密钥。 此类不能被继承。

表示一个安全令牌，它基于使用 RSA 算法创建的密钥。

表示 来处理类型的令牌 。

表示 按 SAML 2.0 定义的元素。

表示在 [Saml2Core，2.6.1] 中指定的建议元素。

表示在 [Saml2Core，2.3.3] 中指定了 Assertion 元素。

表示 引用基于 SAML2 安全令牌的实现。

表示在 [Saml2Core，2.7.3.1] 中指定的属性元素。

表示在 [Saml2Core，2.7.3] 中指定的 AttributeStatement 元素。

表示 AudienceRestriction 元素 [Saml2Core，2.5.1.4] 中指定。

表示在 [Saml2Core，2.7.2.2] 中指定的 AuthnContext 元素。

表示在 [Saml2Core，2.7.2] 中指定的 AuthnStatement 元素。

表示 按 SAML 2.0 定义的元素。

表示在 [Saml2Core，2.5.1] 中指定的条件元素。

表示在 [Saml2Core，2.7.4.3] 中指定的证据元素。

表示用于 SAML 断言的标识符。

表示在 [Saml2Core，2.2.3] 中指定的 NameID 元素或 [Saml2Core，2.2.4] 中指定的 EncryptedID 元素。

表示在 [Saml2Core，2.5.1.6] 中指定的 ProxyRestriction 元素。

当 Saml2Assertion 收到不是签名元素中的 < ds:KeyInfo > 元素的情况下，使用此类。 KeyInfo 描述需检查签名的密钥。 此子句时需要该密钥将显示与当前 。 它将包含 Saml2Assertion 充分阅读这可以通过查询来确定所需的密钥。

表示基于 SAML 断言的安全令牌。

表示从 SAML 2.0 断言创建安全令牌的安全令牌处理程序。

表示 StatementAbstractType [Saml2Core，2.7.1] 中指定。

表示在 [Saml2Core，2.4.1] 中指定的主题元素。

表示在 [Saml2Core，2.4.1.1] 中指定的 SubjectConfirmation 元素。

表示关联中定义的 KeyInfoConfirmationDataType 和 SubjectConfirmationData 元素 [Saml2Core，2.4.1.2-2.4.1.3]。

表示在 [Saml2Core，2.7.2.1] 中指定的 SubjectLocality 元素。

指定是否授予 安全令牌的主题访问给定资源的权限。

指定对资源的访问权限被授予。

指定对资源的访问被拒绝。

指定颁发 安全令牌的安全令牌服务不具有足够的信息来确定对特定资源的访问权限。 安全令牌的接收方必须使用其他方法来确定用户的访问权限。

表示 SAML 断言中的 元素，其中包含对指定资源的操作。

表示 SAML 断言中的 元素，包含 SAML 授权机构提供的附加信息。

表示一个安全断言标记语言 1.1 (SAML 1.1) 断言。

表示一个 元素，它引用 SOAP 消息中的 元素。

表示与 的主题相关联的属性。

包含一组与特定 关联的属性。

指定 SAML 断言是针对特定受众的。

表示从 创建的声明的资源类型。

表示 安全令牌的声明，它断言在特定时间以特定方式对主题进行身份验证。

指定如何检索关于 安全令牌主题的附加信息。

表示 安全令牌的声明，它断言一个与特定资源的访问有关的授权决定。

表示 安全令牌的一个声明，它断言已做出与该主题访问指定资源有关的授权决定。

表示一个在评估 SAML 断言的有效性时必须考虑的条件。

表示评估 SAML 断言的有效性时必须考虑的条件集。

表示一组用于设置 安全令牌的属性的常量。 此类不能被继承。

表示一个在评估 SAML 断言的有效性时必须考虑的条件。

表示用于呈现 安全令牌的授权决定的证据。

表示一个 SAML 安全令牌声明，它断言主题名称。

SamlAssertion 收到而不是签名元素中的 < ds:KeyInfo > 元素时，使用此类。 KeyInfo 描述需检查签名的密钥。 此子句时需要该密钥将显示与当前 。 它将包含完全读取这可以通过查询来确定所需的密钥的 SamlAssertion。

表示基于 SAML 断言的安全令牌。

表示从 SAML 1.1 断言创建安全令牌的安全令牌处理程序。

扩展 类通过添加新属性，可用于已颁发的令牌。

在 对象和 XML 文档之间进行序列化和反序列化操作。

表示 安全令牌的声明。

表示 SAML 安全令牌的主题。

表示 安全令牌的声明。

定义 URI 常数，这些常数表示用于加密 XML 和计算 SOAP 消息数字签名的加密算法。

安全密钥的基类。

通过解析提供的安全密钥的延迟的解析 或 仅仅加密功能在需要时。 这样永远不会使用由一个应用程序进行序列化和 deserialzied 和散布在网络中不会出现问题的密钥标识符子句或密钥标识符。

表示密钥标识符。

表示密钥标识符子句的抽象基类。

序列化程序进行序列化和反序列化密钥标识符子句的抽象基类。

指定与安全令牌关联的密钥的类型。

指定密钥是对称密钥。

指定密钥是非对称密钥。

指定安全令牌不包含所有权证明密钥。

指定如何使用与安全令牌相关联的密钥。

指定密钥可用于在发送方和接收方之间交换密钥。

指定密钥可用于生成数字签名。

表示用于实现所有安全令牌的基类。

这是针对与已颁发的令牌相关的所有属性的占位符

表示数字元素中找到 表示安全令牌。

在处理安全令牌的过程中发生问题时引发的异常。

当收到具有过期时间在过去的安全令牌时引发异常。

安全令牌处理程序的抽象基类。

表示安全令牌处理程序的集合。

管理多个类名为安全令牌处理程序集。

定义由框架使用的标准集合名称。

普遍适用于所有安全令牌处理程序的配置。

当收到具有一个有效的时间在将来的安全令牌时引发异常。

当收到已重播的安全令牌时引发异常。

包含一组静态属性，这些属性返回表示安全令牌类型的字符串。

接收到的安全令牌无效时引发的异常。

定义安全令牌包含与会话关联的数据。

定义会话安全令牌的抽象类的缓存。

表示中的条目的键 。

一个 来处理类型的安全令牌 。

表示用于生成数字签名的加密密钥和安全算法。

此类可以用于颁发对称密钥的基于的令牌。

表示使用对称算法生成的所有密钥的抽象基类。

用于定义方法用来检测重播的令牌缓存的抽象基类。

表示基于用户名和密码的安全令牌。

定义一个抽象基类 来处理类型的安全令牌 。

表示基于 Windows 域或用户帐户标识的安全令牌。

定义 来处理 Windows 用户名令牌。

表示 X.509 证书的非对称密钥。

表示一个令牌解析程序，可以解决类型的令牌 针对指定的 X.509 证书存储区。

表示 ，它可以处理 X.509 证书引用类型。

表示 X.509 令牌用作加密凭据。 此类通常用作密钥换行的凭据。

表示一个密钥标识符子句，它使用证书颁发者的可分辨名称和 X.509 证书的序列号来标识 安全令牌。

表示 X.509 证书验证程序将验证指定的 X.509 证书，并确认是否要将证书映射到 Windows 帐户，以及是否受信任的证书链。

表示一个密钥标识符子句，它使用 X.509 证书的原始数据标识 安全令牌。

表示基于 X.509 证书的安全令牌。

表示处理类型的令牌的安全令牌处理程序 。 默认情况下，该处理程序将执行的 X.509 证书的信任链验证。

表示 X.509 令牌用作签名的凭据。

表示一个密钥标识符子句，它使用 X.509 证书的主题密钥标识符扩展来标识 安全令牌。

表示一个密钥标识符子句，它使用 X.509 证书的指纹来标识 安全令牌。

表示基于 X.509 证书的安全令牌以及将证书映射到 Windows 域用户或本地计算机用户帐户。

具体实现 ，将换行结果 并将其返回时 调用方法。

结果的类型。

当指定的令牌请求 (RST) 不理解由于未知的标记类型时引发的异常。

包含证书颁发机构添加时的身份验证信息创建令牌的主题。

定义身份验证类型 属性。

提供授权事件的上下文的信息。 这包括代表调用方、 正在请求、 资源和正在执行的操作的主体。

定义中包含的属性的键 属性。

定义声明的身份验证管理器的基实现。 声明身份验证管理器提供了索赔处理管道将处理逻辑 （筛选、 验证、 扩展） 应用于传入的主体中的声明集合之前执行到达您的应用程序代码, 中的位置。

定义声明授权管理器的基实现。

表示二进制秘密安全令牌中的密钥标识符子句。

表示安全令牌中的密钥名称标识符子句。

表示安全上下文令牌的密钥标识符子句。

表示二进制秘密安全令牌。

表示在其他令牌中包装密钥的安全令牌。

一个列出验证证书方法的枚举。

未执行任何证书验证。

如果证书位于被信任的人的存储区中，则有效。

如果该链在受信任的根存储区生成证书颁发机构，则证书有效。

如果证书位于被信任的人的存储区或该链在受信任的根存储区生成证书颁发机构，则证书有效。

用户必须插入自定义 以验证证书。