BufferedStream.Write Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
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
La longueur de array
moins offset
est inférieure à count
.
array
a la valeur null
.
offset
ou count
est un nombre négatif.
Le flux est fermé ou null
.
Le flux ne prend pas en charge l'écriture.
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
- CanWrite
- Read(Byte[], Int32, Int32)
- Fichier et flux de données E/S
- Procédure : lire le texte d’un fichier
- Procédure : écrire du texte dans un fichier