复制文件夹但忽略一些子文件夹

Question

SOLVED, thanks to Dave's answer.

He showed me how to stop the async task, which answered my 2nd question.

To filter unwanted folders I have changed the SkipDirectory(string) to check the directory's path (If you have better solution, I would love to hear it). The function is written in the bottom.

I was wondering if there is a way in C# to copy a folder, but with some filters. ie Excluding some sub folders.

And how can I do it without making the program stuck. The current code that I have found copies the folder and all it's sub folders but the program gets stuck for a second.

Another code that I have found uses async method, and it solved the sudden pause's problem but I couldn't stop it in the middle (There must be an option to stop the task)

To sum up, I have 2 things I need:

1) Copy a folder, excluding some sub folders.

2) Copy the folder without making the program get stuck

Here is the first code I used (without async ):

private void Copy(string sourcePath, string destinationPath)
{
    foreach (string dirPath in Directory.GetDirectories(sourcePath, "*",
   SearchOption.AllDirectories))
    {
        if (SkipDirectory(dirPath))
        {
            continue;
        }
        Debug.Log(dirPath);
        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))
    {
        try
        {
            FileInfo file = new FileInfo(newPath);
            if (SkipDirectory(file.DirectoryName)) continue;    
            text += ("Copying " + newPath + "\n\n");
            File.Copy(newPath, newPath.Replace(sourcePath, destinationPath), true);
        }
        catch (System.Exception)
        {

        }
    }
}

And the async code:

private async System.Threading.Tasks.Task Copy(string startDirectory, string endDirectory)
{
    foreach (string dirPath in Directory.GetDirectories(startDirectory, "*", SearchOption.AllDirectories))
    {
        if (!SkipDirectory(dirPath))
        {
            Debug.Log("Creating directory " + dirPath);
            Directory.CreateDirectory(dirPath.Replace(startDirectory, endDirectory));
            foreach (string filename in Directory.EnumerateFiles(dirPath))
            {
                try
                {
                    using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                    {
                        using (FileStream DestinationStream = File.Create(filename.Replace(startDirectory, endDirectory)))
                        {
                            text += ("Copying " + filename + "\n\n");
                            await SourceStream.CopyToAsync(DestinationStream);
                        }
                    }
                }
                catch (System.Exception e)
                {
                    Debug.LogWarning($"Inner loop:\t{filename}\t{e.Message}");
                }
            }
        }
        else
        {
            Debug.Log("Skipping " + dirPath);
        }
    }

    foreach (string filename in Directory.EnumerateFiles(startDirectory))
    {
        try
        {
            using (FileStream SourceStream = File.Open(filename, FileMode.Open))
            {
                using (FileStream DestinationStream = File.Create(endDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                {

                    await SourceStream.CopyToAsync(DestinationStream);
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"Outter loop:\t{filename}\t{e.Message}");
        }
    }
}

The SkipDirectory(string) function only returns true/false based on the folder name:

private bool SkipDirectory(string dirPath)
{
    dirPath = dirPath.ToLower();
    string[] namesToSkip = { "library", "temp", "obj", ".vs" };
    foreach (string nameToSkip in namesToSkip)
    {
        // I now check the path of the folder to see if it matches.
        string unwantedPath = $@"{projectPath}\{nameToSkip}".ToLower();
        if (dirPath.StartsWith(unwantedPath))
        {
            return true;
        }
    }
    return false;
}

Answer 1

So you can pass a CancellationToken to your method and use that for requesting cancellation

here is your're code updated to be use a Cancellation token

private async Task Copy(string startDirectory, string endDirectory, CancellationToken ct)
{
    foreach (string dirPath in Directory.GetDirectories(startDirectory, "*", SearchOption.AllDirectories))
    {
        //Here we check if cancellation has been requesting if it has it will throw an exception (you can also check the IsCancellationRequested property and return) 
        ct.ThrowIfCancellationRequested();

        if (!SkipDirectory(dirPath))
        {
            Debug.Log("Creating directory " + dirPath);
            Directory.CreateDirectory(dirPath.Replace(startDirectory, endDirectory));
            foreach (string filename in Directory.EnumerateFiles(dirPath))
            {
                try
                {
                    using (FileStream SourceStream = File.Open(filename, FileMode.Open))
                    {
                        using (FileStream DestinationStream = File.Create(filename.Replace(startDirectory, endDirectory)))
                        {
                            await SourceStream.CopyToAsync(DestinationStream,81920, ct); //Pass cancellation token in to here and this can also handle cancellation
                        }
                    }
                }
                catch (OperationCanceledException)
                {
                    throw;
                }
                catch (System.Exception e)
                {
                    Debug.LogWarning($"Inner loop:\t{filename}\t{e.Message}");
                }
            }
        }
        else
        {
            Debug.Log("Skipping " + dirPath);
        }
    }

    foreach (string filename in Directory.EnumerateFiles(startDirectory))
    {
        //Here we check if cancellation has been requesting if it has it will throw an exception (you can also check the IsCancellationRequested property and return) 
        ct.ThrowIfCancellationRequested();
        try
        {
            using (FileStream SourceStream = File.Open(filename, FileMode.Open))
            {
                using (FileStream DestinationStream = File.Create(endDirectory + filename.Substring(filename.LastIndexOf('\\'))))
                {

                    await SourceStream.CopyToAsync(DestinationStream,81920, ct); //Pass cancellation token in to here and this can also handle cancellation
                }
            }
        }
        catch(OperationCanceledException)
        {
            throw;
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"Outter loop:\t{filename}\t{e.Message}");
        }
    }
}

then the caller of you're code can create a new Cancellation token by doing the following

var cts = new CancellationTokenSource(); //you can also pass a value for a timeout to this ctor var token = cts.Token;

You can then cancel by calling cts.Cancel()