BinaryWriter.Write Methode

Referenz

Definition

Namespace:: System.IO

Assembly:: System.IO.dll

Assembly:: System.Runtime.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Schreibt einen Wert in den aktuellen Stream.

Überlädt

Write(Char[], Int32, Int32)	Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten `Encoding` und ggf. der in den Stream geschriebenen Zeichen.
Write(Byte[], Int32, Int32)	Schreibt einen Bereich eines Bytearrays in den aktuellen Stream.
Write(UInt64)	Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes.
Write(UInt32)	Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes.
Write(UInt16)	Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes.
Write(String)	Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von BinaryWriter in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen.
Write(Single)	Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes.
Write(SByte)	Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte.
Write(ReadOnlySpan<Char>)	Schreibt einen Bereich von Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten `Encoding` und ggf. der in den Stream geschriebenen Zeichen.
Write(ReadOnlySpan<Byte>)	Schreibt einen Bereich von Bytes in den aktuellen Stream.
Write(Int64)	Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes.
Write(Char[])	Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten `Encoding` und der in den Stream geschriebenen Zeichen.
Write(Int16)	Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes.
Write(Half)	Schreibt einen Zwei-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Streamposition um zwei Bytes.
Write(Double)	Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes.
Write(Decimal)	Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 Bytes.
Write(Char)	Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten `Encoding` und der in den Stream geschriebenen Zeichen.
Write(Byte[])	Schreibt ein Bytearray in den zugrunde liegenden Stream.
Write(Byte)	Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte.
Write(Boolean)	Schreibt einen 1-Byte-`Boolean`-Wert in den aktuellen Stream, wobei 0 (null) `false` und 1 `true` darstellt.
Write(Int32)	Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes.

Write(Char[], Int32, Int32)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Bereich eines Zeichenarrays in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen.

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)

Parameter

chars: Char[]

Ein Zeichenarray mit den zu schreibenden Daten.

index: Int32

Der Index des ersten Zeichens, das aus dem chars gelesen und in den Stream geschrieben werden soll.

count: Int32

Die Anzahl von Zeichen, die aus dem chars gelesen und in den Stream geschrieben werden sollen.

Ausnahmen

ArgumentException

Die Pufferlänge minus index ist kleiner als count.

ArgumentNullException

chars ist null.

ArgumentOutOfRangeException

index oder count ist ein negativer Wert.

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Daten mithilfe von Arbeitsspeicher als Sicherungsspeicher gelesen und geschrieben werden.

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

Hinweise

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Byte[], Int32, Int32)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Bereich eines Bytearrays in den aktuellen 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)

Parameter

buffer: Byte[]

Ein Bytearray, das die zu schreibenden Daten enthält.

index: Int32

Der Index des ersten Bytes, das aus dem buffer gelesen und in den Stream geschrieben werden soll.

count: Int32

Die Anzahl von Bytes, die aus dem buffer gelesen und in den Stream geschrieben werden sollen.

Ausnahmen

ArgumentException

Die Pufferlänge minus index ist kleiner als count.

ArgumentNullException

buffer ist null.

ArgumentOutOfRangeException

index oder count ist ein negativer Wert.

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Sie Binärdaten mit Speicher als Sicherungsspeicher schreiben und dann überprüfen, ob die Daten ordnungsgemäß geschrieben wurden.

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

Hinweise

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(UInt64)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Schreibt eine 8-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 Bytes.

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)

Parameter

value: UInt64

Die zu schreibende 8-Byte-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(UInt32)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Schreibt eine 4-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 Bytes.

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)

Parameter

value: UInt32

Die zu schreibende 4-Byte-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(UInt16)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Schreibt eine 2-Byte-Ganzzahl ohne Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 Bytes.

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)

Parameter

value: UInt16

Die zu schreibende 2-Byte-Ganzzahl ohne Vorzeichen.

Attribute: CLSCompliantAttribute

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(String)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt eine Zeichenfolge mit Längenpräfix in der aktuellen Codierung von BinaryWriter in diesen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Codierung und der in den Stream geschriebenen Zeichen.

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)

Parameter

value: String

Der zu schreibende Wert.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ArgumentNullException

value ist null.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Anwendungseinstellungen in einer Datei gespeichert und abgerufen werden.

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

Hinweise

Längenpräfix bedeutet, dass diese Methode zuerst die Länge der Zeichenfolge in Bytes schreibt, wenn sie mit der aktuellen Codierung des BinaryWriter instance in den Stream codiert wird. Dieser Wert wird als ganze Zahl ohne Vorzeichen geschrieben. Diese Methode schreibt dann so viele Bytes in den Stream.

Beispielsweise hat die Zeichenfolge "A" eine Länge von 1, wenn sie jedoch mit UTF-16 codiert ist; die Länge beträgt 2 Bytes, sodass der im Präfix geschriebene Wert 2 ist und 3 Bytes in den Stream geschrieben werden, einschließlich des Präfixes.

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Single)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen 4-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 4 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)

Parameter

value: Single

Der zu schreibende 4-Byte-Gleitkommawert.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Anwendungseinstellungen in einer Datei gespeichert und abgerufen werden.

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

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(SByte)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Schreibt ein Byte mit Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein Byte.

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)

Parameter

value: SByte

Das zu schreibende Byte mit Vorzeichen.

Attribute: CLSCompliantAttribute

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(ReadOnlySpan<Char>)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Bereich von Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und ggf. der in den Stream geschriebenen Zeichen.

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

Parameter

chars: ReadOnlySpan<Char>

Ein Bereich von zu schreibenden Chars.

Gilt für:

Write(ReadOnlySpan<Byte>)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Bereich von Bytes in den aktuellen 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))

Parameter

buffer: ReadOnlySpan<Byte>

Der Bereich der zu schreibenden Bytes.

Gilt für:

Write(Int64)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt eine 8-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 8 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)

Parameter

value: Int64

Die zu schreibende 8-Byte-Ganzzahl mit Vorzeichen.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Char[])

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt ein Zeichenarray in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen.

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

Parameter

chars: Char[]

Ein Zeichenarray mit den zu schreibenden Daten.

Ausnahmen

ArgumentNullException

chars ist null.

ObjectDisposedException

Der Stream ist geschlossen.

IOException

Ein E/A-Fehler tritt auf.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Daten mithilfe von Arbeitsspeicher als Sicherungsspeicher gelesen und geschrieben werden.

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

Hinweise

Die folgende Tabelle enthält Beispiele für andere typische oder verwandte E/A-Aufgaben.

Aufgabe	Siehe das Beispiel in diesem Thema:
Erstellen einer Textdatei	How to: Schreiben von Text in eine Datei
Schreiben Sie in eine Textdatei.	How to: Schreiben von Text in eine Datei
Aus einer Textdatei lesen.	How to: Lesen von Text aus einer Datei
Fügen Sie Text an eine Datei an.	How to: Öffnen und Anfügen an eine Protokolldatei File.AppendText FileInfo.AppendText
Rufen Sie die Größe einer Datei ab.	FileInfo.Length
Rufen Sie die Attribute einer Datei ab.	File.GetAttributes
Legen Sie die Attribute einer Datei fest.	File.SetAttributes
Ermitteln Sie, ob eine Datei vorhanden ist.	File.Exists
Aus einer Binärdatei lesen.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei
Schreiben Sie in eine Binärdatei.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei

Weitere Informationen

Gilt für:

Write(Int16)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt eine 2-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 2 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)

Parameter

value: Int16

Die zu schreibende 2-Byte-Ganzzahl mit Vorzeichen.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Die folgende Tabelle enthält Beispiele für andere typische oder verwandte E/A-Aufgaben.

Aufgabe	Siehe das Beispiel in diesem Thema:
Erstellen einer Textdatei	How to: Schreiben von Text in eine Datei
Schreiben Sie in eine Textdatei.	How to: Schreiben von Text in eine Datei
Aus einer Textdatei lesen.	How to: Lesen von Text aus einer Datei
Fügen Sie Text an eine Datei an.	How to: Öffnen und Anfügen an eine Protokolldatei File.AppendText FileInfo.AppendText
Rufen Sie die Größe einer Datei ab.	FileInfo.Length
Rufen Sie die Attribute einer Datei ab.	File.GetAttributes
Legen Sie die Attribute einer Datei fest.	File.SetAttributes
Ermitteln Sie, ob eine Datei vorhanden ist.	File.Exists
Aus einer Binärdatei lesen.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei
Schreiben Sie in eine Binärdatei.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei

Weitere Informationen

Gilt für:

Write(Half)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Gleitkommawert von zwei Byte in den aktuellen Stream und erhöht die Streamposition um zwei Bytes.

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)

Parameter

value: Half

Der zu schreibende Gleitkommawert mit zwei Byte.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Sie Daten lesen und in den Arbeitsspeicher schreiben Double , indem Sie die BinaryReader -Klasse und BinaryWriter -Klasse verwenden MemoryStream . MemoryStream liest und schreibt Byte nur Daten.

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

Hinweise

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Double)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen 8-Byte-Gleitkommawert in den aktuellen Stream und erhöht die Position im Stream um 8 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)

Parameter

value: Double

Der zu schreibende 8-Byte-Gleitkommawert.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

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

Hinweise

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Decimal)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen Dezimalwert in den aktuellen Stream und erhöht die Position im Stream um 16 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)

Parameter

value: Decimal

Der zu schreibende Dezimalwert.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Hinweise

Die folgende Tabelle enthält Beispiele für andere typische oder verwandte E/A-Aufgaben.

Aufgabe	Siehe das Beispiel in diesem Thema:
Erstellen einer Textdatei	How to: Schreiben von Text in eine Datei
Schreiben Sie in eine Textdatei.	How to: Schreiben von Text in eine Datei
Aus einer Textdatei lesen.	How to: Lesen von Text aus einer Datei
Fügen Sie Text an eine Datei an.	How to: Öffnen und Anfügen an eine Protokolldatei File.AppendText FileInfo.AppendText
Rufen Sie die Größe einer Datei ab.	FileInfo.Length
Rufen Sie die Attribute einer Datei ab.	File.GetAttributes
Legen Sie die Attribute einer Datei fest.	File.SetAttributes
Ermitteln Sie, ob eine Datei vorhanden ist.	File.Exists
Aus einer Binärdatei lesen.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei
Schreiben Sie in eine Binärdatei.	How to: Vorgehensweise: Lesen von bzw. Schreiben in eine neu erstellte Datendatei

Weitere Informationen

Gilt für:

Write(Char)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt ein Unicode-Zeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream in Abhängigkeit von der verwendeten Encoding und der in den Stream geschriebenen Zeichen.

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)

Parameter

ch: Char

Das zu schreibende Unicode-Zeichen (nicht-Ersatzzeichen).

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

ArgumentException

ch ist ein einzelnes Ersatzzeichen.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie Daten mithilfe von Arbeitsspeicher als Sicherungsspeicher gelesen und geschrieben werden.

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

Hinweise

Aufgrund von Datenformatierungskonflikten wird die Verwendung dieser Methode mit den folgenden Codierungen nicht empfohlen:

UTF-7
ISO-2022-JP
ISCII

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Unicode-Ersatzzeichen müssen als Paare im selben Aufruf und nicht einzeln geschrieben werden. Wenn Sie Unterstützung für Ersatzpaare in Ihrer Anwendung benötigen, sollten Sie ein Zeichenarray und die Write Methodenüberladung verwenden.

Weitere Informationen

Gilt für:

Write(Byte[])

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt ein Bytearray in den zugrunde liegenden 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())

Parameter

buffer: Byte[]

Ein Bytearray, das die zu schreibenden Daten enthält.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

ArgumentNullException

buffer ist null.

Beispiele

Das folgende Codebeispiel zeigt, wie Sie Binärdaten mithilfe von Arbeitsspeicher als Sicherungsspeicher schreiben und dann überprüfen, ob die Daten ordnungsgemäß geschrieben wurden.

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

Hinweise

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Byte)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt ein Byte ohne Vorzeichen in den aktuellen Stream und erhöht die aktuelle Position im Stream um ein 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)

Parameter

value: Byte

Das zu schreibende Byte ohne Vorzeichen.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Das folgende Codebeispiel zeigt, wie Sie Binärdaten mithilfe von Arbeitsspeicher als Sicherungsspeicher schreiben und dann überprüfen, ob die Daten ordnungsgemäß geschrieben wurden.

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

Hinweise

Aufgrund von Datenformatierungskonflikten wird die Verwendung dieser Methode mit den folgenden Codierungen nicht empfohlen:

UTF-7
ISO-2022-JP
ISCII

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Boolean)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt einen 1-Byte-Boolean-Wert in den aktuellen Stream, wobei 0 (null) false und 1 true darstellt.

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)

Parameter

value: Boolean

Der zu schreibende Boolean-Wert (0 (null) oder 1).

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Anwendungseinstellungen in einer Datei gespeichert und abgerufen werden.

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

Hinweise

Eine Liste allgemeiner E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Write(Int32)

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Quelle:: BinaryWriter.cs

Schreibt eine 4-Byte-Ganzzahl mit Vorzeichen in den aktuellen Stream und erhöht die Position im Stream um 4 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)

Parameter

value: Int32

Die zu schreibende 4-Byte-Ganzzahl mit Vorzeichen.

Ausnahmen

IOException

Ein E/A-Fehler tritt auf.

ObjectDisposedException

Der Stream ist geschlossen.

Beispiele

Im folgenden Codebeispiel wird veranschaulicht, wie Anwendungseinstellungen in einer Datei gespeichert und abgerufen werden.

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

Hinweise

BinaryWriter speichert diesen Datentyp im Little-Endian-Format.

Eine Liste der allgemeinen E/A-Aufgaben finden Sie unter Allgemeine E/A-Aufgaben.

Weitere Informationen

Gilt für:

Teilen über

BinaryWriter.Write Methode

Definition

Überlädt

Write(Char[], Int32, Int32)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Write(Byte[], Int32, Int32)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Write(UInt64)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Write(UInt32)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Write(UInt16)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Write(String)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Write(Single)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Write(SByte)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Write(ReadOnlySpan<Char>)

Parameter

Gilt für:

Write(ReadOnlySpan<Byte>)

Parameter

Gilt für:

Write(Int64)

Parameter

Ausnahmen

Hinweise

Weitere Informationen

Gilt für:

Write(Char[])

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Write(Int16)

Parameter

Ausnahmen

Hinweise

Weitere Informationen