/// <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);
}
}
