public async Task <IFile> MoveAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = new CancellationToken()) { var newFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(newPath)) .AsTask(cancellationToken) .ConfigureAwait(false); string newName = System.IO.Path.GetFileName(newPath); try { await _storageFile.MoveAsync(newFolder, newName, collisionOption.ToNameCollisionOption()) .AsTask(cancellationToken) .ConfigureAwait(false); } catch (Exception ex) { if (ex.HResult == FileAlreadyExists) { throw new UnifiedIOException(string.Format("The file {0} already exists", newPath), ex); } throw new UnifiedIOException( string.Format("Could not move the file {0} to {1}: {2}", _path, newPath, ex.Message), ex); } _path = _storageFile.Path; return(this); }
/// <summary> /// Moves the file to the specified directory path /// </summary> /// <param name="destinationDirectoryPath"></param> /// <param name="option"></param> /// <returns></returns> public Task <bool> MoveAsync(string destinationDirectoryPath, CollisionOption option) { AssertFileExists(); return(Task.Factory.StartNew(() => { bool wasMoved = false; string fullDestinationPath = Environment.ExpandEnvironmentVariables(Path.Combine(destinationDirectoryPath, this.Filename)); switch (option) { case CollisionOption.ReplaceExisting: if (File.Exists(fullDestinationPath)) { File.Delete(fullDestinationPath); } _fileInfo.MoveTo(fullDestinationPath); wasMoved = true; break; case CollisionOption.ThrowExisting: if (File.Exists(fullDestinationPath)) { throw new Exceptions.FileAlreadyExistsException("File already exists in the target directory"); } goto case CollisionOption.ReplaceExisting; default: goto case CollisionOption.ReplaceExisting; } return wasMoved; })); }
public async Task <IFile> CreateFileAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = new CancellationToken()) { await EnsureExistsAsync(cancellationToken) .ConfigureAwait(false); StorageFile file; try { file = await _storage.CreateFileAsync(desiredName, option.ToCreationCollisionOption()) .AsTask(cancellationToken) .ConfigureAwait(false); } catch (Exception ex) { if (ex.HResult == WindowsStorageFile.FileAlreadyExists) { // File already exists (and potentially other failures, not sure what the HResult represents) throw new UnifiedIOException(ex.Message, ex); } throw; } return(new WindowsStorageFile(file)); }
/// <summary> /// Moves the directory to the destination directory specified /// </summary> /// <param name="destinationDirectoryPath"></param> /// <param name="collisionOption"></param> /// <returns></returns> public Task <bool> MoveAsync(string destinationDirectoryPath, CollisionOption collisionOption) { AssertDirectoryExists(); return(Task.Factory.StartNew(() => { bool wasMoved = false; switch (collisionOption) { case CollisionOption.ReplaceExisting: string fullDestination = Path.Combine(_systemPathMapper.GetUserContextFolder(destinationDirectoryPath), this.Name); if (Directory.Exists(fullDestination)) { Directory.Delete(fullDestination); } Directory.Move(this.FullPath, fullDestination); _directoryInfo = new DirectoryInfo(fullDestination); wasMoved = true; break; case CollisionOption.ThrowExisting: throw new Exceptions.DirectoryAlreadyExistsException("Directory already exists in the target directory"); default: goto case CollisionOption.ReplaceExisting; } return wasMoved; })); }
public async Task<IFile> CreateFileAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = new CancellationToken()) { await EnsureExistsAsync(cancellationToken) .ConfigureAwait(false); StorageFile file; try { file = await _storage.CreateFileAsync(desiredName, option.ToCreationCollisionOption()) .AsTask(cancellationToken) .ConfigureAwait(false); } catch (Exception ex) { if (ex.HResult == WindowsStorageFile.FileAlreadyExists) { // File already exists (and potentially other failures, not sure what the HResult represents) throw new UnifiedIOException(ex.Message, ex); } throw; } return new WindowsStorageFile(file); }
public async Task <IDirectory> CreateDirectoryAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = default(CancellationToken)) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); EnsureExists(); string nameToUse = desiredName; string newPath = System.IO.Path.Combine(Path, nameToUse); if (Directory.Exists(newPath)) { switch (option) { case CollisionOption.GenerateUniqueName: { for (int num = 2; Directory.Exists(newPath); num++) { cancellationToken.ThrowIfCancellationRequested(); nameToUse = string.Format("{0} ({1})", desiredName, num); newPath = System.IO.Path.Combine(Path, nameToUse); } Directory.CreateDirectory(newPath); break; } case CollisionOption.ReplaceExisting: { Directory.Delete(newPath, true); Directory.CreateDirectory(newPath); break; } case CollisionOption.FailIfExists: throw new UnifiedIOException(string.Format("The directory {0} already exists", newPath)); case CollisionOption.OpenIfExists: { // Do nothing... break; } default: throw new ArgumentOutOfRangeException("option", option, null); } } else { Directory.CreateDirectory(newPath); } return(new DotNetDirectory(newPath)); }
public async Task <IFile> CreateFileAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = default(CancellationToken)) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); string nameToUse = desiredName; string newPath = System.IO.Path.Combine(Path, nameToUse); if (File.Exists(newPath)) { switch (option) { case CollisionOption.GenerateUniqueName: { string desiredRoot = System.IO.Path.GetFileNameWithoutExtension(desiredName); string desiredExtension = System.IO.Path.GetExtension(desiredName); for (int num = 1; File.Exists(newPath); num++) { cancellationToken.ThrowIfCancellationRequested(); nameToUse = string.Format("{0} ({1}).{2}", desiredRoot, num, desiredExtension); newPath = System.IO.Path.Combine(Path, nameToUse); } break; } case CollisionOption.ReplaceExisting: { File.Delete(newPath); CreateFile(newPath); break; } case CollisionOption.FailIfExists: throw new UnifiedIOException("Cannot create file, it already exists"); case CollisionOption.OpenIfExists: { // Do nothing break; } default: throw new ArgumentOutOfRangeException("option", option, null); } } else { // Create file CreateFile(newPath); } return(new DotNetFile(newPath)); }
public async Task RenameAsync(string newFileName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { await Task.Run(() => { var currentFileName = System.IO.Path.GetFileName(Path); var newFilePath = Path.Replace(currentFileName, newFileName); System.IO.File.Move(Path, newFilePath); Path = newFilePath; }, cancellationToken); }
public async Task <IFile> RenameAsync(string newName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { var directory = System.IO.Path.GetDirectoryName(_path); if (newName.StartsWith(directory)) { throw new ArgumentException("The filename must not contain a path", "newName"); } return(await MoveAsync(System.IO.Path.Combine(directory, newName), collisionOption, cancellationToken)); }
public async Task<IFile> CreateFileAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = default(CancellationToken)) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); string nameToUse = desiredName; string newPath = System.IO.Path.Combine(Path, nameToUse); if (File.Exists(newPath)) { switch (option) { case CollisionOption.GenerateUniqueName: { string desiredRoot = System.IO.Path.GetFileNameWithoutExtension(desiredName); string desiredExtension = System.IO.Path.GetExtension(desiredName); for (int num = 1; File.Exists(newPath); num++) { cancellationToken.ThrowIfCancellationRequested(); nameToUse = string.Format("{0} ({1}).{2}", desiredRoot, num, desiredExtension); newPath = System.IO.Path.Combine(Path, nameToUse); } break; } case CollisionOption.ReplaceExisting: { File.Delete(newPath); CreateFile(newPath); break; } case CollisionOption.FailIfExists: throw new UnifiedIOException("Cannot create file, it already exists"); case CollisionOption.OpenIfExists: { // Do nothing break; } default: throw new ArgumentOutOfRangeException("option", option, null); } } else { // Create file CreateFile(newPath); } return new DotNetFile(newPath); }
public Task<IFile> RenameAsync(string newName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); var directoryPath = System.IO.Path.GetDirectoryName(_path); if (directoryPath == null) { throw new ArgumentException("newName"); } return MoveAsync( System.IO.Path.Combine(directoryPath, newName), collisionOption, cancellationToken ); }
public Task <IFile> RenameAsync(string newName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); var directoryPath = System.IO.Path.GetDirectoryName(_path); if (directoryPath == null) { throw new ArgumentException("newName"); } return(MoveAsync(System.IO.Path.Combine(directoryPath, newName), collisionOption, cancellationToken)); }
/// <summary> /// Copies the contents of this directory to the target destination /// CAUTION: If you want to directly copy this directory you must specify this directory name in the destination path /// Example: CopyAsync(C:\ProgramData, CollisionOption) will just copy the files and subdirectories /// in the directory to ProgramData. CopyAsync(C:\ProgramData\[NameOfDirectory], CollisionOption) will be like copying /// the folder itself /// </summary> /// <returns></returns> public Task <bool> CopyAsync(string destinationPath, CollisionOption collisionOption) { AssertDirectoryExists(); return(Task.Factory.StartNew(() => { bool wasCopied = false; // Expand the destination directory and add this directory name to the target directory string expandedDestination = _systemPathMapper.GetUserContextFolder(destinationPath); // Call the copy directory function, requires new method due to recursion wasCopied = CopyDirectory(_directoryInfo.FullName, expandedDestination, collisionOption); return wasCopied; })); }
public static NameCollisionOption ToNameCollisionOption(this CollisionOption option) { switch (option) { case CollisionOption.GenerateUniqueName: return(NameCollisionOption.GenerateUniqueName); case CollisionOption.ReplaceExisting: return(NameCollisionOption.ReplaceExisting); case CollisionOption.FailIfExists: return(NameCollisionOption.FailIfExists); default: throw new ArgumentOutOfRangeException("option", option, null); } }
public async Task <ICrossFolder> CreateFolderAsync(string folderName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { return(await Task.Run(() => { var newFolderPath = System.IO.Path.Combine(Path, folderName); var exists = Directory.Exists(newFolderPath); if (exists && collisionOption == CollisionOption.FailIfExists) { return null; } if (exists && collisionOption == CollisionOption.ReplaceExisting) { Directory.Delete(newFolderPath, false); } Directory.CreateDirectory(newFolderPath); return new CrossFolder(folderName, newFolderPath); }, cancellationToken)); }
/// <summary> /// Moves the directory to the destination directory specified /// </summary> /// <param name="destinationDirectoryPath"></param> /// <param name="collisionOption"></param> /// <returns></returns> public Task <bool> MoveAsync(string destinationDirectoryPath, CollisionOption collisionOption) { AssertDirectoryExists(); return(Task.Factory.StartNew(() => { bool wasMoved = false; string fullDestination = Environment.ExpandEnvironmentVariables(Path.Combine(destinationDirectoryPath, this.Name)); if (Directory.Exists(fullDestination)) { switch (collisionOption) { case CollisionOption.ReplaceExisting: Directory.Delete(fullDestination, true); Directory.Move(this.FullPath, fullDestination); _directoryInfo = new DirectoryInfo(fullDestination); wasMoved = true; break; case CollisionOption.ThrowExisting: throw new Exceptions.DirectoryAlreadyExistsException("Directory already exists in the target directory"); default: goto case CollisionOption.ReplaceExisting; } } else { Directory.Move(this.FullPath, fullDestination); _directoryInfo = new DirectoryInfo(fullDestination); wasMoved = true; } return wasMoved; })); }
public async Task <IFile> CopyAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = new CancellationToken()) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); await EnsureExistsAsync(cancellationToken); StorageFile newFile; using (Stream source = await _storageFile.OpenStreamForReadAsync()) { newFile = await StorageFile.GetFileFromPathAsync(newPath) .AsTask(cancellationToken) .ConfigureAwait(false); const int bufferSize = 4096; using (Stream destination = await newFile.OpenStreamForWriteAsync()) { await source.CopyToAsync(destination, bufferSize, cancellationToken); } } return(new WindowsStorageFile(newFile)); }
public async Task <IFile> CopyAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); using (Stream source = File.Open(_path, FileMode.Open)) { const int bufferSize = 4096; #if __UNIFIED__ || _ANDROID_ using (Stream destination = File.Create(newPath, bufferSize)) #else using (Stream destination = File.Create(newPath, bufferSize, FileOptions.Asynchronous)) #endif { await source.CopyToAsync(destination, bufferSize, cancellationToken); } } return(new DotNetFile(newPath)); }
public async Task MoveAsync(string newFilePath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { await Task.Run(() => { System.IO.File.Move(Path, newFilePath); }, cancellationToken); }
public async Task <IFile> MoveAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); string newDirectory = System.IO.Path.GetDirectoryName(newPath); string newName = System.IO.Path.GetFileName(newPath); for (int counter = 1;; counter++) { cancellationToken.ThrowIfCancellationRequested(); string candidateName = newName; if (counter > 1) { candidateName = string.Format( CultureInfo.InvariantCulture, "{0} ({1}){2}", System.IO.Path.GetFileNameWithoutExtension(newName), counter, System.IO.Path.GetExtension(newName)); } string candidatePath = System.IO.Path.Combine(newDirectory, candidateName); if (File.Exists(candidatePath)) { switch (collisionOption) { case CollisionOption.FailIfExists: { throw new UnifiedIOException("File already exists."); } case CollisionOption.GenerateUniqueName: { // Continue with the loop and generate a new name continue; } case CollisionOption.ReplaceExisting: { File.Delete(candidatePath); break; } default: { throw new ArgumentOutOfRangeException("collisionOption", collisionOption, null); } } } File.Move(_path, candidatePath); _path = candidatePath; return(this); } }
public async Task<IDirectory> CreateDirectoryAsync(string desiredName, CollisionOption option, CancellationToken cancellationToken = default(CancellationToken)) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); EnsureExists(); string nameToUse = desiredName; string newPath = System.IO.Path.Combine(Path, nameToUse); if (Directory.Exists(newPath)) { switch (option) { case CollisionOption.GenerateUniqueName: { for (int num = 2; Directory.Exists(newPath); num++) { cancellationToken.ThrowIfCancellationRequested(); nameToUse = string.Format("{0} ({1})", desiredName, num); newPath = System.IO.Path.Combine(Path, nameToUse); } Directory.CreateDirectory(newPath); break; } case CollisionOption.ReplaceExisting: { Directory.Delete(newPath, true); Directory.CreateDirectory(newPath); break; } case CollisionOption.FailIfExists: throw new UnifiedIOException(string.Format("The directory {0} already exists", newPath)); case CollisionOption.OpenIfExists: { // Do nothing... break; } default: throw new ArgumentOutOfRangeException("option", option, null); } } else { Directory.CreateDirectory(newPath); } return new DotNetDirectory(newPath); }
public async Task<IFile> RenameAsync(string newName, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { var directory = System.IO.Path.GetDirectoryName(_path); if (newName.StartsWith(directory)) { throw new ArgumentException("The filename must not contain a path", "newName"); } return await MoveAsync(System.IO.Path.Combine(directory, newName), collisionOption, cancellationToken); }
public async Task <ICrossFile> WriteTextFileAsync(string fileName, string content, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { return(await Task.Run(() => { var fileExtension = "txt"; var newFilePath = System.IO.Path.Combine(Path, $"{fileName}.{fileExtension}"); var exists = System.IO.File.Exists(newFilePath); if (exists && collisionOption == CollisionOption.FailIfExists) { return null; } if (exists && collisionOption == CollisionOption.ReplaceExisting) { System.IO.File.Delete(newFilePath); } System.IO.File.WriteAllText(newFilePath, content, Encoding.UTF8); return new CrossFile(fileName, fileExtension, newFilePath); }, cancellationToken)); }
public async Task <ICrossFile> CreateFileAsync(string fileName, string fileExtension, byte[] dataBytes, CollisionOption collisionOption = CollisionOption.FailIfExists, CancellationToken cancellationToken = default(CancellationToken)) { return(await Task.Run(() => { var newFilePath = System.IO.Path.Combine(Path, $"{fileName}.{fileExtension}"); var exists = System.IO.File.Exists(newFilePath); if (exists && collisionOption == CollisionOption.FailIfExists) { return null; } if (exists && collisionOption == CollisionOption.ReplaceExisting) { System.IO.File.Delete(newFilePath); } System.IO.File.WriteAllBytes(newFilePath, dataBytes); return new CrossFile(fileName, fileExtension, newFilePath); }, cancellationToken)); }
/// <summary> /// Recursive function to copy directories /// </summary> private bool CopyDirectory(string source, string destination, CollisionOption collisionOption) { bool wasCopied = false; // Get the source directory DirectoryInfo sourceDir = new DirectoryInfo(source); // Create the directory if it does not already exist if (!Directory.Exists(destination)) { Directory.CreateDirectory(destination); } // Get the files & sub directories for the source directory var files = sourceDir.GetFiles(); var subDirectories = sourceDir.GetDirectories(); switch (collisionOption) { // Replaces any existing folders or files case CollisionOption.ReplaceExisting: // Iterate through each file in the directory foreach (var file in files) { // Get the file info for the destination path, to see if it already exists FileInfo fileDestInfo = new FileInfo(Path.Combine(destination, file.Name)); if (fileDestInfo.Exists) { // Delete the existing target file fileDestInfo.Delete(); } // Copy the file to the new destination file.CopyTo(Path.Combine(destination, file.Name), true); } // Iterate through each folder in the directory foreach (var subDirectory in subDirectories) { // Get the directory info for the destination path, to see if it already exists DirectoryInfo dirDestInfo = new DirectoryInfo(Path.Combine(destination, subDirectory.Name)); if (dirDestInfo.Exists) { // Delete the existing target directory dirDestInfo.Delete(true); } // Copy the directory to the new destination CopyDirectory(subDirectory.FullName, dirDestInfo.FullName, collisionOption); } wasCopied = true; break; // Throws exception if there are any pre-existing files or folders case CollisionOption.ThrowExisting: // Iterate through file in the directory foreach (var file in files) { // Get the file info for the destination path, to see if it already exists FileInfo fileDestInfo = new FileInfo(Path.Combine(destination, file.Name)); if (!fileDestInfo.Exists) { // Copy the file to the new destination file.CopyTo(fileDestInfo.FullName, true); } else { throw new Exceptions.FileAlreadyExistsException(String.Format("File path {0} already exists.", file.FullName)); } } // Iterate through each sub-directory foreach (var subDirectory in subDirectories) { // Get the directory info for the destination path, to see if it already exists DirectoryInfo dirDestInfo = new DirectoryInfo(Path.Combine(destination, subDirectory.Name)); if (!dirDestInfo.Exists) { // Copy the directory to the new destination CopyDirectory(subDirectory.FullName, dirDestInfo.FullName, collisionOption); } else { throw new Exceptions.FileAlreadyExistsException(String.Format("Directory path {0} already exists.", subDirectory.FullName)); } } wasCopied = true; break; default: goto case CollisionOption.ReplaceExisting; } return(wasCopied); }
public async Task<IFile> MoveAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = new CancellationToken()) { var newFolder = await StorageFolder.GetFolderFromPathAsync(System.IO.Path.GetDirectoryName(newPath)) .AsTask(cancellationToken) .ConfigureAwait(false); string newName = System.IO.Path.GetFileName(newPath); try { await _storageFile.MoveAsync(newFolder, newName, collisionOption.ToNameCollisionOption()) .AsTask(cancellationToken) .ConfigureAwait(false); } catch (Exception ex) { if (ex.HResult == FileAlreadyExists) { throw new UnifiedIOException(string.Format("The file {0} already exists", newPath), ex); } throw new UnifiedIOException( string.Format("Could not move the file {0} to {1}: {2}", _path, newPath, ex.Message), ex); } _path = _storageFile.Path; return this; }
public async Task<IFile> CopyAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = new CancellationToken()) { await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); await EnsureExistsAsync(cancellationToken); StorageFile newFile; using (Stream source = await _storageFile.OpenStreamForReadAsync()) { newFile = await StorageFile.GetFileFromPathAsync(newPath) .AsTask(cancellationToken) .ConfigureAwait(false); const int bufferSize = 4096; using (Stream destination = await newFile.OpenStreamForWriteAsync()) { await source.CopyToAsync(destination, bufferSize, cancellationToken); } } return new WindowsStorageFile(newFile); }
public async Task<IFile> MoveAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); string newDirectory = System.IO.Path.GetDirectoryName(newPath); string newName = System.IO.Path.GetFileName(newPath); for (int counter = 1;; counter++) { cancellationToken.ThrowIfCancellationRequested(); string candidateName = newName; if (counter > 1) { candidateName = string.Format( CultureInfo.InvariantCulture, "{0} ({1}){2}", System.IO.Path.GetFileNameWithoutExtension(newName), counter, System.IO.Path.GetExtension(newName)); } string candidatePath = System.IO.Path.Combine(newDirectory, candidateName); if (File.Exists(candidatePath)) { switch (collisionOption) { case CollisionOption.FailIfExists: { throw new UnifiedIOException("File already exists."); } case CollisionOption.GenerateUniqueName: { // Continue with the loop and generate a new name continue; } case CollisionOption.ReplaceExisting: { File.Delete(candidatePath); break; } default: { throw new ArgumentOutOfRangeException("collisionOption", collisionOption, null); } } } File.Move(_path, candidatePath); _path = candidatePath; return this; } }
public async Task<IFile> CopyAsync(string newPath, CollisionOption collisionOption = CollisionOption.ReplaceExisting, CancellationToken cancellationToken = default(CancellationToken)) { // Make sure the source file exists EnsureExists(); await AwaitExtensions.SwitchOffMainThreadAsync(cancellationToken); using (Stream source = File.Open(_path, FileMode.Open)) { const int bufferSize = 4096; #if __UNIFIED__ || _ANDROID_ using (Stream destination = File.Create(newPath, bufferSize)) #else using (Stream destination = File.Create(newPath, bufferSize, FileOptions.Asynchronous)) #endif { await source.CopyToAsync(destination, bufferSize, cancellationToken); } } return new DotNetFile(newPath); }