/// <summary> /// Creates the folder information on the basis of the path and the handles /// </summary> /// <param name="pathInfo"><see cref="PathInfo"/></param> /// <param name="win32FindData"><see cref="Win32FindData"/></param> internal DirectoryDetail(PathInfo pathInfo, Win32FindData win32FindData) : base(pathInfo, win32FindData) { if (win32FindData != null) { RetriveDateTimeInformation(win32FindData); } }
/// <summary> /// Creates instance of <see cref="DirectoryMetadata"/> /// </summary> /// <param name="win32FindData">Win32FindData of current directory</param> /// <param name="subDirs">Directories in current directory</param> /// <param name="subFiles">Files in current directory</param> /// <param name="uncFullname">UNC Path of current directory</param> internal DirectoryMetadata(string uncFullname, Win32FindData win32FindData, IList<DirectoryMetadata> subDirs, IList<FileMetadata> subFiles) : base(uncFullname) { Directories = new ReadOnlyCollection<DirectoryMetadata>(subDirs); Files = new ReadOnlyCollection<FileMetadata>(subFiles); SetFindData(win32FindData); }
public Win32FileAttributeData(Win32FindData findData) { FileAttributes = findData.FileAttributes; CreationTime = findData.CreationTime; LastAccessTime = findData.LastAccessTime; LastWriteTime = findData.LastWriteTime; FileSizeHigh = findData.FileSizeHigh; FileSizeLow = findData.FileSizeLow; }
/// <summary> /// Initializes a new instance of the <see cref="LongPathFileSystemInfo"/> class. /// </summary> /// <param name="data">File data.</param> /// <exception cref="ArgumentNullException"><paramref name="data"/> is <see langword="null"/>.</exception> internal LongPathFileSystemInfo(Win32FindData data) { this.entryData = data; this.OriginalPath = this.entryData.Value.FileName; this.NormalizedPath = LongPathCommon.NormalizePath(this.entryData.Value.FileName); this.isDirectory = LongPathCommon.IsDirectory(this.entryData.Value); this.initialized = true; }
/// <summary> /// Determined all files of a directory /// </summary> /// <param name="uncDirectoryPath">Path of the directory</param> /// <param name="pattern">Search pattern. Uses Win32 native filtering.</param> /// <param name="searchOption"> /// <see cref="SearchOption" /> /// </param> /// <param name="enumerateOptions">The enumeration options for exception handling</param> /// <returns>Collection of files</returns> internal static IEnumerable<FileDetail> EnumerateFiles(String uncDirectoryPath, String pattern = "*", SearchOption searchOption = SearchOption.TopDirectoryOnly, SuppressExceptions enumerateOptions = SuppressExceptions.None) { // Match for start of search string currentPath = PathTools.Combine(uncDirectoryPath, pattern); // Find First file var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstFileManaged(currentPath, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid && EnumerationHandleInvalidFileHandle(uncDirectoryPath, enumerateOptions, win32Error)) { yield return null; } // Treffer auswerten do { // Ignore . and .. directories if (IsSystemDirectoryEntry(win32FindData)) { continue; } // Create hit for current search result string resultPath = PathTools.Combine(uncDirectoryPath, win32FindData.cFileName); // Check for Directory if (!ContainsFileAttribute(win32FindData.dwFileAttributes, FileAttributes.Directory)) { yield return new FileDetail(resultPath, win32FindData); } else { // SubFolders?! if (searchOption == SearchOption.AllDirectories) { foreach (var match in EnumerateFiles(resultPath, pattern, searchOption, enumerateOptions)) { yield return match; } } } // Create new FindData object for next result win32FindData = new Win32FindData(); } // Search for next entry while (Win32SafeNativeMethods.FindNextFile(fileHandle, win32FindData)); } }
/// <summary> /// Determined all subfolders of a directory /// </summary> /// <param name="pathInfo">Path of the directory</param> /// <param name="pattern">Search pattern. Uses Win32 native filtering.</param> /// <param name="searchOption"> /// <see cref="SearchOption" /> /// </param> /// <param name="enumerateOptions">The enumeration options for exception handling</param> /// <returns><see cref="DirectoryDetail" /> collection of subfolders</returns> internal static IEnumerable<DirectoryDetail> EnumerateDirectories(PathInfo pathInfo, String pattern = "*", SearchOption searchOption = SearchOption.TopDirectoryOnly, SuppressExceptions enumerateOptions = SuppressExceptions.None) { // Match for start of search string currentPath = PathTools.Combine(pathInfo.FullNameUnc, pattern); // Find First file var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstSafeFileHandle(currentPath, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid) { if (win32Error != ERROR_NO_MORE_FILES) { NativeExceptionMapping(pathInfo.FullName, win32Error); } if (EnumerationHandleInvalidFileHandle(pathInfo.FullName, enumerateOptions, win32Error)) { yield return null; } } do { // Ignore . and .. directories if (IsSystemDirectoryEntry(win32FindData)) { continue; } // Create hit for current search result string resultPath = PathTools.Combine(pathInfo.FullName, win32FindData.cFileName); // Check for Directory if (ContainsFileAttribute(win32FindData.dwFileAttributes, FileAttributes.Directory)) { yield return new DirectoryDetail(new PathInfo(resultPath), win32FindData); // SubFolders?! if (searchOption == SearchOption.AllDirectories) { foreach (var match in EnumerateDirectories(new PathInfo(resultPath, win32FindData.cFileName), pattern, searchOption, enumerateOptions)) { yield return match; } } } // Create new FindData object for next result win32FindData = new Win32FindData(); } // Search for next entry while (Win32SafeNativeMethods.FindNextFile(fileHandle, win32FindData)); } }
/// <summary> /// Gets the <see cref="Win32FindData" /> from the passed path. /// </summary> /// <param name="pathInfo">Path</param> /// <param name="pathFindData"><seealso cref="Win32FindData" />. Will be null if path does not exist.</param> /// <returns>true if path is valid and <see cref="Win32FindData" /> is set</returns> /// <remarks> /// <see> /// <cref>QuickIOCommon.NativeExceptionMapping</cref> /// </see> /// if invalid handle found. /// </remarks> public static bool TryGetFindDataFromPath(PathInfo pathInfo, out Win32FindData pathFindData) { var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstSafeFileHandle(pathInfo.FullNameUnc, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid) { NativeExceptionMapping(pathInfo.FullName, win32Error); } // Ignore . and .. directories if (!IsSystemDirectoryEntry(win32FindData)) { pathFindData = win32FindData; return true; } } pathFindData = null; return false; }
public static extern IntPtr FindFirstFlashCard(out Win32FindData findData);
internal static extern SafeFindFileHandle FindFirstFileTransacted( [MarshalAs(UnmanagedType.LPWStr)] string lpFileName, FindExInfoLevels fInfoLevelId, out Win32FindData lpFindFileData, FindExSearchOps fSearchOp, IntPtr lpSearchFilter, FindExAdditionalFlags dwAdditionalFlags, SafeHandle hTransaction);
public static extern bool FindNextFile(IntPtr hFindFile, out Win32FindData lpFindFileData);
/// <summary> /// Creates the file information on the basis of the path and <see cref="Win32FindData"/> /// </summary> /// <param name="fullName">Full path to the file</param> /// <param name="win32FindData"><see cref="Win32FindData"/></param> internal FileDetail(String fullName, Win32FindData win32FindData) : this(new PathInfo(fullName), win32FindData) { RetriveDateTimeInformation(win32FindData); CalculateSize(win32FindData); }
/// <summary> /// Determines the time stamp of the given <see cref="Win32FindData"/> /// </summary> /// <param name="win32FindData"><see cref="Win32FindData"/></param> private void RetriveDateTimeInformation(Win32FindData win32FindData) { LastWriteTimeUtc = win32FindData.GetLastWriteTimeUtc(); LastAccessTimeUtc = win32FindData.GetLastAccessTimeUtc(); CreationTimeUtc = win32FindData.GetCreationTimeUtc(); }
/// <summary> /// Determines the type based on the attributes of the handle /// </summary> /// <param name="findData"><see cref="Win32FindData"/></param> /// <returns><see cref="QuickIOFileSystemEntryType"/></returns> internal static QuickIOFileSystemEntryType DetermineFileSystemEntry(Win32FindData findData) { Contract.Requires(findData != null); return(!InternalHelpers.ContainsFileAttribute(findData.dwFileAttributes, FileAttributes.Directory) ? QuickIOFileSystemEntryType.File : QuickIOFileSystemEntryType.Directory); }
public static extern bool FindNextFileW(SafeHandle hFindFile, out Win32FindData lpFindFileData);
/// <summary> /// Returns the <see cref="SafeFileHandle" /> and fills <see cref="Win32FindData" /> from the passes path. /// </summary> /// <param name="path">Path to the file system entry</param> /// <param name="win32FindData"></param> /// <param name="win32Error">Last error code. 0 if no error occurs</param> /// <returns> /// <see cref="SafeFileHandle" /> /// </returns> static Win32FileHandle FindFirstSafeFileHandle(string path, Win32FindData win32FindData, out Int32 win32Error) { var result = Win32SafeNativeMethods.FindFirstFile(path, win32FindData); win32Error = Marshal.GetLastWin32Error(); return result; }
static Boolean IsSystemDirectoryEntry(Win32FindData win32FindData) { if (win32FindData.cFileName.Length >= 3) { return false; } return (win32FindData.cFileName == "." || win32FindData.cFileName == ".."); }
/// <summary> /// Creates the file information on the basis of the path and <see cref="Win32FindData"/> /// </summary> /// <param name="pathInfo">Full path to the file</param> /// <param name="win32FindData"><see cref="Win32FindData"/></param> internal FileDetail(PathInfo pathInfo, Win32FindData win32FindData) : base(pathInfo, win32FindData) { RetriveDateTimeInformation(win32FindData); CalculateSize(win32FindData); }
public static extern SafeFindFileHandle FindFirstFileW( string lpFileName, out Win32FindData lpFindFileData);
public static extern IntPtr FindFirstFileW( string lpFileName, out Win32FindData lpFindFileData);
internal static extern bool FindNextFile(SafeFindFileHandle hFindFile, out Win32FindData lpFindFileData);
public static extern bool FindNextFileW( IntPtr hFindFile, out Win32FindData lpFindFileData);
/// <summary> /// Start enumeration by calling the <see cref="Native.NativeMethods.FindFirstFile"/> method. /// </summary> /// <param name="normalizedPathWithSearchPattern">The normalized path with search pattern.</param> /// <param name="findData">Data received.</param> /// <returns>Handle to the first file system entry found.</returns> private static SafeFindHandle BeginFind(string normalizedPathWithSearchPattern, out Win32FindData findData) { SafeFindHandle handle = NativeMethods.FindFirstFile(normalizedPathWithSearchPattern, out findData); if (handle.IsInvalid) { int hr = Marshal.GetHRForLastWin32Error(); if (hr != NativeMethods.ErrorFileNotFound && hr != NativeMethods.ErrorPathNotFound) { throw LongPathCommon.GetExceptionForHr(hr, normalizedPathWithSearchPattern); } return null; } return handle; }
/// <summary> /// Creates the folder information on the basis of the path and the handles /// </summary> /// <param name="pathInfo"><see cref="QuickIOPathInfo"/></param> /// <param name="win32FindData"><see cref="Win32FindData"/></param> internal QuickIODirectoryInfo(QuickIOPathInfo pathInfo, Win32FindData win32FindData) : base(pathInfo, win32FindData) { }
/// <summary> /// Returns the <see cref="Win32FindData" /> from specified <paramref name="pathInfo" /> /// </summary> /// <param name="pathInfo">Path to the file system entry</param> /// <returns> /// <see cref="Win32FindData" /> /// </returns> public static Win32FindData GetFindDataFromPath(PathInfo pathInfo) { var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstSafeFileHandle(pathInfo.FullNameUnc, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid) { NativeExceptionMapping(pathInfo.FullName, win32Error); } // Ignore . and .. directories if (!IsSystemDirectoryEntry(win32FindData)) { return win32FindData; } } throw new Exception("PathNotFound " + pathInfo.FullName); }
internal FileFoundEventArgs(Win32FindData ff) { _ff = ff; }
internal static FileOrDirectory DetermineFileSystemEntry(Win32FindData findData) { return !ContainsFileAttribute(findData.dwFileAttributes, FileAttributes.Directory) ? FileOrDirectory.File : FileOrDirectory.Directory; }
/// <summary> Creates a FindFile instance. </summary> public FindFile(string rootDirectory, string filePattern, bool recursive, bool includeFolders, bool includeFiles) { if (String.IsNullOrEmpty(rootDirectory) || String.IsNullOrEmpty(filePattern)) throw new ArgumentException(); _ff = new Win32FindData(); _ff.BufferAddress = IntPtr.Zero; _ff.Buffer = new char[0x1000]; _ff.Value = new Kernel32.WIN32_FIND_DATA(); _recursive = recursive; _includeFolders = includeFolders; _includeFiles = includeFiles; BaseDirectory = rootDirectory; FilePattern = filePattern; }
/// <summary> /// Determined metadata of directory /// </summary> /// <param name="uncDirectoryPath">Path of the directory</param> /// <param name="findData"> /// <see cref="Win32FindData" /> /// </param> /// <param name="enumerateOptions">The enumeration options for exception handling</param> /// <returns><see cref="DirectoryMetadata" /> started with the given directory</returns> internal static DirectoryMetadata EnumerateDirectoryMetadata(String uncDirectoryPath, Win32FindData findData, SuppressExceptions enumerateOptions) { // Results var subFiles = new List<FileMetadata>(); var subDirs = new List<DirectoryMetadata>(); // Match for start of search string currentPath = PathTools.Combine(uncDirectoryPath, "*"); // Find First file var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstSafeFileHandle(currentPath, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid) { if (win32Error != ERROR_NO_MORE_FILES) { NativeExceptionMapping(uncDirectoryPath, win32Error); } if (EnumerationHandleInvalidFileHandle(uncDirectoryPath, enumerateOptions, win32Error)) { return null; } } // Add any matching non-system results to the output do { // Ignore . and .. directories if (IsSystemDirectoryEntry(win32FindData)) { continue; } // Create hit for current search result var uncResultPath = PathTools.Combine(uncDirectoryPath, win32FindData.cFileName); // if it's a file, add to the collection if (!ContainsFileAttribute(win32FindData.dwFileAttributes, FileAttributes.Directory)) { subFiles.Add(new FileMetadata(uncResultPath, win32FindData)); } else { subDirs.Add(EnumerateDirectoryMetadata(uncResultPath, win32FindData, enumerateOptions)); } // Create new FindData object for next result win32FindData = new Win32FindData(); } // Search for next entry while (Win32SafeNativeMethods.FindNextFile(fileHandle, win32FindData)); } return new DirectoryMetadata(uncDirectoryPath, findData, subDirs, subFiles); }
/// <summary> /// Determines whether the specified attributes belong to a directory. /// </summary> /// <param name="findData">File or directory data object.</param> /// <returns><see langword="true"/> if the specified attributes belong to a directory; otherwise, <see langword="false"/>. /// </returns> internal static bool IsDirectory(Win32FindData findData) { return LongPathCommon.IsDirectory(findData.FileAttributes); }
/// <summary> /// Returns the handle by given path and finddata /// </summary> /// <param name="uncPath">Specified path</param> /// <param name="win32FindData">FindData to fill</param> /// <param name="win32Error">Win32Error Code. 0 on success</param> /// <returns><see cref="Win32FileHandle" /> of specified path</returns> static Win32FileHandle FindFirstFileManaged(String uncPath, Win32FindData win32FindData, out Int32 win32Error) { var handle = Win32SafeNativeMethods.FindFirstFile(uncPath, win32FindData); win32Error = Marshal.GetLastWin32Error(); return handle; }
/// <summary> /// Initializes a new instance of the <see cref="LongPathFileInfo"/> class. /// </summary> /// <param name="entryData">Entry data.</param> internal LongPathFileInfo(Win32FindData entryData) : base(entryData) { this.UpdateProperties(); }
/// <summary> /// Search Exection /// </summary> /// <param name="uncDirectoryPath">Start directory path</param> /// <param name="pattern">Search pattern. Uses Win32 native filtering.</param> /// <param name="searchOption"> /// <see cref="SearchOption" /> /// </param> /// <param name="enumerateOptions">The enumeration options for exception handling</param> /// <param name="pathFormatReturn">Specifies the type of path to return.</param> /// <param name="filterType"> /// <see cref="FileOrDirectory" /> /// </param> /// <returns>Collection of path</returns> static IEnumerable<String> FindPaths(String uncDirectoryPath, String pattern = "*", SearchOption searchOption = SearchOption.TopDirectoryOnly, FileOrDirectory? filterType = null, SuppressExceptions enumerateOptions = SuppressExceptions.None, UncOrRegular pathFormatReturn = UncOrRegular.Regular) { // Result Container var results = new List<String>(); // Match for start of search string currentPath = PathTools.Combine(uncDirectoryPath, pattern); // Find First file var win32FindData = new Win32FindData(); int win32Error; using (var fileHandle = FindFirstSafeFileHandle(currentPath, win32FindData, out win32Error)) { // Take care of invalid handles if (fileHandle.IsInvalid && EnumerationHandleInvalidFileHandle(uncDirectoryPath, enumerateOptions, win32Error)) { return new List<String>(); } do { // Ignore . and .. directories if (IsSystemDirectoryEntry(win32FindData)) { continue; } // Create hit for current search result string resultPath = PathTools.Combine(uncDirectoryPath, win32FindData.cFileName); // if it's a file, add to the collection if (!ContainsFileAttribute(win32FindData.dwFileAttributes, FileAttributes.Directory)) { if (filterType == null || ((FileOrDirectory)filterType == FileOrDirectory.File)) { // It's a file results.Add(FormatPathByType(pathFormatReturn, resultPath)); } } else { // It's a directory // Check for search searchFocus directories if (filterType != null && ((FileOrDirectory)filterType == FileOrDirectory.Directory)) { results.Add(FormatPathByType(pathFormatReturn, resultPath)); } // SubFolders?! if (searchOption == SearchOption.AllDirectories) { var r = new List<String>(FindPaths(resultPath, pattern, searchOption, filterType, enumerateOptions)); if (r.Count > 0) { results.AddRange(r); } } } // Create new FindData object for next result win32FindData = new Win32FindData(); } // Search for next entry while (Win32SafeNativeMethods.FindNextFile(fileHandle, win32FindData)); } // Return result; return results; }
static string[] НайтиФайлы(string маска) { string путь; try { путь = Path.GetDirectoryName(маска); } catch { return new string[0]; } Win32FindData fd = new Win32FindData(); IntPtr handle = FindFirstFile(маска, fd); if (handle == new IntPtr(-1)) return new string[0]; List<string> файлы = new List<string>(); while (true) { файлы.Add(Path.Combine(путь, fd.FileName)); if (!FindNextFile(handle, fd)) break; } FindClose(handle); return файлы.ToArray(); }
public static extern IntPtr FindFirstFile(string lpFileName, out Win32FindData lpFindFileData);
public static extern SafeFindHandle FindFirstFile( /* [in] */ [MarshalAs(UnmanagedType.LPWStr)] string fileName, /* [out] */ out Win32FindData findFileData);
public static extern bool FindNextFile( /* [in] */ SafeFindHandle findFile, /* [out] */ out Win32FindData findFileData);
private void ReadNative(Queue <FolderState> subdirs, CancellationToken token) { Win32FindData find = new Win32FindData(); FolderState folderState = subdirs.Dequeue(); ScanningState state = folderState.State; FolderItem parent = folderState.Folder; bool findResult; string parentPath = parent.FullName; string searchPattern = PathUtils.CombineNoChecks(parentPath, "*"); if (!searchPattern.StartsWith(@"\\?\")) { searchPattern = @"\\?\" + searchPattern; } IntPtr hFind = FindFirstFileEx(searchPattern, FindExInfoLevels.Basic, out find, FindExSearchOps.NameMatch, IntPtr.Zero, FindExFlags.LargeFetch); if (hFind == InvalidHandle) { return; } FolderItem fileCollection = null; FileItem firstFile = null; bool subdirsAdded = false; try { do { string filePath = PathUtils.CombineNoChecks(parentPath, find.cFileName); if (find.IsRelativeDirectory || SkipFile(state, find.cFileName, filePath)) { // Skip these types of entries findResult = FindNextFile(hFind, out find); continue; } FileItemBase child; if (find.IsDirectory) { FolderItem folder = new FolderItem(new ScanFileInfo(find, filePath)); child = folder; if (!find.IsSymbolicLink) { subdirsAdded = true; subdirs.Enqueue(new FolderState(folder, state)); } } else { ExtensionItem extension = Extensions.GetOrAddFromPath(filePath); FileItem file = new FileItem(new ScanFileInfo(find, filePath), extension); child = file; if (!find.IsSymbolicLink) { TotalScannedSize += child.Size; } } parent.AddItem(child, ref fileCollection, ref firstFile); if (AsyncChecks(token)) { return; } findResult = FindNextFile(hFind, out find); } while (findResult); if (!subdirsAdded) { parent.Finish(); } //if (parent.IsWatched) // parent.RaiseChanged(FileItemAction.ChildrenDone); } finally { FindClose(hFind); } }