BinaryWriter.Write Metoda

Definicja

Przestrzeń nazw:

System.IO

Zestaw:

System.Runtime.dll

Zapisuje wartość w bieżącym strumieniu.

Przeciążenia

Write(Char[], Int32, Int32)	Zapisuje sekcję tablicy znaków w bieżącym strumieniu i rozwija bieżącą pozycję strumienia zgodnie z używanym Encoding i być może określonymi znakami zapisywanymi w strumieniu.
Write(Byte[], Int32, Int32)	Zapisuje region tablicy bajtów w bieżącym strumieniu.
Write(UInt64)	Zapisuje ośmiobajtową liczbę całkowitą bez znaku do bieżącego strumienia i rozwija pozycję strumienia o osiem bajtów.
Write(UInt32)	Zapisuje czterobajtową liczbę całkowitą bez znaku do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.
Write(UInt16)	Zapisuje dwubajtową liczbę całkowitą bez znaku do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.
Write(String)	Zapisuje ciąg z prefiksem długości do tego strumienia w bieżącym kodowaniu , i rozwija bieżącą pozycję strumienia zgodnie z używanym kodowaniem BinaryWriteri określonymi znakami zapisywanymi w strumieniu.
Write(Single)	Zapisuje wartość zmiennoprzecinkową czterobajtową do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.
Write(SByte)	Zapisuje podpisany bajt do bieżącego strumienia i przesuwa położenie strumienia o jeden bajt.
Write(ReadOnlySpan<Char>)	Zapisuje zakres znaków w bieżącym strumieniu i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i być może określonymi znakami zapisywanymi w strumieniu.
Write(ReadOnlySpan<Byte>)	Zapisuje zakres bajtów w bieżącym strumieniu.
Write(Int64)	Zapisuje ośmiobajtową liczbę całkowitą ze znakiem do bieżącego strumienia i rozwija pozycję strumienia o osiem bajtów.
Write(Char[])	Zapisuje tablicę znaków w bieżącym strumieniu i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i określonymi znakami zapisywanymi w strumieniu.
Write(Int16)	Zapisuje dwubajtową liczbę całkowitą ze znakiem do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.
Write(Half)	Zapisuje wartość zmiennoprzecinkową dwubajtową do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.
Write(Double)	Zapisuje ośmiobajtową wartość zmiennoprzecinkową do bieżącego strumienia i przesuwa położenie strumienia o osiem bajtów.
Write(Decimal)	Zapisuje wartość dziesiętną do bieżącego strumienia i przesuwa położenie strumienia o szesnaście bajtów.
Write(Char)	Zapisuje znak Unicode do bieżącego strumienia i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i określonymi znakami zapisywanymi w strumieniu.
Write(Byte[])	Zapisuje tablicę bajtów do bazowego strumienia.
Write(Byte)	Zapisuje niepodpisany bajt do bieżącego strumienia i przesuwa położenie strumienia o jeden bajt.
Write(Boolean)	Zapisuje wartość jedno bajtową Boolean do bieżącego strumienia z wartością 0 reprezentującą false i 1 reprezentującą truewartość .
Write(Int32)	Zapisuje czterobajtową liczbę całkowitą ze znakiem do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.

Write(Char[], Int32, Int32)

Źródło:

BinaryWriter.cs

Zapisuje sekcję tablicy znaków w bieżącym strumieniu i rozwija bieżącą pozycję strumienia zgodnie z używanym Encoding i być może określonymi znakami zapisywanymi w strumieniu.

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)

Parametry

chars

Char[]

Tablica znaków zawierająca dane do zapisania.

index

Int32

Indeks pierwszego znaku do odczytu i chars zapisu w strumieniu.

count

Int32

Liczba znaków do odczytania i chars zapisu w strumieniu.

Wyjątki

ArgumentException

Długość buforu minus index jest mniejsza niż count.

ArgumentNullException

chars to null.

ArgumentOutOfRangeException

index lub count jest ujemny.

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

W poniższym przykładzie kodu pokazano, jak odczytywać i zapisywać dane przy użyciu pamięci jako magazynu zapasowego.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Encoding
• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Byte[], Int32, Int32)

Źródło:

BinaryWriter.cs

Zapisuje region tablicy bajtów w bieżącym strumieniu.

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)

Parametry

buffer

Byte[]

Tablica bajtów zawierająca dane do zapisania.

index

Int32

Indeks pierwszego bajtu do odczytu z buffer i zapisu w strumieniu.

count

Int32

Liczba bajtów do odczytu z buffer i zapisu w strumieniu.

Wyjątki

ArgumentException

Długość buforu minus index jest mniejsza niż count.

ArgumentNullException

buffer to null.

ArgumentOutOfRangeException

index lub count jest ujemny.

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu pokazuje, jak zapisywać dane binarne przy użyciu pamięci jako magazynu zapasowego, a następnie sprawdzić, czy dane zostały zapisane poprawnie.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(UInt64)

Źródło:

BinaryWriter.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Zapisuje ośmiobajtową liczbę całkowitą bez znaku do bieżącego strumienia i rozwija pozycję strumienia o osiem bajtów.

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)

Parametry

value

UInt64

Ośmio bajtowa liczba całkowita bez znaku do zapisu.

Atrybuty

CLSCompliantAttribute

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

BinaryWriter przechowuje ten typ danych w niewielkim formacie endianu.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(UInt32)

Źródło:

BinaryWriter.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Zapisuje czterobajtową liczbę całkowitą bez znaku do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.

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)

Parametry

value

UInt32

Liczba całkowita bez znaku z czterema bajtami do zapisu.

Atrybuty

CLSCompliantAttribute

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

BinaryWriter przechowuje ten typ danych w niewielkim formacie endianu.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(UInt16)

Źródło:

BinaryWriter.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Zapisuje dwubajtową niepodpisaną liczbę całkowitą do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.

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)

Parametry

value

UInt16

Liczba całkowita bez znaku dwu bajtów do zapisu.

Atrybuty

CLSCompliantAttribute

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

BinaryWriter przechowuje ten typ danych w niewielkim formacie endianu.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(String)

Źródło:

BinaryWriter.cs

Zapisuje ciąg o długości prefiksu do tego strumienia w bieżącym kodowaniu elementu i rozwija bieżącą pozycję strumienia zgodnie z używanym kodowaniem BinaryWriteri określonymi znakami zapisywanymi w strumieniu.

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)

Parametry

value

String

Wartość do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ArgumentNullException

value to null.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu demonstruje sposób przechowywania i pobierania ustawień aplikacji w pliku.

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

Uwagi

Długość prefiksu oznacza, że ta metoda najpierw zapisuje długość ciągu w bajtach podczas kodowania BinaryWriter z bieżącym kodowaniem wystąpienia do strumienia. Ta wartość jest zapisywana jako niepodpisane liczby całkowite. Następnie ta metoda zapisuje, że wiele bajtów do strumienia.

Na przykład ciąg "A" ma długość 1, ale w przypadku kodowania przy użyciu formatu UTF-16; długość to 2 bajty, więc wartość zapisana w prefiksie wynosi 2, a 3 bajty są zapisywane w strumieniu, w tym prefiks.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Encoding
• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Single)

Źródło:

BinaryWriter.cs

Zapisuje czterobajtową wartość zmiennoprzecinkową do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.

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)

Parametry

value

Single

Wartość zmiennoprzecinkowa z czterema bajtami do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu demonstruje sposób przechowywania i pobierania ustawień aplikacji w pliku.

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

Uwagi

BinaryWriter przechowuje ten typ danych w małym formacie endian.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(SByte)

Źródło:

BinaryWriter.cs

Ważne

Ten interfejs API nie jest zgodny ze specyfikacją CLS.

Zapisuje podpisany bajt do bieżącego strumienia i rozwija pozycję strumienia według jednego bajtu.

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)

Parametry

value

SByte

Podpisany bajt do zapisu.

Atrybuty

CLSCompliantAttribute

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(ReadOnlySpan<Char>)

Źródło:

BinaryWriter.cs

Zapisuje zakres znaków do bieżącego strumienia i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i być może określonymi znakami zapisywanymi w strumieniu.

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

Parametry

chars

ReadOnlySpan<Char>

Zakres znaków do zapisu.

Write(ReadOnlySpan<Byte>)

Źródło:

BinaryWriter.cs

Zapisuje zakres bajtów do bieżącego strumienia.

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

Parametry

buffer

ReadOnlySpan<Byte>

Zakres bajtów do zapisu.

Write(Int64)

Źródło:

BinaryWriter.cs

Zapisuje liczbę całkowitą z podpisem ośmiobajtowym do bieżącego strumienia i rozwija pozycję strumienia o osiem bajtów.

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)

Parametry

value

Int64

Liczba całkowita z podpisem ośmiu bajtów do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

BinaryWriter przechowuje ten typ danych w małym formacie endian.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Char[])

Źródło:

BinaryWriter.cs

Zapisuje tablicę znaków do bieżącego strumienia i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i określonymi znakami zapisywanymi w strumieniu.

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

Parametry

chars

Char[]

Tablica znaków zawierająca dane do zapisu.

Wyjątki

ArgumentNullException

chars to null.

ObjectDisposedException

Strumień jest zamknięty.

IOException

Wystąpi błąd We/Wy.

Przykłady

W poniższym przykładzie kodu pokazano, jak odczytywać i zapisywać dane przy użyciu pamięci jako magazynu zaplecza.

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

Uwagi

W poniższej tabeli wymieniono przykłady innych typowych lub powiązanych zadań we/wy.

Aby wykonać tę czynność...	Zobacz przykład w tym temacie...
Utwórz plik tekstowy.	Instrukcje: Zapisywanie tekstu w pliku
Zapisywanie w pliku tekstowym.	Instrukcje: Zapisywanie tekstu w pliku
Odczyt z pliku tekstowego.	Instrukcje: Odczytywanie tekstu z pliku
Dołącz tekst do pliku.	Instrukcje: Otwieranie pliku dziennika i dołączanie do niego File.AppendText FileInfo.AppendText
Pobierz rozmiar pliku.	FileInfo.Length
Pobierz atrybuty pliku.	File.GetAttributes
Ustaw atrybuty pliku.	File.SetAttributes
Ustal, czy plik istnieje.	File.Exists
Odczyt z pliku binarnego.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych
Zapisywanie w pliku binarnym.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych

Zobacz też

• Encoding
• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Int16)

Źródło:

BinaryWriter.cs

Zapisuje dwubajtową liczbę całkowitą ze znakiem do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.

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)

Parametry

value

Int16

Liczba całkowita podpisana dwu bajtowo do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

BinaryWriter przechowuje ten typ danych w małym formacie endian.

W poniższej tabeli wymieniono przykłady innych typowych lub powiązanych zadań we/wy.

Aby wykonać tę czynność...	Zobacz przykład w tym temacie...
Utwórz plik tekstowy.	Instrukcje: Zapisywanie tekstu w pliku
Zapisywanie w pliku tekstowym.	Instrukcje: Zapisywanie tekstu w pliku
Odczyt z pliku tekstowego.	Instrukcje: Odczytywanie tekstu z pliku
Dołącz tekst do pliku.	Instrukcje: Otwieranie pliku dziennika i dołączanie do niego File.AppendText FileInfo.AppendText
Pobierz rozmiar pliku.	FileInfo.Length
Pobierz atrybuty pliku.	File.GetAttributes
Ustaw atrybuty pliku.	File.SetAttributes
Ustal, czy plik istnieje.	File.Exists
Odczyt z pliku binarnego.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych
Zapisywanie w pliku binarnym.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Half)

Źródło:

BinaryWriter.cs

Zapisuje wartość zmiennoprzecinkową dwubajtową do bieżącego strumienia i przesuwa położenie strumienia o dwa bajty.

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)

Parametry

value

Half

Wartość zmiennoprzecinkowa dwumiesiękowa do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

W poniższym przykładzie kodu pokazano, jak odczytywać i zapisywać Double dane w pamięci przy użyciu BinaryReader klas i BinaryWriter na szczycie MemoryStream klasy . MemoryStream tylko odczytuje i zapisuje Byte dane.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Double)

Źródło:

BinaryWriter.cs

Zapisuje wartość zmiennoprzecinkową ośmiobajtową do bieżącego strumienia i rozwija pozycję strumienia o osiem bajtów.

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)

Parametry

value

Double

Wartość zmiennoprzecinkowa ośmiu bajtów do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

W poniższym przykładzie kodu pokazano, jak odczytywać i zapisywać Double dane w pamięci przy użyciu BinaryReader klas i BinaryWriter na szczycie MemoryStream klasy . MemoryStream tylko odczytuje i zapisuje Byte dane.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Decimal)

Źródło:

BinaryWriter.cs

Zapisuje wartość dziesiętną do bieżącego strumienia i rozwija pozycję strumienia o szesnaście bajtów.

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)

Parametry

value

Decimal

Wartość dziesiętna do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Uwagi

W poniższej tabeli wymieniono przykłady innych typowych lub powiązanych zadań we/wy.

Aby wykonać tę czynność...	Zobacz przykład w tym temacie...
Utwórz plik tekstowy.	Instrukcje: Zapisywanie tekstu w pliku
Zapisywanie w pliku tekstowym.	Instrukcje: Zapisywanie tekstu w pliku
Odczyt z pliku tekstowego.	Instrukcje: Odczytywanie tekstu z pliku
Dołącz tekst do pliku.	Instrukcje: Otwieranie pliku dziennika i dołączanie do niego File.AppendText FileInfo.AppendText
Pobierz rozmiar pliku.	FileInfo.Length
Pobierz atrybuty pliku.	File.GetAttributes
Ustaw atrybuty pliku.	File.SetAttributes
Ustal, czy plik istnieje.	File.Exists
Odczyt z pliku binarnego.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych
Zapisywanie w pliku binarnym.	Instrukcje: Odczyt i zapis we właśnie utworzonym pliku danych

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Char)

Źródło:

BinaryWriter.cs

Zapisuje znak Unicode do bieżącego strumienia i rozwija bieżącą pozycję strumienia zgodnie z używanymi Encoding i określonymi znakami zapisywanymi w strumieniu.

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)

Parametry

ch

Char

Znak innego niż zastępczy, znak Unicode do zapisania.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

ArgumentException

ch jest pojedynczym znakiem zastępczym.

Przykłady

W poniższym przykładzie kodu pokazano, jak odczytywać i zapisywać dane przy użyciu pamięci jako magazynu zaplecza.

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

Uwagi

Ze względu na konflikty formatowania danych użycie tej metody z następującymi kodowaniami nie jest zalecane:

• UTF-7

• ISO-2022-JP

• ISCII

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Znaki zastępcze Unicode muszą być zapisywane razem jako pary w tym samym wywołaniu, a nie indywidualnie. Jeśli potrzebujesz obsługi par zastępczych w aplikacji, rozważ użycie tablicy znaków i Write przeciążenia metody.

Zobacz też

• Encoding
• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Byte[])

Źródło:

BinaryWriter.cs

Zapisuje tablicę bajtów do bazowego strumienia.

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

Parametry

buffer

Byte[]

Tablica bajtów zawierająca dane do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

ArgumentNullException

buffer to null.

Przykłady

Poniższy przykład kodu pokazuje, jak zapisywać dane binarne przy użyciu pamięci jako magazynu zaplecza, a następnie sprawdzić, czy dane zostały zapisane poprawnie.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Byte)

Źródło:

BinaryWriter.cs

Zapisuje niepodpisany bajt do bieżącego strumienia i rozwija pozycję strumienia według jednego bajtu.

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)

Parametry

value

Byte

Niepodpisany bajt do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu pokazuje, jak zapisywać dane binarne przy użyciu pamięci jako magazynu zaplecza, a następnie sprawdzić, czy dane zostały zapisane poprawnie.

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

Uwagi

Ze względu na konflikty formatowania danych użycie tej metody z następującymi kodowaniami nie jest zalecane:

• UTF-7

• ISO-2022-JP

• ISCII

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Boolean)

Źródło:

BinaryWriter.cs

Zapisuje wartość jedno bajtową Boolean do bieżącego strumienia z wartością 0 reprezentującą false i 1 reprezentującą truewartość .

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)

Parametry

value

Boolean

Wartość Boolean do zapisu (0 lub 1).

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu demonstruje sposób przechowywania i pobierania ustawień aplikacji w pliku.

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

Uwagi

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• Plik i Stream we/wy
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku

Write(Int32)

Źródło:

BinaryWriter.cs

Zapisuje czterobajtową liczbę całkowitą ze znakiem do bieżącego strumienia i przesuwa położenie strumienia o cztery bajty.

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)

Parametry

value

Int32

Liczba całkowita z podpisem czterech bajtów do zapisu.

Wyjątki

IOException

Wystąpi błąd We/Wy.

ObjectDisposedException

Strumień jest zamknięty.

Przykłady

Poniższy przykład kodu demonstruje sposób przechowywania i pobierania ustawień aplikacji w pliku.

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

Uwagi

BinaryWriter przechowuje ten typ danych w niewielkim formacie endianu.

Aby uzyskać listę typowych zadań we/wy, zobacz Typowe zadania we/wy.

Zobacz też

• We/wy plików i Stream
• Instrukcje: Odczytywanie tekstu z pliku
• Instrukcje: Zapisywanie tekstu w pliku