public void ArgumentExistsDirectoryInfoTest()
{
var directoryInfo = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData));
try
{
var result = directoryInfo.ArgumentExists();
Assert.IsNotNull(result);
}
catch
{
Assert.Fail();
}
//Test Exceptions
DirectoryInfo nullDirectoryInfo = null;
_ = Assert.ThrowsException <ArgumentNullException>(() => nullDirectoryInfo.ArgumentExists());
var fakeDirectory = new DirectoryInfo("fakefile");
DirectoryHelper.DeleteDirectory(fakeDirectory);
_ = Assert.ThrowsException <DirectoryNotFoundException>(() => new DirectoryInfo("fakefile").ArgumentExists());
}
public static IEnumerable <DirectoryInfo> SafeDirectorySearch([NotNull] DirectoryInfo path, [NotNull] string searchPattern = "*.*", SearchOption searchOption = SearchOption.TopDirectoryOnly)
{
path = path.ArgumentExists();
searchPattern = searchPattern.ArgumentNotNullOrEmpty();
searchOption = searchOption.ArgumentDefined();
var folders = new List <DirectoryInfo>
{
path,
};
for (var directoryCount = 0; directoryCount < path.GetDirectories(searchPattern, searchOption).Length; directoryCount++)
{
try
{
IEnumerable <DirectoryInfo> searchResult = SafeDirectorySearch(path.GetDirectories(searchPattern, searchOption)[directoryCount], searchPattern);
if (searchResult.HasItems())
{
_ = folders.AddRange(searchResult, Tristate.True);
}
}
catch (Exception ex) when(ex is ArgumentException or ArgumentNullException or ArgumentOutOfRangeException or System.IO.DirectoryNotFoundException or UnauthorizedAccessException)
{
Trace.WriteLine(ex.Message);
}
}
return(folders);
}
public static bool SafeDirectoryContainsAny([NotNull] DirectoryInfo path, SearchOption searchOption = SearchOption.TopDirectoryOnly, [NotNull] params string[] searchPatterns)
{
path = path.ArgumentExists();
searchOption = searchOption.ArgumentDefined();
searchPatterns = searchPatterns.ArgumentNotNull();
for (var patternCount = 0; patternCount < searchPatterns.Length; patternCount++)
{
try
{
IEnumerable <DirectoryInfo> searchResult = SafeDirectorySearch(path, searchPatterns[patternCount], searchOption);
if (searchResult.HasItems())
{
return(true);
}
}
catch (Exception ex) when(ex is ArgumentException or ArgumentNullException or ArgumentOutOfRangeException or UnauthorizedAccessException)
{
Trace.WriteLine(ex.Message);
}
}
return(false);
}
public static void MoveDirectory([NotNull] DirectoryInfo source, [NotNull] DirectoryInfo destination, int retries = 10)
{
source = source.ArgumentExists();
retries = retries.ArgumentInRange(1, upper: 100, defaultValue: 10, errorMessage: Resources.RetriesAreLimitedTo0100);
if (destination.ArgumentNotNull().CheckExists(throwException: true))
{
var tries = 0;
do
{
tries++;
if (tries > 1)
{
// If something has a transient lock on the file waiting may resolve the issue
Thread.Sleep((retries + 1) * 10);
}
try
{
Directory.Move(source.FullName, destination.FullName);
return;
}
catch (IOException) when(tries >= retries)
{
throw;
}
catch (UnauthorizedAccessException) when(tries >= retries)
{
throw;
}
}while (tries < retries);
}
}
public static void SetFileAttributesToNormal([NotNull] DirectoryInfo path)
{
path = path.ArgumentExists();
DirectoryInfo[] directories = path.GetDirectories();
for (var directoryCount = 0; directoryCount < path.GetDirectories().Length; directoryCount++)
{
SetFileAttributesToNormal(directories[directoryCount]);
}
for (var fileCount = 0; fileCount < path.GetDirectories().Length; fileCount++)
{
File.SetAttributes(directories[fileCount].FullName, FileAttributes.Normal);
}
}
public void ArgumentExistsDirectoryInfoWithDefaultTest()
{
var directoryInfo = new DirectoryInfo("c:\temp\bogus");
var defaultDirectoryInfo = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData));
try
{
var result = directoryInfo.ArgumentExists(defaultDirectoryInfo);
Assert.AreEqual(result, defaultDirectoryInfo);
}
catch
{
Assert.Fail();
}
}
public static IEnumerable <Type> FindDerivedTypes(DirectoryInfo path, SearchOption fileSearchType, [NotNull] Type baseType, Tristate classOnly)
{
fileSearchType = fileSearchType.ArgumentDefined();
var files = path.ArgumentExists().EnumerateFiles("*.dll", fileSearchType).ToList();
baseType = baseType.ArgumentNotNull();
var list = files.ToList();
var foundTypes = new List <Type>();
for (var fileIndex = 0; fileIndex < list.FastCount(); fileIndex++)
{
try
{
var assembly = Assembly.LoadFrom(list[fileIndex].FullName);
var exportedTypes = assembly.ExportedTypes.Where(p => p.BaseType is not null).ToList();
if (exportedTypes?.FastCount() > 0)
{
var containsBaseType = exportedTypes.Any(p => string.Equals(p.BaseType.FullName, baseType.FullName, StringComparison.Ordinal));
if (containsBaseType)
{
foundTypes.AddRange(LoadDerivedTypes(assembly.DefinedTypes, baseType, classOnly));
}
}
}
catch (BadImageFormatException ex)
{
Trace.WriteLine(ex.GetAllMessages());
}
catch (FileLoadException fileLoadEx)
{
Trace.WriteLine(fileLoadEx.GetAllMessages());
}
}
return(foundTypes);
}
public static void CopyDirectory([NotNull] DirectoryInfo source, [NotNull] DirectoryInfo destination, bool overwrite = true)
{
DirectoryInfo[] directories = source.ArgumentExists().GetDirectories();
destination.ArgumentNotNull().CheckExists();
var destinationPath = destination.FullName;
FileInfo[] files = source.GetFiles();
for (var fileIndex = 0; fileIndex < files.Length; fileIndex++)
{
FileInfo file = files[fileIndex];
_ = file.CopyTo(Path.Combine(destinationPath, file.Name), overwrite);
}
for (var directoryIndex = 0; directoryIndex < directories.Length; directoryIndex++)
{
DirectoryInfo subDirectory = directories[directoryIndex];
CopyDirectory(subDirectory, new DirectoryInfo(Path.Combine(destinationPath, subDirectory.Name)), overwrite);
}
}
