C# Arquivos

Até aqui, tudo o que seus programas sabiam sumia quando eles terminavam: as variáveis vivem na memória, e a memória é apagada no fim. Um arquivo fica no disco e continua lá no dia seguinte. Nesta aula você vai usar a classe File ("arquivo") para gravar a lista de compras da Ana, ler as notas da turma, acrescentar linhas num registro (log) e copiar, mover e apagar arquivos. Também vai conhecer os erros de arquivo mais comuns e como tratá-los.

Esta aula usa arrays, foreach e try e catch. Todos os programas foram rodados com dotnet run (aula Rodar com dotnet run) no .NET 10 da máquina da Ana (usuária ana, computador notebook), dentro da pasta ~/cs, que é /home/ana/cs.

A ideia: o caderno na gaveta

Pense na memória do computador como um quadro branco: rápido de escrever, mas alguém apaga tudo no fim da aula. O disco é um caderno guardado na gaveta: o que você escreve ali continua lá amanhã. Para usar o caderno você precisa de duas coisas: o nome dele (o caminho do arquivo, como compras.txt) e alguém que saiba abrir, ler, escrever e fechar. Em C#, esse alguém é a classe File.

A classe File fica no namespace System.IO (de input/output, entrada e saída). Você não precisa escrever using System.IO;: no .NET 10, ele já vem incluído nos programas de console (são os usings implícitos, da aula Namespaces e using). Todos os métodos desta aula são estáticos: você chama direto File.Método(…), sem criar objeto.

1. Gravar e ler um texto: WriteAllText e ReadAllText

A Ana quer guardar a lista de compras num arquivo. Este programa grava a lista, lê o arquivo de volta e mostra o que leu:

File.WriteAllText("compras.txt", "pão\nleite\n");
string texto = File.ReadAllText("compras.txt");
Console.Write(texto);
Console.WriteLine($"{texto.Length} caracteres");

File.WriteAllText("compras.txt", "pão\nleite\n");

Abre o arquivo compras.txt, grava o texto e fecha. Se o arquivo não existe, ele é criado. Se já existe, o conteúdo antigo é apagado e substituído. O \n é a quebra de linha (aula Escapes): o WriteAllText grava exatamente o que você mandar, sem pular linha sozinho.

string texto = File.ReadAllText("compras.txt");

Abre o arquivo, lê tudo, fecha e devolve o conteúdo numa única string, com as quebras de linha dentro.

Console.Write(texto);

Write, e não WriteLine: o texto já termina com \n. Com WriteLine apareceria uma linha em branco a mais.

texto.Length

Quantos caracteres a string tem: pão (3) + \n (1) + leite (5) + \n (1) = 10.

$ dotnet run compras.cs
pão
leite
10 caracteres
$ cat compras.txt               « o arquivo continua lá depois que o programa terminou
pão
leite

O nome "compras.txt" não diz em que pasta o arquivo fica. Um nome assim é um caminho relativo: ele é procurado (ou criado) na pasta atual, a pasta em que o terminal estava quando a Ana deu o dotnet run. Aqui, /home/ana/cs. A aula Pastas e Caminhos mostra como montar caminhos completos.

2. Linha por linha: WriteAllLines e ReadAllLines

Quase todo arquivo de texto é uma lista de linhas: uma compra por linha, um aluno por linha, um produto por linha. Os métodos …Lines trabalham direto com essas listas, sem você precisar mexer com \n.

string[] alunos = ["Ana;8,5", "Bruno;6", "Carla;9,5"];
File.WriteAllLines("notas.txt", alunos);

string[] linhas = File.ReadAllLines("notas.txt");
Console.WriteLine($"Linhas: {linhas.Length}");
foreach (string linha in linhas)
{
    string[] partes = linha.Split(';');
    Console.WriteLine($"{partes[0]} tirou {partes[1]}");
}

["Ana;8,5", "Bruno;6", "Carla;9,5"]

Um array de string escrito com a expressão de coleção C# 12 (aula Arrays). Cada texto tem o nome e a nota separados por ;.

File.WriteAllLines("notas.txt", alunos);

Grava cada item do array numa linha, com a quebra de linha no fim de cada uma (inclusive da última). Aceita um array, uma List<string> ou qualquer sequência de textos.

File.ReadAllLines("notas.txt")

Lê o arquivo e devolve um string[] com uma linha em cada posição, já sem as quebras de linha.

linha.Split(';')

Corta a linha em cada ; (aula Métodos de String): partes[0] é o nome e partes[1] é a nota, ainda como texto.

$ dotnet run notas.cs
Linhas: 3
Ana tirou 8,5
Bruno tirou 6
Carla tirou 9,5
$ cat notas.txt
Ana;8,5
Bruno;6
Carla;9,5

Um detalhe que confunde: o arquivo termina com uma quebra de linha depois de Carla;9,5, mas o ReadAllLines devolve 3 linhas, e não 4. A última quebra só fecha a última linha; ela não abre uma linha vazia. Um arquivo vazio dá um array vazio (Length = 0).

File.WriteAllText("compras.txt", "pão\nleite\n");

string[] itens = File.ReadAllLines("compras.txt");
Console.WriteLine($"{itens.Length} itens: {string.Join(", ", itens)}");

File.WriteAllText("compras.txt", "pão\nleite\n");
File.AppendAllText("compras.txt", "café\n");

string[] itens = File.ReadAllLines("compras.txt");
Console.WriteLine($"{itens.Length} itens: {string.Join(", ", itens)}");

O string.Join(", ", itens) junta os itens do array num texto só, com ", " entre eles (aula Métodos de String).

3. Acrescentar no fim: AppendAllText e AppendAllLines

Um log (registro) é um arquivo que só cresce: cada vez que algo acontece, o programa escreve uma linha nova no fim. Para isso existem os métodos Append… ("acrescentar"):

File.AppendAllText("log.txt", "Programa iniciado\n");
File.AppendAllLines("log.txt", ["Venda: caderno", "Venda: caneta"]);
Console.WriteLine($"O log tem {File.ReadAllLines("log.txt").Length} linhas");

File.AppendAllText("log.txt", "Programa iniciado\n");

Grava o texto no fim do arquivo, mantendo o que já estava lá. Se o arquivo não existe, ele é criado, como no WriteAllText. A quebra de linha \n continua sendo sua.

File.AppendAllLines("log.txt", [ … ]);

O mesmo, para uma lista: cada item vira uma linha no fim do arquivo, cada uma com a sua quebra.

$ dotnet run log.cs
O log tem 3 linhas
$ dotnet run log.cs               « de novo: as linhas antigas ficam
O log tem 6 linhas
$ cat log.txt
Programa iniciado
Venda: caderno
Venda: caneta
Programa iniciado
Venda: caderno
Venda: caneta

4. Arquivos grandes: ReadLines

ReadAllText e ReadAllLines carregam o arquivo inteiro na memória antes de devolver qualquer coisa. Para a lista de compras, ótimo. Para um log de 2 GB, o programa pode ficar sem memória. O File.ReadLines (sem o All) entrega uma linha por vez, conforme o foreach pede:

int n = 0;
foreach (string linha in File.ReadLines("log.txt"))
{
    n++;
    if (linha.StartsWith("Venda"))
    {
        Console.WriteLine($"{n}: {linha}");
    }
}

File.ReadLines("log.txt")

Não devolve um array: devolve uma sequência (IEnumerable<string>, aula IEnumerable e foreach). Cada volta do foreach lê a próxima linha do disco. Só uma linha fica na memória de cada vez.

n++

Conta as linhas, para mostrar o número de cada uma.

linha.StartsWith("Venda")

Verdadeiro se a linha começa com Venda.

$ dotnet run vendas.cs
2: Venda: caderno
3: Venda: caneta
5: Venda: caderno
6: Venda: caneta

A diferença não aparece na saída: aparece na memória. Se você precisa do Length ou de linhas[3], use ReadAllLines. Se só vai passar pelas linhas uma vez, do começo ao fim, prefira ReadLines. Para ler e escrever aos poucos com mais controle, a próxima aula apresenta o StreamReader e o StreamWriter.

5. Existe? Copiar, mover e apagar

Console.WriteLine(File.Exists("compras.txt"));
Console.WriteLine(File.Exists("fotos.zip"));

File.Copy("compras.txt", "compras-backup.txt", overwrite: true);
File.Move("compras-backup.txt", "backup.txt", overwrite: true);
Console.WriteLine(File.Exists("compras-backup.txt"));
Console.WriteLine(File.Exists("backup.txt"));

File.Delete("backup.txt");
File.Delete("backup.txt");
Console.WriteLine(File.Exists("backup.txt"));

File.Exists("compras.txt")

"O arquivo existe?" Devolve true ou false e nunca lança exceção, nem com um nome estranho.

File.Copy(origem, destino, overwrite: true)

Copia. Sem o overwrite: true ("sobrescrever", um argumento nomeado), ele recusa um destino que já existe e lança IOException (veja "Quando dá errado").

File.Move(origem, destino, overwrite: true)

Move ou renomeia: depois dele, o nome antigo não existe mais. O overwrite funciona como no Copy.

File.Delete("backup.txt")

Apaga de verdade, sem lixeira. Se o arquivo já não existe, ele não reclama: por isso a segunda linha igual não deu erro.

$ dotnet run backup.cs
True
False
False
True
False

6. Texto e bytes: UTF-8

No disco, um arquivo é uma fila de bytes (números de 0 a 255). A codificação (encoding) é a tabela que diz qual byte vira qual letra. Para as letras sem acento, quase todas as tabelas concordam. Para ã, é e ç, não.

O .NET grava e lê em UTF-8 quando você não diz nada, que é a codificação padrão da internet e do Linux. Em UTF-8, cada letra acentuada ocupa 2 bytes. O comando xxd mostra os bytes do arquivo de compras (com o café acrescentado na missão):

$ xxd compras.txt
00000000: 70c3 a36f 0a6c 6569 7465 0a63 6166 c3a9  p..o.leite.caf..
00000010: 0a                                       .

70 é o p, c3 a3 é o ã (dois bytes), 6f é o o e 0a é a quebra de linha. São 15 caracteres, mas 17 bytes.

Arquivos antigos, gerados por programas velhos do Windows, às vezes vêm em Latin-1 (ISO-8859-1), em que ã é um byte só. A Ana recebeu uma lista de clientes assim. O comando printf do terminal cria um arquivo igual, e o comando file descobre a codificação:

using System.Text;

Console.WriteLine(File.ReadAllText("clientes-antigo.txt"));
Console.WriteLine(File.ReadAllText("clientes-antigo.txt", Encoding.Latin1));

$ printf 'Jo\343o;S\343o Paulo\n' > clientes-antigo.txt
$ file clientes-antigo.txt
clientes-antigo.txt: ISO-8859 text
$ dotnet run latin.cs
Jo�o;S�o Paulo

João;São Paulo

using System.Text;

A classe Encoding ("codificação") fica no namespace System.Text, que não vem incluído sozinho.

File.ReadAllText(caminho)

Lê como UTF-8. O byte do ã em Latin-1 não forma uma letra válida em UTF-8, e o .NET o troca pelo símbolo � ("caractere de substituição"). Não há exceção: o texto simplesmente sai estragado.

File.ReadAllText(caminho, Encoding.Latin1)

Todos os métodos de File aceitam a codificação como último argumento. Com a tabela certa, o texto sai certo.

As linhas em branco na saída são o \n do fim do arquivo mais o do WriteLine. Se aparecer �, ou textos como João (UTF-8 lido como Latin-1), o arquivo e o programa estão usando tabelas diferentes. Para gravar, fique sempre com o padrão, UTF-8.

Qual método usar

Quando dá errado

Os erros de arquivo são exceções (aula Exceções): o programa compila, mas para no meio, com o código de saída 134. Todas trazem o caminho completo na mensagem, o que ajuda muito a descobrir o problema. As mensagens das exceções saem em inglês.

string texto = File.ReadAllText("nota.txt");
Console.WriteLine(texto);

$ dotnet run ler.cs; echo "código: $?"
Unhandled exception. System.IO.FileNotFoundException: Could not find file '/home/ana/cs/nota.txt'.
File name: '/home/ana/cs/nota.txt'
   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirError)
   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String path, OpenFlags flags, Int32 mode, Boolean failForSymlink, Boolean& wasSymlink, Func`4 createOpenException)
   at Microsoft.Win32.SafeHandles.SafeFileHandle.Open(String fullPath, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 preallocationSize, UnixFileMode openPermissions, Int64& fileLength, UnixFileMode& filePermissions, Boolean failForSymlink, Boolean& wasSymlink, Func`4 createOpenException)
   at System.IO.Strategies.OSFileStreamStrategy..ctor(String path, FileMode mode, FileAccess access, FileShare share, FileOptions options, Int64 preallocationSize, Nullable`1 unixCreateMode)
   at System.IO.FileStream..ctor(String path, FileMode mode, FileAccess access, FileShare share, Int32 bufferSize, FileOptions options, Int64 preallocationSize)
   at System.IO.StreamReader.ValidateArgsAndOpenPath(String path, Int32 bufferSize)
   at System.IO.File.ReadAllText(String path, Encoding encoding)
   at Program.<Main>$(String[] args) in /home/ana/cs/ler.cs:line 1
código: 134

try
{
    string texto = File.ReadAllText("nota.txt");
    Console.WriteLine(texto);
}
catch (FileNotFoundException e)
{
    Console.WriteLine($"Não achei o arquivo: {e.FileName}");
}

$ dotnet run tratar.cs
Não achei o arquivo: /home/ana/cs/nota.txt

File.WriteAllText("relatorios/outubro.txt", "Vendas: 1520\n");

$ dotnet run pasta.cs
Unhandled exception. System.IO.DirectoryNotFoundException: Could not find a part of the path '/home/ana/cs/relatorios/outubro.txt'.
   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirError)
   …                                                « mais 4 linhas de dentro do .NET
   at Program.<Main>$(String[] args) in /home/ana/cs/pasta.cs:line 1

File.Copy("compras.txt", "copia.txt");
Console.WriteLine("Copiei");

$ dotnet run copiar.cs
Copiei
$ dotnet run copiar.cs               « de novo: agora copia.txt já existe
Unhandled exception. System.IO.IOException: The file '/home/ana/cs/copia.txt' already exists.
   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirError)
   …                                                « mais 3 linhas de dentro do .NET
   at Program.<Main>$(String[] args) in /home/ana/cs/copiar.cs:line 1

$ echo segredo > trancado.txt
$ chmod 444 trancado.txt               « só leitura, para todo mundo
$ cat trancado.cs
File.WriteAllText("trancado.txt", "novo");
$ dotnet run trancado.cs
Unhandled exception. System.UnauthorizedAccessException: Access to the path '/home/ana/cs/trancado.txt' is denied.
 ---> System.IO.IOException: Permission denied
   --- End of inner exception stack trace ---
   at Interop.ThrowExceptionForIoErrno(ErrorInfo errorInfo, String path, Boolean isDirError)
   …                                                « mais 4 linhas de dentro do .NET
   at Program.<Main>$(String[] args) in /home/ana/cs/trancado.cs:line 1

string[] linhas = File.ReadAllLines("notas.txt");
foreach (string linha in linhas)
{
    string[] partes = linha.Split(';');
    double nota = double.Parse(partes[1]);
    Console.WriteLine($"{partes[0]} tirou {nota}");
}

$ cat notas.txt
Ana;8.5
Bruno;6.0
Carla;9.5
$ dotnet run media.cs
Ana tirou 85
Bruno tirou 60
Carla tirou 95

using System.Globalization;

string[] linhas = File.ReadAllLines("notas.txt");
double soma = 0;
foreach (string linha in linhas)
{
    string[] partes = linha.Split(';');
    double nota = double.Parse(partes[1], CultureInfo.InvariantCulture);
    Console.WriteLine($"{partes[0]} tirou {nota}");
    soma += nota;
}
Console.WriteLine($"Média: {soma / linhas.Length:F2}");

$ dotnet run media.cs
Ana tirou 8,5
Bruno tirou 6
Carla tirou 9,5
Média: 8,00

using System.Globalization;

string[] linhas = File.ReadAllLines("notas.txt");
double soma = 0;
foreach (string linha in linhas)
{
    string[] partes = linha.Split(';');
    double nota = double.Parse(partes[1]);
    Console.WriteLine($"{partes[0]} tirou {nota}");
    soma += nota;
}
Console.WriteLine($"Média: {soma / linhas.Length:F2}");

Ana;8.5
Bruno;6.0
Carla;9.5

using System.Globalization;

string[] linhas = File.ReadAllLines("notas.txt");
double soma = 0;
foreach (string linha in linhas)
{
    string[] partes = linha.Split(';');
    double nota = double.Parse(partes[1], CultureInfo.InvariantCulture);
    Console.WriteLine($"{partes[0]} tirou {nota}");
    soma += nota;
}
Console.WriteLine($"Média: {soma / linhas.Length:F2}");

string[] linhas = File.ReadAllText("notas.txt");
Console.WriteLine(linhas.Length);

$ dotnet run erro.cs
/home/ana/cs/erro.cs(1,19): error CS0029: Não é possível converter implicitamente tipo "string" em "string[]"

Ocorreu uma falha no build. Corrija os erros de build e execute novamente.

Referência rápida

Exercícios

Missão final: o relatório do estoque

Caderno: 190,80
Caneta azul: 100,00
Cola branca: 34,00
Total: 324,80

using System.Globalization;

string[] linhas = File.ReadAllLines("estoque.csv");
List<string> relatorio = [];
decimal total = 0;
for (int i = 1; i < linhas.Length; i++)
{
    string[] campos = linhas[i].Split(';');
    int qtd = int.Parse(campos[1]);
    decimal preco = decimal.Parse(campos[2], CultureInfo.InvariantCulture);
    decimal valor = qtd * preco;
    // 1. acrescente o produto na lista e some o valor no total
}
// 2. acrescente o total na lista
// 3. grave a lista em relatorio.txt
// 4. leia o relatorio.txt e mostre

produto;qtd;preco
Caderno;12;15.90
Caneta azul;40;2.50
Cola branca;8;4.25

using System.Globalization;

string[] linhas = File.ReadAllLines("estoque.csv");
List<string> relatorio = [];
decimal total = 0;
for (int i = 1; i < linhas.Length; i++)
{
    string[] campos = linhas[i].Split(';');
    int qtd = int.Parse(campos[1]);
    decimal preco = decimal.Parse(campos[2], CultureInfo.InvariantCulture);
    decimal valor = qtd * preco;
    relatorio.Add($"{campos[0]}: {valor:F2}");
    total += valor;
}
relatorio.Add($"Total: {total:F2}");
File.WriteAllLines("relatorio.txt", relatorio);
Console.Write(File.ReadAllText("relatorio.txt"));

O preço está em decimal, o tipo certo para dinheiro (aula float, double e decimal), e o for começa em 1 para pular o cabeçalho produto;qtd;preco. Se quiser ir além: acrescente uma linha Régua;5;1.20 no CSV e veja o total mudar para 330,80.

Resumo

• A classe File (namespace System.IO, já incluído) lê e grava arquivos com uma linha de código. Um nome sem pasta, como "compras.txt", é procurado na pasta em que o programa foi rodado.
• WriteAllText e WriteAllLines criam ou substituem o arquivo. AppendAllText e AppendAllLines acrescentam no fim.
• ReadAllText devolve uma string; ReadAllLines, um string[] sem as quebras. Os dois leem tudo de uma vez; para arquivos grandes, ReadLines entrega uma linha por vez.
• Exists pergunta sem lançar exceção; Copy e Move recusam um destino existente sem overwrite: true; Delete apaga de verdade.
• O padrão é UTF-8, em que ã ocupa 2 bytes. Para um arquivo antigo, passe a codificação: Encoding.Latin1.
• Erros comuns: FileNotFoundException, DirectoryNotFoundException, IOException e UnauthorizedAccessException. E números com ponto: double.Parse(texto, CultureInfo.InvariantCulture).