Click here to Skip to main content
Click here to Skip to main content

xDirectory.Copy() - Copy Folder, SubFolders, and Files

, 19 Oct 2006 CPOL
Rate this:
Please Sign up or sign in to vote.
The .NET framework doesn't have a Directory.Copy() method. So I developed one myself.

Introduction

I was near the end of a drawn out development project for adding users to an Active Directory server when I was informed I would also need to set up their Thunderbird client settings. This required me to create a copy of a directory, sub-directories, and files over at the user's "My Documents" folder.

I tried using Microsoft's MSDN Online to search for a way to copy directories with their subfolders and files, when I determined that the Directory.Copy() method did not exist natively. I did not find anything remotely close.

I then searched the internet for other user's code examples, hoping someone had found a solution to this seemingly simple problem. And I did come across a few; still, the code I did find was inelegant and very much a "quick fix".

So I ended up writing my own.

NEW! Version 3.0 Description

Written October 18th, 2006

Well, after much more feedback and a lot of research, I give you Version 3 of the xDirectory Copier. This version is built on an almost completely different method: It's event-driven.

Yes, that's right, the xDirectory object now copies files and subfolders on a separate thread, and responds with events. This version will work both with Console as well as GUI (such as Windows Forms-Based) programs. It is UI-Thread Friendly, so it will allow you to update your controls on the events. It can give you a progress report, and you can cancel the copy thread at any time. Also, you can set multiple file filters to copy multiple file types (see below).

You'll definately want to download the provided code and look through it yourself. There's enough changes in the code that posting it here is probably just wasting your time. I will however post some highlights.

So, to use this new class, you would do this:

xDirectory Copier = new xDirectory();
Copier.ItemIndexed += new ItemIndexedEventHandler(Copier_ItemIndexed);
Copier.IndexComplete += new IndexCompleteEventHandler(Copier_IndexComplete);
Copier.ItemCopied += new ItemCopiedEventHandler(Copier_ItemCopied);
Copier.CopyComplete += new CopyCompleteEventHandler(Copier_CopyComplete);
Copier.CopyError += new CopyErrorEventHandler(Copier_CopyError);

Then, there are two ways to use the code once initialized. You can do as below:

Copier.Source = new DirectoryInfo(sSource);
Copier.Destination = new DirectoryInfo(sDestination);
Copier.Overwrite = true;
Copier.FolderFilter = "*";
Copier.FileFilters.Add("*.jpg");
Copier.FileFilters.Add("*.bmp");
Copier.FileFilters.Add("*.png");
Copier.StartCopy();

Or, you can simply call the overloaded StartCopy Method:

List<string> FileFilters = new List<string>();
FileFilters.Add("*.jpg");
Copier.StartCopy(sSource, sDestination, FileFilters, null, true);

If you place the Initialization part in a Form_Load method, and then put Usage part in a Button_Click event, it will run asynchronously and will allow you to update your controls (such as a progress bar) through the event methods.

One of the best parts of this new class is that if there's an error in copying a file, instead of cancelling the entire process, it will simply send a 'CopyError' Event! So you can list the files that had errors in copying but continue to copy the rest of the files successfully!

And here's the method that does all the work. It's a bit more complex-looking than version 2:

/// <span class="code-SummaryComment"><summary></span>
/// The Main Work Method of the xDirectory Class: Handled in a Separate Thread.
/// <span class="code-SummaryComment"></summary></span>
/// <span class="code-SummaryComment"><param name="StateInfo">Undefined</param></span>
private void DoWork(object StateInfo)
{
    _CopierStatus = xDirectoryStatus.Started;

    int iterator = 0;
    List<DirectoryInfo> FolderSourceList = new List<DirectoryInfo>();
    List<FileInfo> FileSourceList = new List<FileInfo>();
    DirectoryInfo FolderPath;
    FileInfo FilePath;

    try
    {
        // Part 1: Indexing
        ///////////////////////////////////////////////////////
        
        _CopierStatus = xDirectoryStatus.Indexing;
        
        FolderSourceList.Add(_Source);

        while (iterator < FolderSourceList.Count)
        {
            if (_CancelCopy) return;

            foreach (DirectoryInfo di in 
                     FolderSourceList[iterator].GetDirectories(_FolderFilter))
            {
                if (_CancelCopy) return;

                FolderSourceList.Add(di);

                OnItemIndexed(new ItemIndexedEventArgs(
                    di.FullName,
                    0,
                    FolderSourceList.Count,
                    true));
            }

            foreach (string FileFilter in _FileFilters)
            {
                foreach (FileInfo fi in 
                         FolderSourceList[iterator].GetFiles(FileFilter))
                {
                    if (_CancelCopy) return;

                    FileSourceList.Add(fi);

                    OnItemIndexed(new ItemIndexedEventArgs(
                        fi.FullName,
                        fi.Length,
                        FileSourceList.Count,
                        false));
                }
            }

            iterator++;
        }

        OnIndexComplete(new IndexCompleteEventArgs(
            FolderSourceList.Count, 
            FileSourceList.Count));



        // Part 2: Destination Folder Creation
        ///////////////////////////////////////////////////////

        _CopierStatus = xDirectoryStatus.CopyingFolders;

        for (iterator = 0; iterator < FolderSourceList.Count; iterator++)
        {
            if (_CancelCopy) return;

            
            if (FolderSourceList[iterator].Exists)
            {
                FolderPath = new DirectoryInfo(
                    _Destination.FullName +
                    Path.DirectorySeparatorChar +
                    FolderSourceList[iterator].FullName.Remove(0, 
                                                 _Source.FullName.Length));

                try
                {
                    // Prevent IOException
                    if (!FolderPath.Exists) FolderPath.Create(); 

                    OnItemCopied(new ItemCopiedEventArgs(
                            FolderSourceList[iterator].FullName,
                            FolderPath.FullName,
                            0,
                            iterator,
                            FolderSourceList.Count,
                            true));
                }
                catch (Exception iError)
                {
                    OnCopyError(new CopyErrorEventArgs(
                            FolderSourceList[iterator].FullName,
                            FolderPath.FullName,
                            iError));
                }
            }
            
        }



        // Part 3: Source to Destination File Copy
        ///////////////////////////////////////////////////////

        _CopierStatus = xDirectoryStatus.CopyingFiles;

        for (iterator = 0; iterator < FileSourceList.Count; iterator++)
        {
                if (_CancelCopy) return;

                if (FileSourceList[iterator].Exists)
                {
                    FilePath = new FileInfo(
                        _Destination.FullName +
                        Path.DirectorySeparatorChar +
                        FileSourceList[iterator].FullName.Remove(0, 
                                             _Source.FullName.Length + 1));

                    try
                    {
                        if (_Overwrite)
                            FileSourceList[iterator].CopyTo(FilePath.FullName,
                                                            true); 
                        else
                        {
                            if (!FilePath.Exists)
                                FileSourceList[iterator].CopyTo(
                                                    FilePath.FullName, true);
                        }

                        OnItemCopied(new ItemCopiedEventArgs(
                                FileSourceList[iterator].FullName,
                                FilePath.FullName,
                                FileSourceList[iterator].Length,
                                iterator,
                                FileSourceList.Count,
                                false));

                    }
                    catch (Exception iError)
                    {
                        OnCopyError(new CopyErrorEventArgs(
                                FileSourceList[iterator].FullName,
                                FilePath.FullName,
                                iError));
                    }
                }
            
        }

    }
    catch
    { throw; }
    finally
    {
        _CopierStatus = xDirectoryStatus.Stopped;
        OnCopyComplete(new CopyCompleteEventArgs(_CancelCopy));
    }
}

Old Version 2.0 Description

Written May 18th, 2006

Updated July 25th, 2006 - Fixed a major (but minute) error, added a ... + @"\" + ... to the string sFolderPath = ... and string sFilePath = ... declarations. Should fix any "files with foldername copied" errors.

After so much feedback, I decided I would revisit the Copy code. It's been quite a while since I posted the original, and I've learned a great deal more in the intervening time with regards to programming, and so I hope to bring this method to a new level.

The original version was written in .NET 1.1, and since then, I've gotten used to .NET 2.0, so this is what the second version is written in. Everyone cheer for Generic Collections!

Also, if you notice in the source code, the xDirectory.Copy method is now iterative instead of recursive. The iterative version of this code performs better than the recursive (for obvious reasons), and actually uses less overall memory.

Some key points were brought up, both in my work and in the comments; hopefully, all these have been rectified to everyone's satisfaction!

  • When the Overwrite variable was set to false, if any file was found to exist in the destination directory, the entire method would rrror out with an IOException.
  • The recursive nature of the original version meant encountering a never-ending recursive loop if the destination directory was inside of the source directory (say, creating a backup of a folder and putting it in the folder/backup.) The iterative version gets a full listing of the source directory first, before the copy begins, and then during the copy, makes sure that if a file has been moved in the small interval between the read and the copy, the whole method won't simply error out.
  • I introduced error handling into the method for common problems. Relieves some of the work for the weary coder.

Here's the xDirectory.Copy() method in all its glory. (There are overloads in the source project.)

/// <span class="code-SummaryComment"><summary></span>

/// xDirectory.Copy() - Copy a Source Directory
/// and it's SubDirectories/Files
/// <span class="code-SummaryComment"></summary></span>
/// <span class="code-SummaryComment"><param name="diSource">The Source Directory</param></span>
/// <span class="code-SummaryComment"><param name="diDestination">The Destination Directory</param></span>
/// <span class="code-SummaryComment"><param name="FileFilter">The File Filter</span>
/// (Standard Windows Filter Parameter, Wildcards: "*" and "?")<span class="code-SummaryComment"></param></span>

/// <span class="code-SummaryComment"><param name="DirectoryFilter">The Directory Filter</span>
/// (Standard Windows Filter Parameter, Wildcards: "*" and "?")<span class="code-SummaryComment"></param></span>
/// <span class="code-SummaryComment"><param name="Overwrite">Whether or not to Overwrite</span>
/// a Destination File if it Exists.<span class="code-SummaryComment"></param></span>
/// <span class="code-SummaryComment"><param name="FolderLimit">Iteration Limit - Total Number</span>
/// of Folders/SubFolders to Copy<span class="code-SummaryComment"></param></span>
public static void Copy(DirectoryInfo diSource, 
       DirectoryInfo diDestination, 
       string FileFilter, string DirectoryFilter, 
       bool Overwrite, int FolderLimit)
{
    int iterator = 0;
    List<DirectoryInfo> diSourceList = 
            new List<DirectoryInfo>();
    List<FileInfo> fiSourceList = 
            new List<FileInfo>();

    try
    {
        ///// Error Checking /////
        if (diSource == null) 
            throw new ArgumentException("Source Directory: NULL");
        if (diDestination == null) 
            throw new ArgumentException("Destination Directory: NULL");
        if (!diSource.Exists) 
            throw new IOException("Source Directory: Does Not Exist");
        if (!(FolderLimit > 0)) 
            throw new ArgumentException("Folder Limit: Less Than 1");
        if (DirectoryFilter == null || DirectoryFilter == string.Empty)
            DirectoryFilter = "*";
        if (FileFilter == null || FileFilter == string.Empty)
            FileFilter = "*";

        ///// Add Source Directory to List /////
        diSourceList.Add(diSource);

        ///// First Section: Get Folder/File Listing /////
        while (iterator < diSourceList.Count && iterator < FolderLimit)
        {
            foreach (DirectoryInfo di in 
              diSourceList[iterator].GetDirectories(DirectoryFilter))
                diSourceList.Add(di);

            foreach (FileInfo fi in 
                                diSourceList[iterator].GetFiles(FileFilter))
                fiSourceList.Add(fi);

            iterator++;
        }

        ///// Second Section: Create Folders from Listing /////
        foreach (DirectoryInfo di in diSourceList)
        {
            if (di.Exists)
            {
                string sFolderPath = diDestination.FullName + @"\" +
                       di.FullName.Remove(0, diSource.FullName.Length);
                
                ///// Prevent Silly IOException /////
                if (!Directory.Exists(sFolderPath))
                    Directory.CreateDirectory(sFolderPath);
            }
        }

        ///// Third Section: Copy Files from Listing /////
        foreach (FileInfo fi in fiSourceList)
        {
            if (fi.Exists)
            {
                string sFilePath = diDestination.FullName + @"\" +
                       fi.FullName.Remove(0, diSource.FullName.Length);
                
                //// Better Overwrite Test W/O IOException from CopyTo() ////
                if (Overwrite)
                    fi.CopyTo(sFilePath, true);
                else
                {
                    ///// Prevent Silly IOException /////
                    if (!File.Exists(sFilePath))
                        fi.CopyTo(sFilePath, true);
                }
            }
        }
    }
    catch
    { throw; }
}

Hopefully, you'll be able to put the new code to work easier than before! I've left both versions on here just in case .NET 2.0 is out of your reach; though, if pressed, you can use this code in .NET 1.1 with just a little tweaking. Essentially, change the generic List<DirectoryInfo> to an ArrayList, and do some type-casting to get it to work.

Enjoy!

Version History

  • Version 3 [.NET 2.0] - Written October 18th, 2006
  • Version 2 [.NET 2.0] - Updated July 25th, 2006
  • Version 2 [.NET 2.0] - Written May 18th, 2006
  • Version 1 [.NET 1.1] - Written April 6th, 2005

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

John Storer II
Software Developer Employer's Security
United States United States
I'm a Computer Support Technician for a Indiana School System. Really, I'm a C#/ASP.NET Developer in a Software Support coat. Jack-of-all-trades, I do Hardware Support, Software Support, Programming in C#.NET, ASP.NET / Javascript, Web Design, Graphic Arts and lots of other stuff.
 
I've been programming almost 21 years now, and have used more than 10 different languages in the past.

Comments and Discussions

 
Question2 bugs(?) PinmemberMember 867899926-Feb-12 7:43 
Questionany updates ?? Pinmemberalhambra-eidos10-Mar-11 1:37 
AnswerCode to copy folders and SubFolders with files. PinmemberMember 188450412-Jan-12 1:00 
GeneralRe: Code to copy folders and SubFolders with files. PinmemberJohn Storer II12-Jan-12 2:03 
AnswerRe: any updates ?? PinmemberJohn Storer II12-Jan-12 2:06 
GeneralTest App Error Handling Not Working [modified] Pinmembermason.c15-Jul-10 9:16 
Questioncopy multiple folder simultaneously Pinmemberc13l18-May-10 17:37 
AnswerRe: copy multiple folder simultaneously PinmemberJohn Storer II9-Nov-10 6:05 
QuestionFolder filter.....errrrmmm? Pinmemberriscy12-Feb-10 21:40 
AnswerRe: Folder filter.....errrrmmm? PinmemberJohn Storer II9-Nov-10 6:19 
GeneralError Message: System.IO.PathTooLongException (Path and/or Filename is too long) Pinmemberpebo664507-Dec-09 21:39 
GeneralRe: Error Message: System.IO.PathTooLongException (Path and/or Filename is too long) PinmemberJohn Storer II8-Dec-09 2:26 
GeneralRe: Error Message: System.IO.PathTooLongException (Path and/or Filename is too long) Pinmemberpebo664508-Dec-09 3:11 
Generalsome bug in version 3 Pinmembershenjian2508-Nov-09 8:56 
QuestionQuestion about me converting your utility to VB.Net PinmemberJim Tyler14-Oct-09 7:45 
AnswerRe: Question about me converting your utility to VB.Net PinmemberJim Tyler14-Oct-09 8:08 
GeneralRe: Question about me converting your utility to VB.Net PinmemberJohn Storer II14-Oct-09 8:14 
GeneralRe: Question about me converting your utility to VB.Net PinmemberJim Tyler14-Oct-09 8:22 
GeneralEnhancements I made Pinmemberjverbarg13-Oct-08 6:54 
GeneralRe: Enhancements I made PinmemberJan R Hansen23-Sep-09 2:06 
GeneralRe: Enhancements I made Pinmemberjverbarg23-Sep-09 3:26 
GeneralRe: Enhancements I made PinmemberJohn Storer II23-Sep-09 5:28 
GeneralRe: Enhancements I made Pinmemberamthamang22-Sep-10 10:18 
GeneralRe: Enhancements I made Pinmembervikramhaibatti11-Dec-11 22:46 
Generalgreat utility Pinmemberdmitriy_burdan21-Jul-08 10:54 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web03 | 2.8.141216.1 | Last Updated 20 Oct 2006
Article Copyright 2005 by John Storer II
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid