ProcessFiles.cs 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. namespace ProcessFiles
  6. {
  7. public enum Result
  8. {
  9. File,
  10. Directory,
  11. Failure
  12. }
  13. public class ProcessFiles
  14. {
  15. private readonly List<string> errors = [];
  16. private static readonly char[] invalidCharactersForExtension =
  17. [.. ExtraChars(), .. Enumerable.Range(0x00, 0x20).Select(i => (char)i)];
  18. private static IEnumerable<char> ExtraChars() => ['"', '<', '>', ':', '|', '?', '*',
  19. '\\', '/'];
  20. public static char[] InvalidCharactersForExtension => [.. invalidCharactersForExtension];
  21. private Result WhatIsIt(string path)
  22. {
  23. if (!File.Exists(path) && !Directory.Exists(path))
  24. {
  25. errors.Add($"{path} doesn't exist!");
  26. return Result.Failure;
  27. }
  28. try
  29. {
  30. var attr = File.GetAttributes(path);
  31. return (attr & FileAttributes.Directory) == FileAttributes.Directory ? Result.Directory : Result.File;
  32. }
  33. catch (Exception e)
  34. {
  35. errors.Add($"Problem getting attributes of {path}: {e.Message} ({e.Source})");
  36. return Result.Failure;
  37. }
  38. }
  39. private string? GetExtension(string path)
  40. {
  41. var extension = Path.GetExtension(path).TrimStart('.');
  42. if (!string.IsNullOrWhiteSpace(extension)) return extension;
  43. errors.Add($"Can't establish extension of {path}!");
  44. return null;
  45. }
  46. private static bool CheckExtension(string extension, string[] validExtensions)
  47. {
  48. return validExtensions.Any(validExtension => extension.Equals(validExtension, StringComparison.OrdinalIgnoreCase));
  49. }
  50. private bool IsValid(string path, string[] fileExtensions)
  51. {
  52. var extension = GetExtension(path);
  53. if (extension == null)
  54. return false;
  55. if (CheckExtension(extension, fileExtensions)) return true;
  56. errors.Add($"Extension of {path} doesn't match any extension ({string.Join(", ", fileExtensions)})!");
  57. return false;
  58. }
  59. private void PerformAction(string path, Action<string> action)
  60. {
  61. try
  62. {
  63. action(path);
  64. }
  65. catch (Exception e)
  66. {
  67. errors.Add($"Problem performing action on {path}: {e.Message} ({e.Source})");
  68. }
  69. }
  70. private void ProcessFile(string path, string[] fileExtensions, Action<string> action)
  71. {
  72. if (!IsValid(path, fileExtensions))
  73. return;
  74. PerformAction(path, action);
  75. }
  76. private void ProcessDir(string path, string[] fileExtensions, Action<string> action, bool recursive = false)
  77. {
  78. if (!Directory.Exists(path))
  79. {
  80. errors.Add($"{path} doesn't exist!");
  81. return;
  82. }
  83. var searchOption = recursive switch
  84. {
  85. false => SearchOption.TopDirectoryOnly,
  86. true => SearchOption.AllDirectories,
  87. };
  88. string[] allFiles = [];
  89. try
  90. {
  91. allFiles = Directory.GetFiles(path, "*", searchOption);
  92. }
  93. catch (Exception e)
  94. {
  95. errors.Add($"Problem getting files: {e.Message} ({e.Source})");
  96. return;
  97. }
  98. var files = allFiles
  99. .Where(file => CheckExtension(Path.GetExtension(file).TrimStart('.'), fileExtensions))
  100. .Distinct()
  101. .ToList();
  102. if (files.Count == 0)
  103. {
  104. errors.Add($"There are no files in {path} with given extensions ({string.Join(", ", fileExtensions)})!");
  105. return;
  106. }
  107. foreach (var file in files)
  108. ProcessFile(file, fileExtensions, action);
  109. }
  110. private static bool ValidExtension(string fileExtension) => !invalidCharactersForExtension.Any(fileExtension.Contains);
  111. private static List<string> GetInvalidExtensions(string [] fileExtensions) => [.. fileExtensions.Where(x => !ValidExtension(x))];
  112. public List<string> Process(IEnumerable<string> arguments, string fileExtension, Action<string> action, bool recursive = false)
  113. {
  114. return Process(arguments, [fileExtension], action, recursive);
  115. }
  116. public List<string> Process(IEnumerable<string> arguments, string[] fileExtensions, Action<string> action, bool recursive = false)
  117. {
  118. var invalidExtensions = GetInvalidExtensions(fileExtensions);
  119. if (invalidExtensions.Count > 0) throw new ArgumentException($"Following extensions contain invalid characters ({string.Join(", ", invalidCharactersForExtension)}):\n{string.Join(Environment.NewLine, invalidExtensions)}");
  120. foreach (var argument in arguments)
  121. {
  122. switch (WhatIsIt(argument))
  123. {
  124. case Result.File:
  125. ProcessFile(argument, fileExtensions, action);
  126. break;
  127. case Result.Directory:
  128. ProcessDir(argument, fileExtensions, action, recursive);
  129. break;
  130. case Result.Failure:
  131. default:
  132. continue;
  133. }
  134. }
  135. return [.. errors];
  136. }
  137. }
  138. }