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) { }