Cosmetic changes to BITS code files

pull/303/head
dahall 2022-05-21 13:42:27 -06:00
parent ec712439e4
commit b2bb3ce4ea
2 changed files with 310 additions and 429 deletions

View File

@ -79,7 +79,7 @@ namespace Vanara.IO
/// BackgroundCopyManager.CopyAsync(src, dest, cts.Token, prog); /// BackgroundCopyManager.CopyAsync(src, dest, cts.Token, prog);
/// </code> /// </code>
/// </example> /// </example>
public static async Task CopyAsync(string sourceFileName, string destFileName, CancellationToken cancellationToken, IProgress<Tuple<BackgroundCopyJobState, byte>> progress) public static async Task CopyAsync(string sourceFileName, string destFileName, [Optional] CancellationToken cancellationToken, [Optional] IProgress<Tuple<BackgroundCopyJobState, byte>> progress)
{ {
#if NET40 #if NET40
await TaskEx.Run(() => CopyTemplate(destFileName, cancellationToken, (s, p) => progress?.Report(new Tuple<BackgroundCopyJobState, byte>(s,p)), f => f.Add(sourceFileName, destFileName)), cancellationToken); await TaskEx.Run(() => CopyTemplate(destFileName, cancellationToken, (s, p) => progress?.Report(new Tuple<BackgroundCopyJobState, byte>(s,p)), f => f.Add(sourceFileName, destFileName)), cancellationToken);
@ -93,7 +93,7 @@ namespace Vanara.IO
{ {
try try
{ {
IMgr.CreateJob(displayName, jobType, out var newJobID, out var newJob); IMgr.CreateJob(displayName, jobType, out Guid newJobID, out IBackgroundCopyJob newJob);
return newJob; return newJob;
} }
catch (COMException cex) catch (COMException cex)
@ -143,18 +143,16 @@ namespace Vanara.IO
return wp.IsInRole(WindowsBuiltInRole.Administrator); return wp.IsInRole(WindowsBuiltInRole.Administrator);
} }
private static void CopyTemplate(string destFileName, CancellationToken ct, Action<BackgroundCopyJobState, byte> report, Action<BackgroundCopyFileCollection> add) private static void CopyTemplate(string destFileName, CancellationToken ct, Action<BackgroundCopyJobState, byte> report, Action<BackgroundCopyFileCollection> add)
{ {
var type = (Uri.TryCreate(destFileName, UriKind.Absolute, out var uri) && !uri.IsFile) ? BackgroundCopyJobType.Upload : BackgroundCopyJobType.Download; BackgroundCopyJobType type = (Uri.TryCreate(destFileName, UriKind.Absolute, out Uri uri) && !uri.IsFile) ? BackgroundCopyJobType.Upload : BackgroundCopyJobType.Download;
using var mainJob = Jobs.Add("Temp" + Guid.NewGuid().ToString(), string.Empty, type); using BackgroundCopyJob mainJob = Jobs.Add("Temp" + Guid.NewGuid().ToString(), string.Empty, type);
using var manualReset = new ManualResetEventSlim(false); using var manualReset = new ManualResetEventSlim(false);
BackgroundCopyException err = null; BackgroundCopyException err = null;
// Set event handlers for job, these are weak references. // Set event handlers for job, these are weak references.
mainJob.Completed += OnCompleted; mainJob.Completed += OnCompleted;
mainJob.Error += OnError; mainJob.Error += OnError;
@ -167,7 +165,6 @@ namespace Vanara.IO
manualReset.Wait(ct); manualReset.Wait(ct);
var raiseException = false; var raiseException = false;
if (ct.IsCancellationRequested) if (ct.IsCancellationRequested)
@ -176,26 +173,20 @@ namespace Vanara.IO
raiseException = true; raiseException = true;
} }
// Remove weak references to prevent memory leak. // Remove weak references to prevent memory leak.
mainJob.FileRangesTransferred -= OnFileRangesTransferred; mainJob.FileRangesTransferred -= OnFileRangesTransferred;
mainJob.FileTransferred -= OnFileTransferred; mainJob.FileTransferred -= OnFileTransferred;
mainJob.Completed -= OnCompleted; mainJob.Completed -= OnCompleted;
mainJob.Error -= OnError; mainJob.Error -= OnError;
if (raiseException) if (raiseException)
throw new OperationCanceledException(); throw new OperationCanceledException();
if (null != err) if (null != err)
throw err; throw err;
// Better performance when event methods are defined seperately, preferably static. // Better performance when event methods are defined seperately, preferably static.
void OnCompleted(object s, BackgroundCopyJobEventArgs e) void OnCompleted(object s, BackgroundCopyJobEventArgs e)
{ {
if (s is BackgroundCopyJob job) if (s is BackgroundCopyJob job)
@ -208,7 +199,6 @@ namespace Vanara.IO
} }
} }
void OnError(object s, BackgroundCopyJobEventArgs e) void OnError(object s, BackgroundCopyJobEventArgs e)
{ {
if (s is BackgroundCopyJob job) if (s is BackgroundCopyJob job)
@ -221,25 +211,19 @@ namespace Vanara.IO
} }
} }
void OnFileTransferred(object s, BackgroundCopyFileTransferredEventArgs e) void OnFileTransferred(object s, BackgroundCopyFileTransferredEventArgs e)
{ {
if (s is BackgroundCopyJob job) if (s is BackgroundCopyJob job)
ReportProgress(job, job.State); ReportProgress(job, job.State);
} }
void OnFileRangesTransferred(object s, BackgroundCopyFileRangesTransferredEventArgs e) void OnFileRangesTransferred(object s, BackgroundCopyFileRangesTransferredEventArgs e)
{ {
if (s is BackgroundCopyJob job) if (s is BackgroundCopyJob job)
ReportProgress(job, job.State); ReportProgress(job, job.State);
} }
void ReportProgress(BackgroundCopyJob job, BackgroundCopyJobState state) => report?.Invoke(state, job.Progress.PercentComplete);
void ReportProgress(BackgroundCopyJob job, BackgroundCopyJobState state)
{
report?.Invoke(state, job.Progress.PercentComplete);
}
} }
} }
} }

View File

@ -22,413 +22,310 @@
using NUnit.Framework; using NUnit.Framework;
using System; using System;
using System.Globalization; using System.Globalization;
using System.IO;
using System.Security.AccessControl; using System.Security.AccessControl;
using static System.IO.Path;
namespace Vanara.IO.Tests namespace Vanara.IO.Tests
{ {
/// <summary>Used to create a temporary directory that will be deleted once this instance is disposed.</summary> /// <summary>Used to create a temporary directory that will be deleted once this instance is disposed.</summary>
public sealed class TemporaryDirectory : IDisposable public sealed class TemporaryDirectory : IDisposable
{ {
#region Fields public const int OneMebibyte = 1 << 20;
public const int OneMebibyte = 1048576; /// <summary>The path to the temporary folder, ending with a backslash.</summary>
private static readonly string TempPath = GetTempPath();
#endregion //Fields public TemporaryDirectory() : this(false)
{
}
public TemporaryDirectory(bool isNetwork, string folderPrefix = null, string root = null)
{
if (string.IsNullOrWhiteSpace(folderPrefix))
folderPrefix = "Vanara.TempRoot";
#region Constructors if (string.IsNullOrWhiteSpace(root))
root = TempPath;
public TemporaryDirectory() : this(false) { } //if (isNetwork)
// root = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(root);
//UnitTestConstants.PrintUnitTestHeader(isNetwork);
public TemporaryDirectory(bool isNetwork, string folderPrefix = null, string root = null) do
{ {
if (string.IsNullOrWhiteSpace(folderPrefix)) Directory = new DirectoryInfo(Combine(root, folderPrefix + "." + RandomString));
folderPrefix = "Vanara.TempRoot"; } while (Directory.Exists);
Directory.Create();
}
~TemporaryDirectory()
{
Dispose(false);
}
if (string.IsNullOrWhiteSpace(root)) public DirectoryInfo Directory { get; private set; }
root = TempPath;
//if (isNetwork) /// <summary>Returns the full path to a non-existing directory with a random name, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\Directory_wqáánmvh.z03".</summary>
// root = Alphaleonis.Win32.Filesystem.Path.LocalToUnc(root); public string RandomDirectoryFullPath => Combine(Directory.FullName, RandomDirectoryName);
/// <summary>Returns a random directory name, such as: "Directory_wqáánmvh".</summary>
public string RandomDirectoryName => string.Format(CultureInfo.InvariantCulture, "Directory.{0}", RandomString);
//UnitTestConstants.PrintUnitTestHeader(isNetwork); /// <summary>Returns the full path to a non-existing file with a random name and without an extension, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\File_wqáánmvh".</summary>
public string RandomFileNoExtensionFullPath => Combine(Directory.FullName, GetFileNameWithoutExtension(RandomTxtFileName));
/// <summary>Returns a random string of 8 characters in length, possibly with diacritic characters.</summary>
public string RandomString
{
get
{
var randomFileName = GetFileNameWithoutExtension(GetRandomFileName());
return randomFileName;
//switch (new Random(DateTime.UtcNow.Millisecond).Next(1, 3))
//{
// case 1:
// return randomFileName.Replace("a", "ä").Replace("e", "ë").Replace("i", "ï").Replace("o", "ö").Replace("u", "ü");
// case 2: return randomFileName.Replace("a", "á").Replace("e", "é").Replace("i", "í").Replace("o", "ó").Replace("u", "ú");
// case 3: return randomFileName.Replace("a", "â").Replace("e", "ê").Replace("i", "î").Replace("o", "ô").Replace("u", "û");
// default:
// return randomFileName;
//}
}
}
/// <summary>Returns the full path to a non-existing file with a random name, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\File_wqáánmvh.txt".</summary>
public string RandomTxtFileFullPath => Combine(Directory.FullName, RandomTxtFileName);
do /// <summary>Returns the full path to a non-existing file with a random name, such as: "File_wqáánmvh.txt".</summary>
{ public string RandomTxtFileName => string.Format(CultureInfo.InvariantCulture, "File_{0}.txt", RandomString);
Directory = new System.IO.DirectoryInfo(System.IO.Path.Combine(root, folderPrefix + "." + RandomString));
} while (Directory.Exists); /// <summary>Returns a <see cref="DirectoryInfo"/> instance to an existing directory.</summary>
public DirectoryInfo CreateDirectory() => CreateDirectoryCore(null);
Directory.Create();
} /// <summary>Returns a <see cref="DirectoryInfo"/> instance to an existing directory.</summary>
public DirectoryInfo CreateDirectory(string directoryNameSuffix) => CreateDirectoryCore(Directory.FullName + directoryNameSuffix);
#endregion // Constructors
/// <summary>
/// Returns a <see cref="DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden
#region Properties /// attributes set.
/// </summary>
public System.IO.DirectoryInfo Directory { get; private set; } public DirectoryInfo CreateDirectoryRandomizedAttributes() => CreateDirectoryCore(null, false, true, true);
/// <summary>
/// <summary>Returns a random directory name, such as: "Directory_wqáánmvh".</summary> /// Returns a <see cref="DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden
public string RandomDirectoryName /// attributes set.
{ /// </summary>
get { return string.Format(CultureInfo.InvariantCulture, "Directory.{0}", RandomString); } public DirectoryInfo CreateDirectoryRandomizedAttributes(string directoryNameSuffix) => CreateDirectoryCore(Directory.FullName + directoryNameSuffix, false, true, true);
}
/// <summary>Returns a <see cref="FileInfo"/> instance to an existing file.</summary>
public FileInfo CreateFile() => CreateFileCore(null);
/// <summary>Returns the full path to a non-existing file with a random name, such as: "File_wqáánmvh.txt".</summary>
public string RandomTxtFileName /// <summary>Returns a <see cref="FileInfo"/> instance to an existing file of <paramref name="fileSize"/> bytes.</summary>
{ public FileInfo CreateFile(int fileSize) => CreateFileCore(null, fileSize: fileSize);
get { return string.Format(CultureInfo.InvariantCulture, "File_{0}.txt", RandomString); }
} /// <summary>
/// Returns a <see cref="FileInfo"/> instance to an existing file, possibly with read-only and/or hidden attributes set.
/// </summary>
/// <summary>Returns the full path to a non-existing directory with a random name, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\Directory_wqáánmvh.z03".</summary> public FileInfo CreateFileRandomizedAttributes() => CreateFileCore(null, false, true, true);
public string RandomDirectoryFullPath
{ /// <summary>
get { return System.IO.Path.Combine(Directory.FullName, RandomDirectoryName); } /// Creates a directory structure populated with subdirectories and files of random size and possibly with read-only and/or hidden
} /// attributes set.
/// </summary>
public DirectoryInfo CreateRandomizedAttributesTree(int level = 1) => CreateTreeCore(null, level, false, false, true, true);
/// <summary>Returns the full path to a non-existing file with a random name, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\File_wqáánmvh.txt".</summary>
public string RandomTxtFileFullPath /// <summary>
{ /// Creates a recursive directory structure populated with subdirectories and files of random size and possibly with read-only and/or
get { return System.IO.Path.Combine(Directory.FullName, RandomTxtFileName); } /// hidden attributes set.
} /// </summary>
public DirectoryInfo CreateRecursiveRandomizedAttributesTree(int level = 1) => CreateTreeCore(null, level, true, false, true, true);
/// <summary>Returns the full path to a non-existing file with a random name and without an extension, such as: "C:\Users\UserName\AppData\Local\Temp\AlphaFS.TempRoot.lpqdzf\File_wqáánmvh".</summary> /// <summary>
public string RandomFileNoExtensionFullPath /// Creates a recursive directory structure populated with subdirectories and files, possibly with randomized CreationTime,
{ /// LastAccessTime and/or LastWriteTime. The file size, read-only and/or hidden attributes might also be randomized.
get { return System.IO.Path.Combine(Directory.FullName, System.IO.Path.GetFileNameWithoutExtension(RandomTxtFileName)); } /// </summary>
} public DirectoryInfo CreateRecursiveRandomizedDatesAndAttributesTree(int level = 1) => CreateTreeCore(null, level, true, true, true, true);
/// <summary>
/// <summary>Returns a random string of 8 characters in length, possibly with diacritic characters.</summary> /// Creates a recursive directory structure populated with subdirectories and files, possibly with randomized CreationTime,
public string RandomString /// LastAccessTime and/or LastWriteTime.
{ /// </summary>
get public DirectoryInfo CreateRecursiveRandomizedDatesTree(int level = 1) => CreateTreeCore(null, level, true, true);
{
var randomFileName = System.IO.Path.GetFileNameWithoutExtension(System.IO.Path.GetRandomFileName()); /// <summary>Creates a recursive directory structure populated with subdirectories and files of random size.</summary>
return randomFileName; public DirectoryInfo CreateRecursiveTree(int level = 1) => CreateTreeCore(null, level, true);
//switch (new Random(DateTime.UtcNow.Millisecond).Next(1, 3)) /// <summary>Creates a recursive directory structure populated with subdirectories and files of random size.</summary>
//{ public DirectoryInfo CreateRecursiveTree(int level, string rootFullPath) => CreateTreeCore(rootFullPath, level, true);
// case 1:
// return randomFileName.Replace("a", "ä").Replace("e", "ë").Replace("i", "ï").Replace("o", "ö").Replace("u", "ü"); /// <summary>Returns a <see cref="DirectoryInfo"/> instance to an existing directory.</summary>
public DirectoryInfo CreateSubDirectory(string directoryName) => CreateDirectoryCore(Combine(Directory.FullName, directoryName));
// case 2:
// return randomFileName.Replace("a", "á").Replace("e", "é").Replace("i", "í").Replace("o", "ó").Replace("u", "ú"); /// <summary>Returns a <see cref="FileInfo"/> instance to an existing file.</summary>
public FileInfo CreateSubDirectoryFile(DirectoryInfo directoryInfo, string fileName = null, int fileSize = OneMebibyte) => CreateFileCore(Combine(directoryInfo.FullName, fileName ?? RandomTxtFileName), fileSize: fileSize);
// case 3:
// return randomFileName.Replace("a", "â").Replace("e", "ê").Replace("i", "î").Replace("o", "ô").Replace("u", "û"); /// <summary>Creates a directory structure populated with subdirectories and files of random size.</summary>
public DirectoryInfo CreateTree(int level = 1) => CreateTreeCore(null, level);
// default:
// return randomFileName; /// <inheritdoc/>
//} public void Dispose()
} {
} Dispose(true);
GC.SuppressFinalize(this);
#endregion // Properties }
public DateTime GetRandomFileDate()
#region Methods {
var rnd = new Random(DateTime.Now.Millisecond);
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory.</summary> return new DateTime(rnd.Next(1971, DateTime.Now.Year), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59));
public System.IO.DirectoryInfo CreateDirectory() }
{
return CreateDirectoryCore(null); /// <summary>Enables or disables deny access for the current User.</summary>
} public void SetDirectoryDenyPermission(bool enable, string folderFullPath)
{
// ╔═════════════╦═════════════╦═══════════════════════════════╦════════════════════════╦══════════════════╦═══════════════════════╦═════════════╦═════════════╗
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory.</summary> // ║ ║ folder only ║ folder, sub-folders and files ║ folder and sub-folders ║ folder and files ║ sub-folders and files ║
public System.IO.DirectoryInfo CreateDirectory(string directoryNameSuffix) // sub-folders ║ files ║
{ // ╠═════════════╬═════════════╬═══════════════════════════════╬════════════════════════╬══════════════════╬═══════════════════════╬═════════════╬═════════════╣
return CreateDirectoryCore(Directory.FullName + directoryNameSuffix); // ║ Propagation ║ none ║ none ║ none ║ none ║ InheritOnly ║ InheritOnly ║ InheritOnly ║ ║ Inheritance ║ none ║ Container|Object
} // ║ Container ║ Object ║ Container|Object ║ Container ║ Object ║ ╚═════════════╩═════════════╩═══════════════════════════════╩════════════════════════╩══════════════════╩═══════════════════════╩═════════════╩═════════════╝
var user = (Environment.UserDomainName + @"\" + Environment.UserName).TrimStart('\\');
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory.</summary>
public System.IO.DirectoryInfo CreateSubDirectory(string directoryName) var rule = new FileSystemAccessRule(user, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Deny);
{
return CreateDirectoryCore(System.IO.Path.Combine(Directory.FullName, directoryName)); DirectorySecurity dirSecurity;
}
DirectoryInfo dirInfo = CreateDirectoryCore(folderFullPath);
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden attributes set.</summary> // Set DENY for current User.
public System.IO.DirectoryInfo CreateDirectoryRandomizedAttributes() if (enable)
{ {
return CreateDirectoryCore(null, false, true, true); dirSecurity = dirInfo.GetAccessControl();
} dirSecurity.AddAccessRule(rule);
dirInfo.SetAccessControl(dirSecurity);
}
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden attributes set.</summary>
public System.IO.DirectoryInfo CreateDirectoryRandomizedAttributes(string directoryNameSuffix) // Remove DENY for current User.
{ else
return CreateDirectoryCore(Directory.FullName + directoryNameSuffix, false, true, true); {
} dirSecurity = dirInfo.GetAccessControl();
dirSecurity.RemoveAccessRule(rule);
dirInfo.SetAccessControl(dirSecurity);
/// <summary>Returns a <see cref="System.IO.FileInfo"/> instance to an existing file.</summary> }
public System.IO.FileInfo CreateFile() }
{
return CreateFileCore(null); /// <inheritdoc/>
} public override string ToString() => Directory.FullName;
private static void SetReadOnlyAndOrHiddenAttributes(FileSystemInfo fsi, bool readOnly = false, bool hidden = false)
/// <summary>Returns a <see cref="System.IO.FileInfo"/> instance to an existing file.</summary> {
public System.IO.FileInfo CreateSubDirectoryFile(System.IO.DirectoryInfo directoryInfo, string fileName = null, int fileSize = OneMebibyte) if (readOnly && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
{ fsi.Attributes |= FileAttributes.ReadOnly;
return CreateFileCore(System.IO.Path.Combine(directoryInfo.FullName, fileName ?? RandomTxtFileName), fileSize: fileSize);
} if (hidden && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
fsi.Attributes |= FileAttributes.Hidden;
}
/// <summary>Returns a <see cref="System.IO.FileInfo"/> instance to an existing file of <paramref name="fileSize"/> bytes.</summary>
public System.IO.FileInfo CreateFile(int fileSize) /// <summary>
{ /// Returns a <see cref="DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden
return CreateFileCore(null, fileSize: fileSize); /// attributes set.
} /// </summary>
private DirectoryInfo CreateDirectoryCore(string folderFullPath, bool randomizedDates = false, bool readOnly = false, bool hidden = false)
{
/// <summary>Returns a <see cref="System.IO.FileInfo"/> instance to an existing file, possibly with read-only and/or hidden attributes set.</summary> DirectoryInfo dirInfo = System.IO.Directory.CreateDirectory(!string.IsNullOrWhiteSpace(folderFullPath) ? folderFullPath : RandomDirectoryFullPath);
public System.IO.FileInfo CreateFileRandomizedAttributes()
{ SetRandomizedDates(dirInfo, randomizedDates);
return CreateFileCore(null, false, true, true);
} SetReadOnlyAndOrHiddenAttributes(dirInfo, readOnly, hidden);
return dirInfo;
/// <summary>Creates a directory structure populated with subdirectories and files of random size.</summary> }
public System.IO.DirectoryInfo CreateTree(int level = 1)
{ /// <summary>
return CreateTreeCore(null, level); /// Returns a <see cref="FileInfo"/> instance to an existing file, possibly with read-only and/or hidden attributes set.
} /// </summary>
private FileInfo CreateFileCore(string fileFullPath, bool randomizedDates = false, bool readOnly = false, bool hidden = false, int fileSize = 0)
{
/// <summary>Creates a recursive directory structure populated with subdirectories and files of random size.</summary> var fileInfo = new FileInfo(!string.IsNullOrWhiteSpace(fileFullPath) ? fileFullPath : RandomTxtFileFullPath);
public System.IO.DirectoryInfo CreateRecursiveTree(int level = 1)
{ using (FileStream fs = fileInfo.Create())
return CreateTreeCore(null, level, true); {
} if (fileSize > OneMebibyte)
fs.SetLength(fileSize);
else
/// <summary>Creates a recursive directory structure populated with subdirectories and files of random size.</summary> fs.SetLength(new Random(DateTime.UtcNow.Millisecond).Next(0, OneMebibyte));
public System.IO.DirectoryInfo CreateRecursiveTree(int level, string rootFullPath) }
{
return CreateTreeCore(rootFullPath, level, true); SetRandomizedDates(fileInfo, randomizedDates);
}
SetReadOnlyAndOrHiddenAttributes(fileInfo, readOnly, hidden);
/// <summary>Creates a directory structure populated with subdirectories and files of random size and possibly with read-only and/or hidden attributes set.</summary> return fileInfo;
public System.IO.DirectoryInfo CreateRandomizedAttributesTree(int level = 1) }
{
return CreateTreeCore(null, level, false, false, true, true); /// <summary>
} /// Creates an, optional recursive, directory structure of <param name="level"/> levels deep, populated with subdirectories and files
/// of random size and possibly with read-only and/or hidden attributes set.
/// </summary>
/// <summary>Creates a recursive directory structure populated with subdirectories and files of random size and possibly with read-only and/or hidden attributes set.</summary> private DirectoryInfo CreateTreeCore(string rootFullPath, int level = 1, bool recurse = false, bool randomizedDates = false, bool readOnly = false, bool hidden = false)
public System.IO.DirectoryInfo CreateRecursiveRandomizedAttributesTree(int level = 1) {
{ DirectoryInfo dirInfo = CreateDirectoryCore(rootFullPath, randomizedDates, readOnly, hidden);
return CreateTreeCore(null, level, true, false, true, true);
} var folderCount = 0;
for (var fsoCount = 0; fsoCount < level; fsoCount++)
/// <summary>Creates a recursive directory structure populated with subdirectories and files, possibly with randomized CreationTime, LastAccessTime and/or LastWriteTime.</summary> {
public System.IO.DirectoryInfo CreateRecursiveRandomizedDatesTree(int level = 1) folderCount++;
{
return CreateTreeCore(null, level, true, true); var fsoName = RandomString + "-" + fsoCount;
}
// Always create folder.
/// <summary>Creates a recursive directory structure populated with subdirectories and files, possibly with randomized CreationTime, LastAccessTime and/or LastWriteTime. DirectoryInfo di = CreateDirectoryCore(Combine(dirInfo.FullName, $"Directory_{fsoName}_directory"), randomizedDates, readOnly, hidden);
/// The file size, read-only and/or hidden attributes might also be randomized.
/// </summary> // Create file, every other iteration.
public System.IO.DirectoryInfo CreateRecursiveRandomizedDatesAndAttributesTree(int level = 1) CreateFileCore(Combine(fsoCount % 2 == 0 ? di.FullName : dirInfo.FullName, $"File_{fsoName}_file.txt"), randomizedDates, readOnly, hidden);
{ }
return CreateTreeCore(null, level, true, true, true, true);
} if (recurse)
{
foreach (var folder in System.IO.Directory.EnumerateDirectories(dirInfo.FullName))
public DateTime GetRandomFileDate() CreateTreeCore(folder, level, false, randomizedDates, readOnly, hidden);
{ }
var rnd = new Random(DateTime.Now.Millisecond);
return new DateTime(rnd.Next(1971, DateTime.Now.Year), rnd.Next(1, 12), rnd.Next(1, 28), rnd.Next(0, 23), rnd.Next(0, 59), rnd.Next(0, 59)); Assert.AreEqual(level, folderCount, "The number of folders does not equal level argument, but is expected to.");
}
return dirInfo;
}
/// <summary>Enables or disables deny access for the current User.</summary>
public void SetDirectoryDenyPermission(bool enable, string folderFullPath) private void Dispose(bool isDisposing)
{ {
// ╔═════════════╦═════════════╦═══════════════════════════════╦════════════════════════╦══════════════════╦═══════════════════════╦═════════════╦═════════════╗ try
// ║ ║ folder only ║ folder, sub-folders and files ║ folder and sub-folders ║ folder and files ║ sub-folders and files ║ sub-folders ║ files ║ {
// ╠═════════════╬═════════════╬═══════════════════════════════╬════════════════════════╬══════════════════╬═══════════════════════╬═════════════╬═════════════╣ if (isDisposing)
// ║ Propagation ║ none ║ none ║ none ║ none ║ InheritOnly ║ InheritOnly ║ InheritOnly ║ System.IO.Directory.Delete(Directory.FullName, true);
// ║ Inheritance ║ none ║ Container|Object ║ Container ║ Object ║ Container|Object ║ Container ║ Object ║ }
// ╚═════════════╩═════════════╩═══════════════════════════════╩════════════════════════╩══════════════════╩═══════════════════════╩═════════════╩═════════════╝ catch (Exception ex)
{
var user = (Environment.UserDomainName + @"\" + Environment.UserName).TrimStart('\\'); Console.WriteLine($"{nameof(TemporaryDirectory)} delete failure. Error: {ex.Message.Replace(Environment.NewLine, string.Empty)}");
}
var rule = new FileSystemAccessRule(user, FileSystemRights.FullControl, InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Deny); }
DirectorySecurity dirSecurity; private void SetRandomizedDates(FileSystemInfo fsi, bool randomizedDates = false)
{
var dirInfo = CreateDirectoryCore(folderFullPath); if (randomizedDates && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
{
fsi.CreationTime = GetRandomFileDate();
// Set DENY for current User. fsi.LastAccessTime = GetRandomFileDate();
if (enable) fsi.LastWriteTime = GetRandomFileDate();
{ }
dirSecurity = dirInfo.GetAccessControl(); }
dirSecurity.AddAccessRule(rule); }
dirInfo.SetAccessControl(dirSecurity);
}
// Remove DENY for current User.
else
{
dirSecurity = dirInfo.GetAccessControl();
dirSecurity.RemoveAccessRule(rule);
dirInfo.SetAccessControl(dirSecurity);
}
}
public override string ToString()
{
return Directory.FullName;
}
#endregion // Methods
#region Private Members
/// <summary>The path to the temporary folder, ending with a backslash.</summary>
private static readonly string TempPath = System.IO.Path.GetTempPath();
/// <summary>Returns a <see cref="System.IO.DirectoryInfo"/> instance to an existing directory, possibly with read-only and/or hidden attributes set.</summary>
private System.IO.DirectoryInfo CreateDirectoryCore(string folderFullPath, bool randomizedDates = false, bool readOnly = false, bool hidden = false)
{
var dirInfo = System.IO.Directory.CreateDirectory(!string.IsNullOrWhiteSpace(folderFullPath) ? folderFullPath : RandomDirectoryFullPath);
SetRandomizedDates(dirInfo, randomizedDates);
SetReadOnlyAndOrHiddenAttributes(dirInfo, readOnly, hidden);
return dirInfo;
}
/// <summary>Returns a <see cref="System.IO.FileInfo"/> instance to an existing file, possibly with read-only and/or hidden attributes set.</summary>
private System.IO.FileInfo CreateFileCore(string fileFullPath, bool randomizedDates = false, bool readOnly = false, bool hidden = false, int fileSize = 0)
{
var fileInfo = new System.IO.FileInfo(!string.IsNullOrWhiteSpace(fileFullPath) ? fileFullPath : RandomTxtFileFullPath);
using (var fs = fileInfo.Create())
{
if (fileSize > OneMebibyte)
fs.SetLength(fileSize);
else
fs.SetLength(new Random(DateTime.UtcNow.Millisecond).Next(0, OneMebibyte));
}
SetRandomizedDates(fileInfo, randomizedDates);
SetReadOnlyAndOrHiddenAttributes(fileInfo, readOnly, hidden);
return fileInfo;
}
/// <summary>Creates an, optional recursive, directory structure of <param name="level"/> levels deep, populated with subdirectories and files of random size and possibly with read-only and/or hidden attributes set.</summary>
private System.IO.DirectoryInfo CreateTreeCore(string rootFullPath, int level = 1, bool recurse = false, bool randomizedDates = false, bool readOnly = false, bool hidden = false)
{
var dirInfo = CreateDirectoryCore(rootFullPath, randomizedDates, readOnly, hidden);
var folderCount = 0;
for (var fsoCount = 0; fsoCount < level; fsoCount++)
{
folderCount++;
var fsoName = RandomString + "-" + fsoCount;
// Always create folder.
var di = CreateDirectoryCore(System.IO.Path.Combine(dirInfo.FullName, $"Directory_{fsoName}_directory"), randomizedDates, readOnly, hidden);
// Create file, every other iteration.
CreateFileCore(System.IO.Path.Combine(fsoCount % 2 == 0 ? di.FullName : dirInfo.FullName, $"File_{fsoName}_file.txt"), randomizedDates, readOnly, hidden);
}
if (recurse)
{
foreach (var folder in System.IO.Directory.EnumerateDirectories(dirInfo.FullName))
CreateTreeCore(folder, level, false, randomizedDates, readOnly, hidden);
}
Assert.AreEqual(level, folderCount, "The number of folders does not equal level argument, but is expected to.");
return dirInfo;
}
private void SetRandomizedDates(System.IO.FileSystemInfo fsi, bool randomizedDates = false)
{
if (randomizedDates && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
{
fsi.CreationTime = GetRandomFileDate();
fsi.LastAccessTime = GetRandomFileDate();
fsi.LastWriteTime = GetRandomFileDate();
}
}
private static void SetReadOnlyAndOrHiddenAttributes(System.IO.FileSystemInfo fsi, bool readOnly = false, bool hidden = false)
{
if (readOnly && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
fsi.Attributes |= System.IO.FileAttributes.ReadOnly;
if (hidden && new Random(DateTime.UtcNow.Millisecond).Next(0, 1000) % 2 == 0)
fsi.Attributes |= System.IO.FileAttributes.Hidden;
}
#endregion Private Members
#region Disposable Members
~TemporaryDirectory()
{
Dispose(false);
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
private void Dispose(bool isDisposing)
{
try
{
if (isDisposing)
System.IO.Directory.Delete(Directory.FullName, true);
}
catch (Exception ex)
{
Console.WriteLine($"{nameof(TemporaryDirectory)} delete failure. Error: {ex.Message.Replace(Environment.NewLine, string.Empty)}");
}
}
#endregion // Disposable Members
}
} }