FileSystem.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
 
namespace Waher.Content.SystemFiles
{
    public static class FileSystem
    {
        public static string[] FindFiles(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)
        {
            return FindFiles(GetFolders(Folders), Pattern, IncludeSubfolders, BreakOnFirst ? 1 : int.MaxValue);
        }
 
        public static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, bool BreakOnFirst)
        {
            return FindFiles(Folders, Pattern, IncludeSubfolders, BreakOnFirst ? 1 : int.MaxValue);
        }
 
        public static string[] FindFiles(string[] Folders, string Pattern, bool IncludeSubfolders, int MaxCount)
        {
            return FindFiles(Folders, Pattern, IncludeSubfolders ? int.MaxValue : 0, MaxCount);
        }
 
        public static string[] FindFiles(string[] Folders, string Pattern, int SubfolderDepth, int MaxCount)
        {
            if (MaxCount <= 0)
                throw new ArgumentException("Must be positive.", nameof(MaxCount));
 
            LinkedList<KeyValuePair<string, int>> ToProcess = new LinkedList<KeyValuePair<string, int>>();
            Dictionary<string, bool> Processed = new Dictionary<string, bool>(StringComparer.CurrentCultureIgnoreCase);
            List<string> Result = new List<string>();
            int Count = 0;
 
            foreach (string Folder in Folders)
                ToProcess.AddLast(new KeyValuePair<string, int>(Folder, SubfolderDepth));
 
            while (!(ToProcess.First is null))
            {
                KeyValuePair<string, int> Processing = ToProcess.First.Value;
                string Folder = Processing.Key;
                int Depth = Processing.Value;
 
                ToProcess.RemoveFirst();
                if (Processed.ContainsKey(Folder))
                    continue;
 
                if (!Directory.Exists(Folder))
                    continue;
                    
                Processed[Folder] = true;
 
                try
                {
                    string[] Names = Directory.GetFiles(Folder, Pattern, SearchOption.TopDirectoryOnly);
 
                    foreach (string FileName in Names)
                    {
                        Result.Add(FileName);
                        if (++Count >= MaxCount)
                            return Result.ToArray();
                    }
 
                    if (Depth-- > 0)
                    {
                        Names = Directory.GetDirectories(Folder);
 
                        foreach (string SubFolder in Names)
                            ToProcess.AddLast(new KeyValuePair<string, int>(SubFolder, Depth));
                    }
                }
                catch (Exception)
                {
                    // Ignore
                }
            }
 
            return Result.ToArray();
        }
 
        public static string[] GetFolders(Environment.SpecialFolder[] Folders, params string[] AppendWith)
        {
            List<string> Result = new List<string>();
 
            foreach (Environment.SpecialFolder Folder in Folders)
            {
                string Path = Environment.GetFolderPath(Folder, Environment.SpecialFolderOption.None);
 
                if (!string.IsNullOrEmpty(Path))
                {
                    // In 64-bit operating systems, the 32-bit folder can be returned anyway, if the process is running in 32 bit.
 
                    if (Environment.Is64BitOperatingSystem && !Environment.Is64BitProcess)
                    {
                        switch (Folder)
                        {
                            case Environment.SpecialFolder.CommonProgramFiles:
                            case Environment.SpecialFolder.ProgramFiles:
                            case Environment.SpecialFolder.System:
                                if (Path.EndsWith(" (x86)"))
                                {
                                    Path = Path.Substring(0, Path.Length - 6);
                                    if (!Directory.Exists(Path))
                                        continue;
                                }
                                break;
                        }
                    }
 
                    Result.Add(Path);
 
                    if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && Path.StartsWith("/usr/share"))
                        Result.Add(Path.Replace("/usr/share", "/usr/local/share"));
                    else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && Path.StartsWith("/usr/share"))
                        Result.Add(Path.Replace("/usr/share", "/var/lib"));
                }
            }
 
            foreach (string Path in AppendWith)
                Result.Add(Path);
 
            return Result.ToArray();
        }
 
        public static string FindLatestFile(Environment.SpecialFolder[] Folders, string Pattern, bool IncludeSubfolders)
        {
            return FindLatestFile(GetFolders(Folders), Pattern, IncludeSubfolders);
        }
 
        public static string FindLatestFile(string[] Folders, string Pattern, bool IncludeSubfolders)
        {
            return FindLatestFile(Folders, Pattern, IncludeSubfolders ? int.MaxValue : 0);
        }
 
        public static string FindLatestFile(string[] Folders, string Pattern, int SubfolderDepth)
        {
            string[] Files = FindFiles(Folders, Pattern, SubfolderDepth, int.MaxValue);
            string Result = string.Empty;
            DateTime BestTP = DateTime.MinValue;
            DateTime TP;
 
            foreach (string FilePath in Files)
            {
                TP = File.GetCreationTimeUtc(FilePath);
                if (TP > BestTP)
                {
                    BestTP = TP;
                    Result = FilePath;
                }
            }
 
            return Result;
        }
 
        public static string ExecutableExtension
        {
            get
            {
                switch (Environment.OSVersion.Platform)
                {
                    case PlatformID.Win32S:
                    case PlatformID.Win32Windows:
                    case PlatformID.Win32NT:
                    case PlatformID.WinCE:
                        return ".exe";
 
                    default:
                        return string.Empty;
                }
            }
        }
    }
}