Simply use a VB function: Microsoft.VisualBasic.FileIO.FileSystem.CopyDirectory

Add a reference of Microsoft.VisualBasic to your .Net assembly. MS does not stop us from doing so.

Hope this helps somebody out there.

if (!File.Exists(DestinPath))
{
Directory.CreateDirectory(DestinPath);
}

DirectoryInfo[] SrcFle = SourceFile.GetDirectories();
DirectoryInfo[] DstFle = DestinFile.GetDirectories();

List SrcLst = new List();
List DstLst = new List();

foreach (DirectoryInfo d1 in SrcFle)
{
SrcLst.Add(d1);
}
foreach (DirectoryInfo d2 in DstFle)
{
DstLst.Add(d2);
}

int cnt;
cnt = 0;
for (int a = 0; a < SrcFle.Length; a++)
{
if (DstFle.Length == 0)
{
Directory.CreateDirectory(DestinPath + SrcFle[a].Name);
goto top;
}
cnt = 0;
for (int b = 0; b < DstFle.Length; b++)
{
if (SrcLst[a].Name == DstLst[b].Name)
{
cnt++;
}
}
if (cnt == 0)
{
Directory.CreateDirectory(DestinPath + SrcLst[a].Name);

StreamWriter sw;
sw = new StreamWriter(@"c:LockFile@Folder" + System.DateTime.Now.ToString("dd-MMM-yyyy") + ".txt", true);
sw.WriteLine(z + " " + " Folder Created:" + " " + SrcLst[a].Name);
sw.WriteLine();
sw.Close();
z++;
}
fnCopyDirFile(SourcePath + SrcLst[a].Name + @"", DestinPath + SrcLst[a].Name + @"");
}
}
catch (Exception ex)
{
Console.Write(ex.Message.ToString());
}
}

I tried the Parallel framework in .NET 4 and updated my code is here. It will give better performance.

private void CopyFilesRecursively(DirectoryInfo source, DirectoryInfo target)
{
foreach (DirectoryInfo dir in source.GetDirectories())
{
DirectoryInfo targetSubDirectory = target.CreateSubdirectory(dir.Name);
CopyFilesRecursively(dir, targetSubDirectory);
}

Parallel.ForEach(source.GetFiles(),
filePath =>
{
System.Threading.Tasks.Task task = System.Threading.Tasks.Task.Factory.StartNew(() =>
{
filePath.CopyTo(Path.Combine(target.FullName, filePath.Name));
});
});
}

public static void CopyAllFiles(string sourceFolder, string destinationFolder)
{
foreach (string directory in Directory.GetDirectories(sourceFolder, “*”, SearchOption.AllDirectories))
{
string DestinationFilePath = String.Format(“{0}{1}{2}”,
destinationFolder, Path.DirectorySeparatorChar, directory.Replace(sourceFolder, “”));

if (!Directory.Exists(DestinationFilePath))
Directory.CreateDirectory(DestinationFilePath);

foreach (string file in Directory.GetFiles(directory, “*”, SearchOption.TopDirectoryOnly))
{
File.Copy(file, Path.Combine(DestinationFilePath, Path.GetFileName(file)), true);
}
}
}

I don’t think that there are performance differences between the recursive or iterative versions, the bottleneck is the copy itself. I just don’t like recursion. In order to lower copy times, you will need 1) go to a lower level (maybe file streams at byte level), and/or 2) multi-threaded copy (the new parallel framework in .NET 4 might help here, although I haven’t tried it, yet)

I tried your code. Its fail when i have empty folder inside the sub directory. otherwise I didn’t see any performance improvements

http://01792.org/blog/post/2010/10/06/Recursive-file-and-folder-copy.aspx

In 4 lines