คัดลอกเนื้อหาทั้งหมดของไดเรกทอรีใน C #

ฉันต้องการคัดลอกเนื้อหาทั้งหมดของไดเรกทอรีจากที่หนึ่งไปอีกที่หนึ่งใน C #

ดูเหมือนจะไม่มีทางทำสิ่งนี้โดยใช้System.IOคลาสโดยไม่มีการสอบถามซ้ำ

มีวิธีการใน VB ที่เราสามารถใช้ถ้าเราเพิ่มการอ้างอิงถึงMicrosoft.VisualBasic:

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

ดูเหมือนว่าแฮ็คจะค่อนข้างน่าเกลียด มีวิธีที่ดีกว่า?

ง่ายกว่ามาก

//Now Create all of the directories
foreach (string dirPath in Directory.GetDirectories(SourcePath, "*", 
    SearchOption.AllDirectories))
    Directory.CreateDirectory(dirPath.Replace(SourcePath, DestinationPath));

//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, DestinationPath), true);

อืมฉันคิดว่าฉันเข้าใจผิดคำถาม แต่ฉันจะเสี่ยงมัน มีอะไรผิดปกติกับวิธีการตรงไปตรงมาต่อไปนี้?

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));
}

แก้ไขเนื่องจากการโพสต์นี้ได้รวบรวมจำนวน downvotes ที่น่าประทับใจสำหรับคำตอบง่ายๆสำหรับคำถามง่าย ๆ ให้ฉันเพิ่มคำอธิบาย โปรด อ่านก่อนลงคะแนน

ก่อนอื่นรหัสนี้ไม่ได้มีเจตนาเพื่อเป็นการแทนที่ในรหัสในคำถาม มันมีวัตถุประสงค์เพื่อประกอบการอธิบายเท่านั้น

Microsoft.VisualBasic.Devices.Computer.FileSystem.CopyDirectoryทำการทดสอบความถูกต้องเพิ่มเติมบางอย่าง (เช่นแหล่งที่มาและเป้าหมายเป็นไดเรกทอรีที่ถูกต้องไม่ว่าจะเป็นแหล่งกำเนิดของเป้าหมาย ฯลฯ ) ที่หายไปจากคำตอบนี้ รหัสนั้นน่าจะเหมาะกว่า

ที่กล่าวว่ารหัสทำงานได้ดี มันมี (เกือบจะเหมือนกัน) ถูกนำมาใช้ในซอฟแวร์สำหรับผู้ใหญ่ปี นอกเหนือจากความไม่แน่นอนที่มีอยู่ในตัวจัดการ IO ทั้งหมด (เช่นจะเกิดอะไรขึ้นถ้าผู้ใช้ถอดปลั๊ก USB ไดรฟ์ด้วยตนเองในขณะที่โค้ดของคุณเขียนอยู่?) ไม่มีปัญหาใด ๆ

โดยเฉพาะอย่างยิ่งฉันต้องการชี้ให้เห็นว่าการใช้การเรียกซ้ำที่นี่ไม่ใช่ปัญหาอย่างแน่นอน ทั้งในทางทฤษฎี (แนวคิดมันเป็นทางออกที่สวยงามมากที่สุด) หรือในการปฏิบัติ: รหัสนี้จะไม่ล้นสแต็ค สแต็กมีขนาดใหญ่พอที่จะจัดการกับลำดับชั้นของไฟล์ที่ซ้อนกันได้ นานก่อนที่พื้นที่สแต็กจะกลายเป็นปัญหาข้อ จำกัด ความยาวพา ธ ของโฟลเดอร์จะเริ่มขึ้น

ขอให้สังเกตว่าผู้ใช้ที่เป็นอันตรายอาจสามารถทำลายสมมติฐานนี้ได้โดยใช้ไดเรกทอรีที่ซ้อนกันของตัวอักษรละตัว ฉันไม่ได้ลองสิ่งนี้ แต่เพียงเพื่อแสดงจุด: เพื่อให้รหัสนี้ล้นบนคอมพิวเตอร์ทั่วไปไดเรกทอรีจะต้องซ้อนกันสองสามพันครั้ง นี่ไม่ใช่สถานการณ์จริง

คัดลอกมาจาก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.
}

ลองสิ่งนี้:

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();

อาร์กิวเมนต์ xcopy ของคุณอาจแตกต่างกัน แต่คุณได้รับแนวคิด

หรือถ้าคุณต้องการใช้วิธีที่ยากเพิ่มการอ้างอิงถึงโครงการของคุณสำหรับ Microsoft.VisualBasic แล้วใช้สิ่งต่อไปนี้:

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

อย่างไรก็ตามการใช้หนึ่งในฟังก์ชั่นวนซ้ำเป็นวิธีที่ดีกว่าในการดำเนินการเนื่องจากไม่จำเป็นต้องโหลด VB dll

ไซต์นี้ช่วยฉันออกมามากมายและตอนนี้ถึงเวลาแล้วที่ฉันจะช่วยเหลือผู้อื่นในสิ่งที่ฉันรู้

ฉันหวังว่ารหัสของฉันด้านล่างจะมีประโยชน์สำหรับใครบางคน

string source_dir = @"E:\";
string destination_dir = @"C:\";

// substring is to remove destination_dir absolute path (E:\).

// Create subdirectory structure in destination    
    foreach (string dir in System.IO.Directory.GetDirectories(source_dir, "*", System.IO.SearchOption.AllDirectories))
    {
        System.IO.Directory.CreateDirectory(System.IO.Path.Combine(destination_dir, dir.Substring(source_dir.Length + 1)));
        // Example:
        //     > C:\sources (and not C:\E:\sources)
    }

    foreach (string file_name in System.IO.Directory.GetFiles(source_dir, "*", System.IO.SearchOption.AllDirectories))
    {
        System.IO.File.Copy(file_name, System.IO.Path.Combine(destination_dir, file_name.Substring(source_dir.Length + 1)));
    }

คัดลอกโฟลเดอร์ซ้ำโดยไม่เรียกซ้ำเพื่อหลีกเลี่ยงการล้นสแต็ค

public static void CopyDirectory(string source, string target)
{
    var stack = new Stack<Folders>();
    stack.Push(new Folders(source, target));

    while (stack.Count > 0)
    {
        var folders = stack.Pop();
        Directory.CreateDirectory(folders.Target);
        foreach (var file in Directory.GetFiles(folders.Source, "*.*"))
        {
            File.Copy(file, Path.Combine(folders.Target, Path.GetFileName(file)));
        }

        foreach (var folder in Directory.GetDirectories(folders.Source))
        {
            stack.Push(new Folders(folder, Path.Combine(folders.Target, Path.GetFileName(folder))));
        }
    }
}

public class Folders
{
    public string Source { get; private set; }
    public string Target { get; private set; }

    public Folders(string source, string target)
    {
        Source = source;
        Target = target;
    }
}

นี่คือคลาสยูทิลิตี้ที่ฉันใช้สำหรับงาน IO เช่นนี้

using System;
using System.Runtime.InteropServices;

namespace MyNameSpace
{
    public class ShellFileOperation
    {
        private static String StringArrayToMultiString(String[] stringArray)
        {
            String multiString = "";

            if (stringArray == null)
                return "";

            for (int i=0 ; i<stringArray.Length ; i++)
                multiString += stringArray[i] + '\0';

            multiString += '\0';

            return multiString;
        }

        public static bool Copy(string source, string dest)
        {
            return Copy(new String[] { source }, new String[] { dest });
        }

        public static bool Copy(String[] source, String[] dest)
        {
            Win32.SHFILEOPSTRUCT FileOpStruct = new Win32.SHFILEOPSTRUCT();

            FileOpStruct.hwnd = IntPtr.Zero;
            FileOpStruct.wFunc = (uint)Win32.FO_COPY;

            String multiSource = StringArrayToMultiString(source);
            String multiDest = StringArrayToMultiString(dest);
            FileOpStruct.pFrom = Marshal.StringToHGlobalUni(multiSource);
            FileOpStruct.pTo = Marshal.StringToHGlobalUni(multiDest);

            FileOpStruct.fFlags = (ushort)Win32.ShellFileOperationFlags.FOF_NOCONFIRMATION;
            FileOpStruct.lpszProgressTitle = "";
            FileOpStruct.fAnyOperationsAborted = 0;
            FileOpStruct.hNameMappings = IntPtr.Zero;

            int retval = Win32.SHFileOperation(ref FileOpStruct);

            if(retval != 0) return false;
            return true;
        }

        public static bool Move(string source, string dest)
        {
            return Move(new String[] { source }, new String[] { dest });
        }

        public static bool Delete(string file)
        {
            Win32.SHFILEOPSTRUCT FileOpStruct = new Win32.SHFILEOPSTRUCT();

            FileOpStruct.hwnd = IntPtr.Zero;
            FileOpStruct.wFunc = (uint)Win32.FO_DELETE;

            String multiSource = StringArrayToMultiString(new string[] { file });
            FileOpStruct.pFrom = Marshal.StringToHGlobalUni(multiSource);
            FileOpStruct.pTo =  IntPtr.Zero;

            FileOpStruct.fFlags = (ushort)Win32.ShellFileOperationFlags.FOF_SILENT | (ushort)Win32.ShellFileOperationFlags.FOF_NOCONFIRMATION | (ushort)Win32.ShellFileOperationFlags.FOF_NOERRORUI | (ushort)Win32.ShellFileOperationFlags.FOF_NOCONFIRMMKDIR;
            FileOpStruct.lpszProgressTitle = "";
            FileOpStruct.fAnyOperationsAborted = 0;
            FileOpStruct.hNameMappings = IntPtr.Zero;

            int retval = Win32.SHFileOperation(ref FileOpStruct);

            if(retval != 0) return false;
            return true;
        }

        public static bool Move(String[] source, String[] dest)
        {
            Win32.SHFILEOPSTRUCT FileOpStruct = new Win32.SHFILEOPSTRUCT();

            FileOpStruct.hwnd = IntPtr.Zero;
            FileOpStruct.wFunc = (uint)Win32.FO_MOVE;

            String multiSource = StringArrayToMultiString(source);
            String multiDest = StringArrayToMultiString(dest);
            FileOpStruct.pFrom = Marshal.StringToHGlobalUni(multiSource);
            FileOpStruct.pTo = Marshal.StringToHGlobalUni(multiDest);

            FileOpStruct.fFlags = (ushort)Win32.ShellFileOperationFlags.FOF_NOCONFIRMATION;
            FileOpStruct.lpszProgressTitle = "";
            FileOpStruct.fAnyOperationsAborted = 0;
            FileOpStruct.hNameMappings = IntPtr.Zero;

            int retval = Win32.SHFileOperation(ref FileOpStruct);

            if(retval != 0) return false;
            return true;
        }
    }
}

อาจไม่ทราบประสิทธิภาพ แต่ฉันใช้มันสำหรับโฟลเดอร์ 30MB และใช้งานได้อย่างไม่มีที่ติ นอกจากนี้ฉันไม่ชอบจำนวนของรหัสและการเรียกซ้ำทั้งหมดที่จำเป็นสำหรับงานที่ง่ายเช่นนี้

var source_folder = "c:\src";
var dest_folder = "c:\dest";
var zipFile = source_folder + ".zip";

ZipFile.CreateFromDirectory(source_folder, zipFile);
ZipFile.ExtractToDirectory(zipFile, dest_folder);
File.Delete(zipFile);

หมายเหตุ: ZipFile พร้อมใช้งานบน. NET 4.5+ ในเนมสเปซ System.IO.Compression

การปรับปรุงเล็กน้อยในคำตอบของ d4nt เนื่องจากคุณอาจต้องการตรวจสอบข้อผิดพลาดและไม่ต้องเปลี่ยนเส้นทาง xcopy หากคุณทำงานบนเซิร์ฟเวอร์และเครื่องพัฒนา:

public void CopyFolder(string source, string destination)
{
    string xcopyPath = Environment.GetEnvironmentVariable("WINDIR") + @"\System32\xcopy.exe";
    ProcessStartInfo info = new ProcessStartInfo(xcopyPath);
    info.UseShellExecute = false;
    info.RedirectStandardOutput = true;
    info.Arguments = string.Format("\"{0}\" \"{1}\" /E /I", source, destination);

    Process process = Process.Start(info);
    process.WaitForExit();
    string result = process.StandardOutput.ReadToEnd();

    if (process.ExitCode != 0)
    {
        // Or your own custom exception, or just return false if you prefer.
        throw new InvalidOperationException(string.Format("Failed to copy {0} to {1}: {2}", source, destination, result));
    }
}

นี่คือรหัสของฉันหวังว่าความช่วยเหลือนี้

    private void KCOPY(string source, string destination)
    {
        if (IsFile(source))
        {
            string target = Path.Combine(destination, Path.GetFileName(source));
            File.Copy(source, target, true);
        }
        else
        {
            string fileName = Path.GetFileName(source);
            string target = System.IO.Path.Combine(destination, fileName);
            if (!System.IO.Directory.Exists(target))
            {
                System.IO.Directory.CreateDirectory(target);
            }

            List<string> files = GetAllFileAndFolder(source);

            foreach (string file in files)
            {
                KCOPY(file, target);
            }
        }
    }

    private List<string> GetAllFileAndFolder(string path)
    {
        List<string> allFile = new List<string>();
        foreach (string dir in Directory.GetDirectories(path))
        {
            allFile.Add(dir);
        }
        foreach (string file in Directory.GetFiles(path))
        {
            allFile.Add(file);
        }

        return allFile;
    }
    private bool IsFile(string path)
    {
        if ((File.GetAttributes(path) & FileAttributes.Directory) == FileAttributes.Directory)
        {
            return false;
        }
        return true;
    }

หากคุณชอบคำตอบที่ได้รับความนิยมของ Konrad แต่คุณต้องการให้sourceตัวเองเป็นโฟลเดอร์ภายใต้targetแทนที่จะเอาลูก ๆ ไว้ใต้targetโฟลเดอร์นี่คือรหัสสำหรับสิ่งนั้น มันคืนค่าที่สร้างขึ้นใหม่DirectoryInfoซึ่งมีประโยชน์:

public static DirectoryInfo CopyFilesRecursively(DirectoryInfo source, DirectoryInfo target)
{
  var newDirectoryInfo = target.CreateSubdirectory(source.Name);
  foreach (var fileInfo in source.GetFiles())
    fileInfo.CopyTo(Path.Combine(newDirectoryInfo.FullName, fileInfo.Name));

  foreach (var childDirectoryInfo in source.GetDirectories())
    CopyFilesRecursively(childDirectoryInfo, newDirectoryInfo);

  return newDirectoryInfo;
}

คุณสามารถใช้สิ่งนี้ได้จากเว็บไซต์ของ Microsoft

static void Main()
{
    // Copy from the current directory, include subdirectories.
    DirectoryCopy(".", @".\temp", true);
}

private static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs)
{
    // Get the subdirectories for the specified directory.
    DirectoryInfo dir = new DirectoryInfo(sourceDirName);

    if (!dir.Exists)
    {
        throw new DirectoryNotFoundException(
            "Source directory does not exist or could not be found: "
            + sourceDirName);
    }

    DirectoryInfo[] dirs = dir.GetDirectories();
    // If the destination directory doesn't exist, create it.
    if (!Directory.Exists(destDirName))
    {
        Directory.CreateDirectory(destDirName);
    }

    // Get the files in the directory and copy them to the new location.
    FileInfo[] files = dir.GetFiles();
    foreach (FileInfo file in files)
    {
        string temppath = Path.Combine(destDirName, file.Name);
        file.CopyTo(temppath, false);
    }

    // If copying subdirectories, copy them and their contents to new location.
    if (copySubDirs)
    {
        foreach (DirectoryInfo subdir in dirs)
        {
            string temppath = Path.Combine(destDirName, subdir.Name);
            DirectoryCopy(subdir.FullName, temppath, copySubDirs);
        }
    }
}

tboswell 's แทนที่รุ่น Proof (ซึ่งยืดหยุ่นต่อรูปแบบการทำซ้ำใน filepath)

public static void copyAll(string SourcePath , string DestinationPath )
{
   //Now Create all of the directories
   foreach (string dirPath in Directory.GetDirectories(SourcePath, "*", SearchOption.AllDirectories))
      Directory.CreateDirectory(Path.Combine(DestinationPath ,dirPath.Remove(0, SourcePath.Length ))  );

   //Copy all the files & Replaces any files with the same name
   foreach (string newPath in Directory.GetFiles(SourcePath, "*.*",  SearchOption.AllDirectories))
      File.Copy(newPath, Path.Combine(DestinationPath , newPath.Remove(0, SourcePath.Length)) , true);
    }

วิธีการแก้ปัญหาของฉันเป็นการแก้ไขคำตอบของ @ Termininja อย่างไรก็ตามฉันได้ปรับปรุงให้ดีขึ้นเล็กน้อยและดูเหมือนจะเร็วกว่าคำตอบที่ยอมรับมากกว่า 5 เท่า

public static void CopyEntireDirectory(string path, string newPath)
{
    Parallel.ForEach(Directory.GetFileSystemEntries(path, "*", SearchOption.AllDirectories)
    ,(fileName) =>
    {
        string output = Regex.Replace(fileName, "^" + Regex.Escape(path), newPath);
        if (File.Exists(fileName))
        {
            Directory.CreateDirectory(Path.GetDirectoryName(output));
            File.Copy(fileName, output, true);
        }
        else
            Directory.CreateDirectory(output);
    });
}

แก้ไข: การแก้ไข @Ahmed Sabry เป็น full foreach แบบขนานจะให้ผลลัพธ์ที่ดีกว่าอย่างไรก็ตามโค้ดใช้ฟังก์ชันแบบเรียกซ้ำและไม่เหมาะในบางสถานการณ์

public static void CopyEntireDirectory(DirectoryInfo source, DirectoryInfo target, bool overwiteFiles = true)
{
    if (!source.Exists) return;
    if (!target.Exists) target.Create();

    Parallel.ForEach(source.GetDirectories(), (sourceChildDirectory) =>
        CopyEntireDirectory(sourceChildDirectory, new DirectoryInfo(Path.Combine(target.FullName, sourceChildDirectory.Name))));

    Parallel.ForEach(source.GetFiles(), sourceFile =>
        sourceFile.CopyTo(Path.Combine(target.FullName, sourceFile.Name), overwiteFiles));
}

ขออภัยสำหรับรหัสก่อนหน้านี้ยังคงมีข้อบกพร่อง :( (ตกเป็นเหยื่อของปัญหาปืนที่เร็วที่สุด) ที่นี่มีการทดสอบและใช้งานได้ที่สำคัญคือ SearchOption.AllDirectories ซึ่งไม่จำเป็นต้องเรียกซ้ำอย่างชัดเจน

string path = "C:\\a";
string[] dirs = Directory.GetDirectories(path, "*.*", SearchOption.AllDirectories);
string newpath = "C:\\x";
try
{
    Directory.CreateDirectory(newpath);
}
catch (IOException ex)
{
    Console.WriteLine(ex.Message);
}
for (int j = 0; j < dirs.Length; j++)
{
    try
    {
        Directory.CreateDirectory(dirs[j].Replace(path, newpath));
    }
    catch (IOException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

string[] files = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);
for (int j = 0; j < files.Length; j++)            
{
    try
    {
        File.Copy(files[j], files[j].Replace(path, newpath));
    }
    catch (IOException ex)
    {
        Console.WriteLine(ex.Message);
    }
}

นี่คือวิธีการขยายสำหรับ DirectoryInfo a la FileInfo.CopyTo (บันทึกoverwriteพารามิเตอร์):

public static DirectoryInfo CopyTo(this DirectoryInfo sourceDir, string destinationPath, bool overwrite = false)
{
    var sourcePath = sourceDir.FullName;

    var destination = new DirectoryInfo(destinationPath);

    destination.Create();

    foreach (var sourceSubDirPath in Directory.EnumerateDirectories(sourcePath, "*", SearchOption.AllDirectories))
        Directory.CreateDirectory(sourceSubDirPath.Replace(sourcePath, destinationPath));

    foreach (var file in Directory.EnumerateFiles(sourcePath, "*", SearchOption.AllDirectories))
        File.Copy(file, file.Replace(sourcePath, destinationPath), overwrite);

    return destination;
}

ใช้คลาสนี้

public static class Extensions
{
    public static void CopyTo(this DirectoryInfo source, DirectoryInfo target, bool overwiteFiles = true)
    {
        if (!source.Exists) return;
        if (!target.Exists) target.Create();

        Parallel.ForEach(source.GetDirectories(), (sourceChildDirectory) => 
            CopyTo(sourceChildDirectory, new DirectoryInfo(Path.Combine(target.FullName, sourceChildDirectory.Name))));

        foreach (var sourceFile in source.GetFiles())
            sourceFile.CopyTo(Path.Combine(target.FullName, sourceFile.Name), overwiteFiles);
    }
    public static void CopyTo(this DirectoryInfo source, string target, bool overwiteFiles = true)
    {
        CopyTo(source, new DirectoryInfo(target), overwiteFiles);
    }
}

ตัวแปรหนึ่งตัวที่มีการวนซ้ำเพียงครั้งเดียวสำหรับการคัดลอกโฟลเดอร์และไฟล์ทั้งหมด:

foreach (var f in Directory.GetFileSystemEntries(path, "*", SearchOption.AllDirectories))
{
    var output = Regex.Replace(f, @"^" + path, newPath);
    if (File.Exists(f)) File.Copy(f, output, true);
    else Directory.CreateDirectory(output);
}

ดีกว่ารหัสใด ๆ (วิธีการขยายไปยัง DirectoryInfo ด้วยการเรียกซ้ำ)

public static bool CopyTo(this DirectoryInfo source, string destination)
    {
        try
        {
            foreach (string dirPath in Directory.GetDirectories(source.FullName))
            {
                var newDirPath = dirPath.Replace(source.FullName, destination);
                Directory.CreateDirectory(newDirPath);
                new DirectoryInfo(dirPath).CopyTo(newDirPath);
            }
            //Copy all the files & Replaces any files with the same name
            foreach (string filePath in Directory.GetFiles(source.FullName))
            {
                File.Copy(filePath, filePath.Replace(source.FullName,destination), true);
            }
            return true;
        }
        catch (IOException exp)
        {
            return false;
        }
    }

คัดลอกและแทนที่ไฟล์ทั้งหมดของโฟลเดอร์

        public static void CopyAndReplaceAll(string SourcePath, string DestinationPath, string backupPath)
    {
            foreach (string dirPath in Directory.GetDirectories(SourcePath, "*", SearchOption.AllDirectories))
            {
                Directory.CreateDirectory($"{DestinationPath}{dirPath.Remove(0, SourcePath.Length)}");
                Directory.CreateDirectory($"{backupPath}{dirPath.Remove(0, SourcePath.Length)}");
            }
            foreach (string newPath in Directory.GetFiles(SourcePath, "*.*", SearchOption.AllDirectories))
            {
                if (!File.Exists($"{ DestinationPath}{newPath.Remove(0, SourcePath.Length)}"))
                    File.Copy(newPath, $"{ DestinationPath}{newPath.Remove(0, SourcePath.Length)}");
                else
                    File.Replace(newPath
                        , $"{ DestinationPath}{newPath.Remove(0, SourcePath.Length)}"
                        , $"{ backupPath}{newPath.Remove(0, SourcePath.Length)}", false);
            }
    }

รหัสด้านล่างคือข้อเสนอแนะของ Microsoft วิธีคัดลอกไดเรกทอรี และใช้ร่วมกันโดย dear @iato แต่เพียงคัดลอกไดเรกทอรีย่อยและไฟล์ของโฟลเดอร์ต้นทางซ้ำและไม่คัดลอกโฟลเดอร์ต้นทางที่เป็นของตนเอง (เช่นคลิกขวา -> คัดลอก )

แต่มีวิธีที่ยุ่งยากด้านล่างคำตอบนี้:

private static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs = true)
        {
            // Get the subdirectories for the specified directory.
            DirectoryInfo dir = new DirectoryInfo(sourceDirName);

            if (!dir.Exists)
            {
                throw new DirectoryNotFoundException(
                    "Source directory does not exist or could not be found: "
                    + sourceDirName);
            }

            DirectoryInfo[] dirs = dir.GetDirectories();
            // If the destination directory doesn't exist, create it.
            if (!Directory.Exists(destDirName))
            {
                Directory.CreateDirectory(destDirName);
            }

            // Get the files in the directory and copy them to the new location.
            FileInfo[] files = dir.GetFiles();
            foreach (FileInfo file in files)
            {
                string temppath = Path.Combine(destDirName, file.Name);
                file.CopyTo(temppath, false);
            }

            // If copying subdirectories, copy them and their contents to new location.
            if (copySubDirs)
            {
                foreach (DirectoryInfo subdir in dirs)
                {
                    string temppath = Path.Combine(destDirName, subdir.Name);
                    DirectoryCopy(subdir.FullName, temppath, copySubDirs);
                }
            }
        }

หากคุณต้องการคัดลอกเนื้อหาของโฟลเดอร์ต้นทางและโฟลเดอร์ย่อยซ้ำคุณสามารถใช้มันได้ดังนี้:

string source = @"J:\source\";
string dest= @"J:\destination\";
DirectoryCopy(source, dest);

แต่ถ้าคุณต้องการคัดลอกไดเรกทอรีต้นทางมันเอง (คล้ายกับที่คุณคลิกขวาบนโฟลเดอร์ต้นทางและคลิกคัดลอกจากนั้นในโฟลเดอร์ปลายทางที่คุณคลิกวาง) คุณควรใช้ดังนี้:

 string source = @"J:\source\";
 string dest= @"J:\destination\";
 DirectoryCopy(source, Path.Combine(dest, new DirectoryInfo(source).Name));