public static extern SafeFindHandle FindFirstFileExW( string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATAW lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, FINDEX_ADDITIONAL_FLAGS dwAdditionalFlags);
internal static unsafe extern SafeFindHandle FindFirstFileEx(
char *pszPattern,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
FINDEX_ADDITIONAL_FLAGS dwAdditionalFlags);
private static extern SafeSearchHandle FindFirstFileEx(
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATAW lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
int dwAdditionalFlags);
private static extern SafeFindHandle FindFirstFileEx(
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId, //FINDEX_INFO_LEVELS
[In, Out] WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp, //FINDEX_SEARCH_OPS
IntPtr lpSearchFilter,
FIND_FIRST_EX dwAdditionalFlags);
internal static extern SafeFindHandle FindFirstFileExW(
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter, // Reserved
int dwAdditionalFlags);
public static long CalculateFileSize(string path)
{
if (string.IsNullOrEmpty(path))
{
// In MTP devices calculating folder size would be too slow
// Also should use StorageFolder methods instead of FindFirstFileExFromApp
return(0);
}
long size = 0;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(path, findInfoLevel, out WIN32_FIND_DATA findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
if (hFile.ToInt64() != -1)
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
size += findData.GetSize();
}
FindClose(hFile);
Debug.WriteLine("Individual file size for Progress UI will be reported as: " + size.ToString() + " bytes");
return(size);
}
else
{
return(0);
}
}
private void NextFind()
{
var watch = Stopwatch.StartNew();
var path = @"C:\";
WIN32_FIND_DATA findData;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoStandard;
int additionalFlags = 0;
if (Environment.OSVersion.Version.Major >= 6)
{
findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
}
IntPtr hFile = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
var count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (((System.IO.FileAttributes)findData.dwFileAttributes & System.IO.FileAttributes.Directory) == System.IO.FileAttributes.System)
{
// do something with it
var fn = findData.cFileName;
Debug.WriteLine(fn);
++count;
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
}
Debug.WriteLine("count " + count + ", ellapsed=" + watch.ElapsedMilliseconds);
}
internal static extern IntPtr FindFirstFileEx(
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
[In][Out] WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
int dwAdditionalFlags);
public static extern IntPtr FindFirstFileEx(
IntPtr lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
FINDEX_ADDITIONAL_FLAGS dwAdditionalFlags);
public static DateTime GetFileModificationTime(string path)
{
WIN32_FIND_DATA findDataResult;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
var dateModified = DateTime.MinValue;
int additionalFlags = 0;
if (Environment.OSVersion.Version.Major >= 6)
{
findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
}
IntPtr hFile = FindFirstFileExFromApp(path, findInfoLevel, out findDataResult, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
if (hFile.ToInt64() != -1)
{
long datemodifiedoffset = findDataResult.lastWriteTime.dwHighDateTime;
datemodifiedoffset = (datemodifiedoffset << 32);
datemodifiedoffset = datemodifiedoffset | (long)(uint)findDataResult.lastWriteTime.dwLowDateTime;
dateModified = System.DateTimeOffset.FromFileTime(datemodifiedoffset).ToUniversalTime().DateTime;
FindClose(hFile);
}
return(dateModified);
}
private static extern SafeFindHandle FindFirstFileTransactedW(
[In, MarshalAs(UnmanagedType.LPWStr)] string lpFileName,
[In] FINDEX_INFO_LEVELS fInfoLevelId, // TODO: Won't work.
[Out] out WIN32_FIND_DATA lpFindFileData,
[In] FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
[In] uint dwAdditionalFlags,
[In] SafeTxHandle hTransaction);
public static extern IntPtr FindFirstFileExW(
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
uint fSearchOp, // This never actually has meaning and is likely a holdover of 9x
// set it to 0 to avoid failing parameter checks.
IntPtr lpSearchFilter, // Reserved
FindFirstFileExFlags dwAdditionalFlags);
public extern static System.IntPtr FindFirstFileTransactedW(
[System.Runtime.InteropServices.MarshalAs(System.Runtime.InteropServices.UnmanagedType.LPWStr)] string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATAW lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
System.IntPtr lpSearchFilter,
int dwAdditionalFlags,
System.IntPtr hTransaction);
public static extern IntPtr FindFirstFileEx(
[MarshalAs(UnmanagedType.LPWStr)]
string lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
int dwAdditionalFlags);
internal static extern SafeFileHandle FindFirstFileTransacted(
[In] string lpDirSpec,
[In] FINDEX_INFO_LEVELS fInfoLevelId,
[Out] out WIN32_FIND_DATA lpFindFileData,
[In] FINDEX_SEARCH_OPS fSearchOp,
[In] IntPtr lpSearchFilter,
[In] int dwAdditionalFlags,
[In] KtmTransactionHandle hTransaction);
//Count File in a directory Fast
public static uint FCount(string path, string searchPattern)
{
uint count = 0;
WIN32_FIND_DATA findData;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
string pattern = @"\\$";
path = Regex.Replace(path, pattern, "", RegexOptions.IgnoreCase);
searchtext = path + searchPattern;
IntPtr hFile = FindFirstFileExFromApp(searchtext, findInfoLevel, out findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, FIND_FIRST_EX_LARGE_FETCH);
List <string> subDirs = new List <string>();
//check for access denied
if (hFile != new IntPtr(-1))
{
do
{
if (findData.cFileName == "." || findData.cFileName == "..")
{
continue;
}
if ((findData.dwFileAttributes & (uint)FileAttributes.Directory) == (uint)FileAttributes.Directory)
{
subDirs.Add(path + "\\" + findData.cFileName);
}
else
{
//count files
count++;
}
} while (FindNextFile(hFile, out findData));
//object locker = new object();
//Parallel.ForEach(subDirs, subdir =>
//{
// var temp = FCount(subdir, searchPattern);
// //apply lock when adding result from each thread to prevent conflict
// lock (locker)
// {
// count+= temp;
// }
//}
//);
foreach (var subdir in subDirs)
{
count += FCount(subdir, searchPattern);
}
}
else
{
Debug.WriteLine($"Access Denied:: {searchtext}");
}
FindClose(hFile);
return(count);
}
public static async Task <long> CalculateFolderSizeAsync(string path)
{
if (string.IsNullOrEmpty(path))
{
// In MTP devices calculating folder size would be too slow
// Also should use StorageFolder methods instead of FindFirstFileExFromApp
return(0);
}
long size = 0;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(
path + "\\*.*",
findInfoLevel,
out WIN32_FIND_DATA findData,
FINDEX_SEARCH_OPS.FindExSearchNameMatch,
IntPtr.Zero,
additionalFlags);
int count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
size += findData.GetSize();
++count;
}
else if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
if (findData.cFileName != "." && findData.cFileName != "..")
{
string itemPath = Path.Combine(path, findData.cFileName);
size += await CalculateFolderSizeAsync(itemPath);
++count;
}
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
return(size);
}
else
{
return(0);
}
}
/// <summary>
/// This function is used to determine whether or not a folder has any contents.
/// </summary>
/// <param name="targetPath">The path to the target folder</param>
///
public static bool CheckForFilesFolders(string targetPath)
{
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(targetPath + "\\*.*", findInfoLevel, out WIN32_FIND_DATA _, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
FindNextFile(hFile, out _);
var result = FindNextFile(hFile, out _);
FindClose(hFile);
return(result);
}
public static bool GetWin32FindDataForPath(string targetPath, out WIN32_FIND_DATA findData)
{
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(targetPath, findInfoLevel, out findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
if (hFile.ToInt64() != -1)
{
FindClose(hFile);
return(true);
}
return(false);
}
public static bool CheckFolderAccessWithWin32(string path)
{
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFileTsk = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out WIN32_FIND_DATA findDataTsk, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
if (hFileTsk.ToInt64() != -1)
{
FindClose(hFileTsk);
return(true);
}
return(false);
}
public static IEnumerable <string> EnumerateFiles(string path, string searchPattern, SearchOption searchOption)
{
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
Queue <string> subDirectorys = null;
if (searchOption == SearchOption.AllDirectories)
{
subDirectorys = new Queue <string>();
}
do
{
IntPtr hFile = FindFirstFileExFromApp(
path + "\\" + searchPattern,
findInfoLevel,
out WIN32_FIND_DATA findData,
FINDEX_SEARCH_OPS.FindExSearchNameMatch,
IntPtr.Zero,
additionalFlags);
if (hFile.ToInt64() != INVALID_HANDLE_VALUE)
{
do
{
var attributes = (FileAttributes)findData.dwFileAttributes;
if (!attributes.HasFlag(FileAttributes.System))
{
if (!attributes.HasFlag(FileAttributes.Directory))
{
yield return(findData.cFileName);
}
else if (searchOption == SearchOption.AllDirectories && findData.cFileName != "." && findData.cFileName != "..")
{
subDirectorys.Enqueue(Path.Combine(path, findData.cFileName));
}
}
}while (FindNextFile(hFile, out findData));
FindClose(hFile);
}
else
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}while (searchOption == SearchOption.AllDirectories && subDirectorys.TryDequeue(out path));
}
//return just folder names, seperate methods as more of it is stripped out
public static List <MonitoredFolderItem> GetMinInfo(string path)
{
var result = new List <MonitoredFolderItem>();
WIN32_FIND_DATA findDataResult;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = 0;
if (Environment.OSVersion.Version.Major >= 6)
{
findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
}
IntPtr hFile = FindFirstFileExFromApp((@"\\?\" + path + "\\*.*"), findInfoLevel, out findDataResult, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
var count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (IsSystemItem(findDataResult.itemName))
{
continue;
}
// NOTE: This section was originally commented out when the PInvoke method was abandoned
MonitoredFolderItem fileitem = new MonitoredFolderItem(findDataResult.itemName);
result.Add(fileitem);
//set attributes
fileitem.attributes = (FileAttributes)findDataResult.itemAttributes;
//set parent folder
fileitem.ParentFolderPath = path;
++count;
} while (FindNextFile(hFile, out findDataResult));
FindClose(hFile);
}
return(result);
}
public static bool CheckFolderForHiddenAttribute(string path)
{
if (string.IsNullOrEmpty(path))
{
return(false);
}
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFileTsk = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out WIN32_FIND_DATA findDataTsk, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
if (hFileTsk.ToInt64() == -1)
{
return(false);
}
var isHidden = ((FileAttributes)findDataTsk.dwFileAttributes & FileAttributes.Hidden) == FileAttributes.Hidden;
FindClose(hFileTsk);
return(isHidden);
}
public async Task <int> FindFilesWithWin32(string folderPath, int count)
{
WIN32_FIND_DATA findData;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(folderPath + "\\*.*",
findInfoLevel,
out findData,
FINDEX_SEARCH_OPS.FindExSearchNameMatch,
IntPtr.Zero,
additionalFlags);
if (hFile.ToInt32() != -1)
{
do
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
var fn = findData.cFileName;
Debug.WriteLine(fn);
++count;
}
else
{
if (findData.cFileName != "." && findData.cFileName != "..")
{
count = await FindFilesWithWin32(folderPath + "\\" + findData.cFileName, count);
}
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
}
return(count);
}
public static extern IntPtr FindFirstFileEx(
[In] [MarshalAs(UnmanagedType.LPTStr)] string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, IntPtr lpFindFileData, FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter, FIND_FIRST dwAdditionalFlags);
private static extern SafeFindHandle FindFirstFileExPrivate(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, ref WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, int dwAdditionalFlags);
public static unsafe extern IntPtr FindFirstFileExW(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, void *lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, int dwAdditionalFlags);
public static unsafe extern IntPtr FindFirstFileExW(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, void* lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, int dwAdditionalFlags);
public static unsafe extern SafeFindFilesHandle FindFirstFileEx(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, void* lpSearchFilter, FindFirstFileExFlags dwAdditionalFlags);
public SafeFindFilesHandle FindFirstFileEx(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, FindFirstFileExFlags dwAdditionalFlags) => FindFirstFileEx(lpFileName, fInfoLevelId, out lpFindFileData, fSearchOp, lpSearchFilter, dwAdditionalFlags);
static internal extern SafeFindFileHandle FindFirstFileExW([In] string lpFileName, [In] FINDEX_INFO_LEVELS fInfoLevelId, [In, Out] WIN32_FIND_DATA lpFindFileData, [In] FINDEX_SEARCH_OPS fSearchOp, [In] IntPtr lpSearchFilter, [In] FINDEX_FLAGS dwAdditionalFlags);
public async Task <long> CalculateFolderSizeAsync(string path, CancellationToken token)
{
if (string.IsNullOrEmpty(path))
{
// In MTP devices calculating folder size would be too slow
// Also should use StorageFolder methods instead of FindFirstFileExFromApp
return(0);
}
long size = 0;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out WIN32_FIND_DATA findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
var count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
size += findData.GetSize();
++count;
ViewModel.FilesCount++;
}
else if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
if (findData.cFileName != "." && findData.cFileName != "..")
{
var itemPath = Path.Combine(path, findData.cFileName);
size += await CalculateFolderSizeAsync(itemPath, token);
++count;
ViewModel.FoldersCount++;
}
}
if (size > ViewModel.ItemSizeBytes)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
ViewModel.ItemSizeBytes = size;
ViewModel.ItemSize = ByteSize.FromBytes(size).ToBinaryString().ConvertSizeAbbreviation();
SetItemsCountString();
});
}
if (token.IsCancellationRequested)
{
break;
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
return(size);
}
else
{
return(0);
}
}
//function
public static List <MonitoredFolderItem> GetItems(string path)
{
var result = new List <MonitoredFolderItem>();
var watch = Stopwatch.StartNew();
WIN32_FIND_DATA findDataResult;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = 0;
if (Environment.OSVersion.Version.Major >= 6)
{
findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
}
IntPtr hFile = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out findDataResult, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
var count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (IsSystemItem(findDataResult.itemName))
{
continue;
}
// NOTE: This section was originally commented out when the PInvoke method was abandoned
MonitoredFolderItem fileitem = new MonitoredFolderItem(findDataResult.itemName);
//set attributes
fileitem.attributes = (FileAttributes)findDataResult.itemAttributes;
//set parent folder
fileitem.ParentFolderPath = path;
// May need to swap these around if the date is f****d
long datecreatedoffset = findDataResult.creationTime.dwHighDateTime;
datecreatedoffset = (datecreatedoffset << 32);
datecreatedoffset = datecreatedoffset | (long)(uint)findDataResult.creationTime.dwLowDateTime;
fileitem.DateCreated = System.DateTimeOffset.FromFileTime(datecreatedoffset);
//set modified time
long datemodifiedoffset = findDataResult.lastWriteTime.dwHighDateTime;
datemodifiedoffset = (datemodifiedoffset << 32);
datemodifiedoffset = datemodifiedoffset | (long)(uint)findDataResult.creationTime.dwLowDateTime;
fileitem.DateModified = System.DateTimeOffset.FromFileTime(datemodifiedoffset);
//set the size
fileitem.Size = (ulong)findDataResult.fileSizeHigh << 32 | (ulong)(uint)findDataResult.fileSizeLow;
if (((FileAttributes)findDataResult.itemAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
fileitem.IsDir = true;
}
else
{
fileitem.IsDir = false;
}
result.Add(fileitem);
++count;
} while (FindNextFile(hFile, out findDataResult));
FindClose(hFile);
}
return(result);
/// Local Functions
bool IsSystemItem(string itemName)
{
if
(
findDataResult.itemName == "." ||
findDataResult.itemName == ".."
)
{
return(true);
}
return(false);
}
}
public static unsafe extern SafeFindFilesHandle FindFirstFileEx(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, void *lpSearchFilter, FindFirstFileExFlags dwAdditionalFlags);
static extern IntPtr FindFirstFileExW(string lpFileName, FINDEX_INFO_LEVELS fInfoLevelId, out WIN32_FIND_DATA lpFindFileData, FINDEX_SEARCH_OPS fSearchOp, IntPtr lpSearchFilter, uint dwAdditionalFlags);
public async Task <long> CalculateFolderSizeAsync(string path, CancellationToken token)
{
long size = 0;
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(path + "\\*.*", findInfoLevel, out WIN32_FIND_DATA findData, FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero,
additionalFlags);
var count = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
long fDataFSize = findData.nFileSizeLow;
long fileSize;
if (fDataFSize < 0 && findData.nFileSizeHigh > 0)
{
fileSize = fDataFSize + 4294967296 + (findData.nFileSizeHigh * 4294967296);
}
else
{
if (findData.nFileSizeHigh > 0)
{
fileSize = fDataFSize + (findData.nFileSizeHigh * 4294967296);
}
else if (fDataFSize < 0)
{
fileSize = fDataFSize + 4294967296;
}
else
{
fileSize = fDataFSize;
}
}
size += fileSize;
++count;
ViewModel.FilesCount++;
}
else if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
if (findData.cFileName != "." && findData.cFileName != "..")
{
var itemPath = Path.Combine(path, findData.cFileName);
size += await CalculateFolderSizeAsync(itemPath, token);
++count;
ViewModel.FoldersCount++;
}
}
if (size > ViewModel.ItemSizeBytes)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
ViewModel.ItemSizeBytes = size;
ViewModel.ItemSize = ByteSize.FromBytes(size).ToBinaryString().ConvertSizeAbbreviation();
SetItemsCountString();
});
}
if (token.IsCancellationRequested)
{
break;
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
return(size);
}
else
{
return(0);
}
}
internal static extern SafeFindFileHandle FindFirstFileEx([MarshalAs(UnmanagedType.LPWStr)] String lpFileName,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
FindExAdditionalFlags dwAdditionalFlags);
public static async void UpdateFolder(ListedItem folder, CancellationToken cancellationToken)
{
CoreDispatcher dispatcher;
if (folder.PrimaryItemAttribute == Windows.Storage.StorageItemTypes.Folder && folder.FileSizeBytes == 0 && folder.ContainsFilesOrFolders)
{
dispatcher = CoreApplication.MainView.CoreWindow.Dispatcher;
await dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
folder.FileSize = 0L.ToSizeString();
});
_ = await Calculate(folder.ItemPath);
}
async Task <long> Calculate(string folderPath)
{
if (string.IsNullOrEmpty(folderPath))
{
return(0);
}
FINDEX_INFO_LEVELS findInfoLevel = FINDEX_INFO_LEVELS.FindExInfoBasic;
int additionalFlags = FIND_FIRST_EX_LARGE_FETCH;
IntPtr hFile = FindFirstFileExFromApp(folderPath + "\\*.*", findInfoLevel, out WIN32_FIND_DATA findData,
FINDEX_SEARCH_OPS.FindExSearchNameMatch, IntPtr.Zero, additionalFlags);
long size = 0;
if (hFile.ToInt64() != -1)
{
do
{
if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) != FileAttributes.Directory)
{
size += findData.GetSize();
}
else if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
{
if (findData.cFileName is not "." and not "..")
{
string path = Path.Combine(folderPath, findData.cFileName);
size += await Calculate(path);
}
}
await dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
if (size > folder.FileSizeBytes)
{
folder.FileSizeBytes = size;
folder.FileSize = size.ToSizeString();
}
;
});
if (cancellationToken.IsCancellationRequested)
{
break;
}
} while (FindNextFile(hFile, out findData));
FindClose(hFile);
return(size);
}
else
{
return(0);
}
}
}
internal static unsafe extern SafeFindHandle FindFirstFileEx(
char* pszPattern,
FINDEX_INFO_LEVELS fInfoLevelId,
out WIN32_FIND_DATA lpFindFileData,
FINDEX_SEARCH_OPS fSearchOp,
IntPtr lpSearchFilter,
FINDEX_ADDITIONAL_FLAGS dwAdditionalFlags);
