Copier l'intégralité du contenu d'un répertoire en C#

Question

Je souhaite copier l'intégralité du contenu d'un répertoire d'un emplacement à un autre en C#.

Il ne semble pas y avoir de moyen de faire cela en utilisant System.IO sans beaucoup de récursion.

Il y a une méthode en VB que nous pouvons utiliser si nous ajoutons une référence à Microsoft.VisualBasic :

new Microsoft.VisualBasic.Devices.Computer().
    FileSystem.CopyDirectory( sourceFolder, outputFolder );

Cela semble être un hack plutôt moche. Existe-t-il un meilleur moyen ?

Answer 1

Beaucoup plus facile

private static void CopyFilesRecursively(string sourcePath, string targetPath)
{
    //Now Create all of the directories
    foreach (string dirPath in Directory.GetDirectories(sourcePath, "*", SearchOption.AllDirectories))
    {
        Directory.CreateDirectory(dirPath.Replace(sourcePath, targetPath));
    }

    //Copy all the files & Replaces any files with the same name
    foreach (string newPath in Directory.GetFiles(sourcePath, "*.*",SearchOption.AllDirectories))
    {
        File.Copy(newPath, newPath.Replace(sourcePath, targetPath), true);
    }
}

Answer 2

Hmm, je crois que j'ai mal compris la question mais je vais m'y risquer. Quel est le problème avec la méthode simple suivante ?

public static void CopyFilesRecursively(DirectoryInfo source, DirectoryInfo target) {
    foreach (DirectoryInfo dir in source.GetDirectories())
        CopyFilesRecursively(dir, target.CreateSubdirectory(dir.Name));
    foreach (FileInfo file in source.GetFiles())
        file.CopyTo(Path.Combine(target.FullName, file.Name));
}

EDIT Puisque ce message a recueilli un nombre impressionnant de votes négatifs pour une réponse aussi simple à une question tout aussi simple, permettez-moi d'ajouter une explication. S'il vous plaît Lisez ceci avant de voter à la baisse .

Tout d'abord, Ce code n'est pas destiné à être remplacé par un autre code. au code de la question. Il s'agit uniquement d'une illustration.

Microsoft.VisualBasic.Devices.Computer.FileSystem.CopyDirectory effectue quelques tests d'exactitude supplémentaires (par exemple, si la source et la cible sont des répertoires valides, si la source est un parent de la cible, etc.) qui sont absents de cette réponse. Ce code est probablement aussi plus optimisé.

Cela dit, le code fonctionne bien . Il s'agit de a (presque identique) est utilisé dans un logiciel mature depuis des années. En dehors de l'inconstance inhérente à toute gestion des entrées/sorties (par exemple, que se passe-t-il si l'utilisateur débranche manuellement la clé USB alors que votre code est en train d'écrire dessus ?

En particulier, j'aimerais souligner que l'utilisation de la récursion ici n'est absolument pas un problème. Ni en théorie (conceptuellement, c'est la solution la plus élégante), ni en pratique : ce code ne débordera pas de la pile . La pile est suffisamment grande pour gérer même les hiérarchies de fichiers profondément imbriquées. Bien avant que l'espace de la pile ne devienne un problème, la limitation de la longueur du chemin du dossier entre en jeu.

Notez qu'un utilisateur malveillant Il est possible de briser cette hypothèse en utilisant des répertoires profondément imbriqués d'une lettre chacun. Je n'ai pas essayé. Mais juste pour illustrer le point : afin de faire déborder ce code sur un ordinateur typique, les répertoires devraient être imbriqués plusieurs fois. mille temps. Ce n'est tout simplement pas un scénario réaliste.

Answer 3

Copié de MSDN :

using System;
using System.IO;

class CopyDir
{
    public static void Copy(string sourceDirectory, string targetDirectory)
    {
        DirectoryInfo diSource = new DirectoryInfo(sourceDirectory);
        DirectoryInfo diTarget = new DirectoryInfo(targetDirectory);

        CopyAll(diSource, diTarget);
    }

    public static void CopyAll(DirectoryInfo source, DirectoryInfo target)
    {
        Directory.CreateDirectory(target.FullName);

        // Copy each file into the new directory.
        foreach (FileInfo fi in source.GetFiles())
        {
            Console.WriteLine(@"Copying {0}\{1}", target.FullName, fi.Name);
            fi.CopyTo(Path.Combine(target.FullName, fi.Name), true);
        }

        // Copy each subdirectory using recursion.
        foreach (DirectoryInfo diSourceSubDir in source.GetDirectories())
        {
            DirectoryInfo nextTargetSubDir =
                target.CreateSubdirectory(diSourceSubDir.Name);
            CopyAll(diSourceSubDir, nextTargetSubDir);
        }
    }

    public static void Main()
    {
        string sourceDirectory = @"c:\sourceDirectory";
        string targetDirectory = @"c:\targetDirectory";

        Copy(sourceDirectory, targetDirectory);
    }

    // Output will vary based on the contents of the source directory.
}

Answer 4

Ou, si vous voulez employer la manière forte, ajoutez une référence à votre projet pour Microsoft.VisualBasic et utilisez ensuite ce qui suit :

Microsoft.VisualBasic.FileIO.FileSystem.CopyDirectory(fromDirectory, toDirectory);

Toutefois, il est préférable d'utiliser l'une des fonctions récursives, car elle ne devra pas charger la dll VB.

Answer 5

Essayez ça :

Process proc = new Process();
proc.StartInfo.UseShellExecute = true;
proc.StartInfo.FileName = Path.Combine(Environment.SystemDirectory, "xcopy.exe");
proc.StartInfo.Arguments = @"C:\source C:\destination /E /I";
proc.Start();

Vos arguments de xcopy peuvent varier mais vous avez l'idée.