BinaryWriter.Write Metodo

Definizione

Spazio dei nomi:

System.IO

Assembly:

System.Runtime.dll

Scrive un valore nel flusso corrente.

Overload

Write(Char[], Int32, Int32)	Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.
Write(Byte[], Int32, Int32)	Scrive un'area di una matrice di byte nel flusso corrente.
Write(UInt64)	Scrive un intero senza segno a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.
Write(UInt32)	Scrive un intero senza segno a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.
Write(UInt16)	Scrive un intero senza segno a due byte nel flusso corrente e sposta in avanti di due byte la posizione del flusso.
Write(String)	Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto BinaryWriter e sposta in avanti la posizione corrente del flusso secondo la codifica usata e i caratteri specifici scritti nel flusso.
Write(Single)	Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.
Write(SByte)	Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso.
Write(ReadOnlySpan<Char>)	Scrive un intervallo di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.
Write(ReadOnlySpan<Byte>)	Scrive un intervallo di byte nel flusso corrente.
Write(Int64)	Scrive un intero con segno a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.
Write(Char[])	Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.
Write(Int16)	Scrive un intero con segno a due byte nel flusso corrente e sposta in avanti di due byte la posizione del flusso.
Write(Half)	Scrive un valore a virgola mobile a due byte nel flusso corrente e avanza la posizione del flusso in due byte.
Write(Double)	Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.
Write(Decimal)	Scrive un valore decimale nel flusso corrente e sposta in avanti di sedici byte la posizione del flusso.
Write(Char)	Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.
Write(Byte[])	Scrive una matrice di byte nel flusso sottostante.
Write(Byte)	Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso.
Write(Boolean)	Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta true.
Write(Int32)	Scrive un intero con segno a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.

Write(Char[], Int32, Int32)

Source:

BinaryWriter.cs

Scrive una sezione di una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.

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)

Parametri

chars

Char[]

Matrice di caratteri che contiene i dati da scrivere.

index

Int32

L'indice del primo carattere da leggere da chars e da scrivere nel flusso.

count

Int32

Il numero di caratteri da leggere da chars e da scrivere nel flusso.

Eccezioni

ArgumentException

La lunghezza del buffer meno index è minore di count.

ArgumentNullException

chars è null.

ArgumentOutOfRangeException

index o count è negativo.

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere dati usando la memoria come archivio di backup.

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);
    }
}

open System.IO

let invalidPathChars = Path.GetInvalidPathChars()
let memStream = new MemoryStream()
let binWriter = new BinaryWriter(memStream)

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

// Create the reader using the same MemoryStream
// as used with the writer.
let 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.
printf $"{binReader.ReadString()}"
let arraySize = memStream.Length - memStream.Position |> int
let memoryData = Array.zeroCreate<char> arraySize
binReader.Read(memoryData, 0, arraySize) |> ignore
printfn $"{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

Commenti

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• Encoding
• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Byte[], Int32, Int32)

Source:

BinaryWriter.cs

Scrive un'area di una matrice di byte nel flusso corrente.

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)

Parametri

buffer

Byte[]

Matrice di byte che contiene i dati da scrivere.

index

Int32

L'indice del primo byte da leggere da buffer e da scrivere nel flusso.

count

Int32

Il numero di byte da leggere da buffer e da scrivere nel flusso.

Eccezioni

ArgumentException

La lunghezza del buffer meno index è minore di count.

ArgumentNullException

buffer è null.

ArgumentOutOfRangeException

index o count è negativo.

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come scrivere dati binari usando la memoria come archivio di backup e quindi verificare che i dati siano stati scritti correttamente.

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.");
        }
    }
}

open System
open System.IO

let arrayLength = 1000
let dataArray = Array.zeroCreate<byte> arrayLength
let verifyArray = Array.zeroCreate<byte> arrayLength

Random().NextBytes dataArray

do
    use binWriter = new BinaryWriter(new MemoryStream())
    printfn "Writing the data."
    binWriter.Write(dataArray, 0, arrayLength)

    use binReader = new BinaryReader(binWriter.BaseStream)
    binReader.BaseStream.Position <- 0

    if binReader.Read(verifyArray, 0, arrayLength) <> arrayLength then
        printfn "Error writing the data."
    else
        for i = 0 to arrayLength - 1 do
            if verifyArray[i] <> dataArray[i] then
                printfn "Error writing the data."
            else
                printfn "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

Commenti

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(UInt64)

Source:

BinaryWriter.cs

Importante

Questa API non è conforme a CLS.

Scrive un intero senza segno a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.

public:
 virtual void Write(System::UInt64 value);

[System.CLSCompliant(false)]
public virtual void Write (ulong value);

[<System.CLSCompliant(false)>]
abstract member Write : uint64 -> unit
override this.Write : uint64 -> unit

Public Overridable Sub Write (value As ULong)

Parametri

value

UInt64

Intero senza segno a otto byte da scrivere.

Attributi

CLSCompliantAttribute

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

BinaryWriter archivia questo tipo di dati in formato endian piccolo.

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(UInt32)

Source:

BinaryWriter.cs

Importante

Questa API non è conforme a CLS.

Scrive un intero senza segno a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.

public:
 virtual void Write(System::UInt32 value);

[System.CLSCompliant(false)]
public virtual void Write (uint value);

[<System.CLSCompliant(false)>]
abstract member Write : uint32 -> unit
override this.Write : uint32 -> unit

Public Overridable Sub Write (value As UInteger)

Parametri

value

UInt32

Intero senza segno a quattro byte da scrivere.

Attributi

CLSCompliantAttribute

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

BinaryWriter archivia questo tipo di dati in formato endian piccolo.

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(UInt16)

Source:

BinaryWriter.cs

Importante

Questa API non è conforme a CLS.

Scrive un intero senza segno a due byte nel flusso corrente e sposta in avanti di due byte la posizione del flusso.

public:
 virtual void Write(System::UInt16 value);

[System.CLSCompliant(false)]
public virtual void Write (ushort value);

[<System.CLSCompliant(false)>]
abstract member Write : uint16 -> unit
override this.Write : uint16 -> unit

Public Overridable Sub Write (value As UShort)

Parametri

value

UInt16

Intero senza segno a due byte da scrivere.

Attributi

CLSCompliantAttribute

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

BinaryWriter archivia questo tipo di dati in formato endian piccolo.

Per un elenco di attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(String)

Source:

BinaryWriter.cs

Scrive una stringa con prefisso di lunghezza nel flusso con la codifica corrente dell'oggetto BinaryWriter e sposta in avanti la posizione corrente del flusso secondo la codifica usata e i caratteri specifici scritti nel flusso.

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)

Parametri

value

String

Valore da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ArgumentNullException

value è null.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come archiviare e recuperare le impostazioni dell'applicazione in un file.

using System;
using System.IO;
using System.Text;

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

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

    public static void WriteDefaultValues()
    {
        using (var stream = File.Open(fileName, FileMode.Create))
        {
            using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
            {
                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 (var stream = File.Open(fileName, FileMode.Open))
            {
                using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
                {
                    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);
        }
    }
}

open System.IO
open System.Text

let fileName = "AppSettings.dat"

let writeDefaultValues () =
    use stream = File.Open(fileName, FileMode.Create)
    use writer = new BinaryWriter(stream, Encoding.UTF8, false)
    writer.Write 1.250F
    writer.Write @"c:\Temp"
    writer.Write 10
    writer.Write true

let displayValues () =
    if File.Exists fileName then
        use stream = File.Open(fileName, FileMode.Open)
        use reader = new BinaryReader(stream, Encoding.UTF8, false)
        let aspectRatio = reader.ReadSingle()
        let tempDirectory = reader.ReadString()
        let autoSaveTime = reader.ReadInt32()
        let showStatusBar = reader.ReadBoolean()

        printfn $"Aspect ratio set to: {aspectRatio}"
        printfn $"Temp directory is: {tempDirectory}"
        printfn $"Auto save time set to: {autoSaveTime}"
        printfn $"Show status bar: {showStatusBar}"

writeDefaultValues ()
displayValues ()

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

Commenti

Il prefisso length indica che questo metodo scrive prima la lunghezza della stringa, espressa in byte, quando viene codificata con la BinaryWriter codifica corrente dell'istanza nel flusso. Questo valore viene scritto come intero senza segno. Questo metodo scrive quindi il numero di byte nel flusso.

Ad esempio, la stringa "A" ha una lunghezza pari a 1, ma quando viene codificata con UTF-16; la lunghezza è di 2 byte, quindi il valore scritto nel prefisso è 2 e 3 byte vengono scritti nel flusso, incluso il prefisso.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• Encoding
• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Single)

Source:

BinaryWriter.cs

Scrive un valore a virgola mobile a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.

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)

Parametri

value

Single

Valore a virgola mobile a quattro byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come archiviare e recuperare le impostazioni dell'applicazione in un file.

using System;
using System.IO;
using System.Text;

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

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

    public static void WriteDefaultValues()
    {
        using (var stream = File.Open(fileName, FileMode.Create))
        {
            using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
            {
                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 (var stream = File.Open(fileName, FileMode.Open))
            {
                using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
                {
                    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);
        }
    }
}

open System.IO
open System.Text

let fileName = "AppSettings.dat"

let writeDefaultValues () =
    use stream = File.Open(fileName, FileMode.Create)
    use writer = new BinaryWriter(stream, Encoding.UTF8, false)
    writer.Write 1.250F
    writer.Write @"c:\Temp"
    writer.Write 10
    writer.Write true

let displayValues () =
    if File.Exists fileName then
        use stream = File.Open(fileName, FileMode.Open)
        use reader = new BinaryReader(stream, Encoding.UTF8, false)
        let aspectRatio = reader.ReadSingle()
        let tempDirectory = reader.ReadString()
        let autoSaveTime = reader.ReadInt32()
        let showStatusBar = reader.ReadBoolean()

        printfn $"Aspect ratio set to: {aspectRatio}"
        printfn $"Temp directory is: {tempDirectory}"
        printfn $"Auto save time set to: {autoSaveTime}"
        printfn $"Show status bar: {showStatusBar}"

writeDefaultValues ()
displayValues ()

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

Commenti

BinaryWriter archivia questo tipo di dati in formato little endian.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(SByte)

Source:

BinaryWriter.cs

Importante

Questa API non è conforme a CLS.

Scrive un byte con segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso.

public:
 virtual void Write(System::SByte value);

[System.CLSCompliant(false)]
public virtual void Write (sbyte value);

[<System.CLSCompliant(false)>]
abstract member Write : sbyte -> unit
override this.Write : sbyte -> unit

Public Overridable Sub Write (value As SByte)

Parametri

value

SByte

Byte con segno da scrivere.

Attributi

CLSCompliantAttribute

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(ReadOnlySpan<Char>)

Source:

BinaryWriter.cs

Scrive un intervallo di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.

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))

Parametri

chars

ReadOnlySpan<Char>

Intervallo di caratteri da scrivere.

Write(ReadOnlySpan<Byte>)

Source:

BinaryWriter.cs

Scrive un intervallo di byte nel flusso corrente.

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))

Parametri

buffer

ReadOnlySpan<Byte>

Intervallo di byte da scrivere.

Write(Int64)

Source:

BinaryWriter.cs

Scrive un intero con segno a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.

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)

Parametri

value

Int64

Intero con segno a otto byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

BinaryWriter archivia questo tipo di dati in formato little endian.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Char[])

Source:

BinaryWriter.cs

Scrive una matrice di caratteri nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.

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())

Parametri

chars

Char[]

Matrice di caratteri che contiene i dati da scrivere.

Eccezioni

ArgumentNullException

chars è null.

ObjectDisposedException

Il flusso è chiuso.

IOException

Si è verificato un errore di I/O.

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere dati usando la memoria come archivio di backup.

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)));
    }
}

open System.IO

let invalidPathChars = Path.GetInvalidPathChars()
let memStream = new MemoryStream()
let binWriter = new BinaryWriter(memStream)

// Write to memory.
binWriter.Write "Invalid file path characters are: "
binWriter.Write invalidPathChars

// Create the reader using the same MemoryStream
// as used with the writer.
let 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.
printf $"{binReader.ReadString()}"
printfn $"{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

Commenti

Nella tabella seguente sono elencati esempi di altre attività di I/O tipiche o correlate.

Per eseguire questa operazione...	Vedere l'esempio riportato in questo argomento...
Creare un file di testo.	Procedura: Scrivere un testo in un file
Scrivere in un file di testo.	Procedura: Scrivere un testo in un file
Leggere da un file di testo.	Procedura: Leggere testo da un file
Aggiungere testo a un file.	Procedura: Aprire e accodare un file di log File.AppendText FileInfo.AppendText
Ottenere le dimensioni di un file.	FileInfo.Length
Ottiene gli attributi di un file.	File.GetAttributes
Impostare gli attributi di un file.	File.SetAttributes
Determinare se esiste un file.	File.Exists
Leggere da un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato
Scrivere in un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato

Vedi anche

• Encoding
• I/O di file e Stream
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Int16)

Source:

BinaryWriter.cs

Scrive un intero con segno a due byte nel flusso corrente e sposta in avanti di due byte la posizione del flusso.

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)

Parametri

value

Int16

Intero con segno a due byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

BinaryWriter archivia questo tipo di dati in formato little endian.

Nella tabella seguente sono elencati esempi di altre attività di I/O tipiche o correlate.

Per eseguire questa operazione...	Vedere l'esempio riportato in questo argomento...
Creare un file di testo.	Procedura: Scrivere un testo in un file
Scrivere in un file di testo.	Procedura: Scrivere un testo in un file
Leggere da un file di testo.	Procedura: Leggere testo da un file
Aggiungere testo a un file.	Procedura: Aprire e accodare un file di log File.AppendText FileInfo.AppendText
Ottenere le dimensioni di un file.	FileInfo.Length
Ottiene gli attributi di un file.	File.GetAttributes
Impostare gli attributi di un file.	File.SetAttributes
Determinare se esiste un file.	File.Exists
Leggere da un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato
Scrivere in un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato

Vedi anche

• I/O di file e Stream
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Half)

Source:

BinaryWriter.cs

Scrive un valore a virgola mobile a due byte nel flusso corrente e sposta in avanti la posizione del flusso di due byte.

public:
 virtual void Write(Half value);

public virtual void Write (Half value);

abstract member Write : Half -> unit
override this.Write : Half -> unit

Public Overridable Sub Write (value As Half)

Parametri

value

Half

Valore a virgola mobile a due byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere Double dati in memoria usando le BinaryReader classi e BinaryWriter sopra la MemoryStream classe . MemoryStream legge e scrive Byte solo i dati.

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);
                }
            }
        }
    }
}

open System
open System.IO

let arrayLength = 1000

// Create random data to write to the stream.
let randomGenerator = Random()
let dataArray = 
    Array.init arrayLength (fun _ -> 100.1 * randomGenerator.NextDouble())
do
    use binWriter = new BinaryWriter(new MemoryStream())
    // Write the data to the stream.
    printfn $"Writing data to the stream."
    for num in dataArray do
        binWriter.Write num

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

        // Read and verify the data.
        printfn "Verifying the written data."
        for num in dataArray do
            if binReader.ReadDouble() <> num then
                printfn "Error writing data."
        printfn "The data was written and verified."
    with :? EndOfStreamException as e ->
        printfn $"Error writing data: {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

Commenti

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Double)

Source:

BinaryWriter.cs

Scrive un valore a virgola mobile a otto byte nel flusso corrente e sposta in avanti di otto byte la posizione del flusso.

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)

Parametri

value

Double

Valore a virgola mobile a otto byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere Double dati in memoria usando le BinaryReader classi e BinaryWriter sopra la MemoryStream classe . MemoryStream legge e scrive Byte solo i dati.

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);
                }
            }
        }
    }
}

open System
open System.IO

let arrayLength = 1000

// Create random data to write to the stream.
let randomGenerator = Random()
let dataArray = 
    Array.init arrayLength (fun _ -> 100.1 * randomGenerator.NextDouble())
do
    use binWriter = new BinaryWriter(new MemoryStream())
    // Write the data to the stream.
    printfn $"Writing data to the stream."
    for num in dataArray do
        binWriter.Write num

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

        // Read and verify the data.
        printfn "Verifying the written data."
        for num in dataArray do
            if binReader.ReadDouble() <> num then
                printfn "Error writing data."
        printfn "The data was written and verified."
    with :? EndOfStreamException as e ->
        printfn $"Error writing data: {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

Commenti

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Decimal)

Source:

BinaryWriter.cs

Scrive un valore decimale nel flusso corrente e sposta in avanti di sedici byte la posizione del flusso.

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)

Parametri

value

Decimal

Valore decimale da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Commenti

Nella tabella seguente sono elencati esempi di altre attività di I/O tipiche o correlate.

Per eseguire questa operazione...	Vedere l'esempio riportato in questo argomento...
Creare un file di testo.	Procedura: Scrivere un testo in un file
Scrivere in un file di testo.	Procedura: Scrivere un testo in un file
Leggere da un file di testo.	Procedura: Leggere testo da un file
Aggiungere testo a un file.	Procedura: Aprire e accodare un file di log File.AppendText FileInfo.AppendText
Ottenere le dimensioni di un file.	FileInfo.Length
Ottiene gli attributi di un file.	File.GetAttributes
Impostare gli attributi di un file.	File.SetAttributes
Determinare se esiste un file.	File.Exists
Leggere da un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato
Scrivere in un file binario.	Procedura: Leggere e scrivere su un file di dati appena creato

Vedi anche

• I/O di file e Stream
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Char)

Source:

BinaryWriter.cs

Scrive un carattere Unicode nel flusso corrente e sposta in avanti la posizione corrente del flusso secondo il valore Encoding usato e i caratteri specifici scritti nel flusso.

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)

Parametri

ch

Char

Carattere Unicode non surrogato da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

ArgumentException

ch è un carattere surrogato singolo.

Esempio

Nell'esempio di codice seguente viene illustrato come leggere e scrivere dati usando la memoria come archivio di backup.

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);
    }
}

open System.IO

let invalidPathChars = Path.GetInvalidPathChars()
let memStream = new MemoryStream()
let binWriter = new BinaryWriter(memStream)

// Write to memory.
binWriter.Write "Invalid file path characters are: "
for i = 0 to invalidPathChars.Length - 1 do
    binWriter.Write invalidPathChars[i]

// Create the reader using the same MemoryStream
// as used with the writer.
let 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.
printf $"{binReader.ReadString()}"
let memoryData = Array.zeroCreate<char> (int (memStream.Length - memStream.Position))
for i = 0 to memoryData.Length - 1 do
    memoryData[i] <- binReader.ReadChar()
printfn $"{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

Commenti

A causa dei conflitti di formattazione dei dati, non è consigliabile usare questo metodo con le codifiche seguenti:

• UTF-7

• ISO-2022-JP

• ISCII

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

I caratteri surrogati Unicode devono essere scritti come coppie insieme nella stessa chiamata, non singolarmente. Se è necessario il supporto per le coppie di surrogati nell'applicazione, è consigliabile usare una matrice di caratteri e l'overload del Write metodo.

Vedi anche

• Encoding
• I/O di file e Stream
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Byte[])

Source:

BinaryWriter.cs

Scrive una matrice di byte nel flusso sottostante.

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())

Parametri

buffer

Byte[]

Matrice di byte che contiene i dati da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

ArgumentNullException

buffer è null.

Esempio

Nell'esempio di codice seguente viene illustrato come scrivere dati binari usando la memoria come archivio di backup e quindi verificare che i dati siano stati scritti correttamente.

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.");
    }
}

open System
open System.IO

let arrayLength = 1000

// Create random data to write to the stream.
let dataArray = Array.zeroCreate<byte> arrayLength
Random().NextBytes dataArray

let binWriter = new BinaryWriter(new MemoryStream())

// Write the data to the stream.ch
printfn "Writing the data."
binWriter.Write dataArray

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

// Set Position to the beginning of the stream.
binReader.BaseStream.Position <- 0

// Read and verify the data.
let verifyArray = binReader.ReadBytes arrayLength
if verifyArray.Length <> arrayLength then
    printfn "Error writing the data."
else
    let mutable failed = false
    for i = 0 to arrayLength - 1 do
        if verifyArray[i] <> dataArray[i] then
            printfn "Error writing the data."
            failed <- true
    if not failed then
        printfn "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

Commenti

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Byte)

Source:

BinaryWriter.cs

Scrive un byte senza segno nel flusso corrente e sposta in avanti di un byte la posizione del flusso.

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)

Parametri

value

Byte

Byte senza segno da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come scrivere dati binari usando la memoria come archivio di backup e quindi verificare che i dati siano stati scritti correttamente.

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);
        }
    }
}

open System
open System.IO

// Create random data to write to the stream.
let writeArray = Array.zeroCreate<byte> 1000
Random().NextBytes writeArray

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

try
    // Write the data to the stream.
    printfn "Writing the data."
    for i = 0 to writeArray.Length - 1 do
        binWriter.Write writeArray[i]

    // Set the stream position to the beginning of the stream.
    binReader.BaseStream.Position <- 0

    let mutable failed = false
    // Read and verify the data from the stream.
    for i = 0 to writeArray.Length - 1 do
        if binReader.ReadByte() <> writeArray[i] then
            printfn "Error writing the data."
            failed <- true
    if not failed then
        printfn "The data was written and verified."

// Catch the EndOfStreamException and write an error message.
with :? EndOfStreamException as e ->
    printfn $"Error writing the data.\n{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

Commenti

A causa dei conflitti di formattazione dei dati, non è consigliabile usare questo metodo con le codifiche seguenti:

• UTF-7

• ISO-2022-JP

• ISCII

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Boolean)

Source:

BinaryWriter.cs

Scrive un valore Boolean a un byte nel flusso corrente, con 0 che rappresenta false e 1 che rappresenta 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)

Parametri

value

Boolean

Valore Boolean da scrivere (0 o 1).

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come archiviare e recuperare le impostazioni dell'applicazione in un file.

using System;
using System.IO;
using System.Text;

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

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

    public static void WriteDefaultValues()
    {
        using (var stream = File.Open(fileName, FileMode.Create))
        {
            using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
            {
                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 (var stream = File.Open(fileName, FileMode.Open))
            {
                using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
                {
                    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);
        }
    }
}

open System.IO
open System.Text

let fileName = "AppSettings.dat"

let writeDefaultValues () =
    use stream = File.Open(fileName, FileMode.Create)
    use writer = new BinaryWriter(stream, Encoding.UTF8, false)
    writer.Write 1.250F
    writer.Write @"c:\Temp"
    writer.Write 10
    writer.Write true

let displayValues () =
    if File.Exists fileName then
        use stream = File.Open(fileName, FileMode.Open)
        use reader = new BinaryReader(stream, Encoding.UTF8, false)
        let aspectRatio = reader.ReadSingle()
        let tempDirectory = reader.ReadString()
        let autoSaveTime = reader.ReadInt32()
        let showStatusBar = reader.ReadBoolean()

        printfn $"Aspect ratio set to: {aspectRatio}"
        printfn $"Temp directory is: {tempDirectory}"
        printfn $"Auto save time set to: {autoSaveTime}"
        printfn $"Show status bar: {showStatusBar}"

writeDefaultValues ()
displayValues ()

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

Commenti

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file

Write(Int32)

Source:

BinaryWriter.cs

Scrive un intero con segno a quattro byte nel flusso corrente e sposta in avanti di quattro byte la posizione del flusso.

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)

Parametri

value

Int32

Intero con segno a quattro byte da scrivere.

Eccezioni

IOException

Si è verificato un errore di I/O.

ObjectDisposedException

Il flusso è chiuso.

Esempio

Nell'esempio di codice seguente viene illustrato come archiviare e recuperare le impostazioni dell'applicazione in un file.

using System;
using System.IO;
using System.Text;

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

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

    public static void WriteDefaultValues()
    {
        using (var stream = File.Open(fileName, FileMode.Create))
        {
            using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
            {
                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 (var stream = File.Open(fileName, FileMode.Open))
            {
                using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
                {
                    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);
        }
    }
}

open System.IO
open System.Text

let fileName = "AppSettings.dat"

let writeDefaultValues () =
    use stream = File.Open(fileName, FileMode.Create)
    use writer = new BinaryWriter(stream, Encoding.UTF8, false)
    writer.Write 1.250F
    writer.Write @"c:\Temp"
    writer.Write 10
    writer.Write true

let displayValues () =
    if File.Exists fileName then
        use stream = File.Open(fileName, FileMode.Open)
        use reader = new BinaryReader(stream, Encoding.UTF8, false)
        let aspectRatio = reader.ReadSingle()
        let tempDirectory = reader.ReadString()
        let autoSaveTime = reader.ReadInt32()
        let showStatusBar = reader.ReadBoolean()

        printfn $"Aspect ratio set to: {aspectRatio}"
        printfn $"Temp directory is: {tempDirectory}"
        printfn $"Auto save time set to: {autoSaveTime}"
        printfn $"Show status bar: {showStatusBar}"

writeDefaultValues ()
displayValues ()

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

Commenti

BinaryWriter archivia questo tipo di dati in formato little endian.

Per un elenco delle attività di I/O comuni, vedere Attività di I/O comuni.

Vedi anche

• I/O di file e di flussi
• Procedura: Leggere testo da un file
• Procedura: Scrivere un testo in un file