1. Introdução
Antes de começar a usar uma nova classe, vale entender por que ela existe. Vamos ver o que acontece quando trabalhamos com um arquivo "diretamente" usando FileStream.
Quando você chama Read ou Write em um stream criado via FileStream, na prática ocorre uma operação na subsistema de disco do computador. Esse processo (especialmente em discos rígidos antigos, mas também em SSDs) é muito mais lento do que operar na memória RAM. Imagine que quando você pede batatas fritas no McDonalds, o caixa corre até o depósito para pegar um saco novo toda vez. Imagine o tamanho da fila!
Se você trabalha com pedaços pequenos de dados, acessos frequentes ao disco ou à rede prejudicam o desempenho. Quanto maior o volume de dados — mais perceptível fica o efeito.
Analogia curta
Streams sem buffer são como ir ao mercado 10 vezes para comprar um iogurte por vez. Um stream com buffer é quando você pega logo uma cesta cheia de iogurtes, reduzindo as idas ao mínimo.
2. A classe BufferedStream: uma primeira olhada
Pra que serve
BufferedStream é um wrapper em torno de qualquer stream (Stream) que mantém um buffer intermediário na memória. Quando você escreve dados, eles vão primeiro pro buffer e só quando o buffer enche — são despejados no disco em uma operação grande. O mesmo vale pra leitura: na primeira leitura ele carrega um bloco grande de dados pra memória e então vai servindo pedaços da memória até o buffer acabar.
Exemplo de código: criar um BufferedStream
Vamos criar um exemplo simples. Suponha que precisamos escrever 100 000 linhas em um arquivo:
string filePath = "big_output.txt";
using var fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write);
using var bufferedStream = new BufferedStream(fileStream);
using var writer = new StreamWriter(bufferedStream);
for (int i = 0; i < 100_000; i++)
{
writer.WriteLine($"Stroka nomer {i}");
}
Console.WriteLine("Gravacao concluida!");
Comentário:
- Abrimos o arquivo para escrita via FileStream.
- Depois o envolvendo com BufferedStream, e então com StreamWriter (ele escreve linhas de texto no stream).
- Quando o buffer enche — os dados são despejados no disco de uma só vez.
3. Como a bufferização funciona "por dentro"
Vamos entender isso com um diagrama:
[Seu codigo] → [StreamWriter] → [BufferedStream] → [FileStream] → [Arquivo no disco]
Quando você chama WriteLine() no StreamWriter, o texto vai primeiro para o buffer interno dele, depois passa pelo BufferedStream — para outro buffer, e só quando o buffer enche ou o stream é fechado, os dados são gravados no disco.
Quantos bytes cabem em um balde?
O tamanho de buffer padrão é 4096 bytes (4 KB), mas você pode especificar explicitamente:
int myBufferSize = 16 * 1024; // 16 KB
using var fileStream = new FileStream(filePath, FileMode.Create);
using var bufferedStream = new BufferedStream(fileStream, myBufferSize);
// ...
Dica prática: Em sistemas modernos faz sentido usar buffers de 8–64 KB. Para operações de arquivo muito grandes — pode ser maior. Mas não exagere: se você roda em um microcontrolador com 128 KB de RAM, um buffer de 64 KB é uma má ideia :)
4. Experimento: comparar velocidade com e sem buffer
Pra entender o quanto isso importa, vamos escrever um teste que compara gravação via FileStream com e sem buffer:
using System.Diagnostics;
using System.Text;
string data = new string('X', 1000); // 1 000 caracteres
void WriteWithoutBuffer()
{
using var fs = new FileStream("no_buffer.txt", FileMode.Create, FileAccess.Write, FileShare.None, 4096, useAsync: false);
for (int i = 0; i < 10_000; i++)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
fs.Write(bytes, 0, bytes.Length); // Diretamente no arquivo – cada vez acesso ao disco
}
}
void WriteWithBuffer()
{
using var fs = new FileStream("with_buffer.txt", FileMode.Create, FileAccess.Write, FileShare.None);
using var bs = new BufferedStream(fs, 16 * 1024);
for (int i = 0; i < 10_000; i++)
{
byte[] bytes = Encoding.UTF8.GetBytes(data);
bs.Write(bytes, 0, bytes.Length);
}
}
// Medimos o tempo
Stopwatch sw = Stopwatch.StartNew();
WriteWithoutBuffer();
sw.Stop();
Console.WriteLine("Sem buffer: " + sw.ElapsedMilliseconds + " ms");
sw.Restart();
WriteWithBuffer();
sw.Stop();
Console.WriteLine("Com buffer: " + sw.ElapsedMilliseconds + " ms");
Saída esperada:
Na maioria dos casos você vai ver ganho de velocidade com buffer! Especialmente em HDD. Em SSD o efeito também existe, mas é menos dramático.
5. Qual buffer escolher? Comparação e prática
No .NET existem várias classes que fazem bufferização. Vamos esclarecer:
| Classe | Pra que serve | Buffer embutido? | Precisa usar BufferedStream? |
|---|---|---|---|
|
Trabalhar com arquivos | Sim (4 KB) | Quase não precisa (mas pode) |
|
Trabalhar com rede | Não | Muito recomendável |
|
Leitura/escrita de texto | Sim (desde 1 KB) | Normalmente não é necessário |
|
Compressão/descompressão | Não | Pode/precisa para acelerar |
Importante:
FileStream com o parâmetro de construtor bufferSize já é, na prática, um stream com buffer. Se você definiu um buffer suficientemente grande no FileStream, um BufferedStream adicional não vai trazer muito ganho. Mas se você usa outro tipo de stream (por exemplo, de rede), então BufferedStream é um bom aliado.
6. Exemplo: copiar arquivo usando BufferedStream
string source = "big_input.dat";
string dest = "big_output.dat";
int bufferSize = 64 * 1024; // 64 KB
using var inputStream = new FileStream(source, FileMode.Open, FileAccess.Read);
using var outputStream = new FileStream(dest, FileMode.Create, FileAccess.Write);
using var bufferedInput = new BufferedStream(inputStream, bufferSize);
using var bufferedOutput = new BufferedStream(outputStream, bufferSize);
byte[] buffer = new byte[bufferSize];
int bytesRead;
while ((bytesRead = bufferedInput.Read(buffer, 0, buffer.Length)) > 0)
{
bufferedOutput.Write(buffer, 0, bytesRead);
}
// Nao se esqueça do flush – senao os ultimos bytes nao vao pro disco!
bufferedOutput.Flush();
Console.WriteLine("Copia concluida!");
Comentário:
- Lemos blocos grandes (64 KB) de um arquivo via BufferedStream.
- Escrevemos em outro arquivo também com buffer.
- Ao terminar o loop, chame Flush() para garantir que os últimos dados sejam gravados.
7. Nuances úteis
Dica: quando realmente usar BufferedStream
- Se você usa streams que não têm buffer (por exemplo, streams de rede, ou implementações customizadas de Stream);
- Se você manipula grandes volumes de dados binários (por exemplo, cópia de arquivos, conversão de formatos, backup);
- Se você otimiza código existente e percebe que o gargalo são muitas operações pequenas de Write/Read.
Um pouco sobre assíncrono e bufferização
Com a chegada de operações assíncronas (ReadAsync/WriteAsync), a bufferização continua útil, mas lembre: se você usa métodos assíncronos sobre um buffer, o processamento ainda ocorre na memória e as interações físicas com o disco ficam ainda mais reduzidas.
No .NET 8+ e .NET 9 a bufferização está cada vez mais integrada, e a maioria das classes já tem buffers por padrão. Mas pra compatibilidade com streams de rede ou suas implementações customizadas, ainda vale a pena usar BufferedStream manualmente.
Você vai ver mais sobre assíncrono no nível 58 :P
Diagrama visual do funcionamento dos streams com buffer
flowchart LR
A[Seu codigo] --> B[StreamReader/Writer]
B --> C[BufferedStream]
C --> D[FileStream]
D --> E[Arquivo/Dispositivo]
- A — Seu código que chama Write/Read.
- B — Stream de alto nível (trabalha com texto ou dados).
- C — Bufferização (agrupa dados para melhorar a velocidade).
- D — Implementação concreta do stream (arquivo, rede).
- E — Dispositivo físico (HD, SSD, rede etc.).
Dicas e truques práticos
- Se você escreve uma linha por vez no arquivo (por exemplo, logging), é melhor especificar um tamanho de buffer maior que o tamanho de uma linha. Isso permite despejar grandes lotes de dados mais rápido.
- Se cada ação precisa ser gravada instantaneamente (logs críticos), chame Flush() após cada escrita. Mas isso reduz a vantagem do buffer!
- Se você cria arquivos temporários que são excluídos logo depois, pode não importar se algo ficou no buffer — mas cuidado se for importante que o arquivo esteja realmente gravado.
- Ao trabalhar com arquivos muito grandes (por exemplo, dezenas de GB), não hesite em aumentar o buffer para 1_048_576 bytes (1 MB) ou mais — desde que haja RAM suficiente.
8. Erros típicos e nuances de uso
Se você sentiu vontade de "colocar buffer em tudo" — não faça isso sem pensar. Tudo em excesso faz mal!
Um erro comum é esquecer de chamar Flush() ou fechar o stream quando necessário. Se o stream não for fechado e o programa terminar inesperadamente, os últimos bytes podem ficar só no buffer em RAM e não irem pro disco. Por exemplo, se você escreve logs e o programa cai, a última entrada pode sumir.
BufferedStream por si só não "sabe" o fim das suas mensagens lógicas — ele apenas espera acumular um chunk do tamanho esperado. Portanto, para coisas críticas (logs, backups etc.) chame periodicamente Flush():
bufferedStream.Flush(); // Força o buffer a gravar os dados no disco
Se você usa StreamWriter, ele tem seu próprio buffer! Ou seja, usando ambos em camadas você tem bufferização dupla (e isso nem sempre é bom). Muitas vezes um único nível de buffer já basta, e se você usa StreamWriter, um BufferedStream adicional pode ser desnecessário.
GO TO FULL VERSION