/// <summary>
/// Receives <see cref="QuickIODirectoryMetadata"/> of current directory
/// </summary>
/// <returns><see cref="QuickIODirectoryMetadata"/></returns>
public static QuickIODirectoryMetadata EnumerateDirectoryMetadata( String path, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( path ) );
Contract.Ensures( Contract.Result<QuickIODirectoryMetadata>() != null );
return InternalEnumerateFileSystem.EnumerateDirectoryMetadata( path, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of directory names in a specified path.
/// </summary>
/// <param name="path">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable<string> EnumerateDirectoryPaths( string path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( path ) );
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
return InternalEnumerateFileSystem.EnumerateSystemPaths( path, pattern, searchOption, enumerateOptions, pathFormatReturn, QuickIOFileSystemEntryType.Directory );
}
/// <summary>
/// Returns an enumerable collection of files in a specified path.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">Specifiy depth with <see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
public IEnumerable<QuickIOFileInfo> EnumerateFiles( String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
Contract.Ensures(Contract.Result<IEnumerable<QuickIOFileInfo>>() != null);
return QuickIODirectory.EnumerateFiles( FullNameUnc, pattern, searchOption );
}
/// <summary>
/// Returns an enumerable collection of directory names in a specified path.
/// </summary>
/// <param name="info">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable<string> EnumerateDirectoryPaths( QuickIODirectoryInfo info, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( info != null );
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
return EnumerateDirectoryPaths( info.FullNameUnc, pattern, searchOption, pathFormatReturn, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of file names in a specified path.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">Specifiy depth with <see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options</param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
public IEnumerable<string> EnumerateFilePaths( String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( pattern ) );
Contract.Ensures( Contract.Result<IEnumerable<string>>() != null );
return QuickIODirectory.EnumerateFilePaths( FullNameUnc, pattern, searchOption, pathFormatReturn, enumerateOptions );
}
/// <summary>
/// Determined all sub system entries of a directory
/// </summary>
/// <param name="path">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 <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<Tuple<string, Win32FileSystemEntry>> EnumerateWin32FileSystemEntries( String path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( path ) );
Contract.Ensures( Contract.Result<IEnumerable<Tuple<string, Win32FileSystemEntry>>>() != null );
// Stack
Stack<string> directoryPathStack = new Stack<string>();
directoryPathStack.Push( path );
while( directoryPathStack.Count > 0 )
{
string currentDirectory = directoryPathStack.Pop();
foreach( Win32FileSystemEntry systemEntry in new Win32FileHandleCollection( QuickIOPath.Combine( currentDirectory, pattern ) ) )
{
yield return new Tuple<string, Win32FileSystemEntry>( currentDirectory, systemEntry );
// Create hit for current search result
string resultPath = QuickIOPath.Combine( currentDirectory, systemEntry.Name );
// Check for Directory
if( searchOption == SearchOption.AllDirectories && systemEntry.IsDirectory )
{
directoryPathStack.Push( resultPath );
}
}
}
}
/// <summary>
/// Receives <see cref="QuickIODirectoryMetadata"/> of current directory
/// </summary>
/// <returns><see cref="QuickIODirectoryMetadata"/></returns>
public static QuickIODirectoryMetadata EnumerateDirectoryMetadata( QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( pathInfo != null );
Contract.Ensures( Contract.Result<QuickIODirectoryMetadata>() != null );
return EnumerateDirectoryMetadata( pathInfo.FullNameUnc, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of files in a specified path.
/// </summary>
/// <param name="directoryInfo">The directory to search. </param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383458(v=vs.110).aspx</remarks>
public static IEnumerable <QuickIOFileInfo> EnumerateFiles(QuickIODirectoryInfo directoryInfo,
String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly,
QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(directoryInfo != null);
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
return(EnumerateFiles(directoryInfo.FullNameUnc, pattern, searchOption, enumerateOptions));
}
/// <summary>
/// Determined all sub system entries 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 <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<QuickIOFileSystemEntry> EnumerateFileSystemEntries( String uncDirectoryPath, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
Contract.Requires( !String.IsNullOrWhiteSpace( uncDirectoryPath ) );
Contract.Ensures( Contract.Result<IEnumerable<QuickIOFileSystemEntry>>() != null );
return
( from pair in EnumerateWin32FileSystemEntries( uncDirectoryPath, pattern, searchOption, enumerateOptions )
let parentDirectory = pair.Item1
let win32Entry = pair.Item2
let fullpath = QuickIOPath.Combine( parentDirectory, win32Entry.Name )
select
new QuickIOFileSystemEntry( fullpath, win32Entry.FileSystemEntryType, win32Entry.Attributes, win32Entry.Bytes ) );
}
/// <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="QuickIOFileSystemEntryType"/></param>
/// <returns>Collection of path</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static IEnumerable<String> EnumerateSystemPaths( String uncDirectoryPath, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOFileSystemEntryType? filterType = null )
{
Contract.Requires( !String.IsNullOrWhiteSpace( uncDirectoryPath ) );
Contract.Ensures( Contract.Result<IEnumerable<String>>() != null );
IEnumerable<QuickIOFileSystemEntry> entries = EnumerateFileSystemEntries( uncDirectoryPath, pattern, searchOption, enumerateOptions );
// filter?
if( filterType != null )
{
entries = entries.Where( entry => entry.Type == filterType );
}
// TODO: path format
return entries.Select( entry => entry.Path );
}
/// <summary>
/// Determined all subfolders 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><see cref="QuickIODirectoryInfo"/> collection of subfolders</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable <QuickIODirectoryInfo> EnumerateDirectories(string uncDirectoryPath,
String pattern = QuickIOPatterns.PathMatchAll,
SearchOption searchOption = SearchOption.TopDirectoryOnly,
QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(uncDirectoryPath));
Contract.Ensures(Contract.Result <IEnumerable <QuickIODirectoryInfo> >() != null);
// Stack
Stack <string> directoryPathStack = new Stack <string>();
directoryPathStack.Push(uncDirectoryPath);
while (directoryPathStack.Count > 0)
{
string currentDirectory = directoryPathStack.Pop();
foreach (Win32FileSystemEntry systemEntry in new Win32FileHandleCollection(QuickIOPath.Combine(currentDirectory, pattern)))
{
// Create hit for current search result
var resultPath = QuickIOPath.Combine(currentDirectory, systemEntry.Name);
// Check for Directory
if (systemEntry.IsDirectory)
{
yield return(new QuickIODirectoryInfo(resultPath, systemEntry.FindData));
// SubFolders?!
if (searchOption == SearchOption.AllDirectories)
{
directoryPathStack.Push(resultPath);
}
}
}
}
}
/// <summary>
/// Determined all sub file system entries of a directory
/// </summary>
/// <param name="pathInfo">Path of the directory</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<KeyValuePair<String, QuickIOFileSystemEntryType>> EnumerateFileSystemEntryPaths( QuickIOPathInfo pathInfo, SearchOption searchOption, QuickIOEnumerateOptions enumerateOptions, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
return EnumerateFileSystemEntryPaths( pathInfo.FullNameUnc, searchOption, enumerateOptions, pathFormatReturn );
}
/// <summary>
/// Determined metadata of directory
/// </summary>
/// <param name="path">Path of the directory</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns><see cref="QuickIODirectoryMetadata"/> started with the given directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static QuickIODirectoryMetadata EnumerateDirectoryMetadata(String path, QuickIOEnumerateOptions enumerateOptions)
{
Contract.Requires(!String.IsNullOrWhiteSpace(path));
Contract.Ensures(Contract.Result <QuickIODirectoryMetadata>() != null);
IList <Win32FileSystemEntry> entries =
new Win32FileHandleCollection(path).Cast <Win32FileSystemEntry>().ToList();
// TODO: search another solution instead of enumerator
if (entries.Count > 1)
{
throw new InvalidOperationException("Found more than one entry to one specific path.");
}
return(EnumerateDirectoryMetadata(path, entries.ElementAt(0), enumerateOptions));;
}
/// <summary>
/// Determined all sub file system entries 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="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<KeyValuePair<String, QuickIOFileSystemEntryType>> EnumerateFileSystemEntryPaths( QuickIOPathInfo pathInfo, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
return EnumerateFileSystemEntryPaths( pathInfo.FullNameUnc, pattern, searchOption, enumerateOptions, pathFormatReturn );
}
/// <summary>
/// Determined all files 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">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>Collection of files</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<QuickIOFileInfo> EnumerateFiles( QuickIOPathInfo pathInfo, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return EnumerateFiles( pathInfo.FullNameUnc, pattern, searchOption, enumerateOptions );
}
/// <summary>
/// Determines the statistics of the given directory. This includes the number of files, folders and the total size in bytes.
/// </summary>
/// <param name="pathInfo">PathInfo of the directory to generate the statistics.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>Provides the statistics of the directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static QuickIOFolderStatisticResult GetDirectoryStatistics(QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
throw new NotImplementedException();
}
/// <summary>
/// Returns an enumerable collection of directory names in a specified path.
/// </summary>
/// <param name="info">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable <string> EnumerateDirectoryPaths(QuickIODirectoryInfo info, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(info != null);
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
return(EnumerateDirectoryPaths(info.FullNameUnc, pattern, searchOption, pathFormatReturn, enumerateOptions));
}
/// <summary>
/// Returns an enumerable collection of directories in a specified path.
/// </summary>
/// <param name="info">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable <QuickIODirectoryInfo> EnumerateDirectories(QuickIODirectoryInfo info, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
return(EnumerateDirectories(info.FullNameUnc, pattern, searchOption, enumerateOptions));
}
/// <summary>
/// Determined metadata of directory
/// </summary>
/// <param name="path">Path of the directory</param>
/// <param name="fileSystemEntry"><see cref="Win32FileSystemEntry"/></param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns><see cref="QuickIODirectoryMetadata"/> started with the given directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
private static QuickIODirectoryMetadata EnumerateDirectoryMetadata(String path, Win32FileSystemEntry fileSystemEntry, QuickIOEnumerateOptions enumerateOptions)
{
Contract.Requires(!String.IsNullOrWhiteSpace(path));
Contract.Ensures(Contract.Result <QuickIODirectoryMetadata>() != null);
// Results
IList <QuickIOFileMetadata> subFiles = new List <QuickIOFileMetadata>();
IList <QuickIODirectoryMetadata> subDirs = new List <QuickIODirectoryMetadata>();
foreach (Win32FileSystemEntry systemEntry in new Win32FileHandleCollection(QuickIOPath.Combine(path, QuickIOPatterns.PathMatchAll)))
{
// Create hit for current search result
var uncResultPath = QuickIOPath.Combine(path, systemEntry.Name);
// if it's a file, add to the collection
if (systemEntry.IsFile)
{
subFiles.Add(new QuickIOFileMetadata(uncResultPath, systemEntry.FindData));
}
else
{
subDirs.Add(EnumerateDirectoryMetadata(uncResultPath, systemEntry, enumerateOptions));
}
}
return(new QuickIODirectoryMetadata(path, fileSystemEntry.FindData, subDirs, subFiles));
}
/// <summary>
/// Returns an enumerable collection of file names and directory names that match a search pattern in a specified path, and optionally searches subdirectories in a seperate task created by the default <see cref="TaskScheduler"/>.
/// </summary>
/// <param name="directoryInfo">The directory to search. </param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <param name="searchOption">One of the enumeration values that specifies whether the search operation should include only the current directory or should include all subdirectories.The default value is TopDirectoryOnly.</param>
/// <returns>An enumerable collection of file-system entries in the directory specified by path and that match the specified search pattern and option.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383459(v=vs.110).aspx</remarks>
/// <remarks><b>Requires .NET 4.0 or higher</b><br /><u>Warning:</u> parallel file system browsing on the same hard disk (HDD/SSD) will decrease performance. Use this only on stripped RAIDs or with network shares.</remarks>
public static Task<IEnumerable<KeyValuePair<QuickIOPathInfo, QuickIOFileSystemEntryType>>> EnumerateFileSystemEntriesAsync( QuickIODirectoryInfo directoryInfo, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return NETCompatibility.AsyncExtensions.GetAsyncResult( () => EnumerateFileSystemEntries( directoryInfo.PathInfo, searchOption, enumerateOptions ) );
}
/// <summary>
/// Returns an enumerable collection of directories names in a specified path.
/// </summary>
/// <param name="info">The directory to search.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable<QuickIODirectoryInfo> EnumerateDirectories( QuickIOPathInfo info, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return InternalQuickIO.EnumerateDirectories( info, searchOption, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of file names and directory names that match a search pattern in a specified path, and optionally searches subdirectories in a seperate task created by the default <see cref="TaskScheduler"/>.
/// </summary>
/// <param name="pathInfo">The directory to search. </param>
/// <param name="searchOption">One of the enumeration values that specifies whether the search operation should include only the current directory or should include all subdirectories.The default value is TopDirectoryOnly.</param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of file-system entries in the directory specified by path and that match the specified search pattern and option.</returns>
/// <remarks><b>Requires .NET 4.0 or higher</b><br /><u>Warning:</u> parallel file system browsing on the same hard disk (HDD/SSD) will decrease performance. Use this only on stripped RAIDs or with network shares.</remarks>
public static Task<IEnumerable<KeyValuePair<string, QuickIOFileSystemEntryType>>> EnumerateFileSystemEntryPathsAsync( QuickIOPathInfo pathInfo, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return NETCompatibility.AsyncExtensions.GetAsyncResult( () => EnumerateFileSystemEntryPaths( pathInfo, searchOption, pathFormatReturn, enumerateOptions ) );
}
/// <summary>
/// Determined all sub system entries 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 <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable <QuickIOFileSystemEntry> EnumerateFileSystemEntries(String uncDirectoryPath, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(uncDirectoryPath));
Contract.Ensures(Contract.Result <IEnumerable <QuickIOFileSystemEntry> >() != null);
return
(from pair in EnumerateWin32FileSystemEntries(uncDirectoryPath, pattern, searchOption, enumerateOptions)
let parentDirectory = pair.Item1
let win32Entry = pair.Item2
let fullpath = QuickIOPath.Combine(parentDirectory, win32Entry.Name)
select
new QuickIOFileSystemEntry(fullpath, win32Entry.FileSystemEntryType, win32Entry.Attributes, win32Entry.Bytes));
}
/// <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="QuickIOFileSystemEntryType"/></param>
/// <returns>Collection of path</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static IEnumerable <String> EnumerateSystemPaths(String uncDirectoryPath, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOFileSystemEntryType?filterType = null)
{
Contract.Requires(!String.IsNullOrWhiteSpace(uncDirectoryPath));
Contract.Ensures(Contract.Result <IEnumerable <String> >() != null);
IEnumerable <QuickIOFileSystemEntry> entries = EnumerateFileSystemEntries(uncDirectoryPath, pattern, searchOption, enumerateOptions);
// filter?
if (filterType != null)
{
entries = entries.Where(entry => entry.Type == filterType);
}
// TODO: path format
return(entries.Select(entry => entry.Path));
}
/// <summary>
/// Returns an enumerable collection of file names in a specified path.
/// </summary>
/// <param name="path">The directory to search. </param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383458(v=vs.110).aspx</remarks>
public static IEnumerable <string> EnumerateFilePaths(string path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
return(InternalEnumerateFileSystem.EnumerateSystemPaths(path, pattern, searchOption, enumerateOptions, pathFormatReturn, QuickIOFileSystemEntryType.File));
}
/// <summary>
/// Determines the statistics of the given directory. This includes the number of files, folders and the total size in bytes.
/// </summary>
/// <param name="pathInfo">PathInfo of the directory to generate the statistics.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>Provides the statistics of the directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static QuickIOFolderStatisticResult GetDirectoryStatistics( QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return GetDirectoryStatistics( pathInfo.FullNameUnc, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of files in a specified path.
/// </summary>
/// <param name="path">The directory to search. </param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383458(v=vs.110).aspx</remarks>
/// <example>
/// <code>
/// // Get subfiles
/// IEnumerable<QuickIOFileInfo> allSubFiles = QuickIODirectory.EnumerateFiles( @"C:\temp\QuickIO", SearchOption.AllDirectories );
///
/// foreach ( QuickIOFileInfo fileInfo in allSubFiles )
/// {
/// Console.WriteLine( "File found: {0} Readonly: {1}", fileInfo.Path, fileInfo.IsReadOnly );
/// }
///</code>
/// </example>
public static IEnumerable <QuickIOFileInfo> EnumerateFiles(string path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(path));
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
return(InternalEnumerateFileSystem.EnumerateFiles(path, pattern, searchOption, enumerateOptions));
}
/// <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="QuickIODirectoryInfo"/> collection of subfolders</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<QuickIODirectoryInfo> EnumerateDirectories( QuickIOPathInfo pathInfo, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
// Match for start of search
var currentPath = QuickIOPath.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 != Win32ErrorCodes.ERROR_NO_MORE_FILES )
{
InternalQuickIOCommon.NativeExceptionMapping( pathInfo.FullName, win32Error );
}
if ( EnumerationHandleInvalidFileHandle( pathInfo.FullName, enumerateOptions, win32Error ) )
{
yield return null;
}
}
// Treffer auswerten
do
{
// Ignore . and .. directories
if ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var resultPath = QuickIOPath.Combine( pathInfo.FullName, win32FindData.cFileName );
// Check for Directory
if ( InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
yield return new QuickIODirectoryInfo( resultPath, win32FindData );
// SubFolders?!
if ( searchOption == SearchOption.AllDirectories )
{
foreach ( var match in EnumerateDirectories( new QuickIOPathInfo( 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>
/// Returns an enumerable collection of directory names in a specified path.
/// </summary>
/// <param name="path">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable <string> EnumerateDirectoryPaths(string path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(path));
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
return(InternalEnumerateFileSystem.EnumerateSystemPaths(path, pattern, searchOption, enumerateOptions, pathFormatReturn, QuickIOFileSystemEntryType.Directory));
}
/// <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="QuickIODirectoryMetadata"/> started with the given directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static QuickIODirectoryMetadata EnumerateDirectoryMetadata( String uncDirectoryPath, Win32FindData findData, QuickIOEnumerateOptions enumerateOptions )
{
// Results
var subFiles = new List<QuickIOFileMetadata>( );
var subDirs = new List<QuickIODirectoryMetadata>( );
// Match for start of search
var currentPath = QuickIOPath.Combine( uncDirectoryPath, QuickIOPatternConstants.All );
// 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 != Win32ErrorCodes.ERROR_NO_MORE_FILES )
{
InternalQuickIOCommon.NativeExceptionMapping( uncDirectoryPath, win32Error );
}
if ( EnumerationHandleInvalidFileHandle( uncDirectoryPath, enumerateOptions, win32Error ) )
{
return null;
}
}
// Treffer auswerten
do
{
// Ignore . and .. directories
if ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var uncResultPath = QuickIOPath.Combine( uncDirectoryPath, win32FindData.cFileName );
#region File
// if it's a file, add to the collection
if ( !InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
var fileMetaData = new QuickIOFileMetadata( uncResultPath, win32FindData );
subFiles.Add( fileMetaData );
}
#endregion
#region Directory
else
{
var dir = EnumerateDirectoryMetadata( uncResultPath, win32FindData, enumerateOptions );
subDirs.Add( dir );
}
#endregion
// Create new FindData object for next result
win32FindData = new Win32FindData( );
} // Search for next entry
while ( Win32SafeNativeMethods.FindNextFile( fileHandle, win32FindData ) );
}
return new QuickIODirectoryMetadata( uncDirectoryPath, findData, subDirs, subFiles );
}
/// <summary>
/// Returns an enumerable collection of directories in a specified path.
/// </summary>
/// <param name="path">The directory to search.</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
/// <example>
/// <code>
/// // Get subfolders
/// IEnumerable>QuickIODirectoryInfo< allSubFolders = QuickIODirectory.EnumerateDirectories( @"C:\temp\QuickIO", SearchOption.AllDirectories );
///
/// foreach ( QuickIODirectoryInfo directoryInfo in allSubFolders )
/// {
/// Console.WriteLine( "Directory found: {0} Readonly: {1}", directoryInfo.Path, directoryInfo.IsReadOnly );
/// }
/// </code>
/// </example>
public static IEnumerable <QuickIODirectoryInfo> EnumerateDirectories(string path, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
return(InternalEnumerateFileSystem.EnumerateDirectories(path, pattern, searchOption, enumerateOptions));
}
/// <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>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable <QuickIOFileInfo> EnumerateFiles(String uncDirectoryPath, String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(uncDirectoryPath));
Contract.Ensures(Contract.Result <IEnumerable <QuickIOFileInfo> >() != null);
foreach (Win32FileSystemEntry systemEntry in new Win32FileHandleCollection(QuickIOPath.Combine(uncDirectoryPath, pattern)))
{
// Create hit for current search result
var resultPath = QuickIOPath.Combine(uncDirectoryPath, systemEntry.Name);
// Check for Directory
if (systemEntry.IsFile)
{
yield return(new QuickIOFileInfo(resultPath, systemEntry.FindData));
}
else if (/* it's already a directory here */ searchOption == SearchOption.AllDirectories)
{
foreach (var match in EnumerateFiles(resultPath, pattern, searchOption, enumerateOptions))
{
yield return(match);
}
}
}
}
/// <summary>
/// Returns an enumerable collection of directory names in a specified path.
/// </summary>
/// <param name="path">The directory to search.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the directories in the directory specified by path.</returns>
/// <remarks>http://msdn.microsoft.com/en-us/library/dd383304(v=vs.110).aspx</remarks>
public static IEnumerable<string> EnumerateDirectoryPaths( string path, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return EnumerateDirectoryPaths( new QuickIOPathInfo( path ), searchOption, pathFormatReturn, enumerateOptions );
}
/// <summary>
/// Handles the options to the fired exception
/// </summary>
private static bool EnumerationHandleInvalidFileHandle( string path, QuickIOEnumerateOptions enumerateOptions, int win32Error )
{
try
{
InternalQuickIOCommon.NativeExceptionMapping( path, win32Error );
}
catch ( Exception )
{
if ( ( enumerateOptions & QuickIOEnumerateOptions.SuppressAllExceptions ) == QuickIOEnumerateOptions.SuppressAllExceptions )
{
return true;
}
throw;
}
return false;
}
/// <summary>
/// Determined all sub file system entries 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="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
private static IEnumerable<KeyValuePair<String, QuickIOFileSystemEntryType>> EnumerateFileSystemEntryPaths( String uncDirectoryPath, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
// Match for start of search
var currentPath = QuickIOPath.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 )
{
if ( win32Error != Win32ErrorCodes.ERROR_NO_MORE_FILES )
{
InternalQuickIOCommon.NativeExceptionMapping( uncDirectoryPath, win32Error );
}
if ( EnumerationHandleInvalidFileHandle( uncDirectoryPath, enumerateOptions, win32Error ) )
{
yield return new KeyValuePair<string, QuickIOFileSystemEntryType>( );
}
}
// Treffer auswerten
do
{
// Ignore . and .. directories
if ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var resultPath = QuickIOPath.Combine( uncDirectoryPath, win32FindData.cFileName );
// Check for Directory
if ( InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
yield return new KeyValuePair<String, QuickIOFileSystemEntryType>( FormatPathByType( pathFormatReturn, resultPath ), QuickIOFileSystemEntryType.Directory );
// SubFolders?!
if ( searchOption == SearchOption.AllDirectories )
{
foreach ( var match in EnumerateFileSystemEntryPaths( resultPath, pattern, searchOption, enumerateOptions, pathFormatReturn ) )
{
yield return match;
}
}
}
else
{
yield return new KeyValuePair<String, QuickIOFileSystemEntryType>( FormatPathByType( pathFormatReturn, resultPath ), QuickIOFileSystemEntryType.File );
}
// Create new FindData object for next result
win32FindData = new Win32FindData( );
} // Search for next entry
while ( Win32SafeNativeMethods.FindNextFile( fileHandle, win32FindData ) );
}
}
/// <summary>
/// Receives <see cref="QuickIODirectoryMetadata"/> of current directory
/// </summary>
/// <returns><see cref="QuickIODirectoryMetadata"/></returns>
public static QuickIODirectoryMetadata EnumerateDirectoryMetadata(String path, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(path));
Contract.Ensures(Contract.Result <QuickIODirectoryMetadata>() != null);
return(InternalEnumerateFileSystem.EnumerateDirectoryMetadata(path, enumerateOptions));
}
/// <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="QuickIOFileSystemEntryType"/></param>
/// <returns>Collection of path</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
private static IEnumerable<String> FindPaths( String uncDirectoryPath, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOFileSystemEntryType? filterType = null, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
// Result Container
var results = new List<String>( );
// Match for start of search
var currentPath = QuickIOPath.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>( );
}
// Treffer auswerten
do
{
// Ignore . and .. directories
if ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var resultPath = QuickIOPath.Combine( uncDirectoryPath, win32FindData.cFileName );
// if it's a file, add to the collection
if ( !InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
if ( filterType != null && ( ( QuickIOFileSystemEntryType ) filterType == QuickIOFileSystemEntryType.File ) )
{
// It's a file
results.Add( FormatPathByType( pathFormatReturn, resultPath ) );
}
}
else
{
// It's a directory
// Check for search searchFocus directories
if ( filterType != null && ( ( QuickIOFileSystemEntryType ) filterType == QuickIOFileSystemEntryType.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;
}
/// <summary>
/// Receives <see cref="QuickIODirectoryMetadata"/> of current directory
/// </summary>
/// <returns><see cref="QuickIODirectoryMetadata"/></returns>
public static QuickIODirectoryMetadata EnumerateDirectoryMetadata(QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(pathInfo != null);
Contract.Ensures(Contract.Result <QuickIODirectoryMetadata>() != null);
return(EnumerateDirectoryMetadata(pathInfo.FullNameUnc, enumerateOptions));
}
/// <summary>
/// Determines the statistics of the given directory. This includes the number of files, folders and the total size in bytes.
/// </summary>
/// <param name="path">Path to the directory to generate the statistics.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>Provides the statistics of the directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static QuickIOFolderStatisticResult GetDirectoryStatistics( String path, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
UInt64 fileCount = 0;
UInt64 folderCount = 0;
UInt64 totalSize = 0;
// Match for start of search
var currentPath = QuickIOPath.Combine( path, QuickIOPatternConstants.All );
// 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 ( EnumerationHandleInvalidFileHandle( currentPath, enumerateOptions, win32Error ) )
{
return null;
}
}
// Treffer auswerten
do
{
// Ignore . and .. directories
if ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var resultPath = QuickIOPath.Combine( path, win32FindData.cFileName );
// if it's a file, add to the collection
if ( !InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
fileCount++;
totalSize += win32FindData.CalculateBytes( ); win32FindData.CalculateBytes( );
}
else
{
folderCount++;
var result = GetDirectoryStatistics( resultPath, enumerateOptions );
{
folderCount += result.FolderCount;
fileCount += result.FileCount;
totalSize += result.TotalBytes;
}
}
// Create new FindData object for next result
win32FindData = new Win32FindData( );
} // Search for next entry
while ( Win32SafeNativeMethods.FindNextFile( fileHandle, win32FindData ) );
}
// Return result;
return new QuickIOFolderStatisticResult( folderCount, fileCount, totalSize );
}
/// <summary>
/// Returns an enumerable collection of file names and directory names that match a search pattern in a specified path, and optionally searches subdirectories.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">One of the enumeration values that specifies whether the search operation should include only the current directory or should include all subdirectories.The default value is TopDirectoryOnly.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of file-system entries in the directory specified by path and that match the specified search pattern and option.</returns>
public IEnumerable <QuickIOFileSystemEntry> EnumerateFileSystemEntryInfos(String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
Contract.Ensures(Contract.Result <IEnumerable <QuickIOFileSystemEntry> >() != null);
return(EnumerateFileSystemEntries(pattern, searchOption, enumerateOptions));
}
/// <summary>
/// Determined metadata of directory
/// </summary>
/// <param name="pathInfo">Path of the directory</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns><see cref="QuickIODirectoryMetadata"/> started with the given directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static QuickIODirectoryMetadata EnumerateDirectoryMetadata( QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
return EnumerateDirectoryMetadata( pathInfo.FullNameUnc, pathInfo.FindData, enumerateOptions );
}
/// <summary>
/// Returns an enumerable collection of files in a specified path.
/// </summary>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption">Specifiy depth with <see cref="SearchOption"/></param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>An enumerable collection of the full names (including paths) for the files in the directory specified by path.</returns>
public IEnumerable <QuickIOFileInfo> EnumerateFiles(String pattern = QuickIOPatterns.PathMatchAll, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None)
{
Contract.Requires(!String.IsNullOrWhiteSpace(pattern));
Contract.Ensures(Contract.Result <IEnumerable <QuickIOFileInfo> >() != null);
return(QuickIODirectory.EnumerateFiles(FullNameUnc, pattern, searchOption));
}
/// <summary>
/// Determined all files paths of a directory
/// </summary>
/// <param name="path">Path of the directory</param>
/// <param name="pattern">Search pattern. Uses Win32 native filtering.</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of file paths</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<String> EnumerateFilePaths( String path, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
return FindPaths( path, pattern, searchOption, QuickIOFileSystemEntryType.File, enumerateOptions, pathFormatReturn );
}
/// <summary>
/// Determined all files paths of a directory
/// </summary>
/// <param name="path">Path of the directory</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="pathFormatReturn">Specifies the type of path to return.</param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of file paths</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<String> EnumerateFilePaths( String path, SearchOption searchOption, QuickIOEnumerateOptions enumerateOptions, QuickIOPathType pathFormatReturn = QuickIOPathType.Regular )
{
return FindPaths( path, searchOption, QuickIOFileSystemEntryType.File, enumerateOptions, pathFormatReturn );
}
/// <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>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<QuickIOFileInfo> EnumerateFiles( String uncDirectoryPath, String pattern = QuickIOPatternConstants.All, SearchOption searchOption = SearchOption.TopDirectoryOnly, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
// Match for start of search
var currentPath = QuickIOPath.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 ( InternalRawDataHelpers.IsSystemDirectoryEntry( win32FindData ) )
{
continue;
}
// Create hit for current search result
var resultPath = QuickIOPath.Combine( uncDirectoryPath, win32FindData.cFileName );
// Check for Directory
if ( !InternalHelpers.ContainsFileAttribute( win32FindData.dwFileAttributes, FileAttributes.Directory ) )
{
yield return new QuickIOFileInfo( 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 files of a directory
/// </summary>
/// <param name="pathInfo">Path of the directory</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <returns>Collection of files</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<QuickIOFileInfo> EnumerateFiles( QuickIOPathInfo pathInfo, SearchOption searchOption, QuickIOEnumerateOptions enumerateOptions )
{
return EnumerateFiles( pathInfo.FullNameUnc, searchOption, enumerateOptions );
}
/// <summary>
/// Determines the statistics of the given directory. This includes the number of files, folders and the total size in bytes.
/// </summary>
/// <param name="pathInfo">PathInfo of the directory to generate the statistics.</param>
/// <param name="enumerateOptions">Options <see cref="QuickIOEnumerateOptions"/></param>
/// <returns>Provides the statistics of the directory</returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
public static QuickIOFolderStatisticResult GetDirectoryStatistics( QuickIOPathInfo pathInfo, QuickIOEnumerateOptions enumerateOptions = QuickIOEnumerateOptions.None )
{
throw new NotImplementedException();
}
/// <summary>
/// Determined all sub system entries of a directory
/// </summary>
/// <param name="pathInfo">Path of the directory</param>
/// <param name="searchOption"><see cref="SearchOption"/></param>
/// <param name="enumerateOptions">The enumeration options for exception handling</param>
/// <returns>Collection of <see cref="QuickIODirectoryInfo"/></returns>
/// <exception cref="PathNotFoundException">This error is fired if the specified path or a part of them does not exist.</exception>
internal static IEnumerable<KeyValuePair<QuickIOPathInfo, QuickIOFileSystemEntryType>> EnumerateFileSystemEntries( QuickIOPathInfo pathInfo, SearchOption searchOption, QuickIOEnumerateOptions enumerateOptions )
{
return EnumerateFileSystemEntries( pathInfo.FullNameUnc, searchOption, enumerateOptions );
}
