public static void Create(String path, NameConflictOption aNameConflictOption)
{
if (File.Exists(path))
{
switch (aNameConflictOption)
{
case NameConflictOption.Cancel:
case NameConflictOption.Skip:
return;
case NameConflictOption.Overwrite:
FileExt.Delete(path);
break;
case NameConflictOption.RenameExisting:
FileExt.Move(path, FileExt.MakeUnique(path));
break;
case NameConflictOption.RenameNew:
throw new InvalidDataException("Can't rename a file we are trying to create");
default:
break;
}
}
DirectoryExt.Create(Path.GetDirectoryName(path));
FileStream stream = File.Create(path);
stream.Close();
}
public static void Copy(String source, List <String> destinations, NameConflictOption aNameConflictOption, Action <ProcessProgress> handler, ref int cancel)
{
if (destinations.isEmpty())
{
throw new ArgumentNullException("You must specify a destinatino location(s)");
}
List <DestinationInfo> files = new List <DestinationInfo>();
foreach (String file in destinations)
{
if (File.Exists(file))
{
switch (aNameConflictOption)
{
case NameConflictOption.Cancel:
return;
case NameConflictOption.Overwrite:
files.Add(new DestinationInfo(file));
break;
case NameConflictOption.RenameExisting:
File.Move(file, FileExt.MakeUnique(file));
break;
case NameConflictOption.RenameNew:
files.Add(new DestinationInfo(FileExt.MakeUnique(file)));
break;
case NameConflictOption.Skip:
continue;
default:
break;
}
}
else
{
files.Add(new DestinationInfo(file));
}
}
if (files.Count == 0)
{
return;
}
// If we are only copying to one location don't use the multi copy
else if (files.Count == 1)
{
Copy(source, files[0].Path, aNameConflictOption, handler, ref cancel);
}
else
{
CopyFileToMultipleDestinations(source, files, handler, ref cancel);
}
}
/// <summary>
/// Moves a directory from one location to another.
/// </summary>
/// <param name="aSource">The source location for the move.</param>
/// <param name="aDestination">The destination location for the move.</param>
/// <param name="aNameConflictOption">How to handle name conflicts</param>
/// <returns>If the move was successful.</returns>
public static bool Move(String aSource, String aDestination, NameConflictOption aNameConflictOption)
{
if (!Directory.Exists(aSource))
{
throw new FileNotFoundException("The source directory does not exist");
}
bool success = true;
if (Directory.Exists(aSource))
{
success = false;
if (Directory.Exists(aDestination))
{
switch (aNameConflictOption)
{
case NameConflictOption.Skip:
case NameConflictOption.Cancel:
return(false);
case NameConflictOption.Overwrite:
DirectoryExt.Delete(aDestination);
break;
case NameConflictOption.RenameExisting:
DirectoryExt.Move(aDestination, DirectoryExt.MakeUnique(aDestination), NameConflictOption.RenameNew);
break;
case NameConflictOption.RenameNew:
aDestination = DirectoryExt.MakeUnique(aDestination);
break;
default:
throw new ArgumentException("Invalid conflict option.");
}
}
int tries = 0;
while (!success && tries < Constants.STANDARD_RETRY_ATTEMPTS)
{
try
{
Directory.Move(aSource, aDestination);
success = true;
}
catch
{
tries++;
System.Threading.Thread.Sleep(Constants.STANDARD_RETRY_SLEEP);
}
}
}
return(success);
}
public static void Copy(String source, String destination, NameConflictOption aNameConflictOption, Action <ProcessProgress> handler, ref int cancel)
{
if (!File.Exists(source))
{
throw new FileNotFoundException("The source file could not be found.");
}
if (File.Exists(destination))
{
switch (aNameConflictOption)
{
case NameConflictOption.Cancel:
case NameConflictOption.Skip:
return;
case NameConflictOption.Overwrite:
Delete(destination);
break;
case NameConflictOption.RenameExisting:
FileExt.Move(destination, FileExt.MakeUnique(destination));
break;
case NameConflictOption.RenameNew:
destination = FileExt.MakeUnique(destination);
break;
default:
break;
}
}
if (!Directory.Exists(Path.GetDirectoryName(destination)))
{
DirectoryExt.Create(Path.GetDirectoryName(destination));
}
FileInfo fileInfo = new FileInfo(source);
bool noBuffer = fileInfo.Length < Constants.USE_BUFFER_FILE_SIZE_BYTES;
XCopy.Copy(source, destination, aNameConflictOption == NameConflictOption.Overwrite, noBuffer, handler, ref cancel);
}
public static void Copy(String source, String destination, NameConflictOption aNameConflictOption, Action <ProcessProgress> handler)
{
int cancel = 0;
Copy(source, destination, aNameConflictOption, handler, ref cancel);
}
public static void Copy(String source, String destination, NameConflictOption aNameConflictOption)
{
Copy(source, destination, aNameConflictOption, null);
}
/// <summary>
/// Copy a file from on
/// </summary>
/// <param name="aSourceDir">The source directory.</param>
/// <param name="aDestinationDir">The destination directory</param>
/// <param name="aFilename">The name of the file</param>
/// <param name="aNameConflictOption">How to handle conflicts.</param>
/// <param name="aHandler">Callback function to handle progress notifications</param>
/// <param name="aCancel"></param>
public static void Copy(String aSourceDirectory, String aDestinationDirectory, String aFilename, NameConflictOption aNameConflictOption, Action <ProcessProgress> aHandler, ref int aCancel)
{
Copy(PathExt.Combine(aSourceDirectory, aFilename), PathExt.Combine(aDestinationDirectory, aFilename), aNameConflictOption, aHandler, ref aCancel);
}
/// <summary>
/// Copy a file from on
/// </summary>
/// <param name="aSourceDir">The source directory.</param>
/// <param name="aDestinationDir">The destination directory</param>
/// <param name="aFilename">The name of the file</param>
/// <param name="aNameConflictOption">How to handle conflicts.</param>
/// <param name="aHandler">Callback function to handle progress notifications</param>
public static void Copy(String aSourceDirectory, String aDestinationDirectory, String aFilename, NameConflictOption aNameConflictOption, Action <ProcessProgress> aHandler)
{
int cancel = 0;
Copy(aSourceDirectory, aDestinationDirectory, aFilename, aNameConflictOption, aHandler, ref cancel);
}
/// <summary>
/// Copies a file from one directory to another.
/// </summary>
/// <param name="aSourceDir">The source directory.</param>
/// <param name="aDestinationDir">The destination directory</param>
/// <param name="aFilename">The name of the file</param>
/// <param name="aNameConflictOption">How to handle conflicts.</param>
public static void Copy(String aSourceDir, String aDestinationDir, String aFilename, NameConflictOption aNameConflictOption)
{
Copy(aSourceDir, aDestinationDir, aFilename, aNameConflictOption, null);
}
public static void Copy(String source, List <String> destinations, NameConflictOption aNameConflictOption)
{
Copy(source, destinations, aNameConflictOption, null);
}
/// <summary>
/// Copies a directory.
/// </summary>
/// <param name="aSource">The source location.</param>
/// <param name="aDestination">The destination location.</param>
/// <param name="aSearchOption">If sub directories should be copied.</param>
/// <param name="aConflictOption">How to handle name conflicts.</param>
public static void Copy(String aSource, String aDestination, DirectorySearchOption aSearchOption, NameConflictOption aConflictOption)
{
if (Directory.Exists(aSource))
{
if (!Directory.Exists(aDestination))
{
Directory.CreateDirectory(aDestination);
}
//Now Create all of the directories
foreach (string dirPath in DirectoryExt.GetDirectories(aSource, aSearchOption))
{
Create(dirPath.Replace(aSource.endDir(), aDestination.endDir()));
}
//Copy all the files
foreach (string copyFrom in DirectoryExt.GetFiles(aSource, aSearchOption))
{
String copyTo = copyFrom.Replace(aSource.endDir(), aDestination.endDir());
if (File.Exists(copyTo))
{
if (aConflictOption == NameConflictOption.Cancel)
{
return;
}
else if (aConflictOption == NameConflictOption.Skip)
{
continue;
}
}
FileExt.Copy(copyFrom, copyTo, aConflictOption);
}
}
}
/// <summary>
/// Creates a new DirectoryBuilder that will place items in the specified directory
/// and uses the specified conflict resolution
/// </summary>
/// <param name="directory">The target directory</param>
/// <param name="conflictResolution">The method that will be used to resolve naming conflicts</param>
public DirectoryBuilder(StoragePath directory, NameConflictOption conflictResolution = NameConflictOption.ThrowException)
{
this.RootDirectory = directory;
this.ConflictResolution = conflictResolution;
}
/// <summary>
/// Creates a new DirectoryBuilder that will place items in the specified directory
/// </summary>
/// <param name="directory">The target directory</param>
public DirectoryBuilder(string directory, NameConflictOption conflictResolution = NameConflictOption.ThrowException) : this(new StoragePath(directory), NameConflictOption.ThrowException)
{
}
