Partager via


BufferedStream.Write Méthode

Définition

Surcharges

Nom Description
Write(ReadOnlySpan<Byte>)

Écrit une séquence d’octets dans le flux mis en mémoire tampon actuelle et avance la position actuelle dans ce flux mis en mémoire tampon par le nombre d’octets écrits.

Write(Byte[], Int32, Int32)

Copie les octets dans le flux mis en mémoire tampon et avance la position actuelle dans le flux mis en mémoire tampon par le nombre d’octets écrits.

Write(ReadOnlySpan<Byte>)

Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs

Écrit une séquence d’octets dans le flux mis en mémoire tampon actuelle et avance la position actuelle dans ce flux mis en mémoire tampon par le nombre d’octets écrits.

public:
 override void Write(ReadOnlySpan<System::Byte> buffer);
public override void Write(ReadOnlySpan<byte> buffer);
override this.Write : ReadOnlySpan<byte> -> unit
Public Overrides Sub Write (buffer As ReadOnlySpan(Of Byte))

Paramètres

buffer
ReadOnlySpan<Byte>

Une région de mémoire. Cette méthode copie le contenu de cette région dans le flux mis en mémoire tampon actuelle.

Remarques

Utilisez la CanWrite propriété pour déterminer si l’instance actuelle prend en charge l’écriture. Utilisez la WriteAsync méthode pour écrire de manière asynchrone dans le flux mis en mémoire tampon actuelle.

Si l’opération d’écriture réussit, la position dans le flux mis en mémoire tampon avance par le nombre d’octets écrits. Si une exception se produit, la position dans le flux mis en mémoire tampon reste inchangée.

S’applique à

Write(Byte[], Int32, Int32)

Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs
Source:
BufferedStream.cs

Copie les octets dans le flux mis en mémoire tampon et avance la position actuelle dans le flux mis en mémoire tampon par le nombre d’octets écrits.

public:
 override void Write(cli::array <System::Byte> ^ buffer, int offset, int count);
public:
 override void Write(cli::array <System::Byte> ^ array, int offset, int count);
public override void Write(byte[] buffer, int offset, int count);
public override void Write(byte[] array, int offset, int count);
override this.Write : byte[] * int * int -> unit
override this.Write : byte[] * int * int -> unit
Public Overrides Sub Write (buffer As Byte(), offset As Integer, count As Integer)
Public Overrides Sub Write (array As Byte(), offset As Integer, count As Integer)

Paramètres

bufferarray
Byte[]
offset
Int32

Décalage dans la mémoire tampon à laquelle commencer la copie d’octets dans le flux mis en mémoire tampon actuelle.

count
Int32

Nombre d’octets à écrire dans le flux mis en mémoire tampon actuelle.

Exceptions

La longueur de array moins offset est inférieure à count.

array a la valeur null.

offset ou count est négatif.

Le flux est fermé ou null.

Le flux ne prend pas en charge l’écriture.

Les méthodes ont été appelées après la fermeture du flux.

Exemples

Cet exemple de code fait partie d’un exemple plus grand fourni pour la BufferedStream classe.

// Send the data using the BufferedStream.
Console.WriteLine("Sending data using BufferedStream.");
startTime = DateTime.Now;
for(int i = 0; i < numberOfLoops; i++)
{
    bufStream.Write(dataToSend, 0, dataToSend.Length);
}
bufStream.Flush();
bufferedTime = (DateTime.Now - startTime).TotalSeconds;
Console.WriteLine("{0} bytes sent in {1} seconds.\n",
    numberOfLoops * dataToSend.Length,
    bufferedTime.ToString("F1"));
// Send the data using the BufferedStream.
printfn "Sending data using BufferedStream."
let startTime = DateTime.Now
for _ = 0 to numberOfLoops - 1 do
    bufStream.Write(dataToSend, 0, dataToSend.Length)
bufStream.Flush()
let bufferedTime = (DateTime.Now - startTime).TotalSeconds
printfn $"{numberOfLoops * dataToSend.Length} bytes sent in {bufferedTime:F1} seconds.\n"
' Send the data using the BufferedStream.
Console.WriteLine("Sending data using BufferedStream.")
startTime = DateTime.Now
For i As Integer = 1 To numberOfLoops
    bufStream.Write(dataToSend, 0, dataToSend.Length)
Next i

bufStream.Flush()
bufferedTime = DateTime.Now.Subtract(startTime).TotalSeconds
Console.WriteLine("{0} bytes sent In {1} seconds." & vbCrLf, _
    numberOfLoops * dataToSend.Length, _
    bufferedTime.ToString("F1"))

Voir aussi

S’applique à