CodeGym /Cursos /C# SELF /Copiando arquivos e diretórios

Copiando arquivos e diretórios

C# SELF
Nível 40, Lição 2
Disponível

1. Copiando arquivos

Até agora nossas operações com o sistema de arquivos eram tipo um "golpe único": cria o arquivo, lê, apaga — e pronto. Mas no mundo real frequentemente precisamos copiar conteúdo: backup de documentos, duplicar templates, automatizar processos com dados. Copiar parece uma tarefa infantil (Ctrl+C e Ctrl+V — nossa salvação), mas na prática tem muitos detalhes.

Hoje vamos ver todas as formas de copiar arquivos e pastas — das mais simples até as um pouco mais complicadas. Também vamos ver como as classes embutidas do .NET resolvem isso, quais são as limitações, que erros podem aparecer e o que fazer se de repente houver dois mil diretórios e um milhão de arquivos.

Classe File e método Copy

A maneira mais simples de copiar um arquivo é usar o método estático File.Copy. Esse método recebe o caminho do arquivo de origem, o caminho do novo arquivo e um parâmetro opcional: permitir sobrescrever se o arquivo já existir.

using System.IO;

// Exemplo simples de cópia de arquivo
File.Copy("source.txt", "destination.txt");

Se o arquivo de destino já existir, o método lançará uma exceção. Para permitir sobrescrita explicitamente, use o terceiro parâmetro:

File.Copy("source.txt", "destination.txt", overwrite: true);

Ponto importante: Se o segundo parâmetro ("destination.txt") for o caminho de um diretório existente, e não de um arquivo, dará erro. O método espera o caminho exatamente de um arquivo!

Trabalhando com caminhos

Como sempre, não esqueça de usar Path.Combine para não cair nas armadilhas de barras duplas ou barras invertidas:

string sourcePath = Path.Combine("Data", "input.txt");
string destPath = Path.Combine("Backup", "input_backup.txt");

File.Copy(sourcePath, destPath, overwrite: true);

Tratamento de erros

O que pode dar errado ao copiar um arquivo? Muitas coisas: o arquivo pode estar em uso por outro processo, o arquivo de origem pode não existir, você pode não ter permissões, o disco de destino pode estar cheio. Use tratamento de exceções:

try
{
    File.Copy("bigdata.txt", "bigdata_backup.txt", overwrite: false);
    Console.WriteLine("Arquivo copiado com sucesso!");
}
catch (IOException ex)
{
    Console.WriteLine($"Erro de I/O: {ex.Message}");
}
catch (UnauthorizedAccessException)
{
    Console.WriteLine("Sem acesso ao arquivo ou pasta.");
}
catch (Exception ex)
{
    Console.WriteLine($"Outro erro: {ex.Message}");
}

Classe FileInfo e método CopyTo

Se você já tem um objeto FileInfo, pode chamar o método CopyTo nele:

var fi = new FileInfo("report.xlsx");
fi.CopyTo("backup_report.xlsx");

O terceiro argumento (overwrite) em CopyTo apareceu só no .NET Core 2.0+, então se você estiver targeting uma versão antiga do framework — não estranhe o erro.

Copiando um arquivo "para lugar nenhum" (ou "quem não foi pego, não foi")

Preste atenção ao caminho de destino. Se a pasta de destino não existir, o .NET vai lançar erro. Então antes de copiar é bom garantir que o diretório receptor existe:

string backupDir = "Backup";
if (!Directory.Exists(backupDir))
{
    Directory.CreateDirectory(backupDir);
}

string targetPath = Path.Combine(backupDir, "mydoc.txt");
File.Copy("mydoc.txt", targetPath);

2. Copiando diretórios: tarefa não para os fracos

Aí começam as aventuras! No .NET não existe um método "mágico" Directory.Copy que faça tudo em uma linha (como o File). Vai ser preciso trabalhar um pouco e escrever uma função para copiar recursivamente todos os arquivos e subpastas.

Por que não existe Directory.Copy?

Copiar diretórios nem sempre é trivial. É preciso considerar que cada pasta pode ter arquivos, subpastas, arquivos ocultos, arquivos com permissões especiais e caminhos longos. Então os desenvolvedores do .NET decidiram: "Deixa os programadores escolherem o que copiar." Mas a gente não foge do problema — vamos criar nossa função!

Exemplo de cópia recursiva de diretório

Tarefa: copiar o conteúdo de uma pasta (e todo o seu sub-universo) para outra.

using System;
using System.IO;

void CopyDirectory(string sourceDir, string destDir, bool recursive)
{
    // Verifica se a pasta de origem existe
    if (!Directory.Exists(sourceDir))
        throw new DirectoryNotFoundException($"Pasta de origem não encontrada: {sourceDir}");

    // Cria a pasta de destino, se ainda não existir
    if (!Directory.Exists(destDir))
        Directory.CreateDirectory(destDir);

    // Copia todos os arquivos
    foreach (string filePath in Directory.GetFiles(sourceDir))
    {
        string fileName = Path.GetFileName(filePath);
        string destFilePath = Path.Combine(destDir, fileName);
        File.Copy(filePath, destFilePath, overwrite: true);
    }

    // Se for recursivo — copia todas as subpastas
    if (recursive)
    {
        foreach (string dirPath in Directory.GetDirectories(sourceDir))
        {
            string dirName = Path.GetFileName(dirPath);
            string destSubDir = Path.Combine(destDir, dirName);
            // Chamada recursiva!
            CopyDirectory(dirPath, destSubDir, recursive);
        }
    }
}

Uso:

CopyDirectory("C:\\MyData", "D:\\Backup\\MyData", recursive: true);

Essa função cria a estrutura de diretórios e copia todos os arquivos, inclusive o conteúdo das subpastas.

Analisando o código e os detalhes

Primeiro criamos o diretório de destino (se não existir) — senão ao tentar copiar um arquivo para lá vai dar erro. Dentro de cada loop usamos Path.GetFileName para não perder o nome do arquivo ou pasta ao montar o novo caminho.

Aliás, se você copiar um diretório para dentro de si mesmo ou para uma subpasta sua, vai ter uma recursão épica... e um StackOverflowException. Não copie "C:\\Data" para "C:\\Data\\Backup". O computador vai ficar chateado!

Copiando só os arquivos (sem subpastas)

Às vezes basta copiar só os arquivos do nível superior (sem descer nas subpastas):

void CopyFilesOnly(string sourceDir, string destDir)
{
    if (!Directory.Exists(destDir))
        Directory.CreateDirectory(destDir);

    foreach (string filePath in Directory.GetFiles(sourceDir))
    {
        string fileName = Path.GetFileName(filePath);
        string destFilePath = Path.Combine(destDir, fileName);
        File.Copy(filePath, destFilePath, overwrite: true);
    }
}

Exemplo — implementando backup

Vamos adicionar essa funcionalidade ao nosso "HomeApp" que estamos desenvolvendo no curso. Que ele agora saiba fazer backup dos seus dados.

using System;
using System.IO;

namespace HomeApp
{
    class Program
    {
        static void CopyDirectory(string sourceDir, string destDir, bool recursive)
        {
            if (!Directory.Exists(sourceDir))
                throw new DirectoryNotFoundException($"Pasta de origem não encontrada: {sourceDir}");

            if (!Directory.Exists(destDir))
                Directory.CreateDirectory(destDir);

            foreach (string filePath in Directory.GetFiles(sourceDir))
            {
                string fileName = Path.GetFileName(filePath);
                string destFilePath = Path.Combine(destDir, fileName);
                File.Copy(filePath, destFilePath, overwrite: true);
            }

            if (recursive)
            {
                foreach (string dirPath in Directory.GetDirectories(sourceDir))
                {
                    string dirName = Path.GetFileName(dirPath);
                    string destSubDir = Path.Combine(destDir, dirName);
                    CopyDirectory(dirPath, destSubDir, recursive);
                }
            }
        }

        static void Main(string[] args)
        {
            Console.WriteLine("Digite o caminho do diretório de trabalho:");
            string source = Console.ReadLine()!;
            Console.WriteLine("Digite o caminho da pasta para o backup:");
            string dest = Console.ReadLine()!;

            try
            {
                CopyDirectory(source, dest, recursive: true);
                Console.WriteLine("Backup criado com sucesso!");
            }
            catch (Exception ex)
            {
                Console.WriteLine("Erro ao copiar: " + ex.Message);
            }
        }
    }
}

3. Dicas úteis

Comparação: arquivo vs diretório — tabela

Arquivo Diretório
Método embutido
File.Copy
-
Orientado a objeto
FileInfo.CopyTo
-
Percorrer hierarquia Não necessário Necessário recursão
Criar estrutura Automaticamente Precisa criar manualmente a hierarquia
Perigo de recursão Não Sim — não copie "pra dentro de si"

Aplicação prática e exercícios

Tarefas de copiar arquivos e pastas aparecem em todo lugar: de backup a migração de dados ou atualização de recursos em launchers de jogos. Normalmente esses processos são automatizados para evitar trabalho manual e o clássico "ah, esqueci o arquivo!" na segunda de manhã.

Copiar diretórios é importante em cenários onde você precisa preservar não só o conteúdo, mas também a "estrutura" — incluindo subpastas, arquivos internos e configurações.

Checklist para copiar (pra não se ferrar)

  • Existência da fonte
  • Existência da pasta de destino (criar se necessário via Directory.CreateDirectory)
  • Política de sobrescrita de arquivos — precisa de overwrite: true?
  • Você não está copiando a pasta "para dentro de si"?
  • O comprimento do caminho não está estourando (especialmente no Windows)?
  • Você está considerando arquivos ocultos/sistema?

4. Particularidades e erros típicos ao copiar

Permissões

A cópia pode falhar se seu programa não tiver permissões para ler os arquivos de origem ou escrever no diretório de destino. Nesse caso você receberá uma variação de UnauthorizedAccessException. A solução — rodar o programa como administrador (só se realmente precisar!) ou escolher pastas apropriadas para operação.

Arquivos em uso

Se o arquivo estiver aberto em outro programa (por exemplo, Excel mantendo ele bloqueado), File.Copy pode lançar exceção. Certifique-se que o app que trava o arquivo não atrapalhe, ou implemente lógica de tentativas repetidas (try-catch com retries).

Sobrescrita de arquivos

Qual lógica escolher: sobrescrever os arquivos de destino ou deixá-los intactos se já existirem? Para backup normalmente faz sentido sobrescrever (overwrite: true), para duplicar templates talvez não (overwrite: false).

Arquivos ocultos e de sistema

Por padrão os métodos que usamos (Directory.GetFiles) retornam todos os arquivos, incluindo ocultos e de sistema. Se quiser pular eles, filtre explicitamente:

foreach (string filePath in Directory.GetFiles(sourceDir))
{
    var attr = File.GetAttributes(filePath);
    if ((attr & FileAttributes.Hidden) == FileAttributes.Hidden)
        continue; // Pulamos arquivos ocultos

    // Resto do código de cópia
}

Erros por caminhos longos

O Windows por muito tempo limitou o comprimento do caminho a ~260 caracteres. Em versões modernas dá para remover essa limitação, mas se você trabalha com sistemas antigos caminhos longos podem ser um problema.

Links simbólicos e "junctions"

Em cenários específicos podem existir symbolic links ou junctions dentro dos diretórios. Métodos normais de cópia podem copiá-los como pastas normais ou ignorar. Para a maioria das tarefas didáticas isso não importa, mas ao mexer com pastas do sistema — fique atento.

2
Tarefa
C# SELF, nível 40, lição 2
Bloqueado
Cópia recursiva de pastas
Cópia recursiva de pastas
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION