BinaryWriter.Write BinaryWriter.Write BinaryWriter.Write BinaryWriter.Write Method

정의

현재 스트림에 값을 씁니다.Writes a value to the current stream.

오버로드

Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32)

현재 스트림에 바이트 배열 영역을 씁니다.Writes a region of a byte array to the current stream.

Write(UInt64) Write(UInt64) Write(UInt64) Write(UInt64)

8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.Writes an eight-byte unsigned integer to the current stream and advances the stream position by eight bytes.

Write(UInt32) Write(UInt32) Write(UInt32) Write(UInt32)

4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.Writes a four-byte unsigned integer to the current stream and advances the stream position by four bytes.

Write(UInt16) Write(UInt16) Write(UInt16) Write(UInt16)

2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다.Writes a two-byte unsigned integer to the current stream and advances the stream position by two bytes.

Write(String) Write(String) Write(String) Write(String)

BinaryWriter의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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) Write(Single) Write(Single) Write(Single)

4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.Writes a four-byte floating-point value to the current stream and advances the stream position by four bytes.

Write(SByte) Write(SByte) Write(SByte) Write(SByte)

부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다.Writes a signed byte to the current stream and advances the stream position by one byte.

Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>)

문자 범위를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.Writes a span of characters to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>)

현재 스트림에 바이트 범위를 씁니다.Writes a span of bytes to the current stream.

Write(Int64) Write(Int64) Write(Int64) Write(Int64)

8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.Writes an eight-byte signed integer to the current stream and advances the stream position by eight bytes.

Write(Char) Write(Char) Write(Char) Write(Char)

유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.Writes a Unicode character to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

Write(Int16) Write(Int16) Write(Int16) Write(Int16)

2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다.Writes a two-byte signed integer to the current stream and advances the stream position by two bytes.

Write(Double) Write(Double) Write(Double) Write(Double)

8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.Writes an eight-byte floating-point value to the current stream and advances the stream position by eight bytes.

Write(Decimal) Write(Decimal) Write(Decimal) Write(Decimal)

10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다.Writes a decimal value to the current stream and advances the stream position by sixteen bytes.

Write(Char[]) Write(Char[]) Write(Char[]) Write(Char[])

문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.Writes a character array to the current stream and advances the current position of the stream in accordance with the Encoding used and the specific characters being written to the stream.

Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32)

문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.Writes a section of a character array to the current stream, and advances the current position of the stream in accordance with the Encoding used and perhaps the specific characters being written to the stream.

Write(Byte[]) Write(Byte[]) Write(Byte[]) Write(Byte[])

내부 스트림에 바이트 배열을 씁니다.Writes a byte array to the underlying stream.

Write(Byte) Write(Byte) Write(Byte) Write(Byte)

부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다.Writes an unsigned byte to the current stream and advances the stream position by one byte.

Write(Boolean) Write(Boolean) Write(Boolean) Write(Boolean)

Boolean를 나타내는 0과 false를 나타내는 1을 사용하여 1바이트 true 값을 현재 스트림에 씁니다.Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true.

Write(Int32) Write(Int32) Write(Int32) Write(Int32)

4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.Writes a four-byte signed integer to the current stream and advances the stream position by four bytes.

Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32)

현재 스트림에 바이트 배열 영역을 씁니다.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)

매개 변수

buffer
Byte[]

쓸 데이터를 포함하는 바이트 배열입니다.A byte array containing the data to write.

index
Int32 Int32 Int32 Int32

buffer에서 읽고 스트림에 쓸 첫 번째 바이트의 인덱스입니다.The index of the first byte to read from buffer and to write to the stream.

count
Int32 Int32 Int32 Int32

buffer에서 읽고 스트림에 쓸 바이트 수입니다.The number of bytes to read from buffer and to write to the stream.

예외

버퍼 길이에서 index를 빼면 count보다 작습니다.The buffer length minus index is less than count.

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 이진 데이터를 쓰고 다음 데이터 쓰여졌는지 확인 하는 방법을 보여 줍니다.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

using System;
using System.IO;

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

            new Random().NextBytes(dataArray);

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

                using (BinaryReader binReader = new BinaryReader(binWriter.BaseStream))
                {
                    binReader.BaseStream.Position = 0;
                    
                    if (binReader.Read(verifyArray, 0, arrayLength) != arrayLength)
                    {
                        Console.WriteLine("Error writing the data.");
                        return;
                    }
                }
            }

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

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

Module Module1

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

        Dim randomGenerator As New Random
        randomGenerator.NextBytes(dataArray)

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

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

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

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

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

End Module

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(UInt64) Write(UInt64) Write(UInt64) Write(UInt64)

중요

이 API는 CLS 규격이 아닙니다.

8바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.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);
abstract member Write : uint64 -> unit
override this.Write : uint64 -> unit
Public Overridable Sub Write (value As ULong)

매개 변수

value
UInt64 UInt64 UInt64 UInt64

쓸 8바이트 부호 없는 정수입니다.The eight-byte unsigned integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(UInt32) Write(UInt32) Write(UInt32) Write(UInt32)

중요

이 API는 CLS 규격이 아닙니다.

4바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.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);
abstract member Write : uint32 -> unit
override this.Write : uint32 -> unit
Public Overridable Sub Write (value As UInteger)

매개 변수

value
UInt32 UInt32 UInt32 UInt32

쓸 4바이트 부호 없는 정수입니다.The four-byte unsigned integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(UInt16) Write(UInt16) Write(UInt16) Write(UInt16)

중요

이 API는 CLS 규격이 아닙니다.

2바이트 부호 없는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다.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);
abstract member Write : uint16 -> unit
override this.Write : uint16 -> unit
Public Overridable Sub Write (value As UShort)

매개 변수

value
UInt16 UInt16 UInt16 UInt16

쓸 2바이트 부호 없는 정수입니다.The two-byte unsigned integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(String) Write(String) Write(String) Write(String)

BinaryWriter의 현재 인코딩으로 된 이 스트림에 문자열의 길이가 맨 앞에 나오는 문자열을 쓴 다음 사용된 인코딩과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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)

매개 변수

value
String String String String

작성할 값입니다.The value to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 저장 하 고 파일에서 애플리케이션 설정을 검색 하는 방법을 보여 줍니다.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

        If (File.Exists(fileName)) Then

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

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

End Module

설명

이 메서드가 먼저 쓰도록 문자열의 길이 (바이트)를 사용 하 여 인코딩된 경우 길이 접두사가 의미는 BinaryWriter 스트림에 인스턴스의 현재 인코딩이 있습니다.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.

예를 들어 "A" 문자열 길이가 1, 하지만 u t F-16으로 인코딩된 경우 접두사에 기록 된 값은 2, 2 바이트 길이가 3 바이트 접두사를 포함 하 여 스트림을에 기록 됩니다.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.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Single) Write(Single) Write(Single) Write(Single)

4바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.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)

매개 변수

value
Single Single Single Single

쓸 4바이트 부동 소수점 값입니다.The four-byte floating-point value to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 저장 하 고 파일에서 애플리케이션 설정을 검색 하는 방법을 보여 줍니다.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

        If (File.Exists(fileName)) Then

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

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

End Module

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(SByte) Write(SByte) Write(SByte) Write(SByte)

중요

이 API는 CLS 규격이 아닙니다.

부호 있는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다.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);
abstract member Write : sbyte -> unit
override this.Write : sbyte -> unit
Public Overridable Sub Write (value As SByte)

매개 변수

value
SByte SByte SByte SByte

쓸 부호 있는 바이트입니다.The signed byte to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>) Write(ReadOnlySpan<Char>)

문자 범위를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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))

매개 변수

chars
ReadOnlySpan<Char>

쓸 문자 범위입니다.A span of chars to write.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>)

현재 스트림에 바이트 범위를 씁니다.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))

매개 변수

buffer
ReadOnlySpan<Byte>

쓸 바이트 범위입니다.The span of bytes to write.

Write(Int64) Write(Int64) Write(Int64) Write(Int64)

8바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.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)

매개 변수

value
Int64 Int64 Int64 Int64

쓸 8바이트 부호 있는 정수입니다.The eight-byte signed integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Char) Write(Char) Write(Char) Write(Char)

유니코드 문자를 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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)

매개 변수

ch
Char Char Char Char

쓰려고 하는 서로게이트가 아닌 유니코드 문자입니다.The non-surrogate, Unicode character to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

ch가 단일 서로게이트 문자인 경우ch is a single surrogate character.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 데이터를 쓰고 읽는 방법을 보여 줍니다.The following code example shows how to read and write data using memory as a backing store.

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

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

   }
   Console::WriteLine( memoryData );
}

using System;
using System.IO;

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

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

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

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

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

Public Class BinaryRW

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

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

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

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

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

설명

데이터 서식 충돌 때문에이 메서드를 사용 하 여 다음 인코딩을 사용 하 여 권장 되지 않습니다.Because of data formatting conflicts, using this method with the following encodings is not recommended:

  • UTF-7UTF-7

  • ISO-2022-JPISO-2022-JP

  • ISCII-ISCII

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.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. 애플리케이션에서 서로게이트 쌍에 대 한 지원에 필요한 경우 문자 배열을 사용 하 여 고려해 야 하며 Write 메서드 오버 로드 합니다.If you require support for surrogate pairs in your application, consider using a character array and the Write method overload.

추가 정보

Write(Int16) Write(Int16) Write(Int16) Write(Int16)

2바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 2바이트씩 앞으로 이동합니다.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)

매개 변수

value
Int16 Int16 Int16 Int16

쓸 2바이트 부호 있는 정수입니다.The two-byte signed integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

다음 표에서 일반적인 하거나 관련 된 I/O 작업의 예제를 나열합니다.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
추가 정보

Write(Double) Write(Double) Write(Double) Write(Double)

8바이트 부동 소수점 값을 현재 스트림에 쓰고 스트림 위치를 8바이트씩 앞으로 이동합니다.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)

매개 변수

value
Double Double Double Double

쓸 8바이트 부동 소수점 값입니다.The eight-byte floating-point value to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 읽기 및 쓰기는 방법을 보여 줍니다 Double 를 사용 하 여 메모리 데이터를 BinaryReaderBinaryWriter 의 맨 위에 있는 클래스는 MemoryStream 클래스.The following code example shows how to read and write Double data to memory by using the BinaryReader and BinaryWriter classes on top of the MemoryStream class. MemoryStream 읽기 및 쓰기만 Byte 데이터입니다.MemoryStream only reads and writes Byte data.

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

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

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

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

   }
   finally
   {
      binWriter->Close();
   }

}

using System;
using System.IO;

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

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

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

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

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

Public Class BinaryRW

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

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

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

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

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

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

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

    End Sub
End Class

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Decimal) Write(Decimal) Write(Decimal) Write(Decimal)

10진 값을 현재 스트림에 쓰고 스트림 위치를 16바이트씩 앞으로 이동합니다.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)

매개 변수

value
Decimal Decimal Decimal Decimal

쓸 10진수 값입니다.The decimal value to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

설명

다음 표에서 일반적인 하거나 관련 된 I/O 작업의 예제를 나열합니다.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
추가 정보

Write(Char[]) Write(Char[]) Write(Char[]) Write(Char[])

문자 배열을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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())

매개 변수

chars
Char[]

쓸 데이터를 포함하는 문자 배열입니다.A character array containing the data to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 데이터를 쓰고 읽는 방법을 보여 줍니다.The following code example shows how to read and write data using memory as a backing store.

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

using System;
using System.IO;

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

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

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

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

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

Public Class BinaryRW

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

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

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

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

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

설명

다음 표에서 일반적인 하거나 관련 된 I/O 작업의 예제를 나열합니다.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
추가 정보

Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32) Write(Char[], Int32, Int32)

문자 배열 섹션을 현재 스트림에 쓴 다음 사용된 Encoding과 스트림에 쓰여지는 특정 문자의 길이만큼 스트림의 현재 위치를 앞으로 이동합니다.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)

매개 변수

chars
Char[]

쓸 데이터를 포함하는 문자 배열입니다.A character array containing the data to write.

index
Int32 Int32 Int32 Int32

chars에서 읽고 스트림에 쓸 첫 번째 문자의 인덱스입니다.The index of the first character to read from chars and to write to the stream.

count
Int32 Int32 Int32 Int32

chars에서 읽고 스트림에 쓸 문자의 인덱스입니다.The number of characters to read from chars and to write to the stream.

예외

버퍼 길이에서 index를 빼면 count보다 작습니다.The buffer length minus index is less than count.

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 데이터를 쓰고 읽는 방법을 보여 줍니다.The following code example shows how to read and write data using memory as a backing store.

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

using System;
using System.IO;

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

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

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

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

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

Public Class BinaryRW

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

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

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

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

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

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Byte[]) Write(Byte[]) Write(Byte[]) Write(Byte[])

내부 스트림에 바이트 배열을 씁니다.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())

매개 변수

buffer
Byte[]

쓸 데이터를 포함하는 바이트 배열입니다.A byte array containing the data to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 이진 데이터를 쓰고 다음 데이터 쓰여졌는지 확인 하는 방법을 보여 줍니다.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

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

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

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

using System;
using System.IO;

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

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

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

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

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

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

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

Public Class BinaryRW

    Shared Sub Main()
    
        Const upperBound As Integer = 1000

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

        Dim binWriter As New BinaryWriter(New MemoryStream())

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

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

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

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

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Byte) Write(Byte) Write(Byte) Write(Byte)

부호 없는 바이트를 현재 스트림에 쓰고 스트림 위치를 1바이트씩 앞으로 이동합니다.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)

매개 변수

value
Byte Byte Byte Byte

쓸 부호 없는 바이트입니다.The unsigned byte to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 메모리를 사용 하 여 백업 저장소로 이진 데이터를 쓰고 다음 데이터 쓰여졌는지 확인 하는 방법을 보여 줍니다.The following code example shows how to write binary data using memory as a backing store, and then verify that the data was written correctly.

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

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

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

}

using System;
using System.IO;

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

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

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

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

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

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

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

Public Class BinaryRW

    Shared Sub Main()
    
        Dim i As Integer = 0

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

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

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

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

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

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

설명

데이터 서식 충돌 때문에이 메서드를 사용 하 여 다음 인코딩을 사용 하 여 권장 되지 않습니다.Because of data formatting conflicts, using this method with the following encodings is not recommended:

  • UTF-7UTF-7

  • ISO-2022-JPISO-2022-JP

  • ISCII-ISCII

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Boolean) Write(Boolean) Write(Boolean) Write(Boolean)

Boolean를 나타내는 0과 false를 나타내는 1을 사용하여 1바이트 true 값을 현재 스트림에 씁니다.Writes a one-byte Boolean value to the current stream, with 0 representing false and 1 representing true.

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

매개 변수

value
Boolean Boolean Boolean Boolean

Boolean 값(0 또는 1)입니다.The Boolean value to write (0 or 1).

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 저장 하 고 파일에서 애플리케이션 설정을 검색 하는 방법을 보여 줍니다.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

        If (File.Exists(fileName)) Then

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

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

End Module

설명

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

Write(Int32) Write(Int32) Write(Int32) Write(Int32)

4바이트 부호 있는 정수를 현재 스트림에 쓰고 스트림 위치를 4바이트씩 앞으로 이동합니다.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)

매개 변수

value
Int32 Int32 Int32 Int32

쓸 4바이트 부호 있는 정수입니다.The four-byte signed integer to write.

예외

I/O 오류가 발생했습니다.An I/O error occurs.

예제

다음 코드 예제에는 저장 하 고 파일에서 애플리케이션 설정을 검색 하는 방법을 보여 줍니다.The following code example demonstrates how to store and retrieve application settings in a file.

using System;
using System.IO;

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

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

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

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

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

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

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

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

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

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

        If (File.Exists(fileName)) Then

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

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

End Module

설명

BinaryWriter little endian 형식만이 데이터 형식을 저장합니다.BinaryWriter stores this data type in little endian format.

공통적인 I/O 작업의 목록을 참조 하세요 공통적인 I/O 작업합니다.For a list of common I/O tasks, see Common I/O Tasks.

추가 정보

적용 대상