Freigeben über


RC2CryptoServiceProvider Klasse

Definition

Achtung

Derived cryptographic types are obsolete. Use the Create method on the base type instead.

Definiert ein Wrapperobjekt, um auf die Kryptografiedienstanbieter-Implementierung (Cryptographic Service Provider) des RC2-Algorithmus zuzugreifen. Diese Klasse kann nicht vererbt werden.

public ref class RC2CryptoServiceProvider sealed : System::Security::Cryptography::RC2
public sealed class RC2CryptoServiceProvider : System.Security.Cryptography.RC2
[System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public sealed class RC2CryptoServiceProvider : System.Security.Cryptography.RC2
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class RC2CryptoServiceProvider : System.Security.Cryptography.RC2
type RC2CryptoServiceProvider = class
    inherit RC2
[<System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type RC2CryptoServiceProvider = class
    inherit RC2
[<System.Runtime.InteropServices.ComVisible(true)>]
type RC2CryptoServiceProvider = class
    inherit RC2
Public NotInheritable Class RC2CryptoServiceProvider
Inherits RC2
Vererbung
RC2CryptoServiceProvider
Attribute

Beispiele

Im folgenden Codebeispiel wird eine Zeichenfolge verschlüsselt und dann entschlüsselt.

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

namespace RC2CryptoServiceProvider_Examples
{
    class MyMainClass
    {
        public static void Main()
        {

            // Create a new instance of the RC2CryptoServiceProvider class
            // and automatically generate a Key and IV.
            RC2CryptoServiceProvider rc2CSP = new RC2CryptoServiceProvider();

            Console.WriteLine("Effective key size is {0} bits.", rc2CSP.EffectiveKeySize);

            // Get the key and IV.
            byte[] key = rc2CSP.Key;
            byte[] IV = rc2CSP.IV;

            // Get an encryptor.
            ICryptoTransform encryptor = rc2CSP.CreateEncryptor(key, IV);

            // Encrypt the data as an array of encrypted bytes in memory.
            MemoryStream msEncrypt = new MemoryStream();
            CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);

            // Convert the data to a byte array.
            string original = "Here is some data to encrypt.";
            byte[] toEncrypt = Encoding.ASCII.GetBytes(original);

            // Write all data to the crypto stream and flush it.
            csEncrypt.Write(toEncrypt, 0, toEncrypt.Length);
            csEncrypt.FlushFinalBlock();

            // Get the encrypted array of bytes.
            byte[] encrypted = msEncrypt.ToArray();

            ///////////////////////////////////////////////////////
            // This is where the data could be transmitted or saved.
            ///////////////////////////////////////////////////////

            //Get a decryptor that uses the same key and IV as the encryptor.
            ICryptoTransform decryptor = rc2CSP.CreateDecryptor(key, IV);

            // Now decrypt the previously encrypted message using the decryptor
            // obtained in the above step.
            MemoryStream msDecrypt = new MemoryStream(encrypted);
            CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);

            // Read the decrypted bytes from the decrypting stream
            // and place them in a StringBuilder class.

            StringBuilder roundtrip = new StringBuilder();

            int b = 0;

            do
            {
                b = csDecrypt.ReadByte();

                if (b != -1)
                {
                    roundtrip.Append((char)b);
                }
            } while (b != -1);

            // Display the original data and the decrypted data.
            Console.WriteLine("Original:   {0}", original);
            Console.WriteLine("Round Trip: {0}", roundtrip);
        }
    }
}
Imports System.IO
Imports System.Text
Imports System.Security.Cryptography



Module Crypto

    Sub Main()

        ' Create a new instance of the RC2CryptoServiceProvider class
        ' and automatically generate a Key and IV.
        Dim rc2CSP As New RC2CryptoServiceProvider()

        Console.WriteLine("Effective key size is {0} bits.", rc2CSP.EffectiveKeySize)

        ' Get the key and IV.
        Dim key As Byte() = rc2CSP.Key
        Dim IV As Byte() = rc2CSP.IV

        ' Get an encryptor.
        Dim encryptor As ICryptoTransform = rc2CSP.CreateEncryptor(key, IV)

        ' Encrypt the data as an array of encrypted bytes in memory.
        Dim msEncrypt As New MemoryStream()
        Dim csEncrypt As New CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)

        ' Convert the data to a byte array.
        Dim original As String = "Here is some data to encrypt."
        Dim toEncrypt As Byte() = Encoding.ASCII.GetBytes(original)

        ' Write all data to the crypto stream and flush it.
        csEncrypt.Write(toEncrypt, 0, toEncrypt.Length)
        csEncrypt.FlushFinalBlock()

        ' Get the encrypted array of bytes.
        Dim encrypted As Byte() = msEncrypt.ToArray()

        '''''''''''''''''''''''''''''''''''''''''''''''''''''''
        ' This is where the data could be transmitted or saved.
        '''''''''''''''''''''''''''''''''''''''''''''''''''''''

        'Get a decryptor that uses the same key and IV as the encryptor.
        Dim decryptor As ICryptoTransform = rc2CSP.CreateDecryptor(key, IV)

        ' Now decrypt the previously encrypted message using the decryptor
        ' obtained in the above step.
        Dim msDecrypt As New MemoryStream(encrypted)
        Dim csDecrypt As New CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)

        ' Read the decrypted bytes from the decrypting stream
        ' and place them in a StringBuilder class.
        Dim roundtrip As New StringBuilder()

        Dim b As Integer = 0

        Do
            b = csDecrypt.ReadByte()

            If b <> -1 Then
                roundtrip.Append(ChrW(b))
            End If
        Loop While b <> -1

        ' Display the original data and the decrypted data.
        Console.WriteLine("Original:   {0}", original)
        Console.WriteLine("Round Trip: {0}", roundtrip)

    End Sub
End Module

Hinweise

Die RC2CryptoServiceProvider Implementierung unterstützt Schlüssellängen von 40 Bit bis 128 Bit in Schritten von 8 Bit.

Das RC2CryptoServiceProvider Objekt ist eine Blockchiffre, die Daten in Blöcken mit 8 Bytes verschlüsselt und entschlüsselt. Diese Klasse zeichnet den endgültigen Datenblock auf, wenn er kleiner als 8 Bytes ist. Durch diese Auffüllung kann die Länge verschlüsselter Daten größer sein als der ursprüngliche Klartext.

Beachten Sie, dass das RC2CryptoServiceProvider Objekt kein Salz verwendet.

Hinweis

Ein neuerer symmetrischer Verschlüsselungsalgorithmus, Advanced Encryption Standard (AES), ist verfügbar. Erwägen Sie die Verwendung des Aes Algorithmus und seiner abgeleiteten Klassen anstelle der RC2CryptoServiceProvider -Klasse. Verwenden Sie RC2CryptoServiceProvider nur zur Kompatibilität mit Legacyanwendungen und -daten.

Konstruktoren

RC2CryptoServiceProvider()
Veraltet.

Initialisiert eine neue Instanz der RC2CryptoServiceProvider-Klasse.

Felder

BlockSizeValue
Veraltet.

Stellt die Blockgröße des kryptografischen Vorgangs in Bits dar.

(Geerbt von SymmetricAlgorithm)
EffectiveKeySizeValue
Veraltet.

Stellt die effektive Größe des geheimen Schlüssels für den RC2-Algorithmus in Bits dar.

(Geerbt von RC2)
FeedbackSizeValue
Veraltet.

Stellt die Feedbackgröße des kryptografischen Vorgangs in Bits dar.

(Geerbt von SymmetricAlgorithm)
IVValue
Veraltet.

Stellt den Initialisierungsvektor (IV) für den symmetrischen Algorithmus dar.

(Geerbt von SymmetricAlgorithm)
KeySizeValue
Veraltet.

Stellt die Größe des vom symmetrischen Algorithmus verwendeten geheimen Schlüssels in Bits dar.

(Geerbt von SymmetricAlgorithm)
KeyValue
Veraltet.

Stellt den geheimen Schlüssel für den symmetrischen Algorithmus dar.

(Geerbt von SymmetricAlgorithm)
LegalBlockSizesValue
Veraltet.

Gibt die vom symmetrischen Algorithmus unterstützten Blockgrößen in Bits an.

(Geerbt von SymmetricAlgorithm)
LegalKeySizesValue
Veraltet.

Gibt die vom symmetrischen Algorithmus unterstützten Schlüsselgrößen in Bits an.

(Geerbt von SymmetricAlgorithm)
ModeValue
Veraltet.

Stellt den im symmetrischen Algorithmus verwendeten Verschlüsselungsmodus dar.

(Geerbt von SymmetricAlgorithm)
PaddingValue
Veraltet.

Stellt den im symmetrischen Algorithmus verwendeten Füllzeichenmodus dar.

(Geerbt von SymmetricAlgorithm)

Eigenschaften

BlockSize
Veraltet.

Ruft die Blockgröße des kryptografischen Vorgangs in Bits ab oder legt diese fest.

(Geerbt von SymmetricAlgorithm)
EffectiveKeySize
Veraltet.

Ruft die effektive Größe des geheimen Schlüssels für den RC2-Algorithmus in Bits ab oder legt diese fest.

FeedbackSize
Veraltet.

Ruft die Feedbackgröße des kryptografischen Vorgangs für den CFB-Modus (Cipher Feedback, Verschlüsselungsverfahren-Feedback) und den OFB-Modus (Output Feedback, Ausgabefeedback) in Bits ab oder legt diese fest.

(Geerbt von SymmetricAlgorithm)
IV
Veraltet.

Ruft den Initialisierungsvektor (IV) für den symmetrischen Algorithmus ab oder legt diesen fest.

(Geerbt von SymmetricAlgorithm)
Key
Veraltet.

Ruft den geheimen Schlüssel für den symmetrischen Algorithmus ab oder legt diesen fest.

(Geerbt von SymmetricAlgorithm)
KeySize
Veraltet.

Ruft die Größe des geheimen Schlüssels für den RC2-Algorithmus in Bit ab oder legt diesen fest.

(Geerbt von RC2)
LegalBlockSizes
Veraltet.

Ruft die vom symmetrischen Algorithmus unterstützten Blockgrößen in Bits ab.

(Geerbt von SymmetricAlgorithm)
LegalKeySizes
Veraltet.

Ruft die vom symmetrischen Algorithmus unterstützten Schlüsselgrößen in Bits ab.

(Geerbt von SymmetricAlgorithm)
Mode
Veraltet.

Ruft den Modus für die Ausführung des symmetrischen Algorithmus ab oder legt diesen fest.

(Geerbt von SymmetricAlgorithm)
Padding
Veraltet.

Ruft den im symmetrischen Algorithmus verwendeten Füllzeichenmodus ab oder legt diesen fest.

(Geerbt von SymmetricAlgorithm)
UseSalt
Veraltet.

Ruft einen Wert ab, der bestimmt, ob ein Schlüssel mit einem Salt mit der Länge 11 Bytes und dem Wert 0 (null) erstellt werden soll, bzw. legt diesen Wert fest.

Methoden

Clear()
Veraltet.

Gibt alle von der SymmetricAlgorithm-Klasse verwendeten Ressourcen frei.

(Geerbt von SymmetricAlgorithm)
CreateDecryptor()
Veraltet.

Erstellt ein symmetrisches Entschlüsselungsobjekt mit der aktuellen Key-Eigenschaft und dem Initialisierungsvektor (IV).

(Geerbt von SymmetricAlgorithm)
CreateDecryptor(Byte[], Byte[])
Veraltet.

Erstellt ein symmetrisches RC2-Entschlüsselungsobjekt mit dem angegebenen Schlüssel (Key) und dem angegebenen Initialisierungsvektor (IV).

CreateEncryptor()
Veraltet.

Erstellt ein symmetrisches Verschlüsselungsobjekt mit der aktuellen Key-Eigenschaft und dem aktuellen Initialisierungsvektor (IV).

(Geerbt von SymmetricAlgorithm)
CreateEncryptor(Byte[], Byte[])
Veraltet.

Erstellt ein symmetrisches RC2-Verschlüsselungsobjekt mit dem angegebenen Schlüssel (Key) und dem angegebenen Initialisierungsvektor (IV).

DecryptCbc(Byte[], Byte[], PaddingMode)
Veraltet.

Entschlüsselt Daten im CBC-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
DecryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, PaddingMode)
Veraltet.

Entschlüsselt Daten im CBC-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
DecryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode)
Veraltet.

Entschlüsselt Daten mithilfe des CBC-Modus mit dem angegebenen Auffüllmodus in den angegebenen Puffer.

(Geerbt von SymmetricAlgorithm)
DecryptCfb(Byte[], Byte[], PaddingMode, Int32)
Veraltet.

Entschlüsselt Daten im CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
DecryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, PaddingMode, Int32)
Veraltet.

Entschlüsselt Daten im CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
DecryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Entschlüsselt Daten im angegebenen Puffer mithilfe des CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
DecryptEcb(Byte[], PaddingMode)
Veraltet.

Entschlüsselt Daten im EZB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
DecryptEcb(ReadOnlySpan<Byte>, PaddingMode)
Veraltet.

Entschlüsselt Daten im EZB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
DecryptEcb(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode)
Veraltet.

Entschlüsselt Daten im angegebenen Puffer mithilfe des ECB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
Dispose()
Veraltet.

Gibt alle von der aktuellen Instanz der SymmetricAlgorithm-Klasse verwendeten Ressourcen frei.

(Geerbt von SymmetricAlgorithm)
Dispose(Boolean)
Veraltet.

Gibt die von SymmetricAlgorithm verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von SymmetricAlgorithm)
EncryptCbc(Byte[], Byte[], PaddingMode)
Veraltet.

Verschlüsselt Daten im CBC-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
EncryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, PaddingMode)
Veraltet.

Verschlüsselt Daten im CBC-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
EncryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode)
Veraltet.

Verschlüsselt Daten im angegebenen Puffer mithilfe des CBC-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
EncryptCfb(Byte[], Byte[], PaddingMode, Int32)
Veraltet.

Verschlüsselt Daten im CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
EncryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, PaddingMode, Int32)
Veraltet.

Verschlüsselt Daten im CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
EncryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Verschlüsselt Daten im angegebenen Puffer mithilfe des CFB-Modus mit dem angegebenen Auffüllungsmodus und der angegebenen Feedbackgröße.

(Geerbt von SymmetricAlgorithm)
EncryptEcb(Byte[], PaddingMode)
Veraltet.

Verschlüsselt Daten im ECB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
EncryptEcb(ReadOnlySpan<Byte>, PaddingMode)
Veraltet.

Verschlüsselt Daten im ECB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
EncryptEcb(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode)
Veraltet.

Verschlüsselt Daten im angegebenen Puffer mithilfe des EZB-Modus mit dem angegebenen Auffüllmodus.

(Geerbt von SymmetricAlgorithm)
Equals(Object)
Veraltet.

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GenerateIV()
Veraltet.

Generiert einen zufälligen Initialisierungsvektor (IV) für den Algorithmus.

GenerateKey()
Veraltet.

Generiert einen Zufallsschlüssel (Key) für den Algorithmus.

GetCiphertextLengthCbc(Int32, PaddingMode)
Veraltet.

Ruft die Länge eines Chiffretexts mit einem angegebenen Auffüllmodus und Klartextlänge im CBC-Modus ab.

(Geerbt von SymmetricAlgorithm)
GetCiphertextLengthCfb(Int32, PaddingMode, Int32)
Veraltet.

Ruft die Länge eines Chiffretexts mit einem angegebenen Auffüllmodus und Klartextlänge im CFB-Modus ab.

(Geerbt von SymmetricAlgorithm)
GetCiphertextLengthEcb(Int32, PaddingMode)
Veraltet.

Ruft die Länge eines Chiffretexts mit einem angegebenen Auffüllmodus und Klartextlänge im EZB-Modus ab.

(Geerbt von SymmetricAlgorithm)
GetHashCode()
Veraltet.

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetType()
Veraltet.

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()
Veraltet.

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()
Veraltet.

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
TryDecryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, PaddingMode)
Veraltet.

Versucht, Daten mithilfe des CBC-Modus mit dem angegebenen Auffüllmodus in den angegebenen Puffer zu entschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryDecryptCbcCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Beim Überschreiben in einer abgeleiteten Klasse versucht, Daten im angegebenen Puffer zu entschlüsseln, wobei der CBC-Modus mit dem angegebenen Auffüllmodus verwendet wird.

(Geerbt von SymmetricAlgorithm)
TryDecryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, PaddingMode, Int32)
Veraltet.

Versucht, Daten im angegebenen Puffer mithilfe des CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße zu entschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryDecryptCfbCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32, Int32)
Veraltet.

Beim Überschreiben in einer abgeleiteten Klasse versucht, Daten im angegebenen Puffer zu entschlüsseln, wobei der CFB-Modus mit dem angegebenen Auffüllungsmodus und der angegebenen Feedbackgröße verwendet wird.

(Geerbt von SymmetricAlgorithm)
TryDecryptEcb(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Versucht, Daten im angegebenen Puffer zu entschlüsseln, indem der ECB-Modus mit dem angegebenen Auffüllmodus verwendet wird.

(Geerbt von SymmetricAlgorithm)
TryDecryptEcbCore(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Versucht beim Überschreiben in einer abgeleiteten Klasse, Daten im angegebenen Puffer zu entschlüsseln, indem der ECB-Modus mit dem angegebenen Auffüllmodus verwendet wird.

(Geerbt von SymmetricAlgorithm)
TryEncryptCbc(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, PaddingMode)
Veraltet.

Versucht, Daten im angegebenen Puffer mithilfe des CBC-Modus mit dem angegebenen Auffüllmodus zu verschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryEncryptCbcCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Wenn Sie in einer abgeleiteten Klasse überschrieben werden, versucht, Daten im angegebenen Puffer zu verschlüsseln, indem Sie den CBC-Modus mit dem angegebenen Auffüllmodus verwenden.

(Geerbt von SymmetricAlgorithm)
TryEncryptCfb(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, Int32, PaddingMode, Int32)
Veraltet.

Versucht, Daten im angegebenen Puffer mithilfe des CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße zu verschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryEncryptCfbCore(ReadOnlySpan<Byte>, ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32, Int32)
Veraltet.

Beim Überschreiben in einer abgeleiteten Klasse versucht, Daten mithilfe des CFB-Modus mit dem angegebenen Auffüllmodus und der angegebenen Feedbackgröße in den angegebenen Puffer zu verschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryEncryptEcb(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Versucht, Daten im angegebenen Puffer mithilfe des ECB-Modus mit dem angegebenen Auffüllmodus zu verschlüsseln.

(Geerbt von SymmetricAlgorithm)
TryEncryptEcbCore(ReadOnlySpan<Byte>, Span<Byte>, PaddingMode, Int32)
Veraltet.

Beim Überschreiben in einer abgeleiteten Klasse versucht, Daten im angegebenen Puffer mithilfe des EZB-Modus mit dem angegebenen Auffüllmodus zu verschlüsseln.

(Geerbt von SymmetricAlgorithm)
ValidKeySize(Int32)
Veraltet.

Bestimmt, ob die angegebene Schlüsselgröße für den aktuellen Algorithmus gültig ist.

(Geerbt von SymmetricAlgorithm)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose()

Diese API unterstützt die Produktinfrastruktur und ist nicht für die direkte Verwendung aus Ihrem Code gedacht.

Veraltet.

Gibt die von SymmetricAlgorithm verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von SymmetricAlgorithm)

Gilt für:

Weitere Informationen