Lendo e escrevendo arquivos

Neste capítulo, vamos examinar a leitura e gravação de arquivos simples com o C #. Felizmente para nós, o C # torna isso muito fácil. A classe File, do namespace Syste.IO, vem com praticamente tudo que poderíamos desejar, facilitando a leitura e a gravação simples de um arquivo.

Em nosso primeiro exemplo, vamos construir um editor de texto extremamente minimalista. Na verdade, é tão simples que só podemos ler um arquivo e depois escrever um novo conteúdo para ele, e apenas uma única linha de texto de cada vez. Mas mostra como é fácil usar a classe File:

using System;
using System.IO;

namespace FileHandlingArticleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            if(File.Exists("test.txt"))
            {
                string content = File.ReadAllText("test.txt");
                Console.WriteLine("Current content of file:");
                Console.WriteLine(content);
            }
            Console.WriteLine("Please enter new content for the file:");
            string newContent = Console.ReadLine();
            File.WriteAllText("test.txt", newContent);
        }
    }
}

Você notará que usamos a classe File em três lugares: Usamos para verificar se o arquivo existe, usamos o método ReadAllText() para ler o conteúdo do arquivo e usamos o método WriteAllText() para escrever novos conteúdos. para o arquivo. Você notará que não estou usando caminhos absolutos, mas apenas um nome de arquivo simples. Isso colocará o arquivo no mesmo diretório do arquivo executável, o que é bom por enquanto. Fora isso, o exemplo deve ser fácil de entender: Nós checamos o arquivo, se ele existir, lemos o seu conteúdo e o enviamos para o console. Em seguida, solicitamos ao usuário novo conteúdo e, uma vez que o tenhamos, ele será gravado no arquivo. Obviamente, isso substituirá o conteúdo anterior, mas por enquanto, tudo bem. No entanto, podemos usar o método AppendAllText. Tente alterar a linha WriteAllText para isso:

File.AppendAllText("test.txt", newContent);

Se você executá-lo, verá que o novo texto é adicionado ao texto existente em vez de sobrescrevê-lo. Tão simples como isso. Mas ainda obtemos apenas uma linha de texto por execução de nossa aplicação. Vamos ser um pouco criativos e mudar isso. Substitua as últimas linhas do nosso exemplo por isso:

Console.WriteLine("Please enter new content for the file - type exit and press enter to finish editing:");
string newContent = Console.ReadLine();
while(newContent != "exit")
{
    File.AppendAllText("test.txt", newContent + Environment.NewLine);
    newContent = Console.ReadLine();
}

Como você pode ver, instruímos o usuário a inserir a palavra exit quando deseja interromper a edição do arquivo e, até que ele faça exatamente isso, anexamos a entrada do usuário ao arquivo e solicitamos uma nova linha. Também adicionamos um caractere de nova linha, o Environment.NewLine, para torná-lo semelhante a linhas de texto reais.

No entanto, em vez de gravar no arquivo a cada vez, uma solução mais bonita provavelmente seria algo assim:

Console.WriteLine("Please enter new content for the file - type exit and press enter to finish editing:");
using(StreamWriter sw = new StreamWriter("test.txt"))
{
    string newContent = Console.ReadLine();
    while(newContent != "exit")
    {
        sw.Write(newContent + Environment.NewLine);
        newContent = Console.ReadLine();
    }
}

O uso do Streams está um pouco fora do escopo deste capítulo, mas o legal disso neste exemplo é que apenas abrimos o arquivo uma vez e depois gravamos as alterações nele assim que estivermos satisfeitos. Nesse caso, estamos aproveitando a instrução using() de C #, que garante que a referência do arquivo seja fechada quando estiver fora do escopo, que é quando o bloco {} é concluído. Se você não usar a instrução using(), terá que chamar manualmente o método Close() na instância do StreamWriter.