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

src/libraries/System.IO.FileSystem/tests/Directory/Copy.cs

@@ -0,0 +1,216 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO.Tests;
+using System.Threading;
+using Xunit;
+
+namespace System.IO.FileSystem.Tests
+{
+    public sealed class Directory_CopyDirectory : FileSystemTest
+    {
+        [Fact]
+        public void Copy()
+        {
+            const string sourceDirName = $"Test_source_{nameof(Copy)}";
+            const string destDirName = $"Test_target_{nameof(Copy)}";
+            CancellationToken cancellationToken = new();
+
+            // Prerequisites
+            // Create source folder
+            if (Directory.Exists(sourceDirName))
+            {
+                Directory.Delete(sourceDirName, true);
+            }
+            Directory.CreateDirectory(sourceDirName);
+
+            // Create destination folder
+            if (Directory.Exists(destDirName))
+            {
+                Directory.Delete(destDirName, true);
+            }
+            Directory.CreateDirectory(destDirName);
+
+            // Create file which does not exist in target folder
+            string firstPath = Path.Combine(sourceDirName, "first.txt");
+            using (StreamWriter firstStreamSource = File.CreateText(firstPath))
+            {
+                firstStreamSource.WriteLine("Test");
+            }
+
+            // Create file which does exist in target folder
+            string secondPathSource = Path.Combine(sourceDirName, "test.txt");
+            using (StreamWriter secondStreamSource = File.CreateText(secondPathSource))
+            {
+                secondStreamSource.WriteLine("Test");
+            }
+
+            string secondPathDest = Path.Combine(destDirName, "test.txt");
+            using (StreamWriter secondStreamDest = File.CreateText(secondPathDest))
+            {
+                secondStreamDest.WriteLine("Test");
+            }
+
+            // Do file system operation
+            Directory.Copy(sourceDirName, destDirName, false, false, cancellationToken);
+
+            // Validate cancellation
+            Assert.False(cancellationToken.IsCancellationRequested);
+        }
+
+        [Fact]
+        public void Copy_SkipExistingFiles()
+        {
+            const string sourceDirName = $"Test_source_{nameof(Copy_SkipExistingFiles)}";
+            const string destDirName = $"Test_target_{nameof(Copy_SkipExistingFiles)}";
+            CancellationToken cancellationToken = new();
+
+            // Prerequisites
+            // Create source folder
+            if (Directory.Exists(sourceDirName))
+            {
+                Directory.Delete(sourceDirName, true);
+            }
+            Directory.CreateDirectory(sourceDirName);
+
+            // Create destination folder
+            if (Directory.Exists(destDirName))
+            {
+                Directory.Delete(destDirName, true);
+            }
+            Directory.CreateDirectory(destDirName);
+
+            // Create file which does not exist in target folder
+            string firstPath = Path.Combine(sourceDirName, "first.txt");
+            using (StreamWriter firstStreamSource = File.CreateText(firstPath))
+            {
+                firstStreamSource.WriteLine("Test");
+            }
+
+            // Create file which does exist in target folder
+            string secondPathSource = Path.Combine(sourceDirName, "test.txt");
+            using (StreamWriter secondStreamSource = File.CreateText(secondPathSource))
+            {
+                secondStreamSource.WriteLine("Test");
+            }
+
+            string secondPathDest = Path.Combine(destDirName, "test.txt");
+            using (StreamWriter secondStreamDest = File.CreateText(secondPathDest))
+            {
+                secondStreamDest.WriteLine("Test");
+            }
+
+            // Do file system operation
+            Directory.Copy(sourceDirName, destDirName, false, true, cancellationToken);
+
+            // Validate cancellation
+            Assert.False(cancellationToken.IsCancellationRequested);
+        }
+
+        [Fact]
+        public void Copy_Recursive()
+        {
+            const string sourceDirName = $"Test_source_{nameof(Copy_Recursive)}";
+            const string destDirName = $"Test_target_{nameof(Copy_Recursive)}";
+            CancellationToken cancellationToken = new();
+
+            // Prerequisites
+            // Create source folder
+            if (Directory.Exists(sourceDirName))
+            {
+                Directory.Delete(sourceDirName, true);
+            }
+            Directory.CreateDirectory(sourceDirName);
+
+            // Create destination folder
+            if (Directory.Exists(destDirName))
+            {
+                Directory.Delete(destDirName, true);
+            }
+            Directory.CreateDirectory(destDirName);
+
+            string sourceTopLevelFilePath = Path.Combine(sourceDirName, "top-level.txt");
+            using (StreamWriter sourceTopLevelFileStream = File.CreateText(sourceTopLevelFilePath))
+            {
+                sourceTopLevelFileStream.WriteLine("Test");
+            }
+
+            string sourceSecondLevelDirectoryPath = Path.Combine(sourceDirName, "subdir");
+            Directory.CreateDirectory(sourceSecondLevelDirectoryPath);
+
+            string sourceThirdLevelFilePath = Path.Combine(sourceSecondLevelDirectoryPath, "test.txt");
+            using (StreamWriter sourceThirdLevelFileStream = File.CreateText(sourceThirdLevelFilePath))
+            {
+                sourceThirdLevelFileStream.WriteLine("Test");
+            }
+
+            // Do file system opreation
+            Directory.Copy(sourceDirName, destDirName, true, false, cancellationToken);
+
+            // Validate cancellation
+            Assert.False(cancellationToken.IsCancellationRequested);
+
+            // Validate copied files
+            string destTopLevelFilePath = Path.Combine(destDirName, "top-level.txt");
+            string destSecondLevelDirectoryPath = Path.Combine(destDirName, "subdir");
+            string destThirdLevelFilePath = Path.Combine(destSecondLevelDirectoryPath, "test.txt");
+
+            Assert.True(File.Exists(destTopLevelFilePath));
+            Assert.True(File.Exists(destThirdLevelFilePath));
+        }
+
+        [Fact]
+        public void Copy_NonRecursive()
+        {
+            const string sourceDirName = $"Test_source_{nameof(Copy_NonRecursive)}";
+            const string destDirName = $"Test_target_{nameof(Copy_NonRecursive)}";
+            CancellationToken cancellationToken = new();
+
+            // Prerequisites
+            // Create source folder
+            if (Directory.Exists(sourceDirName))
+            {
+                Directory.Delete(sourceDirName, true);
+            }
+            Directory.CreateDirectory(sourceDirName);
+
+            // Create destination folder
+            if (Directory.Exists(destDirName))
+            {
+                Directory.Delete(destDirName, true);
+            }
+            Directory.CreateDirectory(destDirName);
+
+            string sourceTopLevelFilePath = Path.Combine(sourceDirName, "top-level.txt");
+            using (StreamWriter sourceTopLevelFileStream = File.CreateText(sourceTopLevelFilePath))
+            {
+                sourceTopLevelFileStream.WriteLine("Test");
+            }
+
+            string sourceSecondLevelDirectoryPath = Path.Combine(sourceDirName, "subdir");
+            Directory.CreateDirectory(sourceSecondLevelDirectoryPath);
+
+            string sourceThirdLevelFilePath = Path.Combine(sourceSecondLevelDirectoryPath, "test.txt");
+            using (StreamWriter sourceThirdLevelFileStream = File.CreateText(sourceThirdLevelFilePath))
+            {
+                sourceThirdLevelFileStream.WriteLine("Test");
+            }
+
+            // Do file system opreation
+            Directory.Copy(sourceDirName, destDirName, false, false, cancellationToken);
+
+            // Validate cancellation
+            Assert.False(cancellationToken.IsCancellationRequested);
+
+            // Validate copied files
+            string destTopLevelFilePath = Path.Combine(destDirName, "top-level.txt");
+            string destSecondLevelDirectoryPath = Path.Combine(destDirName, "subdir");
+            string destThirdLevelFilePath = Path.Combine(destSecondLevelDirectoryPath, "test.txt");
+
+            Assert.True(File.Exists(destTopLevelFilePath));
+
+            // False because we only want to copy top level files (= non-recursive)
+            Assert.False(File.Exists(destThirdLevelFilePath));
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/DirectoryInfo/CopyTo.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.IO.Tests;
+using System.Threading;
+using Xunit;
+
+namespace System.IO.FileSystem.Tests
+{
+    public sealed class CopyTo : Directory_CreateDirectory
+    {
+        [Fact]
+        public void SimpleCopyToTest()
+        {
+            CancellationToken cancellationToken = new();
+            const string sourceFolderPath = $"test_source_{nameof(SimpleCopyToTest)}";
+            const string destFolderPath = $"test_dest_{nameof(SimpleCopyToTest)}";
+
+            // Prerequisites
+            var sourceFolder = Directory.CreateDirectory(sourceFolderPath);
+            var destFolder = Directory.CreateDirectory(destFolderPath);
+
+            // Fill source folder with test files
+            const int n = 10;
+            for (int i = 0; i < n; i++)
+            {
+                string fileName = Path.Combine(sourceFolderPath, $"{i}.txt");
+
+                using StreamWriter writer = File.CreateText(fileName);
+                writer.WriteLine("Lorem ipsum dolor sit a test");
+            }
+
+            // Do file system operation
+            sourceFolder.CopyTo(destFolderPath, false, false, cancellationToken);
+
+            // Validate cancellation
+            Assert.False(cancellationToken.IsCancellationRequested);
+
+            // Validate existing files
+            Assert.Equal(n, destFolder.GetFiles().Length);
+        }
+    }
+}

src/libraries/System.IO.FileSystem/tests/System.IO.FileSystem.Tests.csproj

@@ -18,6 +18,8 @@
     <Compile Include="Base\SymbolicLinks\BaseSymbolicLinks.cs" />
     <Compile Include="Base\SymbolicLinks\BaseSymbolicLinks.FileSystem.cs" />
     <Compile Include="Base\SymbolicLinks\BaseSymbolicLinks.FileSystemInfo.cs" />
+    <Compile Include="DirectoryInfo\CopyTo.cs" />
+    <Compile Include="Directory\Copy.cs" />
     <Compile Include="Directory\EnumerableTests.cs" />
     <Compile Include="Directory\SymbolicLinks.cs" />
     <Compile Include="DirectoryInfo\SymbolicLinks.cs" />

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
 {
@@ -284,5 +285,38 @@ public static FileSystemInfo CreateSymbolicLink(string path, string pathToTarget
             FileSystem.VerifyValidPath(linkPath, nameof(linkPath));
             return FileSystem.ResolveLinkTarget(linkPath, returnFinalTarget, isDirectory: true);
         }
+
+        /// <summary>
+        /// Copies a directory into another directory.
+        /// </summary>
+        /// <param name="sourcePath">The source path</param>
+        /// <param name="destinationPath">The destination path</param>
+        /// <param name="recursive"><see langword="true" /> to copy directories, subdirectories, and files in <paramref name="sourcePath"/>; otherwise, <see langword="false" />.</param>
+        /// <returns><see langword="true"/> if the operation succeeded in copying all the specified files and directories; otherwise, <see langword="false"/>.</returns>
+        /// <exception cref="IOException">A write operation fails</exception>
+        public static bool Copy(string sourcePath, string destinationPath, bool recursive) =>
+            Copy(sourcePath, destinationPath, recursive, true);
+
+        /// <summary>
+        /// Copies a directory into another directory.
+        /// </summary>
+        /// <param name="sourcePath">The source path</param>
+        /// <param name="destinationPath">The destination path</param>
+        /// <param name="recursive"><see langword="true" /> to copy directories, subdirectories, and files in <paramref name="sourcePath"/>; otherwise, <see langword="false" />.</param>
+        /// <param name="skipExistingFiles"><see langword="true" /> to skip overwrite of existing files in <paramref name="destinationPath"/>; otherwise, <see langword="false" />.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" /></param>
+        /// <returns><see langword="true"/> if the operation succeeded in copying all the specified files and directories; otherwise, <see langword="false"/>.</returns>
+        /// <exception cref="IOException">A write operation fails</exception>
+        /// <remarks>
+        /// <paramref name="recursive"/> specifies whether only the top-level files (<see langword="false"/>) should be copied or also subordinate ones (<see langword="true"/>).
+        /// If <paramref name="skipExistingFiles"/> is <see langword="false"/>, an <see cref="IOException"/> is thrown on an already existing file.
+        /// </remarks>
+        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(fullSourcePath, fullDestinationPath, 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
 {
@@ -206,5 +207,37 @@ public void Delete(bool recursive)
             FileSystem.RemoveDirectory(FullPath, recursive);
             Invalidate();
         }
+
+        /// <summary>
+        /// Copies this directory into another directory.
+        /// </summary>
+        ///
+        /// <param name="destinationPath">The destination path</param>
+        /// <param name="recursive"><see langword="true" /> to copy directories, subdirectories, and files in <see cref="FileSystemInfo.OriginalPath"/>; otherwise, <see langword="false" />.</param>
+        /// <returns>If the operation succeeded, <see langword="true"/>. Otherwise <see langword="false"/>.</returns>
+        /// <exception cref="IOException">A write operation fails</exception>
+        public bool CopyTo(string destinationPath, bool recursive) => CopyTo(destinationPath, recursive, true);
+
+        /// <summary>
+        /// Copies this directory into another directory.
+        ///
+        /// <paramref name="recursive"/> specifies whether only the top-level files (<see langword="false"/>) should be copied or also subordinate ones (<see langword="true"/>).
+        /// If <paramref name="skipExistingFiles"/> is <see langword="false"/>, an <see cref="IOException"/> is thrown on an already existing file.
+        /// </summary>
+        /// <param name="destinationPath">The destination path</param>
+        /// <param name="recursive"><see langword="true" /> to copy directories, subdirectories, and files in <see cref="FileSystemInfo.OriginalPath"/>; otherwise, <see langword="false" />.</param>
+        /// <param name="skipExistingFiles"><see langword="true" /> to skip overwrite of existing files in <paramref name="destinationPath"/>; otherwise, <see langword="false" />.</param>
+        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None" /></param>
+        /// <returns><see langword="true"/> if the operation succeeded in copying all the specified files and directories; otherwise, <see langword="false"/>.</returns>
+        /// <exception cref="IOException">A write operation fails</exception>
+        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/EnumerationOptions.cs

@@ -20,7 +20,7 @@ public class EnumerationOptions
         internal static EnumerationOptions Compatible { get; } =
             new EnumerationOptions { MatchType = MatchType.Win32, AttributesToSkip = 0, IgnoreInaccessible = false };
 
-        private static EnumerationOptions CompatibleRecursive { get; } =
+        internal static EnumerationOptions CompatibleRecursive { get; } =
             new EnumerationOptions { RecurseSubdirectories = true, MatchType = MatchType.Win32, AttributesToSkip = 0, IgnoreInaccessible = false };
 
         /// <summary>