BufferedStream.Write Méthode

  • Référence

Définition

Espace de noms:
System.IO
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
System.IO.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Surcharges

Write(ReadOnlySpan<Byte>)

Écrit une séquence d’octets dans le flux mis en mémoire tampon actuel et avance la position actuelle dans ce flux du 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 ce flux du nombre d’octets écrits.

Write(ReadOnlySpan<Byte>)

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

Écrit une séquence d’octets dans le flux mis en mémoire tampon actuel et avance la position actuelle dans ce flux du 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>

Région de la mémoire. Cette méthode copie le contenu de cette région dans le flux mis en mémoire tampon actuel.

Remarques

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

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

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

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

Paramètres

arraybuffer
Byte[]

Tableau d'octets à partir duquel count octets sont copiés vers le flux en cours mis en mémoire tampon.

offset
Int32

Dans la mémoire tampon, offset à partir duquel commence la copie des octets dans le flux actuel mis en mémoire tampon.

count
Int32

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

Exceptions

ArgumentException

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

ArgumentNullException

array a la valeur null.

ArgumentOutOfRangeException

offset ou count est un nombre négatif.

IOException

Le flux est fermé ou null.

NotSupportedException

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

ObjectDisposedException

Des 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).ToString(), bufferedTime.ToString(  "F1" ) );

// 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 à