/// <summary> /// Creates all directories and subdirectories in the specified path unless they already exist. /// </summary> /// <param name="path">The directory to create.</param> public static void CreateDirectory(string path) { #if DOTNET5_4 Directory.CreateDirectory(path); #else LongPathDirectory.CreateDirectory(path); #endif }
public static bool Exists(string path) { #if DOTNET5_4 return(Directory.Exists(path)); #else return(LongPathDirectory.Exists(path)); #endif }
public static void Create(string path) { if (path.Length < MAX_PATH) { System.IO.Directory.CreateDirectory(path); } else { LongPathDirectory.Create(path); } }
public override void Delete() { if (IsHardLink) { JunctionPoint.Delete(Path); } else { LongPathDirectory.Delete(Path, true); } }
public static string[] GetFiles(string path) { if (path.Length < MAX_PATH) { return(System.IO.Directory.GetFiles(path)); } else { return(LongPathDirectory.EnumerateFiles(path).ToArray()); } }
public static bool Exists(string path) { if (path.Length < MAX_PATH) { return(System.IO.Directory.Exists(path)); } else { return(LongPathDirectory.Exists(path)); } }
/// <summary> /// Refreshes the state of the object. /// </summary> /// <exception cref="IOException">A device such as a disk drive is not ready.</exception> public void Refresh() { List <Win32FindData> foundFiles = LongPathDirectory.EnumerateFileSystemIterator( LongPathCommon.GetDirectoryName(this.normalizedPath), Path.GetFileName(this.normalizedPath), SearchOption.TopDirectoryOnly, this.isDirectory, !this.isDirectory).ToList(); this.entryData = foundFiles.Count > 0 ? foundFiles[0] : (Win32FindData?)null; this.initialized = true; }
public static bool Exists(string path) { #if DOTNET5_4 return(Directory.Exists(path)); #else if (DMLibTestConstants.SupportUNCPath) { path = LongPath.ToUncPath(path); } return(LongPathDirectory.Exists(path)); #endif }
/// <summary> /// Determines whether the specified path exists and refers to a junction point. /// </summary> /// <param name = "path">The junction point path</param> /// <returns>True if the specified path represents a junction point</returns> /// <exception cref = "IOException">Thrown if the specified path is invalid /// or some other error occurs</exception> public static bool Exists(Path path) { if (!LongPathDirectory.Exists(path)) { return(false); } using (var handle = OpenReparsePoint(path, EFileAccess.GenericRead)) { var target = InternalGetTarget(handle); return(target != null); } }
public static void Delete(string path) { if (path.Length < MAX_PATH) { System.IO.Directory.Delete(path, true); } else { // NOTE: recursive isn't available on the longpath yet, so we only do this if we have to //TODO: implement the recursive stuff ourself LongPathDirectory.Delete(path); } }
static IEnumerable <Directory> DirectoriesRecurse(FileSystem fs, Directory directory, string filter) { // TODO: needs to be replaced with a cross-platform enumeration foreach (var topDir in LongPathDirectory.EnumerateDirectories(directory.Path, filter)) { foreach (var subDir in DirectoriesRecurse(fs, fs.GetDirectory(topDir), filter)) { yield return(subDir); } yield return(fs.CreateDirectory(topDir)); } }
public override void DeleteDirectory(string directoryPath) { foreach (string subdirectoryPathToDelete in EnumerateDirectories(directoryPath)) { DeleteDirectory(subdirectoryPathToDelete); } foreach (string filePathToDelete in EnumerateFiles(directoryPath)) { DeleteFile(filePathToDelete); } LongPathDirectory.Delete(directoryPath); }
/// <summary> /// Deletes a junction point at the specified source directory along with the directory itself. /// Does nothing if the junction point does not exist. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name = "junctionPoint">The junction point path</param> public static void Delete(Path junctionPoint) { if (!LongPathDirectory.Exists(junctionPoint)) { if (LongPathFile.Exists(junctionPoint)) { throw new IOException("Path is not a junction point."); } return; } using (var handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to delete junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } try { LongPathDirectory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException("Unable to delete junction point.", ex); } } }
private void OnFileSystemEntriesListBoxMouseDoubleClick(object sender, MouseEventArgs e) { if (fileSystemEntriesListBox.SelectedItem != null) { string path = (string)fileSystemEntriesListBox.SelectedItem; if (LongPathDirectory.Exists(path)) { this.currentPath.Text = path; } RefreshFileList(); } }
void IDirectoryAdapter.Delete(string path) { AssertAllowed(path); #if !MONO var mTx = CurrentTransaction(); if (mTx.HasValue) { ((IDirectoryAdapter)mTx.Value).Delete(path); return; } #endif LongPathDirectory.Delete(path); }
bool IDirectoryAdapter.Exists(string path) { AssertAllowed(path); #if !MONO var mTx = CurrentTransaction(); if (mTx.HasValue) { return(((IDirectoryAdapter)mTx.Value).Exists(path)); } #endif return(LongPathDirectory.Exists(path)); }
/// <summary> /// Delete non empty directory tree /// </summary> private void DeleteDirectory(string target_dir) { string[] files = Directory.GetFiles(target_dir); string[] dirs = Directory.GetDirectories(target_dir); foreach (string file in files) { try { File.SetAttributes(file, FileAttributes.Normal); File.Delete(file); } catch (PathTooLongException) { LongPathFile.Delete(file); } } foreach (string dir in dirs) { // Only recurse into "normal" directories if ((File.GetAttributes(dir) & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint) { try { Directory.Delete(dir, false); } catch (PathTooLongException) { LongPathDirectory.Delete(dir); } } else { DeleteDirectory(dir); } } try { Directory.Delete(target_dir, false); } catch (PathTooLongException) { LongPathDirectory.Delete(target_dir); } }
/// <summary> /// Creates all directories and subdirectories in the specified path unless they already exist. /// </summary> /// <param name="path">The directory to create.</param> public static void CreateDirectory(string path) { try { path = DMLibTestConstants.SupportUNCPath ? LongPath.GetFullPath(LongPath.ToUncPath(path)) : LongPath.GetFullPath(path); } catch (Exception) { } #if DOTNET5_4 Directory.CreateDirectory(path); #else LongPathDirectory.CreateDirectory(path); #endif }
protected override async Task <bool> DoWorkInternalAsync() { status = Status.Started; await Task.Run( () => { if (this.TransferJob.Source.Type == TransferLocationType.AzureBlob && this.TransferJob.Destination.Type == TransferLocationType.FilePath) { // Dummy transfer for downloading dummy blobs. var filePath = (this.TransferJob.Destination as FileLocation).FilePath.ToLongPath(); if (LongPathFile.Exists(filePath)) { string exceptionMessage = string.Format( CultureInfo.CurrentCulture, Resources.FailedToCreateDirectoryException, filePath); throw new TransferException( TransferErrorCode.FailedToCreateDirectory, exceptionMessage); } else { LongPathDirectory.CreateDirectory(filePath); } } // Hint: adding new dummy directions here. else { string exceptionMessage = string.Format( CultureInfo.CurrentCulture, Resources.UnsupportedDummyTransferException); throw new TransferException( TransferErrorCode.UnsupportedDummyTransfer, exceptionMessage); } status = Status.Finished; }, this.CancellationToken); return(status == Status.Finished || status == Status.ErrorOccured); }
bool IDirectoryAdapter.Delete(string path, bool recursively) { AssertAllowed(path); #if !MONO var mTx = CurrentTransaction(); if (mTx.HasValue) { return(((IDirectoryAdapter)mTx.Value).Delete(path, recursively)); } #endif // because of http://stackoverflow.com/questions/3764072/c-win32-how-to-wait-for-a-pending-delete-to-complete var target = Path.GetRandomFileName(); LongPathDirectory.Move(path, target); LongPathDirectory.Delete(target, recursively); return(true); }
public override IEnumerable <string> EnumerateFiles(string path, string searchPattern = "*", bool recursive = false) { foreach (string file in LongPathDirectory.EnumerateFiles(path, searchPattern)) { yield return(file); } if (recursive) { foreach (string directory in EnumerateDirectories(path, searchPattern, recursive: false)) { foreach (string file in EnumerateFiles(directory, searchPattern, recursive: true)) { yield return(file); } } } }
private void OnCreateDirectoryButtonClick(object sender, EventArgs e) { try { string path = Path.Combine(this.currentPath.Text, fileNameTextBox.Text); LongPathDirectory.Create(path); } catch (ArgumentException ex) { ShowError(ex); } catch (IOException ex) { ShowError(ex); } catch (UnauthorizedAccessException ex) { ShowError(ex); } RefreshFileList(); }
private void DeleteAllFolder(String parentDirectory) { if (parentDirectory == null) { return; } foreach (String file in LongPathDirectory.EnumerateFiles(parentDirectory)) { LongPathFile.Delete(file); } foreach (String info in LongPathDirectory.EnumerateDirectories(parentDirectory)) { this.DeleteAllFolder(info); } Microsoft.Experimental.IO.LongPathDirectory.Delete(parentDirectory); }
private static void LoadConfigurations(string path) { if (string.IsNullOrEmpty(path)) { path = LongPath.Combine(AssemblyExtensions.ApplicationDirectory, "WebServiceLibraries"); } try { var allFiles = LongPathDirectory.EnumerateFiles(path, "*.config", System.IO.SearchOption.AllDirectories); foreach (var file in allFiles) { try { var info = WebServiceRegistrationInfo.LoadFromFile(file); var gllName = LongPath.ChangeExtension(file, ".gll"); if (info.RegisteredVIs != null) { foreach (var item in info.RegisteredVIs) { if (item.Type == WebServiceType.HttpGetMethod) { var registeredExecutable = new RegisteredHttpGetVI( _connectionManager, _httpServer, gllName, item.VIComponentName, item.UrlPath); _connectionManager.AddConnectionType(registeredExecutable); } } } } catch (Exception e) { Log.LogError(0, e, $"Failed to load configuration: {file}"); } } } catch (Exception enumerateException) { Log.LogError(0, enumerateException, "Failed to enumerate configuration files"); } }
public override IEnumerable <string> EnumerateDirectories(string path, string searchPattern = "*", bool recursive = false) { IEnumerable <string> directories = LongPathDirectory.EnumerateDirectories(path, searchPattern); foreach (string directory in directories) { yield return(directory); } if (recursive) { foreach (string directory in directories) { foreach (string subdirectory in EnumerateDirectories(directory, searchPattern, recursive: true)) { yield return(subdirectory); } } } }
/// <summary> /// 自动创建多层级路径 /// </summary> /// <param name="path"></param> /// <param name="separator">路径分隔符,默认:/</param> public static void createDirectory(string path, char separator = '/') { var dirs = path.Split(separator); var folder = ""; foreach (var dir in dirs) { if (folder != "") { folder = folder + "/" + dir; } else { folder = dir; } if (!LongPathDirectory.Exists(folder)) { LongPathDirectory.Create(folder); } System.Diagnostics.Debug.WriteLine(folder); } }
private void OnDeleteButtonClick(object sender, EventArgs e) { string selectedPath = (string)fileSystemEntriesListBox.SelectedItem; try { if (LongPathDirectory.Exists(selectedPath)) { LongPathDirectory.Delete(selectedPath); } else { LongPathFile.Delete(selectedPath); } } catch (IOException ex) { ShowError(ex); } catch (UnauthorizedAccessException ex) { ShowError(ex); } RefreshFileList(); }
public static IEnumerable <string> EnumerateFileSystemEntries(string path, string searchPattern, SearchOption searchOption, LongPathDirectory.FilesOrDirectory filter = LongPathDirectory.FilesOrDirectory.All) { return(LongPathDirectory.EnumerateFileSystemEntries(path, searchPattern, searchOption, filter)); #endif }
/// <summary> /// Creates a new <c>LazyCopy</c> file. /// </summary> /// <param name="path">Path to the reparse point to get data from.</param> /// <param name="fileData">Reparse file data to be set for the <paramref name="path"/>.</param> /// <exception cref="ArgumentNullException"> /// <paramref name="path"/> is <see langword="null"/> or empty. /// <para>-or-</para> /// <paramref name="fileData"/> is <see langword="null"/>. /// <para>-or-</para> /// <paramref name="fileData"/> contains <see langword="null"/> or empty file path. /// </exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="fileData"/> contains negative file size.</exception> /// <exception cref="IOException">File cannot be created.</exception> /// <exception cref="InvalidOperationException">Reparse point data cannot be set.</exception> public static void CreateLazyCopyFile(string path, LazyCopyFileData fileData) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path)); } if (fileData == null) { throw new ArgumentNullException(nameof(fileData)); } if (string.IsNullOrEmpty(fileData.RemotePath)) { throw new ArgumentNullException(nameof(fileData)); } if (fileData.FileSize < 0) { throw new ArgumentOutOfRangeException(nameof(fileData), fileData.FileSize, "File size is negative."); } string normalizedPath = LongPathCommon.NormalizePath(path); LongPathFileInfo fileInfo = new LongPathFileInfo(normalizedPath); bool shouldCreateFile = false; if (!fileInfo.Exists || fileInfo.Length > 0) { LongPathDirectory.CreateDirectory(fileInfo.DirectoryName); shouldCreateFile = true; } else if (!fileInfo.Attributes.HasFlag(FileAttributes.ReparsePoint)) { shouldCreateFile = true; } else if (fileInfo.Attributes.HasFlag(FileAttributes.ReadOnly)) { fileInfo.Attributes &= ~FileAttributes.ReadOnly; } if (shouldCreateFile) { using (fileInfo.Create()) { // Do nothing. } } // If the original file is empty, we don't need to set a reparse point for it. if (fileData.FileSize == 0) { return; } ReparsePointHelper.SetReparsePointData( path, new object[] // Custom serialization layout for the LazyCopyFileData object. { (long)(fileData.UseCustomHandler ? 1L : 0L), (long)fileData.FileSize, // Add the prefix, if the custom handling is needed for the file. Encoding.Unicode.GetBytes( (fileData.UseCustomHandler ? fileData.RemotePath : PathHelper.ChangeDriveLetterToDeviceName(fileData.RemotePath)) + '\0') }, LazyCopyFileHelper.LazyCopyReparseTag, LazyCopyFileHelper.LazyCopyReparseGuid); // Set the proper file attributes. LongPathCommon.SetAttributes(path, FileAttributes.ReparsePoint | FileAttributes.NotContentIndexed | FileAttributes.Offline); }
public static IEnumerable <string> EnumerateFiles( string path, string searchPattern, string fromFilePath, SearchOption searchOption, bool followsymlink, CancellationToken cancellationToken) { Utils.CheckCancellation(cancellationToken); if ((searchOption != SearchOption.TopDirectoryOnly) && (searchOption != SearchOption.AllDirectories)) { throw new ArgumentOutOfRangeException("searchOption"); } // Remove whitespaces in the end. searchPattern = searchPattern.TrimEnd(); if (searchPattern.Length == 0) { // Returns an empty string collection. return(new List <string>()); } // To support patterns like "folderA\" aiming at listing files under some folder. if ("." == searchPattern) { searchPattern = "*"; } Utils.CheckCancellation(cancellationToken); CheckSearchPattern(searchPattern); Utils.CheckCancellation(cancellationToken); // Check path permissions. string fullPath = null; if (Interop.CrossPlatformHelpers.IsWindows) { fullPath = LongPath.ToUncPath(path); } else { fullPath = Path.GetFullPath(path); } #if CODE_ACCESS_SECURITY CheckPathDiscoveryPermission(fullPath); #endif // CODE_ACCESS_SECURITY string patternDirectory = LongPath.GetDirectoryName(searchPattern); #if CODE_ACCESS_SECURITY if (!string.IsNullOrEmpty(patternDirectory)) { CheckPathDiscoveryPermission(LongPath.Combine(fullPath, patternDirectory)); } #endif // CODE_ACCESS_SECURITY if (!string.IsNullOrEmpty(fromFilePath) && !string.IsNullOrEmpty(patternDirectory)) { // if file pattern is like folder\fileName*, we'll list location\folder with pattern fileName* // but the listted relative path will still be like folder\fileName1, and the continuation token will look the same. // Then here we need to make continuation token to be path relative to location\folder. string tmpPatternDir = AppendDirectorySeparator(patternDirectory); fromFilePath = fromFilePath.Substring(tmpPatternDir.Length); } string fullPathWithPattern = LongPath.Combine(fullPath, searchPattern); // To support patterns like "folderA\" aiming at listing files under some folder. char lastC = fullPathWithPattern[fullPathWithPattern.Length - 1]; if (Path.DirectorySeparatorChar == lastC || Path.AltDirectorySeparatorChar == lastC || Path.VolumeSeparatorChar == lastC) { fullPathWithPattern = fullPathWithPattern + '*'; } string directoryName = AppendDirectorySeparator(LongPath.GetDirectoryName(fullPathWithPattern)); string filePattern = fullPathWithPattern.Substring(directoryName.Length); if (!LongPathDirectory.Exists(directoryName)) { throw new DirectoryNotFoundException( string.Format( CultureInfo.CurrentCulture, Resources.PathNotFound, directoryName)); } Utils.CheckCancellation(cancellationToken); return(InternalEnumerateFiles(directoryName, filePattern, fromFilePath, searchOption, followsymlink, cancellationToken)); }