/// <summary> /// Attempt to extract a stream from an archive /// </summary> /// <param name="entryName">Name of the entry to be extracted</param> /// <param name="realEntry">Output representing the entry name that was found</param> /// <returns>MemoryStream representing the entry, null on error</returns> public virtual (MemoryStream, string) CopyToStream(string entryName) { MemoryStream ms = new MemoryStream(); string realentry = null; // Copy single file from the current folder to the output directory, if exists try { // Make sure the folders exist Directory.CreateDirectory(_filename); // Get all files from the input directory List <string> files = Utilities.RetrieveFiles(_filename, new List <string>()); // Now sort through to find the first file that matches string match = files.Where(s => s.EndsWith(entryName)).FirstOrDefault(); // If we had a file, copy that over to the new name if (!String.IsNullOrWhiteSpace(match)) { Utilities.TryOpenRead(match).CopyTo(ms); realentry = match; } } catch (Exception ex) { Globals.Logger.Error(ex.ToString()); return(ms, realentry); } return(ms, realentry); }
/// <summary> /// Attempt to extract a file from an archive /// </summary> /// <param name="entryName">Name of the entry to be extracted</param> /// <param name="outDir">Output directory for archive extraction</param> /// <returns>Name of the extracted file, null on error</returns> public virtual string CopyToFile(string entryName, string outDir) { string realentry = null; // Copy single file from the current folder to the output directory, if exists try { // Make sure the folders exist Directory.CreateDirectory(_filename); Directory.CreateDirectory(outDir); // Get all files from the input directory List <string> files = Utilities.RetrieveFiles(_filename, new List <string>()); // Now sort through to find the first file that matches string match = files.Where(s => s.EndsWith(entryName)).FirstOrDefault(); // If we had a file, copy that over to the new name if (!String.IsNullOrWhiteSpace(match)) { realentry = match; File.Copy(match, Path.Combine(outDir, entryName)); } } catch (Exception ex) { Globals.Logger.Error(ex.ToString()); return(realentry); } return(realentry); }
// 解析测试视频 private List <TestVideo> ParseTestVideo(string videoPath) { if (Directory.Exists(videoPath)) { List <TestVideo> testVideos = new List <TestVideo>(); var videos = Utility.Director(videoPath).Where(f => { string ex = Path.GetExtension(f); return(ex == ".ts" || ex == ".mp4" || ex == ".flv" || ex == ".avi"); }).ToList(); foreach (var item in videos) { var _testVideoItem = new TestVideo { VideoName = Path.GetFileName(item), VideoPath = Path.GetDirectoryName(item) }; testVideos.Add(_testVideoItem); } return(testVideos); } else { MessageWindow.ShowDialog($"无法访问文件夹 [{videoPath}]", this); } return(null); }
private void DumpGetDriveNameForNtDeviceName(bool isLocal) { Console.WriteLine("\n=== TEST {0} ===\n", isLocal ? "LOCAL" : "NETWORK"); int cnt = 0; // Get Logical Drives from Local Host. foreach (string drive in Directory.GetLogicalDrives()) { string tempPath = isLocal ? drive : Path.LocalToUnc(drive); foreach (string dosDev in Volume.QueryDosDevice(tempPath)) { Console.WriteLine("#{0:000}\tInput Path : [{1}]", ++cnt, dosDev); string result = Volume.GetDriveNameForNtDeviceName(dosDev); Console.WriteLine("\tGetDriveNameForNtDeviceName() : [{0}]", result ?? "null"); Assert.AreEqual(drive, result); result = Volume.GetVolumeGuidForNtDeviceName(dosDev); Console.WriteLine("\tGetVolumeGuidForNtDeviceName(): [{0}]\n", result ?? "null"); } } Console.WriteLine("\t{0}\n", Reporter(true)); if (isLocal) { Assert.IsTrue(cnt > 0, "Nothing was enumerated."); } }
private void SetScreenSizeInPrefs() { var config = new IniParserConfiguration { AllowDuplicateKeys = true, AllowDuplicateSections = true }; foreach (var file in Directory.EnumerateFiles(Path.Combine(OutputFolder, "profiles"), "*refs.ini", DirectoryEnumerationOptions.Recursive)) { try { var parser = new FileIniDataParser(new IniDataParser(config)); var data = parser.ReadFile(file); if (data.Sections["Display"] == null) { return; } if (data.Sections["Display"]["iSize W"] != null && data.Sections["Display"]["iSize H"] != null) { data.Sections["Display"]["iSize W"] = SystemParameters.ScreenWidth.ToString(CultureInfo.CurrentCulture); data.Sections["Display"]["iSize H"] = SystemParameters.ScreenHeight.ToString(CultureInfo.CurrentCulture); } parser.WriteFile(file, data); } catch (Exception ex) { Utils.Log($"Skipping screen size remap for {file} due to parse error."); continue; } } }
private void DumpGetProperties(bool isLocal) { Console.WriteLine("\n=== TEST {0} ===", isLocal ? UnitTestConstants.Local : UnitTestConstants.Network); var path = isLocal ? UnitTestConstants.SysRoot32 : Path.LocalToUnc(UnitTestConstants.SysRoot32); Console.WriteLine("\n\tAggregated properties of file system objects from Directory: [{0}]\n", path); UnitTestConstants.StopWatcher(true); var props = Directory.GetProperties(path, DirectoryEnumerationOptions.FilesAndFolders | DirectoryEnumerationOptions.Recursive | DirectoryEnumerationOptions.ContinueOnException); var report = UnitTestConstants.Reporter(); var total = props["Total"]; var file = props["File"]; var size = props["Size"]; var cnt = 0; foreach (var key in props.Keys) { Console.WriteLine("\t\t#{0:000}\t{1, -17} = [{2}]", ++cnt, key, props[key]); } Console.WriteLine("\n\t{0}", report); if (cnt == 0) { Assert.Inconclusive("Nothing is enumerated, but it is expected."); } Assert.IsTrue(total > 0, "0 Objects."); Assert.IsTrue(file > 0, "0 Files."); Assert.IsTrue(size > 0, "0 Size."); Console.WriteLine(); }
public void Dispose() { if (Directory.Exists(FullName)) { Utils.DeleteDirectory(FullName); } }
public Action Stage(IEnumerable <VirtualFile> files) { var grouped = files.SelectMany(f => f.FilesInPath) .Distinct() .Where(f => f.ParentArchive != null) .GroupBy(f => f.ParentArchive) .OrderBy(f => f.Key == null ? 0 : f.Key.Paths.Length) .ToList(); List <string> Paths = new List <string>(); foreach (var group in grouped) { var tmp_path = Path.Combine(_stagedRoot, Guid.NewGuid().ToString()); FileExtractor.ExtractAll(group.Key.StagedPath, tmp_path); Paths.Add(tmp_path); foreach (var file in group) { file._stagedPath = Path.Combine(tmp_path, file.Paths[group.Key.Paths.Length]); } } return(() => { Paths.Do(p => { if (Directory.Exists(p)) { DeleteDirectory(p); } }); }); }
private async Task BuildBSAs() { var bsas = ModList.Directives.OfType <CreateBSA>().ToList(); Info($"Building {bsas.Count} bsa files"); foreach (var bsa in bsas) { Status($"Building {bsa.To}"); var sourceDir = Path.Combine(OutputFolder, Consts.BSACreationDir, bsa.TempID); using (var a = bsa.State.MakeBuilder()) { await bsa.FileStates.PMap(Queue, state => { Status($"Adding {state.Path} to BSA"); using (var fs = File.OpenRead(Path.Combine(sourceDir, state.Path))) { a.AddFile(state, fs); } }); Info($"Writing {bsa.To}"); a.Build(Path.Combine(OutputFolder, bsa.To)); } } var bsaDir = Path.Combine(OutputFolder, Consts.BSACreationDir); if (Directory.Exists(bsaDir)) { Info($"Removing temp folder {Consts.BSACreationDir}"); Utils.DeleteDirectory(bsaDir); } }
private static void SaveJson(IPrefetch pf, bool pretty, string outDir) { try { if (Directory.Exists(outDir) == false) { Directory.CreateDirectory(outDir); } var outName = $"{DateTimeOffset.UtcNow:yyyyMMddHHmmss}_{Path.GetFileName(pf.SourceFilename)}.json"; var outFile = Path.Combine(outDir, outName); if (pretty) { File.WriteAllText(outFile, pf.Dump()); } else { File.WriteAllText(outFile, pf.ToJson()); } } catch (Exception ex) { _logger.Error($"Error exporting json. Error: {ex.Message}"); } }
public void AlphaFS_Path_LocalToUnc() { Console.WriteLine("Path.LocalToUnc()"); Console.WriteLine("\nInput Path: [{0}]\n", UnitTestConstants.SysRoot); var cnt = 0; UnitTestConstants.StopWatcher(true); foreach (var path2 in Directory.EnumerateFileSystemEntries(UnitTestConstants.SysRoot)) { var uncPath = Path.LocalToUnc(path2); Console.WriteLine("\t#{0:000}\tLocal: [{1}]\t\t\tUNC: [{2}]", ++cnt, path2, uncPath); Assert.IsTrue(Path.IsUncPath(uncPath)); } Console.WriteLine("\n{0}", UnitTestConstants.Reporter(true)); if (cnt == 0) { Assert.Inconclusive("Nothing was enumerated, but it was expected."); } Console.WriteLine(); }
public void AlphaFS_Path_GetMappedConnectionName() { Console.WriteLine("Path.GetMappedConnectionName()"); var cnt = 0; UnitTestConstants.StopWatcher(true); foreach (var drive in Directory.GetLogicalDrives().Where(drive => new DriveInfo(drive).IsUnc)) { ++cnt; UnitTestConstants.StopWatcher(true); var gmCn = Path.GetMappedConnectionName(drive); var gmUn = Path.GetMappedUncName(drive); Console.WriteLine("\n\tMapped drive: [{0}]\tGetMappedConnectionName(): [{1}]", drive, gmCn); Console.WriteLine("\tMapped drive: [{0}]\tGetMappedUncName() : [{1}]", drive, gmUn); Assert.IsTrue(!Utils.IsNullOrWhiteSpace(gmCn)); Assert.IsTrue(!Utils.IsNullOrWhiteSpace(gmUn)); } Console.WriteLine("\n{0}", UnitTestConstants.Reporter(true)); if (cnt == 0) { Assert.Inconclusive("Nothing was enumerated because no mapped drives were found."); } }
private void DumpGetDriveNameForNtDeviceName(bool isLocal) { Console.WriteLine("\n=== TEST {0} ===\n", isLocal ? "LOCAL" : "NETWORK"); var cnt = 0; // Get Logical Drives from UnitTestConstants.Local Host. foreach (var drive in Directory.GetLogicalDrives()) { var tempPath = isLocal ? drive : Path.LocalToUnc(drive); foreach (var dosDev in Volume.QueryDosDevice(tempPath)) { Console.WriteLine("#{0:000}\tInput Path : [{1}]", ++cnt, dosDev); var result = Volume.GetDriveNameForNtDeviceName(dosDev); Console.WriteLine("\tGetDriveNameForNtDeviceName() : [{0}]", result ?? "null"); Assert.AreEqual(drive, result); result = Volume.GetVolumeGuidForNtDeviceName(dosDev); Console.WriteLine("\tGetVolumeGuidForNtDeviceName(): [{0}]\n", result ?? "null"); } } Console.WriteLine("\t{0}\n", UnitTestConstants.Reporter(true)); if (isLocal && cnt == 0) { Assert.Inconclusive("Nothing was enumerated, but it was expected."); } }
public void StartMonitor() { foreach (string efi in this.mDoc.SearchFolders) { if (!Directory.Exists(efi)) //Does not exist { continue; } if ((File.GetAttributes(efi) & FileAttributes.Directory) != (FileAttributes.Directory)) // not a folder { continue; } FileSystemWatcher watcher = new FileSystemWatcher(efi); watcher.Changed += new FileSystemEventHandler(watcher_Changed); watcher.Created += new FileSystemEventHandler(watcher_Changed); watcher.Renamed += new RenamedEventHandler(watcher_Changed); //watcher.Deleted += new FileSystemEventHandler(watcher_Changed); //watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.CreationTime; watcher.IncludeSubdirectories = true; watcher.EnableRaisingEvents = true; Watchers.Add(watcher); logger.Trace("Starting logger for {0}", efi); } }
public void AlphaFS_Directory_HasInheritedPermissions() { Console.WriteLine("Directory.HasInheritedPermissions()\n"); var searchPattern = Path.WildcardStarMatchAll; var searchOption = SearchOption.TopDirectoryOnly; var cnt = 0; UnitTestConstants.StopWatcher(true); foreach (var dir in Directory.EnumerateDirectories(UnitTestConstants.SysRoot, searchPattern, searchOption)) { try { var hasIp = Directory.HasInheritedPermissions(dir); if (hasIp) { Console.WriteLine("\t#{0:000}\t[{1}]\t\tDirectory has inherited permissions: [{2}]", ++cnt, hasIp, dir); } Assert.AreEqual(hasIp, HasInheritedPermissions(dir)); } catch (Exception ex) { Console.Write("\t#{0:000}\tCaught {1} for directory: [{2}]\t[{3}]\n", cnt, ex.GetType().FullName, dir, ex.Message.Replace(Environment.NewLine, " ")); } } Console.Write("\n{0}", UnitTestConstants.Reporter()); }
public IncludeZEditPatches(ACompiler compiler) : base(compiler) { var zEditPath = FindzEditPath(compiler); var havezEdit = zEditPath != null; Utils.Log(havezEdit ? $"Found zEdit at {zEditPath}" : $"zEdit not detected, disabling zEdit routines"); if (!havezEdit) { _mergesIndexed = new Dictionary <string, zEditMerge>(); return; } var merges = Directory.EnumerateFiles(Path.Combine(zEditPath, "profiles"), DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive) .Where(f => f.EndsWith("\\merges.json")) .SelectMany(f => f.FromJSON <List <zEditMerge> >()) .GroupBy(f => (f.name, f.filename)); merges.Where(m => m.Count() > 1) .Do(m => { Utils.Log( $"WARNING, you have two patches named {m.Key.name}\\{m.Key.filename} in your zEdit profiles. We'll pick one at random, this probably isn't what you want."); }); _mergesIndexed = merges.ToDictionary( m => Path.Combine(_mo2Compiler.MO2Folder, "mods", m.Key.name, m.Key.filename), m => m.First()); }
public static IEnumerable <string> EnumerateFiles(string path, IList <string> patterns, Gitignore gitignore, FileFilter filter) { if (string.IsNullOrWhiteSpace(path) || !Directory.Exists(path)) { return(Enumerable.Empty <string>()); } if (patterns == null) { throw new ArgumentNullException(nameof(patterns)); } if (filter == null) { throw new ArgumentNullException(nameof(filter)); } bool simpleSearch = filter.IncludeHidden && filter.MaxSubfolderDepth == -1 && (gitignore == null || gitignore.IsEmpty) && string.IsNullOrWhiteSpace(filter.NamePatternToExclude); if (simpleSearch) { return(EnumerateAllFiles(path, patterns, filter.IncludeArchive, filter.IncludeSubfolders, filter.FollowSymlinks)); } else { return(EnumerateFilesWithFilters(path, patterns, gitignore, filter)); } }
private void CreateOutputMods() { Directory.EnumerateFiles(Path.Combine(OutputFolder, "profiles"), "settings.ini", DirectoryEnumerationOptions.Recursive).Do(f => { var ini = f.LoadIniFile(); if (ini == null) { Utils.Log($"settings.ini is null for {f}, skipping"); return; } var overwrites = ini.custom_overwrites; if (overwrites == null) { Utils.Log("No custom overwrites found, skipping"); return; } if (overwrites is SectionData data) { data.Coll.Do(keyData => { var v = keyData.Value; var mod = Path.Combine(OutputFolder, Consts.MO2ModFolderName, v); if (!Directory.Exists(mod)) { Directory.CreateDirectory(mod); } }); } }); }
private void IndexPath(string path) { var file_list = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories).ToList(); Utils.Log($"Updating the cache for {file_list.Count} files"); file_list.PMap(f => UpdateFile(f)); SyncToDisk(); }
public string AddProfile(string name = null) { string profile_name = name ?? RandomName(); Directory.CreateDirectory(Path.Combine(MO2Folder, "profiles", profile_name)); Profiles.Add(profile_name); return(profile_name); }
public TemporaryDirectory(string name) { FullName = name; if (!Directory.Exists(FullName)) { Directory.CreateDirectory(FullName); } }
/// <summary> /// Adds a file to the given mod with a given path in the mod. Fills it with random data unless /// random_fill == 0; /// </summary> /// <param name="mod_name"></param> /// <param name="path"></param> /// <param name="random_fill"></param> /// <returns></returns> public string AddModFile(string mod_name, string path, int random_fill = 128) { var full_path = Path.Combine(ModsFolder, mod_name, path); Directory.CreateDirectory(Path.GetDirectoryName(full_path)); GenerateRandomFileData(full_path, random_fill); return(full_path); }
private static IEnumerable <string> EnumerateAllFiles(string path, IList <string> patterns, bool includeArchive, bool recursive, bool followSymlinks) { // without filters, just enumerate files, which is faster var fileOptions = baseFileOptions; if (recursive) { fileOptions |= DirectoryEnumerationOptions.Recursive; } if (followSymlinks) { fileOptions &= ~DirectoryEnumerationOptions.SkipReparsePoints; } DirectoryEnumerationFilters fileFilters = new DirectoryEnumerationFilters { ErrorFilter = (errorCode, errorMessage, pathProcessed) => { logger.Error($"Find file error {errorCode}: {errorMessage} on {pathProcessed}"); return(true); } }; bool includeAllFiles = patterns.Count == 0 || (patterns.Count == 1 && (patterns[0] == "*.*" || patterns[0] == "*")); if (!includeAllFiles) { fileFilters.InclusionFilter = fsei => { foreach (string pattern in patterns) { if (WildcardMatch(fsei.FileName, pattern, true)) { return(true); } } if (includeArchive) { foreach (string pattern in ArchiveDirectory.Patterns) { if (WildcardMatch(fsei.FileName, pattern, true)) { return(true); } } } return(false); }; } return(Directory.EnumerateFiles(path, fileOptions, fileFilters, PathFormat.FullPath)); }
private static List <string> EnumerateFiles(string path, ExportFormat format) { if (!path.EndsWith(Path.DirectorySeparatorChar.ToString())) { path += Path.DirectorySeparatorChar; } return(Directory.EnumerateFiles(path, $"*.{format.ToString().ToLower()}", SearchOption.AllDirectories).ToList()); }
public string AddMod(string name = null) { string mod_name = name ?? RandomName(); var mod_folder = Path.Combine(MO2Folder, "mods", mod_name); Directory.CreateDirectory(mod_folder); File.WriteAllText(Path.Combine(mod_folder, "meta.ini"), "[General]"); Mods.Add(mod_name); return(mod_name); }
public void GetDirectoryRoot_WithRelativePath_ReturnsCurrentDirRoot() { var originalDir = Directory.GetCurrentDirectory(); Directory.SetCurrentDirectory(@"C:\Windows\"); var root = Directory.GetDirectoryRoot(@"\Windows"); Assert.That(root, Is.EqualTo(@"C:\")); Directory.SetCurrentDirectory(originalDir); }
private static List <string> GetRecycleBinFiles(string dir) { var files = new List <string>(); Privilege[] privs = { Privilege.EnableDelegation, Privilege.Impersonate, Privilege.Tcb }; using (new PrivilegeEnabler(Privilege.Backup, privs)) { var filters = new DirectoryEnumerationFilters { // Used to abort the enumeration. // CancellationToken = cancelSource.Token, // Filter to decide whether to recurse into subdirectories. RecursionFilter = entryInfo => { if (!entryInfo.IsMountPoint && !entryInfo.IsSymbolicLink) { return(true); } return(false); }, // Filter to process Exception handling. ErrorFilter = delegate(int errorCode, string errorMessage, string pathProcessed) { _logger.Error($"Error accessing '{pathProcessed}'. Error: {errorMessage}"); // Return true to continue, false to throw the Exception. return(true); }, // Filter to in-/exclude file system entries during the enumeration. InclusionFilter = entryInfo => { if (entryInfo.FileName == "INFO2" || entryInfo.FileName.StartsWith("$I")) { _logger.Debug($"Found match: '{entryInfo.FullPath}'"); return(true); } return(false); } }; var dirEnumOptions = DirectoryEnumerationOptions.Files | DirectoryEnumerationOptions.Recursive | DirectoryEnumerationOptions.ContinueOnException | DirectoryEnumerationOptions.SkipReparsePoints; files.AddRange(Directory.EnumerateFileSystemEntryInfos <string>(dir, dirEnumOptions, filters).Where(File.Exists)); } return(files); }
/// <summary> /// The user may already have some files in the OutputFolder. If so we can go through these and /// figure out which need to be updated, deleted, or left alone /// </summary> public async Task OptimizeModlist() { Utils.Log("Optimizing Modlist directives"); var indexed = ModList.Directives.ToDictionary(d => d.To); UpdateTracker.NextStep("Looking for files to delete"); await Directory.EnumerateFiles(OutputFolder, "*", DirectoryEnumerationOptions.Recursive) .PMap(Queue, UpdateTracker, f => { var relative_to = f.RelativeTo(OutputFolder); Utils.Status($"Checking if modlist file {relative_to}"); if (indexed.ContainsKey(relative_to) || f.IsInPath(DownloadFolder)) { return; } Utils.Log($"Deleting {relative_to} it's not part of this modlist"); File.Delete(f); }); UpdateTracker.NextStep("Looking for unmodified files"); (await indexed.Values.PMap(Queue, UpdateTracker, d => { // Bit backwards, but we want to return null for // all files we *want* installed. We return the files // to remove from the install list. Status($"Optimizing {d.To}"); var path = Path.Combine(OutputFolder, d.To); if (!File.Exists(path)) { return(null); } var fi = new FileInfo(path); if (fi.Length != d.Size) { return(null); } return(path.FileHash() == d.Hash ? d : null); })) .Where(d => d != null) .Do(d => indexed.Remove(d.To)); UpdateTracker.NextStep("Updating Modlist"); Utils.Log($"Optimized {ModList.Directives.Count} directives to {indexed.Count} required"); var requiredArchives = indexed.Values.OfType <FromArchive>() .GroupBy(d => d.ArchiveHashPath[0]) .Select(d => d.Key) .ToHashSet(); ModList.Archives = ModList.Archives.Where(a => requiredArchives.Contains(a.Hash)).ToList(); ModList.Directives = indexed.Values.ToList(); }
public void Directory_GetParent() { Console.WriteLine("Directory.GetParent()"); var pathCnt = 0; var errorCnt = 0; UnitTestConstants.StopWatcher(true); foreach (var path in UnitTestConstants.InputPaths) { string expected = null; string actual = null; var skipAssert = false; Console.WriteLine("\n#{0:000}\tInput Path: [{1}]", ++pathCnt, path); // System.IO try { var result = System.IO.Directory.GetParent(path); expected = result == null ? null : result.FullName; } catch (Exception ex) { skipAssert = ex is ArgumentException; Console.WriteLine("\tCaught [System.IO] {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine("\t System.IO : [{0}]", expected ?? "null"); // AlphaFS try { var result = Directory.GetParent(path); actual = result == null ? null : result.FullName; if (!skipAssert) { Assert.AreEqual(expected, actual); } } catch (Exception ex) { errorCnt++; Console.WriteLine("\tCaught [AlphaFS] {0}: [{1}]", ex.GetType().FullName, ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine("\t AlphaFS : [{0}]", actual ?? "null"); } Console.WriteLine("\n{0}", UnitTestConstants.Reporter(true)); Assert.AreEqual(0, errorCnt, "Encountered paths where AlphaFS != System.IO"); }
public void EnumerateVolumeMountPoints() { Console.WriteLine("Volume.EnumerateVolumeMountPoints()"); if (!IsAdmin()) { Assert.Fail(); } #region Logical Drives int cnt = 0; Console.WriteLine("\nLogical Drives\n"); // Get Logical Drives from Local Host, .IsReady Drives only. foreach (string drive in Directory.GetLogicalDrives(false, true)) { try { // Logical Drives --> Volumes --> Volume Mount Points. string uniqueVolName = Volume.GetUniqueVolumeNameForPath(drive); if (!string.IsNullOrWhiteSpace(uniqueVolName) && !uniqueVolName.Equals(drive, StringComparison.OrdinalIgnoreCase)) { foreach (string mountPoint in Volume.EnumerateVolumeMountPoints(uniqueVolName).Where(mp => !string.IsNullOrWhiteSpace(mp))) { StopWatcher(true); string guid = null; try { guid = Volume.GetVolumeGuid(Path.Combine(drive, mountPoint)); } catch (Exception ex) { Console.Write("\n\tCaught Exception (0): [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } Console.WriteLine("\t#{0:000}\tLogical Drive: [{1}]\tGUID: [{2}]\n\t\tDestination : [{3}]\n\t{4}", ++cnt, drive, guid ?? "null", mountPoint, Reporter(true)); } } } catch (Exception ex) { Console.Write("\n\tCaught Exception (1): [{0}]", ex.Message.Replace(Environment.NewLine, " ")); } } // No Assert(); there might be no Mount Points. if (cnt == 0) { Console.WriteLine("\tNo Volume Mount Points found."); } #endregion // Logical Drives }