BinaryWriter.Write Méthode

Définition

Écrit une valeur dans le flux actuel.Writes a value to the current stream.

Surcharges

Write(Char[], Int32, Int32)

Écrit dans le flux actuel une section d’un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits.Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

Write(Byte[], Int32, Int32)

Écrit une zone d’un tableau d’octets dans le flux actuel.Writes a region of a byte array to the current stream.

Write(UInt64)

Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes.

Write(UInt32)

Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes.

Write(UInt16)

Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets.Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes.

Write(String)

Écrit dans ce flux une chaîne préfixée par sa longueur dans l’encodage actuel de BinaryWriter et avance la position actuelle du flux en fonction de l’encodage utilisé et des caractères spécifiques écrits dans le flux.Writes a length-prefixed string to this stream in the current encoding of the BinaryWriter, and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream.

Write(Single)

Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.

Write(SByte)

Écrit un octet signé dans le flux actuel et avance la position du flux d’un octet.Writes a signed byte to the current stream and advances the stream position by one byte.

Write(ReadOnlySpan<Char>)

Écrit une plage de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits dans le flux.Writes a span of characters to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

Write(ReadOnlySpan<Byte>)

Écrit une plage d’octets dans le flux actuel.Writes a span of bytes to the current stream.

Write(Char)

Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d’écriture dans le flux.Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

Write(Int32)

Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte signed integer to the current stream and advances the stream position by four bytes.

Write(Int16)

Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets.Writes a two-byte signed integer to the current stream and advances the stream position by two bytes.

Write(Double)

Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes.

Write(Decimal)

Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets.Writes a decimal value to the current stream and advances the stream position by sixteen bytes.

Write(Char[])

Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d’écriture dans le flux.Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

Write(Byte[])

Écrit un tableau d’octets dans le flux sous-jacent.Writes a byte array to the underlying stream.

Write(Byte)

Écrit un octet non signé dans le flux actuel et avance la position du flux d’un octet.Writes an unsigned byte to the current stream and advances the stream position by one byte.

Write(Boolean)

Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true.Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true.

Write(Int64)

Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes.

Write(Char[], Int32, Int32)

Écrit dans le flux actuel une section d’un tableau de caractères et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits.Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

public:
 virtual void Write(cli::array <char> ^ chars, int index, int count);
public virtual void Write (char[] chars, int index, int count);
abstract member Write : char[] * int * int -> unit
override this.Write : char[] * int * int -> unit
Public Overridable Sub Write (chars As Char(), index As Integer, count As Integer)

Paramètres

chars
Char[]

Tableau de caractères contenant les données à écrire.A character array containing the data to write.

index
Int32

Index du premier caractère à lire dans chars et à écrire dans le flux.The index of the first character to read from chars and to write to the stream.

count
Int32

Nombre de caractères à lire dans chars et à écrire dans le flux.The number of characters to read from chars and to write to the stream.

Exceptions

La longueur de la mémoire tampon moins index est inférieure à count.The buffer length minus index is less than count.

chars a la valeur null.chars is null.

index ou count est un nombre négatif.index or count is negative.

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment lire et écrire des données à l’aide de la mémoire en tant que magasin de stockage.The following code example shows how to read and write data using memory as a backing store.

using namespace System;
using namespace System::IO;
int main()
{
   array<Char>^invalidPathChars = Path::InvalidPathChars;
   MemoryStream^ memStream = gcnew MemoryStream;
   BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
   
   // Write to memory.
   binWriter->Write( "Invalid file path characters are: " );
   binWriter->Write( Path::InvalidPathChars, 0, Path::InvalidPathChars->Length );
   
   // Create the reader using the same MemoryStream 
   // as used with the writer.
   BinaryReader^ binReader = gcnew BinaryReader( memStream );
   
   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read the data from memory and write it to the console.
   Console::Write( binReader->ReadString() );
   int arraySize = (int)(memStream->Length - memStream->Position);
   array<Char>^memoryData = gcnew array<Char>(arraySize);
   binReader->Read( memoryData, 0, arraySize );
   Console::WriteLine( memoryData );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        char[] invalidPathChars = Path.InvalidPathChars;
        MemoryStream memStream = new MemoryStream();
        BinaryWriter binWriter = new BinaryWriter(memStream);

        // Write to memory.
        binWriter.Write("Invalid file path characters are: ");
        binWriter.Write(
            Path.InvalidPathChars, 0, Path.InvalidPathChars.Length);

        // Create the reader using the same MemoryStream
        // as used with the writer.
        BinaryReader binReader = new BinaryReader(memStream);

        // Set Position to the beginning of the stream.
        memStream.Position = 0;

        // Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString());
        int arraySize = (int)(memStream.Length - memStream.Position);
        char[] memoryData = new char[arraySize];
        binReader.Read(memoryData, 0, arraySize);
        Console.WriteLine(memoryData);
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim invalidPathChars() As Char = Path.InvalidPathChars
        Dim memStream As new MemoryStream()
        Dim binWriter As New BinaryWriter(memStream)

        ' Write to memory.
        binWriter.Write("Invalid file path characters are: ")
        binWriter.Write(Path.InvalidPathChars, 0, _
            Path.InvalidPathChars.Length)

        ' Create the reader using the same MemoryStream 
        ' as used with the writer.
        Dim binReader As New BinaryReader(memStream)

        ' Set Position to the beginning of the stream.
        memStream.Position = 0

        ' Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString())
        Dim upperBound As Integer = _
            CInt(memStream.Length - memStream.Position) - 1
        Dim memoryData(upperBound) As Char
        binReader.Read(memoryData, 0, upperBound)
        Console.WriteLine(memoryData)
    
    End Sub
End Class

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Byte[], Int32, Int32)

Écrit une zone d’un tableau d’octets dans le flux actuel.Writes a region of a byte array to the current stream.

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

Paramètres

buffer
Byte[]

Tableau d’octets contenant les données à écrire.A byte array containing the data to write.

index
Int32

Index du premier octet à lire dans buffer et à écrire dans le flux.The index of the first byte to read from buffer and to write to the stream.

count
Int32

Nombre d’octets à lire dans buffer et à écrire dans le flux.The number of bytes to read from buffer and to write to the stream.

Exceptions

La longueur de la mémoire tampon moins index est inférieure à count.The buffer length minus index is less than count.

buffer a la valeur null.buffer is null.

index ou count est un nombre négatif.index or count is negative.

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment écrire des données binaires en utilisant la mémoire en tant que magasin de stockage, puis vérifier que les données ont été correctement écrites.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

using System;
using System.IO;

namespace BinaryRW
{
    class Program
    {
        static void Main(string[] args)
        {
            const int arrayLength = 1000;
            byte[] dataArray = new byte[arrayLength];
            byte[] verifyArray = new byte[arrayLength];

            new Random().NextBytes(dataArray);

            using (BinaryWriter binWriter = new BinaryWriter(new MemoryStream()))
            {
                Console.WriteLine("Writing the data.");
                binWriter.Write(dataArray, 0, arrayLength);

                using (BinaryReader binReader = new BinaryReader(binWriter.BaseStream))
                {
                    binReader.BaseStream.Position = 0;

                    if (binReader.Read(verifyArray, 0, arrayLength) != arrayLength)
                    {
                        Console.WriteLine("Error writing the data.");
                        return;
                    }
                }
            }

            for (int i = 0; i < arrayLength; i++)
            {
                if (verifyArray[i] != dataArray[i])
                {
                    Console.WriteLine("Error writing the data.");
                    return;
                }
            }

            Console.WriteLine("The data was written and verified.");
        }
    }
}
Imports System.IO

Module Module1

    Sub Main()
        Const upperBound As Integer = 1000
        Dim dataArray(upperBound) As Byte
        Dim verifyArray(upperBound) As Byte

        Dim randomGenerator As New Random
        randomGenerator.NextBytes(dataArray)

        Using binWriter As New BinaryWriter(New MemoryStream())
            Console.WriteLine("Writing the data.")
            binWriter.Write(dataArray, 0, dataArray.Length)

            Using binReader As New BinaryReader(binWriter.BaseStream)
                binReader.BaseStream.Position = 0

                If binReader.Read(verifyArray, 0, dataArray.Length) <> dataArray.Length Then
                    Console.WriteLine("Error writing the data.")
                    Return
                End If
            End Using
        End Using

        For i As Integer = 0 To upperBound
            If verifyArray(i) <> dataArray(i) Then
                Console.WriteLine("Error writing the data.")
                Return
            End If
        Next i

        Console.WriteLine("The data was written and verified.")
    End Sub

End Module

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(UInt64)

Important

Cette API n’est pas conforme CLS.

Écrit un entier non signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes.

public:
 virtual void Write(System::UInt64 value);
public virtual void Write (ulong value);
[System.CLSCompliant(false)]
public virtual void Write (ulong value);
abstract member Write : uint64 -> unit
override this.Write : uint64 -> unit
[<System.CLSCompliant(false)>]
abstract member Write : uint64 -> unit
override this.Write : uint64 -> unit
Public Overridable Sub Write (value As ULong)

Paramètres

value
UInt64

Entier non signé de 8 octets à écrire.The eight-byte unsigned integer to write.

Attributs

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(UInt32)

Important

Cette API n’est pas conforme CLS.

Écrit un entier non signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes.

public:
 virtual void Write(System::UInt32 value);
public virtual void Write (uint value);
[System.CLSCompliant(false)]
public virtual void Write (uint value);
abstract member Write : uint32 -> unit
override this.Write : uint32 -> unit
[<System.CLSCompliant(false)>]
abstract member Write : uint32 -> unit
override this.Write : uint32 -> unit
Public Overridable Sub Write (value As UInteger)

Paramètres

value
UInt32

Entier non signé de 4 octets à écrire.The four-byte unsigned integer to write.

Attributs

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(UInt16)

Important

Cette API n’est pas conforme CLS.

Écrit un entier non signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets.Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes.

public:
 virtual void Write(System::UInt16 value);
public virtual void Write (ushort value);
[System.CLSCompliant(false)]
public virtual void Write (ushort value);
abstract member Write : uint16 -> unit
override this.Write : uint16 -> unit
[<System.CLSCompliant(false)>]
abstract member Write : uint16 -> unit
override this.Write : uint16 -> unit
Public Overridable Sub Write (value As UShort)

Paramètres

value
UInt16

Entier non signé de 2 octets à écrire.The two-byte unsigned integer to write.

Attributs

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(String)

Écrit dans ce flux une chaîne préfixée par sa longueur dans l’encodage actuel de BinaryWriter et avance la position actuelle du flux en fonction de l’encodage utilisé et des caractères spécifiques écrits dans le flux.Writes a length-prefixed string to this stream in the current encoding of the BinaryWriter, and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream.

public:
 virtual void Write(System::String ^ value);
public virtual void Write (string value);
abstract member Write : string -> unit
override this.Write : string -> unit
Public Overridable Sub Write (value As String)

Paramètres

value
String

Valeur à écrire.The value to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

value a la valeur null.value is null.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment stocker et récupérer des paramètres d’application dans un fichier.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

class ConsoleApplication
{
    const string fileName = "AppSettings.dat";

    static void Main()
    {
        WriteDefaultValues();
        DisplayValues();
    }

    public static void WriteDefaultValues()
    {
        using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
        {
            writer.Write(1.250F);
            writer.Write(@"c:\Temp");
            writer.Write(10);
            writer.Write(true);
        }
    }

    public static void DisplayValues()
    {
        float aspectRatio;
        string tempDirectory;
        int autoSaveTime;
        bool showStatusBar;

        if (File.Exists(fileName))
        {
            using (BinaryReader reader = new BinaryReader(File.Open(fileName, FileMode.Open)))
            {
                aspectRatio = reader.ReadSingle();
                tempDirectory = reader.ReadString();
                autoSaveTime = reader.ReadInt32();
                showStatusBar = reader.ReadBoolean();
            }

            Console.WriteLine("Aspect ratio set to: " + aspectRatio);
            Console.WriteLine("Temp directory is: " + tempDirectory);
            Console.WriteLine("Auto save time set to: " + autoSaveTime);
            Console.WriteLine("Show status bar: " + showStatusBar);
        }
    }
}
Imports System.IO

Module Module1
    Const fileName As String = "AppSettings.dat"

    Sub Main()
        WriteDefaultValues()
        DisplayValues()
    End Sub

    Sub WriteDefaultValues()
        Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
            writer.Write(1.25F)
            writer.Write("c:\Temp")
            writer.Write(10)
            writer.Write(True)
        End Using
    End Sub

    Sub DisplayValues()
        Dim aspectRatio As Single
        Dim tempDirectory As String
        Dim autoSaveTime As Integer
        Dim showStatusBar As Boolean

        If (File.Exists(fileName)) Then

            Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
                aspectRatio = reader.ReadSingle()
                tempDirectory = reader.ReadString()
                autoSaveTime = reader.ReadInt32()
                showStatusBar = reader.ReadBoolean()
            End Using

            Console.WriteLine("Aspect ratio set to: " & aspectRatio)
            Console.WriteLine("Temp directory is: " & tempDirectory)
            Console.WriteLine("Auto save time set to: " & autoSaveTime)
            Console.WriteLine("Show status bar: " & showStatusBar)
        End If
    End Sub

End Module

Remarques

Le préfixe de longueur signifie que cette méthode écrit d’abord la longueur de la chaîne, en octets, lorsqu’elle est encodée avec l’encodage actuel de l’instance de BinaryWriter vers le flux.Length-prefixed means that this method first writes the length of the string, in bytes, when encoded with the BinaryWriter instance's current encoding to the stream. Cette valeur est écrite sous la forme d’un entier non signé.This value is written as an unsigned integer. Cette méthode écrit ensuite ce nombre d’octets dans le flux.This method then writes that many bytes to the stream.

Par exemple, la chaîne « A » a une longueur de 1, mais en cas d’encodage avec UTF-16 ; la longueur est de 2 octets. par conséquent, la valeur écrite dans le préfixe est 2, et 3 octets sont écrits dans le flux, y compris le préfixe.For example, the string "A" has a length of 1, but when encoded with UTF-16; the length is 2 bytes, so the value written in the prefix is 2, and 3 bytes are written to the stream, including the prefix.

Pour obtenir la liste des tâches d’e/s courantes, consultez tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Single)

Écrit une valeur à virgule flottante de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.

public:
 virtual void Write(float value);
public virtual void Write (float value);
abstract member Write : single -> unit
override this.Write : single -> unit
Public Overridable Sub Write (value As Single)

Paramètres

value
Single

Valeur à virgule flottante de 4 octets à écrire.The four-byte floating-point value to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment stocker et récupérer des paramètres d’application dans un fichier.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

class ConsoleApplication
{
    const string fileName = "AppSettings.dat";

    static void Main()
    {
        WriteDefaultValues();
        DisplayValues();
    }

    public static void WriteDefaultValues()
    {
        using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
        {
            writer.Write(1.250F);
            writer.Write(@"c:\Temp");
            writer.Write(10);
            writer.Write(true);
        }
    }

    public static void DisplayValues()
    {
        float aspectRatio;
        string tempDirectory;
        int autoSaveTime;
        bool showStatusBar;

        if (File.Exists(fileName))
        {
            using (BinaryReader reader = new BinaryReader(File.Open(fileName, FileMode.Open)))
            {
                aspectRatio = reader.ReadSingle();
                tempDirectory = reader.ReadString();
                autoSaveTime = reader.ReadInt32();
                showStatusBar = reader.ReadBoolean();
            }

            Console.WriteLine("Aspect ratio set to: " + aspectRatio);
            Console.WriteLine("Temp directory is: " + tempDirectory);
            Console.WriteLine("Auto save time set to: " + autoSaveTime);
            Console.WriteLine("Show status bar: " + showStatusBar);
        }
    }
}
Imports System.IO

Module Module1
    Const fileName As String = "AppSettings.dat"

    Sub Main()
        WriteDefaultValues()
        DisplayValues()
    End Sub

    Sub WriteDefaultValues()
        Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
            writer.Write(1.25F)
            writer.Write("c:\Temp")
            writer.Write(10)
            writer.Write(True)
        End Using
    End Sub

    Sub DisplayValues()
        Dim aspectRatio As Single
        Dim tempDirectory As String
        Dim autoSaveTime As Integer
        Dim showStatusBar As Boolean

        If (File.Exists(fileName)) Then

            Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
                aspectRatio = reader.ReadSingle()
                tempDirectory = reader.ReadString()
                autoSaveTime = reader.ReadInt32()
                showStatusBar = reader.ReadBoolean()
            End Using

            Console.WriteLine("Aspect ratio set to: " & aspectRatio)
            Console.WriteLine("Temp directory is: " & tempDirectory)
            Console.WriteLine("Auto save time set to: " & autoSaveTime)
            Console.WriteLine("Show status bar: " & showStatusBar)
        End If
    End Sub

End Module

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(SByte)

Important

Cette API n’est pas conforme CLS.

Écrit un octet signé dans le flux actuel et avance la position du flux d’un octet.Writes a signed byte to the current stream and advances the stream position by one byte.

public:
 virtual void Write(System::SByte value);
public virtual void Write (sbyte value);
[System.CLSCompliant(false)]
public virtual void Write (sbyte value);
abstract member Write : sbyte -> unit
override this.Write : sbyte -> unit
[<System.CLSCompliant(false)>]
abstract member Write : sbyte -> unit
override this.Write : sbyte -> unit
Public Overridable Sub Write (value As SByte)

Paramètres

value
SByte

Octet signé à écrire.The signed byte to write.

Attributs

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(ReadOnlySpan<Char>)

Écrit une plage de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et éventuellement des caractères spécifiques écrits dans le flux.Writes a span of characters to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

public:
 virtual void Write(ReadOnlySpan<char> chars);
public virtual void Write (ReadOnlySpan<char> chars);
abstract member Write : ReadOnlySpan<char> -> unit
override this.Write : ReadOnlySpan<char> -> unit
Public Overridable Sub Write (chars As ReadOnlySpan(Of Char))

Paramètres

chars
ReadOnlySpan<Char>

Plage de caractères à écrire.A span of chars to write.

S’applique à

Produit Introduit

Write(ReadOnlySpan<Byte>)

Écrit une plage d’octets dans le flux actuel.Writes a span of bytes to the current stream.

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

Paramètres

buffer
ReadOnlySpan<Byte>

Plage d’octets à écrire.The span of bytes to write.

S’applique à

Produit Introduit

Write(Char)

Écrit un caractère Unicode dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d’écriture dans le flux.Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

public:
 virtual void Write(char ch);
public virtual void Write (char ch);
abstract member Write : char -> unit
override this.Write : char -> unit
Public Overridable Sub Write (ch As Char)

Paramètres

ch
Char

Caractère Unicode de non-substitution à écrire.The non-surrogate, Unicode character to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

ch est un caractère de substitution unique.ch is a single surrogate character.

Exemples

L’exemple de code suivant montre comment lire et écrire des données à l’aide de la mémoire en tant que magasin de stockage.The following code example shows how to read and write data using memory as a backing store.

using namespace System;
using namespace System::IO;
int main()
{
   int i;
   array<Char>^invalidPathChars = Path::InvalidPathChars;
   MemoryStream^ memStream = gcnew MemoryStream;
   BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
   
   // Write to memory.
   binWriter->Write( "Invalid file path characters are: " );
   for ( i = 0; i < invalidPathChars->Length; i++ )
   {
      binWriter->Write( invalidPathChars[ i ] );

   }
   
   // Create the reader using the same MemoryStream 
   // as used with the writer.
   BinaryReader^ binReader = gcnew BinaryReader( memStream );
   
   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read the data from memory and write it to the console.
   Console::Write( binReader->ReadString() );
   array<Char>^memoryData = gcnew array<Char>(memStream->Length - memStream->Position);
   for ( i = 0; i < memoryData->Length; i++ )
   {
      memoryData[ i ] = binReader->ReadChar();

   }
   Console::WriteLine( memoryData );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        int i = 0;
        char[] invalidPathChars = Path.InvalidPathChars;
        MemoryStream memStream = new MemoryStream();
        BinaryWriter binWriter = new BinaryWriter(memStream);

        // Write to memory.
        binWriter.Write("Invalid file path characters are: ");
        for(i = 0; i < invalidPathChars.Length; i++)
        {
            binWriter.Write(invalidPathChars[i]);
        }

        // Create the reader using the same MemoryStream
        // as used with the writer.
        BinaryReader binReader = new BinaryReader(memStream);

        // Set Position to the beginning of the stream.
        memStream.Position = 0;

        // Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString());
        char[] memoryData =
            new char[memStream.Length - memStream.Position];
        for(i = 0; i < memoryData.Length; i++)
        {
            memoryData[i] = binReader.ReadChar();
        }
        Console.WriteLine(memoryData);
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim i As Integer = 0
        Dim invalidPathChars() As Char = Path.InvalidPathChars
        Dim memStream As new MemoryStream()
        Dim binWriter As New BinaryWriter(memStream)

        ' Write to memory.
        binWriter.Write("Invalid file path characters are: ")
        For i = 0 To invalidPathChars.Length - 1
            binWriter.Write(invalidPathChars(i))
        Next i

        ' Create the reader using the same MemoryStream 
        ' as used with the writer.
        Dim binReader As New BinaryReader(memStream)

        ' Set Position to the beginning of the stream.
        memStream.Position = 0

        ' Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString())
        Dim memoryData( _
            CInt(memStream.Length - memStream.Position) - 1) As Char
        For i = 0 To memoryData.Length - 1
            memoryData(i) = binReader.ReadChar()
        Next i
        Console.WriteLine(memoryData)
    
    End Sub
End Class

Remarques

En raison de conflits de mise en forme des données, il n’est pas recommandé d’utiliser cette méthode avec les encodages suivants :Because of data formatting conflicts, using this method with the following encodings is not recommended:

  • UTF-7UTF-7

  • ISO-2022-JPISO-2022-JP

  • ISCIIISCII

Pour obtenir la liste des tâches d’e/s courantes, consultez tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Les caractères de substitution Unicode doivent être écrits en tant que paires dans le même appel, et non individuellement.Unicode surrogate characters must be written out as pairs together in the same call, not individually. Si vous avez besoin de la prise en charge des paires de substitution dans votre application, envisagez d’utiliser un tableau de caractères et la surcharge de la Write méthode.If you require support for surrogate pairs in your application, consider using a character array and the Write method overload.

Voir aussi

S’applique à

Produit Introduit

Write(Int32)

Écrit un entier signé de 4 octets dans le flux actuel et avance la position du flux de 4 octets.Writes a four-byte signed integer to the current stream and advances the stream position by four bytes.

public:
 virtual void Write(int value);
public virtual void Write (int value);
abstract member Write : int -> unit
override this.Write : int -> unit
Public Overridable Sub Write (value As Integer)

Paramètres

value
Int32

Entier signé de 4 octets à écrire.The four-byte signed integer to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment stocker et récupérer des paramètres d’application dans un fichier.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

class ConsoleApplication
{
    const string fileName = "AppSettings.dat";

    static void Main()
    {
        WriteDefaultValues();
        DisplayValues();
    }

    public static void WriteDefaultValues()
    {
        using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
        {
            writer.Write(1.250F);
            writer.Write(@"c:\Temp");
            writer.Write(10);
            writer.Write(true);
        }
    }

    public static void DisplayValues()
    {
        float aspectRatio;
        string tempDirectory;
        int autoSaveTime;
        bool showStatusBar;

        if (File.Exists(fileName))
        {
            using (BinaryReader reader = new BinaryReader(File.Open(fileName, FileMode.Open)))
            {
                aspectRatio = reader.ReadSingle();
                tempDirectory = reader.ReadString();
                autoSaveTime = reader.ReadInt32();
                showStatusBar = reader.ReadBoolean();
            }

            Console.WriteLine("Aspect ratio set to: " + aspectRatio);
            Console.WriteLine("Temp directory is: " + tempDirectory);
            Console.WriteLine("Auto save time set to: " + autoSaveTime);
            Console.WriteLine("Show status bar: " + showStatusBar);
        }
    }
}
Imports System.IO

Module Module1
    Const fileName As String = "AppSettings.dat"

    Sub Main()
        WriteDefaultValues()
        DisplayValues()
    End Sub

    Sub WriteDefaultValues()
        Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
            writer.Write(1.25F)
            writer.Write("c:\Temp")
            writer.Write(10)
            writer.Write(True)
        End Using
    End Sub

    Sub DisplayValues()
        Dim aspectRatio As Single
        Dim tempDirectory As String
        Dim autoSaveTime As Integer
        Dim showStatusBar As Boolean

        If (File.Exists(fileName)) Then

            Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
                aspectRatio = reader.ReadSingle()
                tempDirectory = reader.ReadString()
                autoSaveTime = reader.ReadInt32()
                showStatusBar = reader.ReadBoolean()
            End Using

            Console.WriteLine("Aspect ratio set to: " & aspectRatio)
            Console.WriteLine("Temp directory is: " & tempDirectory)
            Console.WriteLine("Auto save time set to: " & autoSaveTime)
            Console.WriteLine("Show status bar: " & showStatusBar)
        End If
    End Sub

End Module

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Int16)

Écrit un entier signé de 2 octets dans le flux actuel et avance la position du flux de 2 octets.Writes a two-byte signed integer to the current stream and advances the stream position by two bytes.

public:
 virtual void Write(short value);
public virtual void Write (short value);
abstract member Write : int16 -> unit
override this.Write : int16 -> unit
Public Overridable Sub Write (value As Short)

Paramètres

value
Int16

Entier signé de 2 octets à écrire.The two-byte signed integer to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Le tableau suivant répertorie des exemples d’autres tâches d’e/s typiques ou associées.The following table lists examples of other typical or related I/O tasks.

Pour...To do this... Consultez l'exemple décrit dans cette rubrique...See the example in this topic...
Créer un fichier texte.Create a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Écrire dans un fichier texte.Write to a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Lire à partir d’un fichier texte.Read from a text file. Comment : lire du texte dans un fichierHow to: Read Text from a File
Ajoutez du texte à un fichier.Append text to a file. Comment : ouvrir un fichier journal et y ajouter des élémentsHow to: Open and Append to a Log File

File.AppendText

FileInfo.AppendText
Obtenir la taille d’un fichier.Get the size of a file. FileInfo.Length
Obtient les attributs d’un fichier.Get the attributes of a file. File.GetAttributes
Définir les attributs d’un fichier.Set the attributes of a file. File.SetAttributes
Déterminez si un fichier existe.Determine if a file exists. File.Exists
Lire à partir d’un fichier binaire.Read from a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File
Écrire dans un fichier binaire.Write to a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File

Voir aussi

S’applique à

Produit Introduit

Write(Double)

Écrit une valeur à virgule flottante de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes.

public:
 virtual void Write(double value);
public virtual void Write (double value);
abstract member Write : double -> unit
override this.Write : double -> unit
Public Overridable Sub Write (value As Double)

Paramètres

value
Double

Valeur à virgule flottante de 8 octets à écrire.The eight-byte floating-point value to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment lire et écrire des Double des données dans la mémoire à l’aide des classes BinaryReader et BinaryWriter en plus de la classe MemoryStream .The following code example shows how to read and write Double data to memory by using the BinaryReader and BinaryWriter classes on top of the MemoryStream class. MemoryStream lit et écrit uniquement les données Byte .MemoryStream only reads and writes Byte data.

using namespace System;
using namespace System::IO;
int main()
{
   int i;
   const int arrayLength = 1000;
   
   // Create random data to write to the stream.
   array<double>^dataArray = gcnew array<double>(arrayLength);
   Random^ randomGenerator = gcnew Random;
   for ( i = 0; i < arrayLength; i++ )
   {
      dataArray[ i ] = 100.1 * randomGenerator->NextDouble();

   }
   BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
   try
   {
      
      // Write data to the stream.
      Console::WriteLine( "Writing data to the stream." );
      i = 0;
      for ( i = 0; i < arrayLength; i++ )
      {
         binWriter->Write( dataArray[ i ] );

      }
      
      // Create a reader using the stream from the writer.
      BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
      
      // Return to the beginning of the stream.
      binReader->BaseStream->Position = 0;
      try
      {
         
         // Read and verify the data.
         i = 0;
         Console::WriteLine( "Verifying the written data." );
         for ( i = 0; i < arrayLength; i++ )
         {
            if ( binReader->ReadDouble() != dataArray[ i ] )
            {
               Console::WriteLine( "Error writing data." );
               break;
            }

         }
         Console::WriteLine( "The data was written and verified." );
      }
      catch ( EndOfStreamException^ e ) 
      {
         Console::WriteLine( "Error writing data: {0}.", e->GetType()->Name );
      }

   }
   finally
   {
      binWriter->Close();
   }

}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        int i;
        const int arrayLength = 1000;

        // Create random data to write to the stream.
        Random randomGenerator = new Random();
        double[] dataArray = new double[arrayLength];
        for(i = 0; i < arrayLength; i++)
        {
            dataArray[i] = 100.1 * randomGenerator.NextDouble();
        }

        using(BinaryWriter binWriter =
            new BinaryWriter(new MemoryStream()))
        {
            // Write the data to the stream.
            Console.WriteLine("Writing data to the stream.");
            for(i = 0; i < arrayLength; i++)
            {
                binWriter.Write(dataArray[i]);
            }

            // Create a reader using the stream from the writer.
            using(BinaryReader binReader =
                new BinaryReader(binWriter.BaseStream))
            {
                try
                {
                    // Return to the beginning of the stream.
                    binReader.BaseStream.Position = 0;

                    // Read and verify the data.
                    Console.WriteLine("Verifying the written data.");
                    for(i = 0; i < arrayLength; i++)
                    {
                        if(binReader.ReadDouble() != dataArray[i])
                        {
                            Console.WriteLine("Error writing data.");
                            break;
                        }
                    }
                    Console.WriteLine("The data was written " +
                        "and verified.");
                }
                catch(EndOfStreamException e)
                {
                    Console.WriteLine("Error writing data: {0}.",
                        e.GetType().Name);
                }
            }
        }
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim i As Integer
        Const upperBound As Integer = 1000

        ' Create random data to write to the stream.
        Dim dataArray(upperBound) As Double
        Dim randomGenerator As New Random()
        For i = 0 To upperBound
            dataArray(i) = 100.1 * randomGenerator.NextDouble()
        Next i

        Dim binWriter As New BinaryWriter(New MemoryStream())
        Try

            ' Write data to the stream.
            Console.WriteLine("Writing data to the stream.")
            
            For i = 0 To upperBound
                binWriter.Write(dataArray(i))
            Next i

            ' Create a reader using the stream from the writer.
            Dim binReader As New BinaryReader(binWriter.BaseStream)

            ' Return to the beginning of the stream.
            binReader.BaseStream.Position = 0

            ' Read and verify the data.
            Try
                Console.WriteLine("Verifying the written data.")
                For i = 0 To upperBound
                    If binReader.ReadDouble() <> dataArray(i) Then
                        Console.WriteLine("Error writing data.")
                        Exit For
                    End If
                Next i
                Console.WriteLine("The data was written and verified.")
            Catch ex As EndOfStreamException
                Console.WriteLine("Error writing data: {0}.", _
                    ex.GetType().Name)
            End Try
        Finally
            binWriter.Close()
        End Try

    End Sub
End Class

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Decimal)

Écrit une valeur décimale dans le flux actuel et avance la position du flux de 16 octets.Writes a decimal value to the current stream and advances the stream position by sixteen bytes.

public:
 virtual void Write(System::Decimal value);
public virtual void Write (decimal value);
abstract member Write : decimal -> unit
override this.Write : decimal -> unit
Public Overridable Sub Write (value As Decimal)

Paramètres

value
Decimal

Valeur décimale à écrire.The decimal value to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

Le tableau suivant répertorie des exemples d’autres tâches d’e/s typiques ou associées.The following table lists examples of other typical or related I/O tasks.

Pour...To do this... Consultez l'exemple décrit dans cette rubrique...See the example in this topic...
Créer un fichier texte.Create a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Écrire dans un fichier texte.Write to a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Lire à partir d’un fichier texte.Read from a text file. Comment : lire du texte dans un fichierHow to: Read Text from a File
Ajoutez du texte à un fichier.Append text to a file. Comment : ouvrir un fichier journal et y ajouter des élémentsHow to: Open and Append to a Log File

File.AppendText

FileInfo.AppendText
Obtenir la taille d’un fichier.Get the size of a file. FileInfo.Length
Obtient les attributs d’un fichier.Get the attributes of a file. File.GetAttributes
Définir les attributs d’un fichier.Set the attributes of a file. File.SetAttributes
Déterminez si un fichier existe.Determine if a file exists. File.Exists
Lire à partir d’un fichier binaire.Read from a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File
Écrire dans un fichier binaire.Write to a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File

Voir aussi

S’applique à

Produit Introduit

Write(Char[])

Écrit un tableau de caractères dans le flux actuel et avance la position actuelle du flux en fonction du Encoding utilisé et des caractères spécifiques en cours d’écriture dans le flux.Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

public:
 virtual void Write(cli::array <char> ^ chars);
public virtual void Write (char[] chars);
abstract member Write : char[] -> unit
override this.Write : char[] -> unit
Public Overridable Sub Write (chars As Char())

Paramètres

chars
Char[]

Tableau de caractères contenant les données à écrire.A character array containing the data to write.

Exceptions

chars a la valeur null.chars is null.

Le flux est fermé.The stream is closed.

Une erreur d’E/S se produit.An I/O error occurs.

Exemples

L’exemple de code suivant montre comment lire et écrire des données à l’aide de la mémoire en tant que magasin de stockage.The following code example shows how to read and write data using memory as a backing store.

using namespace System;
using namespace System::IO;
int main()
{
   array<Char>^invalidPathChars = Path::InvalidPathChars;
   MemoryStream^ memStream = gcnew MemoryStream;
   BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
   
   // Write to memory.
   binWriter->Write( "Invalid file path characters are: " );
   binWriter->Write( Path::InvalidPathChars );
   
   // Create the reader using the same MemoryStream 
   // as used with the writer.
   BinaryReader^ binReader = gcnew BinaryReader( memStream );
   
   // Set Position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read the data from memory and write it to the console.
   Console::Write( binReader->ReadString() );
   Console::WriteLine( binReader->ReadChars( (int)(memStream->Length - memStream->Position) ) );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        char[] invalidPathChars = Path.InvalidPathChars;
        MemoryStream memStream = new MemoryStream();
        BinaryWriter binWriter = new BinaryWriter(memStream);

        // Write to memory.
        binWriter.Write("Invalid file path characters are: ");
        binWriter.Write(Path.InvalidPathChars);

        // Create the reader using the same MemoryStream
        // as used with the writer.
        BinaryReader binReader = new BinaryReader(memStream);

        // Set Position to the beginning of the stream.
        memStream.Position = 0;

        // Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString());
        Console.WriteLine(binReader.ReadChars(
            (int)(memStream.Length - memStream.Position)));
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim invalidPathChars() As Char = Path.InvalidPathChars
        Dim memStream As new MemoryStream()
        Dim binWriter As New BinaryWriter(memStream)

        ' Write to memory.
        binWriter.Write("Invalid file path characters are: ")
        binWriter.Write(Path.InvalidPathChars)

        ' Create the reader using the same MemoryStream 
        ' as used with the writer.
        Dim binReader As New BinaryReader(memStream)

        ' Set Position to the beginning of the stream.
        memStream.Position = 0

        ' Read the data from memory and write it to the console.
        Console.Write(binReader.ReadString())
        Console.WriteLine(binReader.ReadChars( _
            CInt(memStream.Length - memStream.Position)))
    
    End Sub
End Class

Remarques

Le tableau suivant répertorie des exemples d’autres tâches d’e/s typiques ou associées.The following table lists examples of other typical or related I/O tasks.

Pour...To do this... Consultez l'exemple décrit dans cette rubrique...See the example in this topic...
Créer un fichier texte.Create a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Écrire dans un fichier texte.Write to a text file. Comment : écrire du texte dans un fichierHow to: Write Text to a File
Lire à partir d’un fichier texte.Read from a text file. Comment : lire du texte dans un fichierHow to: Read Text from a File
Ajoutez du texte à un fichier.Append text to a file. Comment : ouvrir un fichier journal et y ajouter des élémentsHow to: Open and Append to a Log File

File.AppendText

FileInfo.AppendText
Obtenir la taille d’un fichier.Get the size of a file. FileInfo.Length
Obtient les attributs d’un fichier.Get the attributes of a file. File.GetAttributes
Définir les attributs d’un fichier.Set the attributes of a file. File.SetAttributes
Déterminez si un fichier existe.Determine if a file exists. File.Exists
Lire à partir d’un fichier binaire.Read from a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File
Écrire dans un fichier binaire.Write to a binary file. Comment : lire et écrire dans un fichier de données créé récemmentHow to: Read and Write to a Newly Created Data File

Voir aussi

S’applique à

Produit Introduit

Write(Byte[])

Écrit un tableau d’octets dans le flux sous-jacent.Writes a byte array to the underlying stream.

public:
 virtual void Write(cli::array <System::Byte> ^ buffer);
public virtual void Write (byte[] buffer);
abstract member Write : byte[] -> unit
override this.Write : byte[] -> unit
Public Overridable Sub Write (buffer As Byte())

Paramètres

buffer
Byte[]

Tableau d’octets contenant les données à écrire.A byte array containing the data to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

buffer a la valeur null.buffer is null.

Exemples

L’exemple de code suivant montre comment écrire des données binaires en utilisant la mémoire en tant que magasin de stockage, puis vérifier que les données ont été correctement écrites.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

using namespace System;
using namespace System::IO;
int main()
{
   const int arrayLength = 1000;
   
   // Create random data to write to the stream.
   array<Byte>^dataArray = gcnew array<Byte>(arrayLength);
   (gcnew Random)->NextBytes( dataArray );
   BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
   
   // Write the data to the stream.
   Console::WriteLine(  "Writing the data." );
   binWriter->Write( dataArray );
   
   // Create the reader using the stream from the writer.
   BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
   
   // Set the stream position to the beginning of the stream.
   binReader->BaseStream->Position = 0;
   
   // Read and verify the data.
   array<Byte>^verifyArray = binReader->ReadBytes( arrayLength );
   if ( verifyArray->Length != arrayLength )
   {
      Console::WriteLine( "Error writing the data." );
      return  -1;
   }

   for ( int i = 0; i < arrayLength; i++ )
   {
      if ( verifyArray[ i ] != dataArray[ i ] )
      {
         Console::WriteLine( "Error writing the data." );
         return  -1;
      }

   }
   Console::WriteLine( "The data was written and verified." );
}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        const int arrayLength = 1000;

        // Create random data to write to the stream.
        byte[] dataArray = new byte[arrayLength];
        new Random().NextBytes(dataArray);

        BinaryWriter binWriter = new BinaryWriter(new MemoryStream());

        // Write the data to the stream.
        Console.WriteLine("Writing the data.");
        binWriter.Write(dataArray);

        // Create the reader using the stream from the writer.
        BinaryReader binReader =
            new BinaryReader(binWriter.BaseStream);

        // Set Position to the beginning of the stream.
        binReader.BaseStream.Position = 0;

        // Read and verify the data.
        byte[] verifyArray = binReader.ReadBytes(arrayLength);
        if(verifyArray.Length != arrayLength)
        {
            Console.WriteLine("Error writing the data.");
            return;
        }
        for(int i = 0; i < arrayLength; i++)
        {
            if(verifyArray[i] != dataArray[i])
            {
                Console.WriteLine("Error writing the data.");
                return;
            }
        }
        Console.WriteLine("The data was written and verified.");
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Const upperBound As Integer = 1000

        ' Create random data to write to the stream.
        Dim dataArray(upperBound) As Byte
        Dim randomGenerator As New Random
        randomGenerator.NextBytes(dataArray)

        Dim binWriter As New BinaryWriter(New MemoryStream())

        ' Write the data to the stream.
        Console.WriteLine("Writing the data.")
        binWriter.Write(dataArray)

        ' Create the reader using the stream from the writer.
        Dim binReader As New BinaryReader(binWriter.BaseStream)

        ' Set the stream position to the beginning of the stream.
        binReader.BaseStream.Position = 0

        ' Read and verify the data.
        Dim verifyArray() As Byte = _
            binReader.ReadBytes(dataArray.Length)
        If verifyArray.Length <> dataArray.Length Then
            Console.WriteLine("Error writing the data.")
            Return
        End If
        For i As Integer = 0 To upperBound
            If verifyArray(i) <> dataArray(i) Then
                Console.WriteLine("Error writing the data.")
                Return
            End If
        Next i
        Console.WriteLine("The data was written and verified.")
    
    End Sub
End Class

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Byte)

Écrit un octet non signé dans le flux actuel et avance la position du flux d’un octet.Writes an unsigned byte to the current stream and advances the stream position by one byte.

public:
 virtual void Write(System::Byte value);
public virtual void Write (byte value);
abstract member Write : byte -> unit
override this.Write : byte -> unit
Public Overridable Sub Write (value As Byte)

Paramètres

value
Byte

Octet non signé à écrire.The unsigned byte to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment écrire des données binaires en utilisant la mémoire en tant que magasin de stockage, puis vérifier que les données ont été correctement écrites.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

using namespace System;
using namespace System::IO;
int main()
{
   int i = 0;
   
   // Create random data to write to the stream.
   array<Byte>^writeArray = gcnew array<Byte>(1000);
   (gcnew Random)->NextBytes( writeArray );
   BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
   BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
   try
   {
      
      // Write the data to the stream.
      Console::WriteLine( "Writing the data." );
      for ( i = 0; i < writeArray->Length; i++ )
      {
         binWriter->Write( writeArray[ i ] );

      }
      
      // Set the stream position to the beginning of the stream.
      binReader->BaseStream->Position = 0;
      
      // Read and verify the data from the stream.
      for ( i = 0; i < writeArray->Length; i++ )
      {
         if ( binReader->ReadByte() != writeArray[ i ] )
         {
            Console::WriteLine( "Error writing the data." );
            return  -1;
         }

      }
      Console::WriteLine( "The data was written and verified." );
   }
   // Catch the EndOfStreamException and write an error message.
   catch ( EndOfStreamException^ e ) 
   {
      Console::WriteLine( "Error writing the data.\n{0}", e->GetType()->Name );
   }

}

using System;
using System.IO;

class BinaryRW
{
    static void Main()
    {
        int i = 0;

        // Create random data to write to the stream.
        byte[] writeArray = new byte[1000];
        new Random().NextBytes(writeArray);

        BinaryWriter binWriter = new BinaryWriter(new MemoryStream());
        BinaryReader binReader =
            new BinaryReader(binWriter.BaseStream);

        try
        {
            // Write the data to the stream.
            Console.WriteLine("Writing the data.");
            for(i = 0; i < writeArray.Length; i++)
            {
                binWriter.Write(writeArray[i]);
            }

            // Set the stream position to the beginning of the stream.
            binReader.BaseStream.Position = 0;

            // Read and verify the data from the stream.
            for(i = 0; i < writeArray.Length; i++)
            {
                if(binReader.ReadByte() != writeArray[i])
                {
                    Console.WriteLine("Error writing the data.");
                    return;
                }
            }
            Console.WriteLine("The data was written and verified.");
        }

        // Catch the EndOfStreamException and write an error message.
        catch(EndOfStreamException e)
        {
            Console.WriteLine("Error writing the data.\n{0}",
                e.GetType().Name);
        }
    }
}
Imports System.IO

Public Class BinaryRW

    Shared Sub Main()
    
        Dim i As Integer = 0

        ' Create random data to write to the stream.
        Dim writeArray(1000) As Byte
        Dim randomGenerator As New Random()
        randomGenerator.NextBytes(writeArray)

        Dim binWriter As New BinaryWriter(New MemoryStream())
        Dim binReader As New BinaryReader(binWriter.BaseStream)

        Try
        
            ' Write the data to the stream.
            Console.WriteLine("Writing the data.")
            For i = 0 To writeArray.Length - 1
                binWriter.Write(writeArray(i))
            Next i

            ' Set the stream position to the beginning of the stream.
            binReader.BaseStream.Position = 0

            ' Read and verify the data from the stream.
            For i = 0 To writeArray.Length - 1
                If binReader.ReadByte() <> writeArray(i) Then
                    Console.WriteLine("Error writing the data.")
                    Return
                End If
            Next i
            Console.WriteLine("The data was written and verified.")

        ' Catch the EndOfStreamException and write an error message.
        Catch ex As EndOfStreamException
            Console.WriteLine("Error writing the data: {0}", _
                ex.GetType().Name)
        End Try
    
    End Sub
End Class

Remarques

En raison de conflits de mise en forme des données, il n’est pas recommandé d’utiliser cette méthode avec les encodages suivants :Because of data formatting conflicts, using this method with the following encodings is not recommended:

  • UTF-7UTF-7

  • ISO-2022-JPISO-2022-JP

  • ISCIIISCII

Pour obtenir la liste des tâches d’e/s courantes, consultez tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Boolean)

Écrit une valeur Boolean de 1 octet dans le flux actuel, 0 représentant false et 1 représentant true.Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true.

public:
 virtual void Write(bool value);
public virtual void Write (bool value);
abstract member Write : bool -> unit
override this.Write : bool -> unit
Public Overridable Sub Write (value As Boolean)

Paramètres

value
Boolean

Valeur Boolean à écrire (0 ou 1).The Boolean value to write (0 or 1).

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Exemples

L’exemple de code suivant montre comment stocker et récupérer des paramètres d’application dans un fichier.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

class ConsoleApplication
{
    const string fileName = "AppSettings.dat";

    static void Main()
    {
        WriteDefaultValues();
        DisplayValues();
    }

    public static void WriteDefaultValues()
    {
        using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
        {
            writer.Write(1.250F);
            writer.Write(@"c:\Temp");
            writer.Write(10);
            writer.Write(true);
        }
    }

    public static void DisplayValues()
    {
        float aspectRatio;
        string tempDirectory;
        int autoSaveTime;
        bool showStatusBar;

        if (File.Exists(fileName))
        {
            using (BinaryReader reader = new BinaryReader(File.Open(fileName, FileMode.Open)))
            {
                aspectRatio = reader.ReadSingle();
                tempDirectory = reader.ReadString();
                autoSaveTime = reader.ReadInt32();
                showStatusBar = reader.ReadBoolean();
            }

            Console.WriteLine("Aspect ratio set to: " + aspectRatio);
            Console.WriteLine("Temp directory is: " + tempDirectory);
            Console.WriteLine("Auto save time set to: " + autoSaveTime);
            Console.WriteLine("Show status bar: " + showStatusBar);
        }
    }
}
Imports System.IO

Module Module1
    Const fileName As String = "AppSettings.dat"

    Sub Main()
        WriteDefaultValues()
        DisplayValues()
    End Sub

    Sub WriteDefaultValues()
        Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
            writer.Write(1.25F)
            writer.Write("c:\Temp")
            writer.Write(10)
            writer.Write(True)
        End Using
    End Sub

    Sub DisplayValues()
        Dim aspectRatio As Single
        Dim tempDirectory As String
        Dim autoSaveTime As Integer
        Dim showStatusBar As Boolean

        If (File.Exists(fileName)) Then

            Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
                aspectRatio = reader.ReadSingle()
                tempDirectory = reader.ReadString()
                autoSaveTime = reader.ReadInt32()
                showStatusBar = reader.ReadBoolean()
            End Using

            Console.WriteLine("Aspect ratio set to: " & aspectRatio)
            Console.WriteLine("Temp directory is: " & tempDirectory)
            Console.WriteLine("Auto save time set to: " & autoSaveTime)
            Console.WriteLine("Show status bar: " & showStatusBar)
        End If
    End Sub

End Module

Remarques

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit

Write(Int64)

Écrit un entier signé de 8 octets dans le flux actuel et avance la position du flux de 8 octets.Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes.

public:
 virtual void Write(long value);
public virtual void Write (long value);
abstract member Write : int64 -> unit
override this.Write : int64 -> unit
Public Overridable Sub Write (value As Long)

Paramètres

value
Int64

Entier signé de 8 octets à écrire.The eight-byte signed integer to write.

Exceptions

Une erreur d’E/S se produit.An I/O error occurs.

Le flux est fermé.The stream is closed.

Remarques

BinaryWriter stocke ce type de données au format Little endian.BinaryWriter stores this data type in little endian format.

Pour obtenir la liste des tâches d’e/s courantes, consultez des tâches d’e/s courantes.For a list of common I/O tasks, see Common I/O Tasks.

Voir aussi

S’applique à

Produit Introduit