CryptoStream Classe

Définition

Définit un flux qui lie les flux de données aux transformations par chiffrement.Defines a stream that links data streams to cryptographic transformations.

public ref class CryptoStream : System::IO::Stream
public class CryptoStream : System.IO.Stream
[System.Runtime.InteropServices.ComVisible(true)]
public class CryptoStream : System.IO.Stream
type CryptoStream = class
    inherit Stream
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type CryptoStream = class
    inherit Stream
    interface IDisposable
Public Class CryptoStream
Inherits Stream
Héritage
CryptoStream
Héritage
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser un CryptoStream pour chiffrer une chaîne.The following example demonstrates how to use a CryptoStream to encrypt a string. Cette méthode utilise RijndaelManaged la classe avec le Key et le vecteur d’initialisation () spécifiés IV .This method uses RijndaelManaged class with the specified Key and initialization vector (IV).

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

namespace RijndaelManaged_Example
{
    class RijndaelExample
    {
        public static void Main()
        {
            try
            {

                string original = "Here is some data to encrypt!";

                // Create a new instance of the Rijndael
                // class.  This generates a new key and initialization
                // vector (IV).
                using (Rijndael myRijndael = Rijndael.Create())
                {
                    // Encrypt the string to an array of bytes.
                    byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV);

                    // Decrypt the bytes to a string.
                    string roundtrip = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV);

                    //Display the original data and the decrypted data.
                    Console.WriteLine("Original:   {0}", original);
                    Console.WriteLine("Round Trip: {0}", roundtrip);
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: {0}", e.Message);
            }
        }
        static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (plainText == null || plainText.Length <= 0)
                throw new ArgumentNullException("plainText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");
            byte[] encrypted;
            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create an encryptor to perform the stream transform.
                ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {

                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                        encrypted = msEncrypt.ToArray();
                    }
                }
            }

            // Return the encrypted bytes from the memory stream.
            return encrypted;
        }

        static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (Key == null || Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (IV == null || IV.Length <= 0)
                throw new ArgumentNullException("IV");

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            // Create an Rijndael object
            // with the specified key and IV.
            using (Rijndael rijAlg = Rijndael.Create())
            {
                rijAlg.Key = Key;
                rijAlg.IV = IV;

                // Create a decryptor to perform the stream transform.
                ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV);

                // Create the streams used for decryption.
                using (MemoryStream msDecrypt = new MemoryStream(cipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plaintext;
        }
    }
}
Imports System.IO
Imports System.Security.Cryptography



Class RijndaelExample

    Public Shared Sub Main()
        Try

            Dim original As String = "Here is some data to encrypt!"

            ' Create a new instance of the Rijndael
            ' class.  This generates a new key and initialization 
            ' vector (IV).
            Using myRijndael = Rijndael.Create()

                ' Encrypt the string to an array of bytes.
                Dim encrypted As Byte() = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV)

                ' Decrypt the bytes to a string.
                Dim roundtrip As String = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV)

                'Display the original data and the decrypted data.
                Console.WriteLine("Original:   {0}", original)
                Console.WriteLine("Round Trip: {0}", roundtrip)
            End Using
        Catch e As Exception
            Console.WriteLine("Error: {0}", e.Message)
        End Try

    End Sub

    Shared Function EncryptStringToBytes(ByVal plainText As String, ByVal Key() As Byte, ByVal IV() As Byte) As Byte()
        ' Check arguments.
        If plainText Is Nothing OrElse plainText.Length <= 0 Then
            Throw New ArgumentNullException("plainText")
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException("Key")
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException("IV")
        End If
        Dim encrypted() As Byte
        ' Create an Rijndael object
        ' with the specified key and IV.
        Using rijAlg = Rijndael.Create()

            rijAlg.Key = Key
            rijAlg.IV = IV

            ' Create an encryptor to perform the stream transform.
            Dim encryptor As ICryptoTransform = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.IV)
            ' Create the streams used for encryption.
            Using msEncrypt As New MemoryStream()
                Using csEncrypt As New CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)
                    Using swEncrypt As New StreamWriter(csEncrypt)

                        'Write all data to the stream.
                        swEncrypt.Write(plainText)
                    End Using
                    encrypted = msEncrypt.ToArray()
                End Using
            End Using
        End Using

        ' Return the encrypted bytes from the memory stream.
        Return encrypted

    End Function 'EncryptStringToBytes

    Shared Function DecryptStringFromBytes(ByVal cipherText() As Byte, ByVal Key() As Byte, ByVal IV() As Byte) As String
        ' Check arguments.
        If cipherText Is Nothing OrElse cipherText.Length <= 0 Then
            Throw New ArgumentNullException("cipherText")
        End If
        If Key Is Nothing OrElse Key.Length <= 0 Then
            Throw New ArgumentNullException("Key")
        End If
        If IV Is Nothing OrElse IV.Length <= 0 Then
            Throw New ArgumentNullException("IV")
        End If
        ' Declare the string used to hold
        ' the decrypted text.
        Dim plaintext As String = Nothing

        ' Create an Rijndael object
        ' with the specified key and IV.
        Using rijAlg = Rijndael.Create()
            rijAlg.Key = Key
            rijAlg.IV = IV

            ' Create a decryptor to perform the stream transform.
            Dim decryptor As ICryptoTransform = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV)

            ' Create the streams used for decryption.
            Using msDecrypt As New MemoryStream(cipherText)

                Using csDecrypt As New CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)

                    Using srDecrypt As New StreamReader(csDecrypt)


                        ' Read the decrypted bytes from the decrypting stream
                        ' and place them in a string.
                        plaintext = srDecrypt.ReadToEnd()
                    End Using
                End Using
            End Using
        End Using

        Return plaintext

    End Function 'DecryptStringFromBytes 
End Class

Remarques

Le common language runtime utilise une conception orientée flux pour le chiffrement.The common language runtime uses a stream-oriented design for cryptography. Le cœur de cette conception est CryptoStream .The core of this design is CryptoStream. Tout objet de chiffrement qui implémente CryptoStream peut être chaîné avec n’importe quel objet qui implémente Stream , de sorte que la sortie diffusée en continu d’un objet peut être alimentée dans l’entrée d’un autre objet.Any cryptographic objects that implement CryptoStream can be chained together with any objects that implement Stream, so the streamed output from one object can be fed into the input of another object. Le résultat intermédiaire (la sortie du premier objet) n’a pas besoin d’être stocké séparément.The intermediate result (the output from the first object) does not need to be stored separately.

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement en appelant sa Clear méthode, qui à son tour appelle son IDisposable implémentation.When you have finished using the type, you should dispose of it either directly or indirectly by calling its Clear method, which in turn calls its IDisposable implementation. Pour supprimer directement le type Clear, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Clear method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Vous devez toujours fermer explicitement votre CryptoStream objet une fois que vous avez fini de l’utiliser en appelant la Clear méthode.You should always explicitly close your CryptoStream object after you are done using it by calling the Clear method. Cela vide le flux sous-jacent et entraîne le traitement de tous les blocs de données restants par l' CryptoStream objet.Doing so flushes the underlying stream and causes all remaining blocks of data to be processed by the CryptoStream object. Toutefois, si une exception se produit avant d’appeler la Close méthode, l' CryptoStream objet ne peut pas être fermé.However, if an exception occurs before you call the Close method, the CryptoStream object might not be closed. Pour vous assurer que la Close méthode est toujours appelée, placez votre appel à la Clear méthode dans le finally bloc d’une try / catch instruction.To ensure that the Close method always gets called, place your call to the Clear method within the finally block of a try/catch statement.

Constructeurs

CryptoStream(Stream, ICryptoTransform, CryptoStreamMode)

Initialise une nouvelle instance de la classe CryptoStream avec un flux de données cible, la transformation à utiliser et le mode du flux.Initializes a new instance of the CryptoStream class with a target data stream, the transformation to use, and the mode of the stream.

CryptoStream(Stream, ICryptoTransform, CryptoStreamMode, Boolean)

Initialise une nouvelle instance de la classe CryptoStream.Initializes a new instance of the CryptoStream class.

Propriétés

CanRead

Obtient une valeur indiquant si le CryptoStream actuel est lisible.Gets a value indicating whether the current CryptoStream is readable.

CanSeek

Obtient une valeur indiquant si vous pouvez effectuer une recherche dans le CryptoStream actuel.Gets a value indicating whether you can seek within the current CryptoStream.

CanTimeout

Obtient une valeur qui détermine si le flux actuel peut dépasser le délai d'attente.Gets a value that determines whether the current stream can time out.

(Hérité de Stream)
CanWrite

Obtient une valeur indiquant si le CryptoStream actuel est accessible en écriture.Gets a value indicating whether the current CryptoStream is writable.

HasFlushedFinalBlock

Obtient une valeur indiquant si le dernier bloc de mémoire tampon a été écrit dans le flux sous-jacent.Gets a value indicating whether the final buffer block has been written to the underlying stream.

Length

Obtient la longueur du flux en octets.Gets the length in bytes of the stream.

Position

Obtient ou définit la position dans le flux actuel.Gets or sets the position within the current stream.

ReadTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’effectuer la lecture avant dépassement du délai d’attente.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to read before timing out.

(Hérité de Stream)
WriteTimeout

Obtient ou définit une valeur, exprimée en millisecondes, qui définit la durée pendant laquelle le flux tentera d’écrire des données avant l’expiration du délai d’attente.Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.

(Hérité de Stream)

Méthodes

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync à la place.)(Consider using ReadAsync instead.)

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération de lecture asynchrone.Begins an asynchronous read operation. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync à la place.)(Consider using WriteAsync instead.)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Débute une opération d'écriture asynchrone.Begins an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
Clear()

Libère toutes les ressources utilisées par CryptoStream.Releases all resources used by the CryptoStream.

Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream.

Close()

Ferme le flux actuel et libère toutes les ressources (comme les sockets et les handles de fichiers) associées à celui-ci.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Au lieu d'appeler cette méthode, assurez-vous que le flux est correctement supprimé.Instead of calling this method, ensure that the stream is properly disposed.

(Hérité de Stream)
CopyTo(Stream)

Lit les octets du flux actuel et les écrit dans un autre flux.Reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyTo(Stream, Int32)

Lit tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Hérité de Stream)
CopyToAsync(Stream, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant un jeton d’annulation spécifié.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Hérité de Stream)
CopyToAsync(Stream, Int32)

Lit de façon asynchrone tous les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon spécifiée.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Hérité de Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Lit de façon asynchrone les octets du flux actuel et les écrit dans un autre flux, en utilisant une taille de mémoire tampon et d'un jeton d'annulation spécifiés.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Hérité de Stream)
CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Hérité de MarshalByRefObject)
CreateWaitHandle()
Obsolète.

Alloue un objet WaitHandle.Allocates a WaitHandle object.

(Hérité de Stream)
Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

(Hérité de Stream)
Dispose(Boolean)

Libère les ressources non managées utilisées par CryptoStream et libère éventuellement les ressources managées.Releases the unmanaged resources used by the CryptoStream and optionally releases the managed resources.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par CryptoStream.Asynchronously releases the unmanaged resources used by the CryptoStream.

DisposeAsync()

Libère de façon asynchrone les ressources non managées utilisées par Stream.Asynchronously releases the unmanaged resources used by the Stream.

(Hérité de Stream)
EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync à la place.)(Consider using ReadAsync instead.)

EndRead(IAsyncResult)

Attend que la requête asynchrone en attente se termine.Waits for the pending asynchronous read to complete. (Utilisez ReadAsync(Byte[], Int32, Int32) à la place.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync à la place.)(Consider using WriteAsync instead.)

EndWrite(IAsyncResult)

Termine une opération d'écriture asynchrone.Ends an asynchronous write operation. (Utilisez WriteAsync(Byte[], Int32, Int32) à la place.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Hérité de Stream)
Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
Finalize()

Autorise un objet à tenter de libérer des ressources et à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

Flush()

Efface toutes les mémoires tampons pour le flux actuel et provoque l'écriture des données mises en mémoire tampon dans le périphérique sous-jacent.Clears all buffers for the current stream and causes any buffered data to be written to the underlying device.

FlushAsync()

Efface de façon asynchrone toutes les mémoires tampons pour ce flux et provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Hérité de Stream)
FlushAsync(CancellationToken)

Efface toutes les mémoires tampons pour le flux actuel de manière asynchrone, provoque l'écriture des données mises en mémoire tampon dans le périphérique sous-jacent et surveille les demandes d'annulation.Clears all buffers for the current stream asynchronously, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

FlushAsync(CancellationToken)

Efface de façon asynchrone toutes les mémoires tampons pour ce flux, provoque l'écriture des données mises en mémoire tampon sur l'appareil sous-jacent et surveille les requêtes d'annulation.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

(Hérité de Stream)
FlushFinalBlock()

Met à jour la source de données sous-jacente ou le référentiel avec l'état actuel de la mémoire tampon, puis efface cette dernière.Updates the underlying data source or repository with the current state of the buffer, then clears the buffer.

FlushFinalBlockAsync(CancellationToken)

Met à jour de façon asynchrone la source de données sous-jacente ou le référentiel avec l'état actuel de la mémoire tampon, puis efface cette dernière.Asynchronously updates the underlying data source or repository with the current state of the buffer, then clears the buffer.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetLifetimeService()
Obsolète.

Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
InitializeLifetimeService()
Obsolète.

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

(Hérité de MarshalByRefObject)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
MemberwiseClone(Boolean)

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

(Hérité de MarshalByRefObject)
ObjectInvariant()
Obsolète.

Assure la prise en charge d'un Contract.Provides support for a Contract.

(Hérité de Stream)
Read(Byte[], Int32, Int32)

Lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

Read(Span<Byte>)

En cas de remplacement dans une classe dérivée, lit une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32)

Lit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position dans le flux du nombre d'octets lus.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Hérité de Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit une séquence d'octets à partir du flux actuel de manière asynchrone, avance la position dans le flux du nombre d'octets lus, et surveille les demandes d'annulation.Reads a sequence of bytes from the current stream asynchronously, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Hérité de Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Lit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position dans le flux du nombre d'octets lus et surveille les demandes d'annulation.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Hérité de Stream)
ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

ReadByte()

Lit un octet du flux et avance d'un octet la position au sein du flux, ou retourne -1 si la fin du flux a été atteinte.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

(Hérité de Stream)
Seek(Int64, SeekOrigin)

Définit la position dans le flux actuel.Sets the position within the current stream.

SetLength(Int64)

Définit la longueur du flux actuel.Sets the length of the current stream.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
Write(Byte[], Int32, Int32)

Écrit une suite d'octets dans le CryptoStream actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.Writes a sequence of bytes to the current CryptoStream and advances the current position within the stream by the number of bytes written.

Write(ReadOnlySpan<Byte>)

En cas de remplacement dans une classe dérivée, écrit une séquence d'octets dans le flux actuel et avance la position actuelle dans ce flux du nombre d'octets écrits.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel et avance la position actuelle dans le flux du nombre d'octets écrits.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Hérité de Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit une séquence d'octets à partir du flux actuel de façon asynchrone, avance la position actuelle dans le flux du nombre d'octets écrits et surveille les demandes d'annulation.Writes a sequence of bytes to the current stream asynchronously, advances the current position within the stream by the number of bytes written, and monitors cancellation requests.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Hérité de Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Écrit de façon asynchrone une séquence d'octets dans le flux actuel, avance la position actuelle dans ce flux du nombre d'octets écrits et surveille les demandes d'annulation.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Hérité de Stream)
WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

WriteByte(Byte)

Écrit un octet à la position actuelle dans le flux et avance d'un octet la position dans le flux.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Hérité de Stream)

Implémentations d’interfaces explicites

IDisposable.Dispose()

Cette API prend en charge l'infrastructure du produit et n'est pas destinée à être utilisée directement à partir de votre code.

Libère les ressources utilisées par l'instance actuelle de la classe CryptoStream.Releases the resources used by the current instance of the CryptoStream class.

IDisposable.Dispose()

Libère toutes les ressources utilisées par Stream.Releases all resources used by the Stream.

(Hérité de Stream)

Méthodes d’extension

ConfigureAwait(IAsyncDisposable, Boolean)

Configure la façon dont les attentes sur les tâches retournées à partir d’un élément supprimable asynchrone sont effectuées.Configures how awaits on the tasks returned from an async disposable are performed.

S’applique à