BinaryWriter.Write Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Writes a value to the current stream.
Overloads
Write(Char[], Int32, Int32) |
Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the |
Write(Byte[], Int32, Int32) |
Writes a region of a byte array to the current stream. |
Write(UInt64) |
Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes. |
Write(UInt32) |
Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes. |
Write(UInt16) |
Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes. |
Write(String) |
Writes a length-prefixed string to this stream in the current encoding of the BinaryWriter, and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream. |
Write(Single) |
Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes. |
Write(SByte) |
Writes a signed byte to the current stream and advances the stream position by one byte. |
Write(ReadOnlySpan<Char>) |
Writes a span of characters to the current stream, and advances the current position of the stream in accordance with the |
Write(ReadOnlySpan<Byte>) |
Writes a span of bytes to the current stream. |
Write(Int64) |
Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes. |
Write(Char[]) |
Writes a character array to the current stream and advances the current position of the stream in accordance with the |
Write(Int16) |
Writes a two-byte signed integer to the current stream and advances the stream position by two bytes. |
Write(Half) |
Writes a two-byte floating-point value to the current stream and advances the stream position by two bytes. |
Write(Double) |
Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes. |
Write(Decimal) |
Writes a decimal value to the current stream and advances the stream position by sixteen bytes. |
Write(Char) |
Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the |
Write(Byte[]) |
Writes a byte array to the underlying stream. |
Write(Byte) |
Writes an unsigned byte to the current stream and advances the stream position by one byte. |
Write(Boolean) |
Writes a one-byte |
Write(Int32) |
Writes a four-byte signed integer to the current stream and advances the stream position by four bytes. |
Write(Char[], Int32, Int32)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding
used and perhaps the specific characters being written to the stream.
public:
virtual void Write(cli::array <char> ^ chars, int index, int count);
public virtual void Write (char[] chars, int index, int count);
abstract member Write : char[] * int * int -> unit
override this.Write : char[] * int * int -> unit
Public Overridable Sub Write (chars As Char(), index As Integer, count As Integer)
Parameters
- chars
- Char[]
A character array containing the data to write.
- index
- Int32
The index of the first character to read from chars
and to write to the stream.
- count
- Int32
The number of characters to read from chars
and to write to the stream.
Exceptions
The buffer length minus index
is less than count
.
chars
is null
.
index
or count
is negative.
An I/O error occurs.
The stream is closed.
Examples
The following code example shows how to read and write data using memory as a backing store.
using namespace System;
using namespace System::IO;
int main()
{
array<Char>^invalidPathChars = Path::InvalidPathChars;
MemoryStream^ memStream = gcnew MemoryStream;
BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
// Write to memory.
binWriter->Write( "Invalid file path characters are: " );
binWriter->Write( Path::InvalidPathChars, 0, Path::InvalidPathChars->Length );
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader^ binReader = gcnew BinaryReader( memStream );
// Set Position to the beginning of the stream.
binReader->BaseStream->Position = 0;
// Read the data from memory and write it to the console.
Console::Write( binReader->ReadString() );
int arraySize = (int)(memStream->Length - memStream->Position);
array<Char>^memoryData = gcnew array<Char>(arraySize);
binReader->Read( memoryData, 0, arraySize );
Console::WriteLine( memoryData );
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
char[] invalidPathChars = Path.InvalidPathChars;
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// Write to memory.
binWriter.Write("Invalid file path characters are: ");
binWriter.Write(
Path.InvalidPathChars, 0, Path.InvalidPathChars.Length);
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader binReader = new BinaryReader(memStream);
// Set Position to the beginning of the stream.
memStream.Position = 0;
// Read the data from memory and write it to the console.
Console.Write(binReader.ReadString());
int arraySize = (int)(memStream.Length - memStream.Position);
char[] memoryData = new char[arraySize];
binReader.Read(memoryData, 0, arraySize);
Console.WriteLine(memoryData);
}
}
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
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Byte[], Int32, Int32)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a region of a byte array to the current stream.
public:
virtual void Write(cli::array <System::Byte> ^ buffer, int index, int count);
public virtual void Write (byte[] buffer, int index, int count);
abstract member Write : byte[] * int * int -> unit
override this.Write : byte[] * int * int -> unit
Public Overridable Sub Write (buffer As Byte(), index As Integer, count As Integer)
Parameters
- buffer
- Byte[]
A byte array containing the data to write.
- index
- Int32
The index of the first byte to read from buffer
and to write to the stream.
- count
- Int32
The number of bytes to read from buffer
and to write to the stream.
Exceptions
The buffer length minus index
is less than count
.
buffer
is null
.
index
or count
is negative.
An I/O error occurs.
The stream is closed.
Examples
The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.
using System;
using System.IO;
namespace BinaryRW
{
class Program
{
static void Main(string[] args)
{
const int arrayLength = 1000;
byte[] dataArray = new byte[arrayLength];
byte[] verifyArray = new byte[arrayLength];
new Random().NextBytes(dataArray);
using (BinaryWriter binWriter = new BinaryWriter(new MemoryStream()))
{
Console.WriteLine("Writing the data.");
binWriter.Write(dataArray, 0, arrayLength);
using (BinaryReader binReader = new BinaryReader(binWriter.BaseStream))
{
binReader.BaseStream.Position = 0;
if (binReader.Read(verifyArray, 0, arrayLength) != arrayLength)
{
Console.WriteLine("Error writing the data.");
return;
}
}
}
for (int i = 0; i < arrayLength; i++)
{
if (verifyArray[i] != dataArray[i])
{
Console.WriteLine("Error writing the data.");
return;
}
}
Console.WriteLine("The data was written and verified.");
}
}
}
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
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(UInt64)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Important
This API is not CLS-compliant.
Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes.
public:
virtual void Write(System::UInt64 value);
[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)
Parameters
- value
- UInt64
The eight-byte unsigned integer to write.
- Attributes
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(UInt32)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Important
This API is not CLS-compliant.
Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes.
public:
virtual void Write(System::UInt32 value);
[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)
Parameters
- value
- UInt32
The four-byte unsigned integer to write.
- Attributes
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(UInt16)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Important
This API is not CLS-compliant.
Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes.
public:
virtual void Write(System::UInt16 value);
[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)
Parameters
- value
- UInt16
The two-byte unsigned integer to write.
- Attributes
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(String)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a length-prefixed string to this stream in the current encoding of the BinaryWriter, and advances the current position of the stream in accordance with the encoding used and the specific characters being written to the stream.
public:
virtual void Write(System::String ^ value);
public virtual void Write (string value);
abstract member Write : string -> unit
override this.Write : string -> unit
Public Overridable Sub Write (value As String)
Parameters
- value
- String
The value to write.
Exceptions
An I/O error occurs.
value
is null
.
The stream is closed.
Examples
The following code example demonstrates how to store and retrieve application settings in a file.
using System;
using System.IO;
using System.Text;
class ConsoleApplication
{
const string fileName = "AppSettings.dat";
static void Main()
{
WriteDefaultValues();
DisplayValues();
}
public static void WriteDefaultValues()
{
using (var stream = File.Open(fileName, FileMode.Create))
{
using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
{
writer.Write(1.250F);
writer.Write(@"c:\Temp");
writer.Write(10);
writer.Write(true);
}
}
}
public static void DisplayValues()
{
float aspectRatio;
string tempDirectory;
int autoSaveTime;
bool showStatusBar;
if (File.Exists(fileName))
{
using (var stream = File.Open(fileName, FileMode.Open))
{
using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
{
aspectRatio = reader.ReadSingle();
tempDirectory = reader.ReadString();
autoSaveTime = reader.ReadInt32();
showStatusBar = reader.ReadBoolean();
}
}
Console.WriteLine("Aspect ratio set to: " + aspectRatio);
Console.WriteLine("Temp directory is: " + tempDirectory);
Console.WriteLine("Auto save time set to: " + autoSaveTime);
Console.WriteLine("Show status bar: " + showStatusBar);
}
}
}
open System.IO
open System.Text
let fileName = "AppSettings.dat"
let writeDefaultValues () =
use stream = File.Open(fileName, FileMode.Create)
use writer = new BinaryWriter(stream, Encoding.UTF8, false)
writer.Write 1.250F
writer.Write @"c:\Temp"
writer.Write 10
writer.Write true
let displayValues () =
if File.Exists fileName then
use stream = File.Open(fileName, FileMode.Open)
use reader = new BinaryReader(stream, Encoding.UTF8, false)
let aspectRatio = reader.ReadSingle()
let tempDirectory = reader.ReadString()
let autoSaveTime = reader.ReadInt32()
let showStatusBar = reader.ReadBoolean()
printfn $"Aspect ratio set to: {aspectRatio}"
printfn $"Temp directory is: {tempDirectory}"
printfn $"Auto save time set to: {autoSaveTime}"
printfn $"Show status bar: {showStatusBar}"
writeDefaultValues ()
displayValues ()
Imports System.IO
Module Module1
Const fileName As String = "AppSettings.dat"
Sub Main()
WriteDefaultValues()
DisplayValues()
End Sub
Sub WriteDefaultValues()
Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
writer.Write(1.25F)
writer.Write("c:\Temp")
writer.Write(10)
writer.Write(True)
End Using
End Sub
Sub DisplayValues()
Dim aspectRatio As Single
Dim tempDirectory As String
Dim autoSaveTime As Integer
Dim showStatusBar As Boolean
If (File.Exists(fileName)) Then
Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
aspectRatio = reader.ReadSingle()
tempDirectory = reader.ReadString()
autoSaveTime = reader.ReadInt32()
showStatusBar = reader.ReadBoolean()
End Using
Console.WriteLine("Aspect ratio set to: " & aspectRatio)
Console.WriteLine("Temp directory is: " & tempDirectory)
Console.WriteLine("Auto save time set to: " & autoSaveTime)
Console.WriteLine("Show status bar: " & showStatusBar)
End If
End Sub
End Module
Remarks
Length-prefixed means that this method first writes the length of the string, in bytes, when encoded with the BinaryWriter instance's current encoding to the stream. This value is written as an unsigned integer. This method then writes that many bytes to the stream.
For example, the string "A" has a length of 1, but when encoded with UTF-16; the length is 2 bytes, so the value written in the prefix is 2, and 3 bytes are written to the stream, including the prefix.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Single)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.
public:
virtual void Write(float value);
public virtual void Write (float value);
abstract member Write : single -> unit
override this.Write : single -> unit
Public Overridable Sub Write (value As Single)
Parameters
- value
- Single
The four-byte floating-point value to write.
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example demonstrates how to store and retrieve application settings in a file.
using System;
using System.IO;
using System.Text;
class ConsoleApplication
{
const string fileName = "AppSettings.dat";
static void Main()
{
WriteDefaultValues();
DisplayValues();
}
public static void WriteDefaultValues()
{
using (var stream = File.Open(fileName, FileMode.Create))
{
using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
{
writer.Write(1.250F);
writer.Write(@"c:\Temp");
writer.Write(10);
writer.Write(true);
}
}
}
public static void DisplayValues()
{
float aspectRatio;
string tempDirectory;
int autoSaveTime;
bool showStatusBar;
if (File.Exists(fileName))
{
using (var stream = File.Open(fileName, FileMode.Open))
{
using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
{
aspectRatio = reader.ReadSingle();
tempDirectory = reader.ReadString();
autoSaveTime = reader.ReadInt32();
showStatusBar = reader.ReadBoolean();
}
}
Console.WriteLine("Aspect ratio set to: " + aspectRatio);
Console.WriteLine("Temp directory is: " + tempDirectory);
Console.WriteLine("Auto save time set to: " + autoSaveTime);
Console.WriteLine("Show status bar: " + showStatusBar);
}
}
}
open System.IO
open System.Text
let fileName = "AppSettings.dat"
let writeDefaultValues () =
use stream = File.Open(fileName, FileMode.Create)
use writer = new BinaryWriter(stream, Encoding.UTF8, false)
writer.Write 1.250F
writer.Write @"c:\Temp"
writer.Write 10
writer.Write true
let displayValues () =
if File.Exists fileName then
use stream = File.Open(fileName, FileMode.Open)
use reader = new BinaryReader(stream, Encoding.UTF8, false)
let aspectRatio = reader.ReadSingle()
let tempDirectory = reader.ReadString()
let autoSaveTime = reader.ReadInt32()
let showStatusBar = reader.ReadBoolean()
printfn $"Aspect ratio set to: {aspectRatio}"
printfn $"Temp directory is: {tempDirectory}"
printfn $"Auto save time set to: {autoSaveTime}"
printfn $"Show status bar: {showStatusBar}"
writeDefaultValues ()
displayValues ()
Imports System.IO
Module Module1
Const fileName As String = "AppSettings.dat"
Sub Main()
WriteDefaultValues()
DisplayValues()
End Sub
Sub WriteDefaultValues()
Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
writer.Write(1.25F)
writer.Write("c:\Temp")
writer.Write(10)
writer.Write(True)
End Using
End Sub
Sub DisplayValues()
Dim aspectRatio As Single
Dim tempDirectory As String
Dim autoSaveTime As Integer
Dim showStatusBar As Boolean
If (File.Exists(fileName)) Then
Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
aspectRatio = reader.ReadSingle()
tempDirectory = reader.ReadString()
autoSaveTime = reader.ReadInt32()
showStatusBar = reader.ReadBoolean()
End Using
Console.WriteLine("Aspect ratio set to: " & aspectRatio)
Console.WriteLine("Temp directory is: " & tempDirectory)
Console.WriteLine("Auto save time set to: " & autoSaveTime)
Console.WriteLine("Show status bar: " & showStatusBar)
End If
End Sub
End Module
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(SByte)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Important
This API is not CLS-compliant.
Writes a signed byte to the current stream and advances the stream position by one 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)
Parameters
- value
- SByte
The signed byte to write.
- Attributes
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(ReadOnlySpan<Char>)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a span of characters to the current stream, and advances the current position of the stream in accordance with the Encoding
used and perhaps the specific characters being written to the stream.
public:
virtual void Write(ReadOnlySpan<char> chars);
public virtual void Write (ReadOnlySpan<char> chars);
abstract member Write : ReadOnlySpan<char> -> unit
override this.Write : ReadOnlySpan<char> -> unit
Public Overridable Sub Write (chars As ReadOnlySpan(Of Char))
Parameters
- chars
- ReadOnlySpan<Char>
A span of chars to write.
Applies to
Write(ReadOnlySpan<Byte>)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a span of bytes to the current stream.
public:
virtual void Write(ReadOnlySpan<System::Byte> buffer);
public virtual void Write (ReadOnlySpan<byte> buffer);
abstract member Write : ReadOnlySpan<byte> -> unit
override this.Write : ReadOnlySpan<byte> -> unit
Public Overridable Sub Write (buffer As ReadOnlySpan(Of Byte))
Parameters
- buffer
- ReadOnlySpan<Byte>
The span of bytes to write.
Applies to
Write(Int64)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes.
public:
virtual void Write(long value);
public virtual void Write (long value);
abstract member Write : int64 -> unit
override this.Write : int64 -> unit
Public Overridable Sub Write (value As Long)
Parameters
- value
- Int64
The eight-byte signed integer to write.
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Char[])
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding
used and the specific characters being written to the stream.
public:
virtual void Write(cli::array <char> ^ chars);
public virtual void Write (char[] chars);
abstract member Write : char[] -> unit
override this.Write : char[] -> unit
Public Overridable Sub Write (chars As Char())
Parameters
- chars
- Char[]
A character array containing the data to write.
Exceptions
chars
is null
.
The stream is closed.
An I/O error occurs.
Examples
The following code example shows how to read and write data using memory as a backing store.
using namespace System;
using namespace System::IO;
int main()
{
array<Char>^invalidPathChars = Path::InvalidPathChars;
MemoryStream^ memStream = gcnew MemoryStream;
BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
// Write to memory.
binWriter->Write( "Invalid file path characters are: " );
binWriter->Write( Path::InvalidPathChars );
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader^ binReader = gcnew BinaryReader( memStream );
// Set Position to the beginning of the stream.
binReader->BaseStream->Position = 0;
// Read the data from memory and write it to the console.
Console::Write( binReader->ReadString() );
Console::WriteLine( binReader->ReadChars( (int)(memStream->Length - memStream->Position) ) );
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
char[] invalidPathChars = Path.InvalidPathChars;
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// Write to memory.
binWriter.Write("Invalid file path characters are: ");
binWriter.Write(Path.InvalidPathChars);
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader binReader = new BinaryReader(memStream);
// Set Position to the beginning of the stream.
memStream.Position = 0;
// Read the data from memory and write it to the console.
Console.Write(binReader.ReadString());
Console.WriteLine(binReader.ReadChars(
(int)(memStream.Length - memStream.Position)));
}
}
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
Remarks
The following table lists examples of other typical or related I/O tasks.
To do this... | See the example in this topic... |
---|---|
Create a text file. | How to: Write Text to a File |
Write to a text file. | How to: Write Text to a File |
Read from a text file. | How to: Read Text from a File |
Append text to a file. | How to: Open and Append to a Log File File.AppendText FileInfo.AppendText |
Get the size of a file. | FileInfo.Length |
Get the attributes of a file. | File.GetAttributes |
Set the attributes of a file. | File.SetAttributes |
Determine if a file exists. | File.Exists |
Read from a binary file. | How to: Read and Write to a Newly Created Data File |
Write to a binary file. | How to: Read and Write to a Newly Created Data File |
See also
Applies to
Write(Int16)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a two-byte signed integer to the current stream and advances the stream position by two bytes.
public:
virtual void Write(short value);
public virtual void Write (short value);
abstract member Write : int16 -> unit
override this.Write : int16 -> unit
Public Overridable Sub Write (value As Short)
Parameters
- value
- Int16
The two-byte signed integer to write.
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
BinaryWriter
stores this data type in little endian format.
The following table lists examples of other typical or related I/O tasks.
To do this... | See the example in this topic... |
---|---|
Create a text file. | How to: Write Text to a File |
Write to a text file. | How to: Write Text to a File |
Read from a text file. | How to: Read Text from a File |
Append text to a file. | How to: Open and Append to a Log File File.AppendText FileInfo.AppendText |
Get the size of a file. | FileInfo.Length |
Get the attributes of a file. | File.GetAttributes |
Set the attributes of a file. | File.SetAttributes |
Determine if a file exists. | File.Exists |
Read from a binary file. | How to: Read and Write to a Newly Created Data File |
Write to a binary file. | How to: Read and Write to a Newly Created Data File |
See also
Applies to
Write(Half)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a two-byte floating-point value to the current stream and advances the stream position by two 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)
Parameters
- value
- Half
The two-byte floating-point value to write.
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example shows how to read and write Double
data to memory by using the BinaryReader and BinaryWriter
classes on top of the MemoryStream class. MemoryStream
only reads and writes Byte
data.
using namespace System;
using namespace System::IO;
int main()
{
int i;
const int arrayLength = 1000;
// Create random data to write to the stream.
array<double>^dataArray = gcnew array<double>(arrayLength);
Random^ randomGenerator = gcnew Random;
for ( i = 0; i < arrayLength; i++ )
{
dataArray[ i ] = 100.1 * randomGenerator->NextDouble();
}
BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
try
{
// Write data to the stream.
Console::WriteLine( "Writing data to the stream." );
i = 0;
for ( i = 0; i < arrayLength; i++ )
{
binWriter->Write( dataArray[ i ] );
}
// Create a reader using the stream from the writer.
BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
// Return to the beginning of the stream.
binReader->BaseStream->Position = 0;
try
{
// Read and verify the data.
i = 0;
Console::WriteLine( "Verifying the written data." );
for ( i = 0; i < arrayLength; i++ )
{
if ( binReader->ReadDouble() != dataArray[ i ] )
{
Console::WriteLine( "Error writing data." );
break;
}
}
Console::WriteLine( "The data was written and verified." );
}
catch ( EndOfStreamException^ e )
{
Console::WriteLine( "Error writing data: {0}.", e->GetType()->Name );
}
}
finally
{
binWriter->Close();
}
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
int i;
const int arrayLength = 1000;
// Create random data to write to the stream.
Random randomGenerator = new Random();
double[] dataArray = new double[arrayLength];
for(i = 0; i < arrayLength; i++)
{
dataArray[i] = 100.1 * randomGenerator.NextDouble();
}
using(BinaryWriter binWriter =
new BinaryWriter(new MemoryStream()))
{
// Write the data to the stream.
Console.WriteLine("Writing data to the stream.");
for(i = 0; i < arrayLength; i++)
{
binWriter.Write(dataArray[i]);
}
// Create a reader using the stream from the writer.
using(BinaryReader binReader =
new BinaryReader(binWriter.BaseStream))
{
try
{
// Return to the beginning of the stream.
binReader.BaseStream.Position = 0;
// Read and verify the data.
Console.WriteLine("Verifying the written data.");
for(i = 0; i < arrayLength; i++)
{
if(binReader.ReadDouble() != dataArray[i])
{
Console.WriteLine("Error writing data.");
break;
}
}
Console.WriteLine("The data was written " +
"and verified.");
}
catch(EndOfStreamException e)
{
Console.WriteLine("Error writing data: {0}.",
e.GetType().Name);
}
}
}
}
}
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
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Double)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes.
public:
virtual void Write(double value);
public virtual void Write (double value);
abstract member Write : double -> unit
override this.Write : double -> unit
Public Overridable Sub Write (value As Double)
Parameters
- value
- Double
The eight-byte floating-point value to write.
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example shows how to read and write Double
data to memory by using the BinaryReader and BinaryWriter
classes on top of the MemoryStream class. MemoryStream
only reads and writes Byte
data.
using namespace System;
using namespace System::IO;
int main()
{
int i;
const int arrayLength = 1000;
// Create random data to write to the stream.
array<double>^dataArray = gcnew array<double>(arrayLength);
Random^ randomGenerator = gcnew Random;
for ( i = 0; i < arrayLength; i++ )
{
dataArray[ i ] = 100.1 * randomGenerator->NextDouble();
}
BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
try
{
// Write data to the stream.
Console::WriteLine( "Writing data to the stream." );
i = 0;
for ( i = 0; i < arrayLength; i++ )
{
binWriter->Write( dataArray[ i ] );
}
// Create a reader using the stream from the writer.
BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
// Return to the beginning of the stream.
binReader->BaseStream->Position = 0;
try
{
// Read and verify the data.
i = 0;
Console::WriteLine( "Verifying the written data." );
for ( i = 0; i < arrayLength; i++ )
{
if ( binReader->ReadDouble() != dataArray[ i ] )
{
Console::WriteLine( "Error writing data." );
break;
}
}
Console::WriteLine( "The data was written and verified." );
}
catch ( EndOfStreamException^ e )
{
Console::WriteLine( "Error writing data: {0}.", e->GetType()->Name );
}
}
finally
{
binWriter->Close();
}
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
int i;
const int arrayLength = 1000;
// Create random data to write to the stream.
Random randomGenerator = new Random();
double[] dataArray = new double[arrayLength];
for(i = 0; i < arrayLength; i++)
{
dataArray[i] = 100.1 * randomGenerator.NextDouble();
}
using(BinaryWriter binWriter =
new BinaryWriter(new MemoryStream()))
{
// Write the data to the stream.
Console.WriteLine("Writing data to the stream.");
for(i = 0; i < arrayLength; i++)
{
binWriter.Write(dataArray[i]);
}
// Create a reader using the stream from the writer.
using(BinaryReader binReader =
new BinaryReader(binWriter.BaseStream))
{
try
{
// Return to the beginning of the stream.
binReader.BaseStream.Position = 0;
// Read and verify the data.
Console.WriteLine("Verifying the written data.");
for(i = 0; i < arrayLength; i++)
{
if(binReader.ReadDouble() != dataArray[i])
{
Console.WriteLine("Error writing data.");
break;
}
}
Console.WriteLine("The data was written " +
"and verified.");
}
catch(EndOfStreamException e)
{
Console.WriteLine("Error writing data: {0}.",
e.GetType().Name);
}
}
}
}
}
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
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Decimal)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a decimal value to the current stream and advances the stream position by sixteen bytes.
public:
virtual void Write(System::Decimal value);
public virtual void Write (decimal value);
abstract member Write : decimal -> unit
override this.Write : decimal -> unit
Public Overridable Sub Write (value As Decimal)
Parameters
- value
- Decimal
The decimal value to write.
Exceptions
An I/O error occurs.
The stream is closed.
Remarks
The following table lists examples of other typical or related I/O tasks.
To do this... | See the example in this topic... |
---|---|
Create a text file. | How to: Write Text to a File |
Write to a text file. | How to: Write Text to a File |
Read from a text file. | How to: Read Text from a File |
Append text to a file. | How to: Open and Append to a Log File File.AppendText FileInfo.AppendText |
Get the size of a file. | FileInfo.Length |
Get the attributes of a file. | File.GetAttributes |
Set the attributes of a file. | File.SetAttributes |
Determine if a file exists. | File.Exists |
Read from a binary file. | How to: Read and Write to a Newly Created Data File |
Write to a binary file. | How to: Read and Write to a Newly Created Data File |
See also
Applies to
Write(Char)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding
used and the specific characters being written to the stream.
public:
virtual void Write(char ch);
public virtual void Write (char ch);
abstract member Write : char -> unit
override this.Write : char -> unit
Public Overridable Sub Write (ch As Char)
Parameters
- ch
- Char
The non-surrogate, Unicode character to write.
Exceptions
An I/O error occurs.
The stream is closed.
ch
is a single surrogate character.
Examples
The following code example shows how to read and write data using memory as a backing store.
using namespace System;
using namespace System::IO;
int main()
{
int i;
array<Char>^invalidPathChars = Path::InvalidPathChars;
MemoryStream^ memStream = gcnew MemoryStream;
BinaryWriter^ binWriter = gcnew BinaryWriter( memStream );
// Write to memory.
binWriter->Write( "Invalid file path characters are: " );
for ( i = 0; i < invalidPathChars->Length; i++ )
{
binWriter->Write( invalidPathChars[ i ] );
}
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader^ binReader = gcnew BinaryReader( memStream );
// Set Position to the beginning of the stream.
binReader->BaseStream->Position = 0;
// Read the data from memory and write it to the console.
Console::Write( binReader->ReadString() );
array<Char>^memoryData = gcnew array<Char>(memStream->Length - memStream->Position);
for ( i = 0; i < memoryData->Length; i++ )
{
memoryData[ i ] = binReader->ReadChar();
}
Console::WriteLine( memoryData );
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
int i = 0;
char[] invalidPathChars = Path.InvalidPathChars;
MemoryStream memStream = new MemoryStream();
BinaryWriter binWriter = new BinaryWriter(memStream);
// Write to memory.
binWriter.Write("Invalid file path characters are: ");
for(i = 0; i < invalidPathChars.Length; i++)
{
binWriter.Write(invalidPathChars[i]);
}
// Create the reader using the same MemoryStream
// as used with the writer.
BinaryReader binReader = new BinaryReader(memStream);
// Set Position to the beginning of the stream.
memStream.Position = 0;
// Read the data from memory and write it to the console.
Console.Write(binReader.ReadString());
char[] memoryData =
new char[memStream.Length - memStream.Position];
for(i = 0; i < memoryData.Length; i++)
{
memoryData[i] = binReader.ReadChar();
}
Console.WriteLine(memoryData);
}
}
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
Remarks
Because of data formatting conflicts, using this method with the following encodings is not recommended:
UTF-7
ISO-2022-JP
ISCII
For a list of common I/O tasks, see Common I/O Tasks.
Unicode surrogate characters must be written out as pairs together in the same call, not individually. If you require support for surrogate pairs in your application, consider using a character array and the Write method overload.
See also
Applies to
Write(Byte[])
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a byte array to the underlying stream.
public:
virtual void Write(cli::array <System::Byte> ^ buffer);
public virtual void Write (byte[] buffer);
abstract member Write : byte[] -> unit
override this.Write : byte[] -> unit
Public Overridable Sub Write (buffer As Byte())
Parameters
- buffer
- Byte[]
A byte array containing the data to write.
Exceptions
An I/O error occurs.
The stream is closed.
buffer
is null
.
Examples
The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.
using namespace System;
using namespace System::IO;
int main()
{
const int arrayLength = 1000;
// Create random data to write to the stream.
array<Byte>^dataArray = gcnew array<Byte>(arrayLength);
(gcnew Random)->NextBytes( dataArray );
BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
// Write the data to the stream.
Console::WriteLine( "Writing the data." );
binWriter->Write( dataArray );
// Create the reader using the stream from the writer.
BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
// Set the stream position to the beginning of the stream.
binReader->BaseStream->Position = 0;
// Read and verify the data.
array<Byte>^verifyArray = binReader->ReadBytes( arrayLength );
if ( verifyArray->Length != arrayLength )
{
Console::WriteLine( "Error writing the data." );
return -1;
}
for ( int i = 0; i < arrayLength; i++ )
{
if ( verifyArray[ i ] != dataArray[ i ] )
{
Console::WriteLine( "Error writing the data." );
return -1;
}
}
Console::WriteLine( "The data was written and verified." );
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
const int arrayLength = 1000;
// Create random data to write to the stream.
byte[] dataArray = new byte[arrayLength];
new Random().NextBytes(dataArray);
BinaryWriter binWriter = new BinaryWriter(new MemoryStream());
// Write the data to the stream.
Console.WriteLine("Writing the data.");
binWriter.Write(dataArray);
// Create the reader using the stream from the writer.
BinaryReader binReader =
new BinaryReader(binWriter.BaseStream);
// Set Position to the beginning of the stream.
binReader.BaseStream.Position = 0;
// Read and verify the data.
byte[] verifyArray = binReader.ReadBytes(arrayLength);
if(verifyArray.Length != arrayLength)
{
Console.WriteLine("Error writing the data.");
return;
}
for(int i = 0; i < arrayLength; i++)
{
if(verifyArray[i] != dataArray[i])
{
Console.WriteLine("Error writing the data.");
return;
}
}
Console.WriteLine("The data was written and verified.");
}
}
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
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Byte)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes an unsigned byte to the current stream and advances the stream position by one byte.
public:
virtual void Write(System::Byte value);
public virtual void Write (byte value);
abstract member Write : byte -> unit
override this.Write : byte -> unit
Public Overridable Sub Write (value As Byte)
Parameters
- value
- Byte
The unsigned byte to write.
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.
using namespace System;
using namespace System::IO;
int main()
{
int i = 0;
// Create random data to write to the stream.
array<Byte>^writeArray = gcnew array<Byte>(1000);
(gcnew Random)->NextBytes( writeArray );
BinaryWriter^ binWriter = gcnew BinaryWriter( gcnew MemoryStream );
BinaryReader^ binReader = gcnew BinaryReader( binWriter->BaseStream );
try
{
// Write the data to the stream.
Console::WriteLine( "Writing the data." );
for ( i = 0; i < writeArray->Length; i++ )
{
binWriter->Write( writeArray[ i ] );
}
// Set the stream position to the beginning of the stream.
binReader->BaseStream->Position = 0;
// Read and verify the data from the stream.
for ( i = 0; i < writeArray->Length; i++ )
{
if ( binReader->ReadByte() != writeArray[ i ] )
{
Console::WriteLine( "Error writing the data." );
return -1;
}
}
Console::WriteLine( "The data was written and verified." );
}
// Catch the EndOfStreamException and write an error message.
catch ( EndOfStreamException^ e )
{
Console::WriteLine( "Error writing the data.\n{0}", e->GetType()->Name );
}
}
using System;
using System.IO;
class BinaryRW
{
static void Main()
{
int i = 0;
// Create random data to write to the stream.
byte[] writeArray = new byte[1000];
new Random().NextBytes(writeArray);
BinaryWriter binWriter = new BinaryWriter(new MemoryStream());
BinaryReader binReader =
new BinaryReader(binWriter.BaseStream);
try
{
// Write the data to the stream.
Console.WriteLine("Writing the data.");
for(i = 0; i < writeArray.Length; i++)
{
binWriter.Write(writeArray[i]);
}
// Set the stream position to the beginning of the stream.
binReader.BaseStream.Position = 0;
// Read and verify the data from the stream.
for(i = 0; i < writeArray.Length; i++)
{
if(binReader.ReadByte() != writeArray[i])
{
Console.WriteLine("Error writing the data.");
return;
}
}
Console.WriteLine("The data was written and verified.");
}
// Catch the EndOfStreamException and write an error message.
catch(EndOfStreamException e)
{
Console.WriteLine("Error writing the data.\n{0}",
e.GetType().Name);
}
}
}
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
Remarks
Because of data formatting conflicts, using this method with the following encodings is not recommended:
UTF-7
ISO-2022-JP
ISCII
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Boolean)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a one-byte Boolean
value to the current stream, with 0 representing false
and 1 representing true
.
public:
virtual void Write(bool value);
public virtual void Write (bool value);
abstract member Write : bool -> unit
override this.Write : bool -> unit
Public Overridable Sub Write (value As Boolean)
Parameters
- value
- Boolean
The Boolean
value to write (0 or 1).
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example demonstrates how to store and retrieve application settings in a file.
using System;
using System.IO;
using System.Text;
class ConsoleApplication
{
const string fileName = "AppSettings.dat";
static void Main()
{
WriteDefaultValues();
DisplayValues();
}
public static void WriteDefaultValues()
{
using (var stream = File.Open(fileName, FileMode.Create))
{
using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
{
writer.Write(1.250F);
writer.Write(@"c:\Temp");
writer.Write(10);
writer.Write(true);
}
}
}
public static void DisplayValues()
{
float aspectRatio;
string tempDirectory;
int autoSaveTime;
bool showStatusBar;
if (File.Exists(fileName))
{
using (var stream = File.Open(fileName, FileMode.Open))
{
using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
{
aspectRatio = reader.ReadSingle();
tempDirectory = reader.ReadString();
autoSaveTime = reader.ReadInt32();
showStatusBar = reader.ReadBoolean();
}
}
Console.WriteLine("Aspect ratio set to: " + aspectRatio);
Console.WriteLine("Temp directory is: " + tempDirectory);
Console.WriteLine("Auto save time set to: " + autoSaveTime);
Console.WriteLine("Show status bar: " + showStatusBar);
}
}
}
open System.IO
open System.Text
let fileName = "AppSettings.dat"
let writeDefaultValues () =
use stream = File.Open(fileName, FileMode.Create)
use writer = new BinaryWriter(stream, Encoding.UTF8, false)
writer.Write 1.250F
writer.Write @"c:\Temp"
writer.Write 10
writer.Write true
let displayValues () =
if File.Exists fileName then
use stream = File.Open(fileName, FileMode.Open)
use reader = new BinaryReader(stream, Encoding.UTF8, false)
let aspectRatio = reader.ReadSingle()
let tempDirectory = reader.ReadString()
let autoSaveTime = reader.ReadInt32()
let showStatusBar = reader.ReadBoolean()
printfn $"Aspect ratio set to: {aspectRatio}"
printfn $"Temp directory is: {tempDirectory}"
printfn $"Auto save time set to: {autoSaveTime}"
printfn $"Show status bar: {showStatusBar}"
writeDefaultValues ()
displayValues ()
Imports System.IO
Module Module1
Const fileName As String = "AppSettings.dat"
Sub Main()
WriteDefaultValues()
DisplayValues()
End Sub
Sub WriteDefaultValues()
Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
writer.Write(1.25F)
writer.Write("c:\Temp")
writer.Write(10)
writer.Write(True)
End Using
End Sub
Sub DisplayValues()
Dim aspectRatio As Single
Dim tempDirectory As String
Dim autoSaveTime As Integer
Dim showStatusBar As Boolean
If (File.Exists(fileName)) Then
Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
aspectRatio = reader.ReadSingle()
tempDirectory = reader.ReadString()
autoSaveTime = reader.ReadInt32()
showStatusBar = reader.ReadBoolean()
End Using
Console.WriteLine("Aspect ratio set to: " & aspectRatio)
Console.WriteLine("Temp directory is: " & tempDirectory)
Console.WriteLine("Auto save time set to: " & autoSaveTime)
Console.WriteLine("Show status bar: " & showStatusBar)
End If
End Sub
End Module
Remarks
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Write(Int32)
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
- Source:
- BinaryWriter.cs
Writes a four-byte signed integer to the current stream and advances the stream position by four bytes.
public:
virtual void Write(int value);
public virtual void Write (int value);
abstract member Write : int -> unit
override this.Write : int -> unit
Public Overridable Sub Write (value As Integer)
Parameters
- value
- Int32
The four-byte signed integer to write.
Exceptions
An I/O error occurs.
The stream is closed.
Examples
The following code example demonstrates how to store and retrieve application settings in a file.
using System;
using System.IO;
using System.Text;
class ConsoleApplication
{
const string fileName = "AppSettings.dat";
static void Main()
{
WriteDefaultValues();
DisplayValues();
}
public static void WriteDefaultValues()
{
using (var stream = File.Open(fileName, FileMode.Create))
{
using (var writer = new BinaryWriter(stream, Encoding.UTF8, false))
{
writer.Write(1.250F);
writer.Write(@"c:\Temp");
writer.Write(10);
writer.Write(true);
}
}
}
public static void DisplayValues()
{
float aspectRatio;
string tempDirectory;
int autoSaveTime;
bool showStatusBar;
if (File.Exists(fileName))
{
using (var stream = File.Open(fileName, FileMode.Open))
{
using (var reader = new BinaryReader(stream, Encoding.UTF8, false))
{
aspectRatio = reader.ReadSingle();
tempDirectory = reader.ReadString();
autoSaveTime = reader.ReadInt32();
showStatusBar = reader.ReadBoolean();
}
}
Console.WriteLine("Aspect ratio set to: " + aspectRatio);
Console.WriteLine("Temp directory is: " + tempDirectory);
Console.WriteLine("Auto save time set to: " + autoSaveTime);
Console.WriteLine("Show status bar: " + showStatusBar);
}
}
}
open System.IO
open System.Text
let fileName = "AppSettings.dat"
let writeDefaultValues () =
use stream = File.Open(fileName, FileMode.Create)
use writer = new BinaryWriter(stream, Encoding.UTF8, false)
writer.Write 1.250F
writer.Write @"c:\Temp"
writer.Write 10
writer.Write true
let displayValues () =
if File.Exists fileName then
use stream = File.Open(fileName, FileMode.Open)
use reader = new BinaryReader(stream, Encoding.UTF8, false)
let aspectRatio = reader.ReadSingle()
let tempDirectory = reader.ReadString()
let autoSaveTime = reader.ReadInt32()
let showStatusBar = reader.ReadBoolean()
printfn $"Aspect ratio set to: {aspectRatio}"
printfn $"Temp directory is: {tempDirectory}"
printfn $"Auto save time set to: {autoSaveTime}"
printfn $"Show status bar: {showStatusBar}"
writeDefaultValues ()
displayValues ()
Imports System.IO
Module Module1
Const fileName As String = "AppSettings.dat"
Sub Main()
WriteDefaultValues()
DisplayValues()
End Sub
Sub WriteDefaultValues()
Using writer As BinaryWriter = New BinaryWriter(File.Open(fileName, FileMode.Create))
writer.Write(1.25F)
writer.Write("c:\Temp")
writer.Write(10)
writer.Write(True)
End Using
End Sub
Sub DisplayValues()
Dim aspectRatio As Single
Dim tempDirectory As String
Dim autoSaveTime As Integer
Dim showStatusBar As Boolean
If (File.Exists(fileName)) Then
Using reader As BinaryReader = New BinaryReader(File.Open(fileName, FileMode.Open))
aspectRatio = reader.ReadSingle()
tempDirectory = reader.ReadString()
autoSaveTime = reader.ReadInt32()
showStatusBar = reader.ReadBoolean()
End Using
Console.WriteLine("Aspect ratio set to: " & aspectRatio)
Console.WriteLine("Temp directory is: " & tempDirectory)
Console.WriteLine("Auto save time set to: " & autoSaveTime)
Console.WriteLine("Show status bar: " & showStatusBar)
End If
End Sub
End Module
Remarks
BinaryWriter
stores this data type in little endian format.
For a list of common I/O tasks, see Common I/O Tasks.
See also
Applies to
Atsauksmes
https://aka.ms/ContentUserFeedback.
Drīzumā: 2024. gada laikā mēs pakāpeniski pārtrauksim izmantot “GitHub problēmas” kā atsauksmju par saturu mehānismu un aizstāsim to ar jaunu atsauksmju sistēmu. Papildinformāciju skatiet:Iesniegt un skatīt atsauksmes par