Manipulando arquivos e diretórios

No capítulo anterior, analisamos a leitura e a escrita de textos com arquivos simples. Usamos a classe File para isso, mas faz muito mais do que apenas ler e escrever. Quando combinado com a classe Directory, podemos executar praticamente qualquer operação do sistema de arquivos, como renomear, mover, excluir e assim por diante.

Este capítulo fornecerá numerosos exemplos de como fazer exatamente essas coisas. As explicações serão limitadas, já que os métodos utilizados são bem simples e fáceis de usar. Você deve estar ciente de duas coisas: Primeiro de tudo, certifique-se de importar o namespace System.IO assim:

using System.IO;

Além disso, esteja ciente de que não estamos fazendo nenhum tratamento de exceção aqui. Vamos verificar se os arquivos e diretórios existem antes de usá-lo, mas não há tratamento de exceção, então, caso algo dê errado, o aplicativo irá travar. O tratamento de exceções geralmente é uma boa ideia ao executar operações de E/S. Para mais informações, leia o capítulo sobre manipulação de exceções neste tutorial.

Em todos os exemplos, usamos nomes simples de arquivos e diretórios, que deverão existir no mesmo diretório que o arquivo EXE gerado em seu aplicativo. Nas configurações do projeto, você pode ver onde seu arquivo EXE é gerado.

Excluindo um arquivo

if(File.Exists("test.txt"))
{
    File.Delete("test.txt");
    if(File.Exists("test.txt") == false)
    Console.WriteLine("File deleted...");
}
else
    Console.WriteLine("File test.txt does not yet exist!");
Console.ReadKey();

Excluindo um diretório

if(Directory.Exists("testdir"))
{
    Directory.Delete("testdir");
    if(Directory.Exists("testdir") == false)
    Console.WriteLine("Directory deleted...");
}
else
    Console.WriteLine("Directory testdir does not yet exist!");
Console.ReadKey();

Se testdir não estiver vazio, você receberá uma exceção. Por quê? Porque esta versão do Delete() na classe Directory só funciona em diretórios vazios. É muito fácil mudar:

Directory.Delete("testdir", true);

O parâmetro extra garante que o método Delete() seja recursivo, o que significa que ele percorrerá subdiretórios e excluirá os arquivos dele, antes de excluir os diretórios.

Renomeando um arquivo

if(File.Exists("test.txt"))
{
    Console.WriteLine("Please enter a new name for this file:");
    string newFilename = Console.ReadLine();
    if(newFilename != String.Empty)
    {
    File.Move("test.txt", newFilename);
    if(File.Exists(newFilename))
    {
        Console.WriteLine("The file was renamed to " + newFilename);
        Console.ReadKey();
    }
    }
}

Você notará que usamos o método Move() para renomear o arquivo. Por que não um método Rename()? Porque não existe tal método, já que mover e renomear é essencialmente a mesma coisa.

Renomeando um diretório

Fazer a mesma coisa com um diretório é igualmente fácil:

if(Directory.Exists("testdir"))
{
    Console.WriteLine("Please enter a new name for this directory:");
    string newDirName = Console.ReadLine();
    if(newDirName != String.Empty)
    {
    Directory.Move("testdir", newDirName);
    if(Directory.Exists(newDirName))
    {
        Console.WriteLine("The directory was renamed to " + newDirName);
        Console.ReadKey();
    }
    }
}

Criando um novo diretório

Criar um novo diretório é fácil também - basta usar o método CreateDirectory() na classe Directory, como neste exemplo:

Console.WriteLine("Please enter a name for the new directory:");
string newDirName = Console.ReadLine();
if(newDirName != String.Empty)
{
    Directory.CreateDirectory(newDirName);
    if(Directory.Exists(newDirName))
    {
    Console.WriteLine("The directory was created!");
    Console.ReadKey();
    }
}

Reading & amp; Escrevendo Arquivos

Como último exemplo, mostrarei como a classe File facilita a leitura e a gravação em um arquivo. Isso pode ser feito de várias maneiras com o C #, mas os métodos Read * e Write *, encontrados na classe File, provavelmente são os mais fáceis de usar. Existem três versões: WriteAllBytes() , WriteAllLines() e WriteAllText() , com os métodos Read correspondentes. O mais simples de usar é o último, que terá uma string simples como entrada. Deixe-me ilustrar como eles funcionam com um exemplo simples:

string fileContents = "John Doe & Jane Doe sitting in a tree...";
File.WriteAllText("test.txt", fileContents);

string fileContentsFromFile = File.ReadAllText("test.txt");
Console.WriteLine(fileContentsFromFile);

Observe como poucas linhas de código eu preciso escrever algo em um arquivo e depois lê-lo de volta! O primeiro parâmetro para ambos os métodos é o caminho para onde o texto deve ser gravado e lido. Normalmente, você especificaria um caminho completo aqui, mas para tornar o exemplo mais claro, eu apenas especifico um nome de arquivo, resultando no arquivo sendo gravado no mesmo diretório que o arquivo EXE.

Resumo

Como você pode ver, as classes Arquivo e Diretório são uma grande ajuda quando você precisa trabalhar com arquivos e diretórios. Eles podem ajudá-lo a fazer a maioria das operações necessárias, e se você precisar fazer coisas ainda mais avançadas, essas classes e seus métodos geralmente servirão como grandes blocos de construção para expandir.