FileStream.WriteByte(Byte) Método

Definição

Espaço de Nomes:
System.IO
Assemblagens:
mscorlib.dll, System.IO.FileSystem.dll
Assemblagem:
mscorlib.dll
Assemblagem:
System.IO.FileSystem.dll
Assemblagem:
netstandard.dll

Escreve um byte na posição atual no fluxo de ficheiros.

public:
 override void WriteByte(System::Byte value);
public override void WriteByte(byte value);
override this.WriteByte : byte -> unit
abstract member WriteByte : byte -> unit
override this.WriteByte : byte -> unit
Public Overrides Sub WriteByte (value As Byte)

Parâmetros

value
Byte

Um byte para escrever no stream.

Exceções

ObjectDisposedException

O riacho está fechado.

NotSupportedException

O stream não suporta escrita.

IOException

.NET 8 e versões posteriores: O tubo subjacente está fechado ou desligado.

Exemplos

O seguinte exemplo de código mostra como escrever dados num ficheiro, byte a byte, e depois verificar se os dados foram escritos corretamente.

using System;
using System.IO;

class FStream
{
    static void Main()
    {
        const string fileName = "Test#@@#.dat";

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

        using(FileStream
            fileStream = new FileStream(fileName, FileMode.Create))
        {
            // Write the data to the file, byte by byte.
            for(int i = 0; i < dataArray.Length; i++)
            {
                fileStream.WriteByte(dataArray[i]);
            }

            // Set the stream position to the beginning of the file.
            fileStream.Seek(0, SeekOrigin.Begin);

            // Read and verify the data.
            for(int i = 0; i < fileStream.Length; i++)
            {
                if(dataArray[i] != fileStream.ReadByte())
                {
                    Console.WriteLine("Error writing data.");
                    return;
                }
            }
            Console.WriteLine("The data was written to {0} " +
                "and verified.", fileStream.Name);
        }
    }
}

open System
open System.IO


let fileName = "Test#@@#.dat"

// Create random data to write to the file.
let dataArray = Array.zeroCreate 100000
Random.Shared.NextBytes dataArray

do
    use fileStream = new FileStream(fileName, FileMode.Create)
    // Write the data to the file, byte by byte.
    for i = 0 to dataArray.Length - 1 do
        fileStream.WriteByte dataArray[i]

    // Set the stream position to the beginning of the file.
    fileStream.Seek(0, SeekOrigin.Begin) |> ignore

    // Read and verify the data.
    for i in 0L .. fileStream.Length - 1L do
        if dataArray[int i] <> (fileStream.ReadByte() |> byte) then
            printfn "Error writing data."
            exit 1

    printfn $"The data was written to {fileStream.Name} and verified."

Imports System.IO
Imports System.Text

Class FStream

    Shared Sub Main()

        Const fileName As String = "Test#@@#.dat"

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

        Dim fileStream As FileStream = _
            new FileStream(fileName, FileMode.Create)
        Try

            ' Write the data to the file, byte by byte.
            For i As Integer = 0 To dataArray.Length - 1
                fileStream.WriteByte(dataArray(i))
            Next i

            ' Set the stream position to the beginning of the stream.
            fileStream.Seek(0, SeekOrigin.Begin)

            ' Read and verify the data.
            For i As Integer = 0 To _
                CType(fileStream.Length, Integer) - 1

                If dataArray(i) <> fileStream.ReadByte() Then
                    Console.WriteLine("Error writing data.")
                    Return
                End If
            Next i
            Console.WriteLine("The data was written to {0} " & _
                "and verified.", fileStream.Name)
        Finally
            fileStream.Close()
        End Try
    
    End Sub
End Class

Observações

Este método substitui o WriteByte.

Use WriteByte para escrever um byte de forma FileStream eficiente. Se o jato estiver fechado ou não puder ser gravado, será lançada uma exceção.

Note

Use a CanWrite propriedade para determinar se a instância atual suporta escrita. Para obter informações adicionais, consulte CanWrite.

Notas para Herdeiros

A implementação padrão em Stream cria um novo array de um byte e depois chama Write(Byte[], Int32, Int32). Embora isto seja formalmente correto, é ineficiente. Qualquer stream com um buffer interno deve sobrepor este método e fornecer uma versão muito mais eficiente que leia o buffer diretamente, evitando a alocação extra de array em cada chamada.

Para obter uma lista de operações comuns de arquivos e diretórios, consulte Tarefas comuns de E/S.

Aplica-se a

Ver também