ECDiffieHellmanCng 类

定义

提供椭圆曲线 Diffie-Hellman (ECDH) 算法的下一代加密技术 (CNG) 实现。 此类用于执行加密操作。

public ref class ECDiffieHellmanCng sealed : System::Security::Cryptography::ECDiffieHellman
public sealed class ECDiffieHellmanCng : System.Security.Cryptography.ECDiffieHellman
type ECDiffieHellmanCng = class
    inherit ECDiffieHellman
Public NotInheritable Class ECDiffieHellmanCng
Inherits ECDiffieHellman
继承
继承

示例

以下示例演示如何使用 ECDiffieHellmanCng 类建立密钥交换,以及如何使用该密钥来加密可以通过公共通道发送并由接收方解密的消息。

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;

class Alice
{
    public static byte[] alicePublicKey;

    public static void Main(string[] args)
    {
        using (ECDiffieHellmanCng alice = new ECDiffieHellmanCng())
        {

            alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            alice.HashAlgorithm = CngAlgorithm.Sha256;
            alicePublicKey = alice.PublicKey.ToByteArray();
            Bob bob = new Bob();
            CngKey bobKey = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob);
            byte[] aliceKey = alice.DeriveKeyMaterial(bobKey);
            byte[] encryptedMessage = null;
            byte[] iv = null;
            Send(aliceKey, "Secret message", out encryptedMessage, out iv);
            bob.Receive(encryptedMessage, iv);
        }
    }

    private static void Send(byte[] key, string secretMessage, out byte[] encryptedMessage, out byte[] iv)
    {
        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = key;
            iv = aes.IV;

            // Encrypt the message
            using (MemoryStream ciphertext = new MemoryStream())
            using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write))
            {
                byte[] plaintextMessage = Encoding.UTF8.GetBytes(secretMessage);
                cs.Write(plaintextMessage, 0, plaintextMessage.Length);
                cs.Close();
                encryptedMessage = ciphertext.ToArray();
            }
        }
    }
}
public class Bob
{
    public byte[] bobPublicKey;
    private byte[] bobKey;
    public Bob()
    {
        using (ECDiffieHellmanCng bob = new ECDiffieHellmanCng())
        {

            bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash;
            bob.HashAlgorithm = CngAlgorithm.Sha256;
            bobPublicKey = bob.PublicKey.ToByteArray();
            bobKey = bob.DeriveKeyMaterial(CngKey.Import(Alice.alicePublicKey, CngKeyBlobFormat.EccPublicBlob));
        }
    }

    public void Receive(byte[] encryptedMessage, byte[] iv)
    {

        using (Aes aes = new AesCryptoServiceProvider())
        {
            aes.Key = bobKey;
            aes.IV = iv;
            // Decrypt the message
            using (MemoryStream plaintext = new MemoryStream())
            {
                using (CryptoStream cs = new CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(encryptedMessage, 0, encryptedMessage.Length);
                    cs.Close();
                    string message = Encoding.UTF8.GetString(plaintext.ToArray());
                    Console.WriteLine(message);
                }
            }
        }
    }
}
Imports System.IO
Imports System.Security.Cryptography
Imports System.Text




Class Alice
    Public Shared alicePublicKey() As Byte


    Public Shared Sub Main(ByVal args() As String)
        Using alice As New ECDiffieHellmanCng()
            alice.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash
            alice.HashAlgorithm = CngAlgorithm.Sha256
            alicePublicKey = alice.PublicKey.ToByteArray()
            Dim bob As New Bob()
            Dim k As CngKey = CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob)
            Dim aliceKey As Byte() = alice.DeriveKeyMaterial(CngKey.Import(bob.bobPublicKey, CngKeyBlobFormat.EccPublicBlob))
            Dim encryptedMessage As Byte() = Nothing
            Dim iv As Byte() = Nothing
            Send(aliceKey, "Secret message", encryptedMessage, iv)
            bob.Receive(encryptedMessage, iv)
        End Using
    End Sub


    Private Shared Sub Send(ByVal key() As Byte, ByVal secretMessage As String, ByRef encryptedMessage() As Byte, ByRef iv() As Byte)
        Using aes As New AesCryptoServiceProvider()
            aes.Key = key
            iv = aes.IV

            ' Encrypt the message
            Using ciphertext As New MemoryStream()
                Using cs As New CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write)
                    Dim plaintextMessage As Byte() = Encoding.UTF8.GetBytes(secretMessage)
                    cs.Write(plaintextMessage, 0, plaintextMessage.Length)
                    cs.Close()
                    encryptedMessage = ciphertext.ToArray()
                End Using
            End Using
        End Using

    End Sub
End Class

Public Class Bob
    Public bobPublicKey() As Byte
    Private bobKey() As Byte

    Public Sub New()
        Using bob As New ECDiffieHellmanCng()

            bob.KeyDerivationFunction = ECDiffieHellmanKeyDerivationFunction.Hash
            bob.HashAlgorithm = CngAlgorithm.Sha256
            bobPublicKey = bob.PublicKey.ToByteArray()
            bobKey = bob.DeriveKeyMaterial(CngKey.Import(Alice.alicePublicKey, CngKeyBlobFormat.EccPublicBlob))
        End Using

    End Sub


    Public Sub Receive(ByVal encryptedMessage() As Byte, ByVal iv() As Byte)

        Using aes As New AesCryptoServiceProvider()
                aes.Key = bobKey
                aes.IV = iv
                ' Decrypt the message
            Using plaintext As New MemoryStream()
                Using cs As New CryptoStream(plaintext, aes.CreateDecryptor(), CryptoStreamMode.Write)
                    cs.Write(encryptedMessage, 0, encryptedMessage.Length)
                    cs.Close()
                    Dim message As String = Encoding.UTF8.GetString(plaintext.ToArray())
                    Console.WriteLine(message)
                End Using
            End Using
        End Using
    End Sub
End Class

注解

ECDiffieHellmanCng 使双方能够交换私钥材料,即使他们通过公共渠道进行通信。 双方可以计算相同的机密值,即托管 Diffie-Hellman 类中的 机密协议 。 然后,机密协议可以用于各种目的,包括作为对称密钥。 但是,类在提供值之前对协议执行一些后处理, ECDiffieHellmanCng 而不是直接公开机密协议。 此后处理称为 (KDF) 的密钥派生函数 ;可以选择要使用的 KDF,并通过 Diffie-Hellman 对象实例上的一组属性设置其参数。

密钥派生函数 属性
Hash HashAlgorithm - 用于处理机密协议的哈希算法。

SecretPrepend - 在对机密协议进行哈希处理之前,要附加到机密协议的可选字节数组。

SecretAppend - 在对机密协议进行哈希处理之前追加到机密协议的可选字节数组。
Hmac HashAlgorithm - 用于处理机密协议的哈希算法。

SecretPrepend- 在对机密协议进行哈希处理之前,要附加到机密协议的可选字节数组。

SecretAppend - 在对机密协议进行哈希处理之前追加到机密协议的可选字节数组。
Tls Label - 键派生的标签。

Seed - 密钥派生的种子。

通过密钥派生函数传递机密协议的结果是一个字节数组,可用作应用程序的密钥材料。 生成的密钥材料的字节数取决于密钥派生函数:例如,SHA-256 将生成 256 位密钥材料,而 SHA-512 将生成 512 位密钥材料。 ECDH 密钥交换的基本流程如下所示:

  1. Alice 和 Bob 创建用于 Diffie-Hellman 密钥交换操作的密钥对

  2. Alice 和 Bob 使用同意的参数配置 KDF。

  3. Alice 将她的公钥发送给 Bob。

  4. Bob 将公钥发送给爱丽丝。

  5. Alice 和 Bob 使用彼此的公钥生成机密协议,并将 KDF 应用于机密协议以生成密钥材料。

构造函数

ECDiffieHellmanCng()

使用随机的密钥对初始化 ECDiffieHellmanCng 类的新实例。

ECDiffieHellmanCng(CngKey)

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

ECDiffieHellmanCng(ECCurve)

创建 ECDiffieHellmanCng 类的新实例,其公钥/私钥对通过指定曲线生成。

ECDiffieHellmanCng(Int32)

使用指定密钥大小,通过随机密钥对来初始化 ECDiffieHellmanCng 类的新实例。

字段

KeySizeValue

表示非对称算法所用密钥模块的大小(以位为单位)。

(继承自 AsymmetricAlgorithm)
LegalKeySizesValue

指定非对称算法支持的密钥大小。

(继承自 AsymmetricAlgorithm)

属性

HashAlgorithm

获取或设置生成密钥材料时要使用的哈希算法。

HmacKey

获取或设置派生密钥材料时要使用的基于哈希的消息身份验证代码 (HMAC) 密钥。

Key

指定当前对象用于加密操作的 CngKey

KeyDerivationFunction

获取或设置 ECDiffieHellmanCng 类的密钥派生函数。

KeyExchangeAlgorithm

获取密钥交换算法的名称。

(继承自 ECDiffieHellman)
KeySize

获取或设置非对称算法所用密钥模块的大小(以位为单位)。

KeySize

获取或设置非对称算法所用密钥模块的大小(以位为单位)。

(继承自 AsymmetricAlgorithm)
Label

获取或设置用于密钥派生的标签值。

LegalKeySizes

获取非对称算法支持的密钥大小。

LegalKeySizes

获取非对称算法支持的密钥大小。

(继承自 AsymmetricAlgorithm)
PublicKey

获取另一个 ECDiffieHellmanCng 对象可用来生成共享机密协议的公钥。

SecretAppend

获取或设置生成密钥材料时将追加到机密协议的值。

SecretPrepend

获取或设置派生密钥材料时将添加到机密协议开头的值。

Seed

获取或设置派生密钥材料时将要使用的种子值。

SignatureAlgorithm

获取签名算法的名称。

(继承自 ECDiffieHellman)
UseSecretAgreementAsHmacKey

获取一个值,该值指示机密协议是否用作基于哈希的消息身份验证代码 (HMAC) 密钥以派生密钥材料。

方法

Clear()

释放 AsymmetricAlgorithm 类使用的所有资源。

(继承自 AsymmetricAlgorithm)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName)

使用指定的哈希算法执行密钥派生。

(继承自 ECDiffieHellman)
DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])

使用指定的哈希算法对可选的添加数据或追加数据执行密钥派生。

DeriveKeyFromHash(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[])

在派生类中实现时,使用指定的哈希算法对可选的添加数据或追加数据执行密钥派生。

(继承自 ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[])

使用指定的 HMAC(基于哈希的消息验证代码)算法执行密钥派生。

(继承自 ECDiffieHellman)
DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])

使用指定的 HMAC(基于哈希的消息验证代码)算法对可选的添加数据或追加数据执行密钥派生。

DeriveKeyFromHmac(ECDiffieHellmanPublicKey, HashAlgorithmName, Byte[], Byte[], Byte[])

在派生类中实现时,使用指定的 HMAC(基于哈希的消息验证代码)算法对可选的添加数据或追加数据执行密钥派生。

(继承自 ECDiffieHellman)
DeriveKeyMaterial(CngKey)

在给定包含第二方公钥的 CngKey 对象的情况下,派生从双方之间的机密协议生成的密钥材料。

DeriveKeyMaterial(ECDiffieHellmanPublicKey)

在给定包含第二方公钥的 ECDiffieHellmanPublicKey 对象的情况下,派生从双方之间的机密协议生成的密钥材料。

DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])

使用 TLS(传输层安全性)1.1 PRF(伪随机函数)执行密钥派生。

DeriveKeyTls(ECDiffieHellmanPublicKey, Byte[], Byte[])

在派生类中实现时,使用 TLS(传输层安全性)1.1 PRF(伪随机函数)执行密钥派生。

(继承自 ECDiffieHellman)
DeriveRawSecretAgreement(ECDiffieHellmanPublicKey)

派生原始密钥材料。

(继承自 ECDiffieHellman)
DeriveSecretAgreementHandle(CngKey)

在给定包含另一方公钥的 CngKey 对象的情况下,获取双方之间生成的机密协议的句柄。

DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey)

在给定包含另一方公钥的 ECDiffieHellmanPublicKey 对象的情况下,获取双方之间生成的机密协议的句柄。

Dispose()

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

(继承自 AsymmetricAlgorithm)
Dispose(Boolean)

释放 AsymmetricAlgorithm 类使用的非托管资源,并可以选择释放托管资源。

(继承自 AsymmetricAlgorithm)
Equals(Object)

确定指定对象是否等于当前对象。

(继承自 Object)
ExportECPrivateKey()

以 ECPrivateKey 格式导出当前密钥。

(继承自 ECDiffieHellman)
ExportECPrivateKeyPem()

以 ECPrivateKey 格式导出当前密钥(PEM 编码)。

(继承自 ECAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

使用基于字节的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式导出当前密钥。

ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters)

使用基于字节的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式导出当前密钥。

(继承自 AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

使用基于字符的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式导出当前密钥。

ExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters)

使用基于字符的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式导出当前密钥。

(继承自 AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters)

使用基于字节的密码(PEM 编码)导出 PKCS#8 EncryptedPrivateKeyInfo 格式的当前密钥。

(继承自 AsymmetricAlgorithm)
ExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters)

使用基于字符的密码(PEM 编码)导出 PKCS#8 EncryptedPrivateKeyInfo 格式的当前密钥。

(继承自 AsymmetricAlgorithm)
ExportExplicitParameters(Boolean)

ECCurve 对象使用的密钥和显式曲线参数导出到 ECParameters 对象。

ExportExplicitParameters(Boolean)

在派生类中替换时,使用显式曲线形式,从正常运行的 ECDiffieHellman 密钥将公钥或公钥和私钥信息导出到 ECParameters 结构,使其可传递到 ImportParameters(ECParameters) 方法。

(继承自 ECDiffieHellman)
ExportParameters(Boolean)

ECCurve 对象使用的密钥导出到 ECParameters 对象。

ExportParameters(Boolean)

在派生类中替换时,从正常运行的 ECDiffieHellman 密钥将公钥或公钥和私钥信息导出到 ECParameters 结构,使其可传递到 ImportParameters(ECParameters) 方法。

(继承自 ECDiffieHellman)
ExportPkcs8PrivateKey()

以 PKCS#8 PrivateKeyInfo 格式导出当前密钥。

(继承自 AsymmetricAlgorithm)
ExportPkcs8PrivateKeyPem()

导出 PKCS#8 PrivateKeyInfo 格式(PEM 编码)的当前密钥。

(继承自 AsymmetricAlgorithm)
ExportSubjectPublicKeyInfo()

以 X.509 SubjectPublicKeyInfo 格式导出当前密钥的公钥部分。

(继承自 AsymmetricAlgorithm)
ExportSubjectPublicKeyInfoPem()

以 X.509 SubjectPublicKeyInfo 格式(PEM 编码)导出当前密钥的公钥部分。

(继承自 AsymmetricAlgorithm)
FromXmlString(String)

未实现此方法。

FromXmlString(String)

在所有情况下均引发此方法。

(继承自 ECDiffieHellman)
FromXmlString(String, ECKeyXmlFormat)
已过时.

使用指定的格式反序列化 XML 字符串中的密钥信息。

GenerateKey(ECCurve)

为指定曲线生成新的临时公钥/私钥对。

GenerateKey(ECCurve)

在派生类中替换时,为指定曲线生成新的临时公钥/私钥对。

(继承自 ECDiffieHellman)
GetHashCode()

作为默认哈希函数。

(继承自 Object)
GetType()

获取当前实例的 Type

(继承自 Object)
ImportECPrivateKey(ReadOnlySpan<Byte>, Int32)

从 ECPrivateKey 结构中导入公共/私有密钥对,替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)

使用基于字节的密码解密之后,从 PKCS#8 EncryptedPrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Int32)

使用基于字节的密码解密之后,从 PKCS#8 EncryptedPrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

使用基于字符的密码解密之后,从 PKCS#8 EncryptedPrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

ImportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, ReadOnlySpan<Byte>, Int32)

使用基于字符的密码解密之后,从 PKCS#8 EncryptedPrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Byte>)

导入已加密的 RFC 7468 PEM 编码的私钥,替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportFromEncryptedPem(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

导入已加密的 RFC 7468 PEM 编码的私钥,替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportFromPem(ReadOnlySpan<Char>)

导入 RFC 7468 PEM 编码的密钥,替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportParameters(ECParameters)

ECCurve 对象的指定参数作为密钥导入当前实例。

ImportParameters(ECParameters)

在派生类中替代时,将 ECCurve 的指定参数作为临时密钥导入到当前 ECDiffieHellman 对象。

(继承自 ECDiffieHellman)
ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)

解密后,从 PKCS#8 PrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

ImportPkcs8PrivateKey(ReadOnlySpan<Byte>, Int32)

解密后,从 PKCS#8 PrivateKeyInfo 结构中导入公/私钥对,以替换此对象的密钥。

(继承自 ECDiffieHellman)
ImportSubjectPublicKeyInfo(ReadOnlySpan<Byte>, Int32)

解密后,从 X.509 SubjectPublicKeyInfo 结构中导入公钥,以替换此对象的密钥。

(继承自 ECDiffieHellman)
MemberwiseClone()

创建当前 Object 的浅表副本。

(继承自 Object)
ToString()

返回表示当前对象的字符串。

(继承自 Object)
ToXmlString(Boolean)

未实现此方法。

ToXmlString(Boolean)

在所有情况下均引发此方法。

(继承自 ECDiffieHellman)
ToXmlString(ECKeyXmlFormat)
已过时.

使用指定的格式将密钥信息序列化为 XML 字符串。

TryExportECPrivateKey(Span<Byte>, Int32)

尝试以 ECPrivateKey 格式将当前密钥导入所提供的缓冲区。

(继承自 ECDiffieHellman)
TryExportECPrivateKeyPem(Span<Char>, Int32)

尝试将 PEM 编码的 ECPrivateKey 格式的当前密钥导出到提供的缓冲区中。

(继承自 ECAlgorithm)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)

尝试使用基于字节的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式将当前密钥导出到所提供的缓冲区。

TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Byte>, PbeParameters, Span<Byte>, Int32)

尝试使用基于字节的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式将当前密钥导出到所提供的缓冲区。

(继承自 ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)

尝试使用基于字符的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式将当前密钥导入所提供的缓冲区。

TryExportEncryptedPkcs8PrivateKey(ReadOnlySpan<Char>, PbeParameters, Span<Byte>, Int32)

尝试使用基于字符的密码以 PKCS#8 EncryptedPrivateKeyInfo 格式将当前密钥导入所提供的缓冲区。

(继承自 ECDiffieHellman)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Byte>, PbeParameters, Span<Char>, Int32)

尝试使用基于字节的密码(PEM 编码)导出 PKCS#8 EncryptedPrivateKeyInfo 格式的当前密钥。

(继承自 AsymmetricAlgorithm)
TryExportEncryptedPkcs8PrivateKeyPem(ReadOnlySpan<Char>, PbeParameters, Span<Char>, Int32)

使用基于字符的密码(PEM 编码)导出 PKCS#8 EncryptedPrivateKeyInfo 格式的当前密钥。

(继承自 AsymmetricAlgorithm)
TryExportPkcs8PrivateKey(Span<Byte>, Int32)

尝试以 PKCS#8 PrivateKeyInfo 格式将当前密钥导出到所提供的缓冲区。

TryExportPkcs8PrivateKey(Span<Byte>, Int32)

尝试以 PKCS#8 PrivateKeyInfo 格式将当前密钥导出到所提供的缓冲区。

(继承自 ECDiffieHellman)
TryExportPkcs8PrivateKeyPem(Span<Char>, Int32)

尝试将 PEM 编码 PKCS#8 PrivateKeyInfo 格式的当前密钥导出到提供的缓冲区中。

(继承自 AsymmetricAlgorithm)
TryExportSubjectPublicKeyInfo(Span<Byte>, Int32)

尝试以 X.509 SubjectPublicKeyInfo 格式将当前密钥导出到所提供的缓冲区。

(继承自 ECDiffieHellman)
TryExportSubjectPublicKeyInfoPem(Span<Char>, Int32)

尝试将 PEM 编码的 X.509 SubjectPublicKeyInfo 格式的当前密钥导出到提供的缓冲区中。

(继承自 AsymmetricAlgorithm)

显式接口实现

IDisposable.Dispose()

此 API 支持产品基础结构,不能在代码中直接使用。

有关此成员的说明,请参见 Dispose()

(继承自 AsymmetricAlgorithm)

适用于