[API Implementation]: DirectoryInfo.CopyTo / Directory.Copy

src/libraries/System.Private.CoreLib/src/System/IO/Directory.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.IO.Enumeration;
+using System.Threading;
 
 namespace System.IO
 {
@@ -350,5 +351,13 @@ public static FileSystemInfo CreateSymbolicLink(string path, string pathToTarget
             FileSystem.VerifyValidPath(linkPath, nameof(linkPath));
             return FileSystem.ResolveLinkTarget(linkPath, returnFinalTarget, isDirectory: true);
         }
+
+        public static bool Copy(string sourcePath, string destinationPath, bool recursive, bool skipExistingFiles = true, CancellationToken cancellationToken = default)
+        {
+            string fullSourcePath = Path.GetFullPath(sourcePath);
+            string fullDestinationPath = Path.GetFullPath(destinationPath);
+
+            return FileSystem.Copy(sourcePath, destinationPath, recursive, skipExistingFiles, cancellationToken);
+        }
     }
 }

src/libraries/System.Private.CoreLib/src/System/IO/DirectoryInfo.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO.Enumeration;
+using System.Threading;
 
 namespace System.IO
 {
@@ -233,5 +234,15 @@ public void Delete(bool recursive)
             FileSystem.RemoveDirectory(FullPath, recursive);
             Invalidate();
         }
+
+        public bool CopyTo(string destinationPath, bool recursive, bool skipExistingFiles = true,
+            CancellationToken cancellationToken = default)
+        {
+            string fullSourcePath = FullPath;
+            string fullDestinationPath = Path.GetFullPath(destinationPath);
+
+            return FileSystem.Copy(fullSourcePath, fullDestinationPath, recursive, skipExistingFiles,
+                cancellationToken);
+        }
     }
 }

src/libraries/System.Private.CoreLib/src/System/IO/FileSystem.cs

@@ -1,6 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
+
 namespace System.IO
 {
     internal static partial class FileSystem
@@ -20,5 +24,55 @@ internal static void VerifyValidPath(string path, string argName)
                 throw new ArgumentException(SR.Argument_InvalidPathChars, argName);
             }
         }
+
+        internal static bool Copy(string sourcePath, string destinationPath, bool recursive,
+            bool skipExistingFiles, CancellationToken cancellationToken)
+        {
+            var searchOption = recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
+            IEnumerable<string> directoryEnumeration;
+
+            try
+            {
+                directoryEnumeration = Directory.EnumerateDirectories(sourcePath, "*", searchOption);
+            }
+            catch (IOException)
+            {
+                // Return false if Enumeration is not possible
+                return false;
+            }
+
+            foreach (string enumeratedDirectory in directoryEnumeration)
+            {
+                string newDirectoryPath = enumeratedDirectory.Replace(sourcePath, destinationPath);
+                Directory.CreateDirectory(newDirectoryPath);
+
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            foreach (string enumeratedFile in Directory.GetFiles(sourcePath, "*.*", searchOption))
+            {
+                if (skipExistingFiles && File.Exists(enumeratedFile))
+                {
+                    cancellationToken.ThrowIfCancellationRequested();
+                    continue;
+                }
+
+                try
+                {
+                    CopyFile(enumeratedFile, enumeratedFile.Replace(sourcePath, destinationPath), true);
+                }
+                catch (IOException ex)
+                {
+                    // Return false for read failures
+                    return ex.HResult == Interop.Errors.ERROR_ACCESS_DENIED ? false :
+                        // Otherwise rethrow
+                        throw ex;
+                }
+
+                cancellationToken.ThrowIfCancellationRequested();
+            }
+
+            return false;
+        }
     }
 }