/// <summary>
/// Retrieves files from a file directory.
/// </summary>
/// <param name="searchInformation">Search information to query the directory with</param>
/// <param name="callback">Callback method to be invoked after each provided timeout period elapses</param>
/// <param name="intCallbackTimeoutSecounds">Number of seconds to wait before invoking the callback method</param>
/// <returns></returns>
public FileObjectList GetFilesAsync(SearchInformation searchInformation, SearchInformation.SearchCallback callback, int intCallbackTimeoutSecounds = 10)
{
try
{
// Validation
FileObjectList fileObjectList = new FileObjectList();
// Set Initial Search
DateTime lastDate = DateTime.Now;
// Create Directories Searched
DirectoryObjectList directoriesSearched = new DirectoryObjectList();
// Get File Asynchronously
this.GetFilesAsync(searchInformation, callback, ref fileObjectList, ref directoriesSearched, ref lastDate, intCallbackTimeoutSecounds);
return(fileObjectList);
}
catch (Exception ex)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(ex.ToString());
return(null);
}
}
private static void Callback(FileObjectList files, DirectoryObjectList directories)
{
DateTime dt = DateTime.Now;
Console.WriteLine(
"Time: " + DateTime.Now.ToLongTimeString() + " | Files: " + files.Count + " | Directories Searched: " + directories.Count);
}
/// <summary>
/// Retrieves files from a file directory
/// </summary>
/// <param name="boolRecurse">Flag that determines whether files are retrieved recursively including files from sub-directories</param>
/// <returns></returns>
public FileObjectList GetFiles(bool boolRecurse)
{
// Create Directory List
FileObjectList files = this.GetFiles("*", boolRecurse);
return(files);
}
/// <summary>
/// Deletes files from a directory
/// </summary>
/// <param name="boolRecurse">Flag that determines whether files are retrieved recursively including files from sub-directories</param>
/// <returns></returns>
public Globals.ResultType DeleteFiles(bool boolRecurse)
{
// Get Files
FileObjectList listFiles = this.GetFiles(boolRecurse);
// Delete Files
Globals.ResultType deleteResult = listFiles.Delete();
return(deleteResult);
}
/// <summary>
/// Retrieves all file content as a string from a directory
/// </summary>
/// <param name="directoryObject">Directory to retrieve content from</param>
/// <param name="strFind">Search string to find</param>
/// <param name="boolRecurse">Flag that determines whether files are retrieved recursively including files from sub-directories</param>
/// <returns></returns>
private static string GetFileContentAsString(this DirectoryObject directoryObject, string strFind, bool boolRecurse)
{
// Create File List
FileObjectList files = directoryObject.GetFiles(strFind, boolRecurse);
// Load All File Content
files.ForEach(file => file.Content.Load());
string strContent = String.Join("\r\n", files.Select(file => file.Content.Value).ToArray());
return(strContent);
}
/// <summary>
/// Retrieves files from a file directory
/// </summary>
/// <param name="strFind">Search string to find</param>
/// <param name="boolRecurse">Flag that determines whether files are retrieved recursively including files from sub-directories</param>
/// <returns></returns>
public FileObjectList GetFiles(string strFind, bool boolRecurse)
{
try
{
// Determine Search Pattern
strFind = (strFind == null || strFind == "") ? "*" : strFind;
strFind = (strFind.Length > 0 && strFind[0].ToString() != "*") ? "*" + strFind + "*" : strFind;
// Determine Search Option
System.IO.SearchOption option = (boolRecurse == true) ? System.IO.SearchOption.AllDirectories : System.IO.SearchOption.TopDirectoryOnly;
// Get Directory Files
List <string> listFileNames = System.IO.Directory.GetFiles(this.FilePath, strFind, option).ToList();
// Create File List
FileObjectList files = new FileObjectList(listFileNames);
return(files);
}
catch (UnauthorizedAccessException e)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(e.Message);
return(null);
}
catch (DirectoryNotFoundException e)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(e.Message);
return(null);
}
catch (IOException e)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(e.Message);
return(null);
}
catch (Exception ex)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(ex.ToString());
return(null);
}
}
/// <summary>
/// Copies directory files to a destination directory
/// </summary>
/// <param name="destinationDirectoryObject">Destination for directory files to be copied to</param>
/// <param name="boolOverWrite">Flag for whether or not to overwrite any existing file in the destination directory</param>
/// <param name="strFind">Search pattern to use retrieving files</param>
/// <param name="boolRecurse">Flag that determines whether files are retrieved recursively including files from sub-directories</param>
/// <param name="boolDeleteOriginal">Flag that determines whether to delete the original files</param>
/// <returns></returns>
public Globals.ResultType CopyFiles(DirectoryObject destinationDirectoryObject, bool boolOverWrite, string strFind, bool boolRecurse, bool boolDeleteOriginal = false)
{
// Get Files
FileObjectList listFiles = this.GetFiles(strFind, boolRecurse);
Globals.ResultType copyResult = Globals.ResultType.Success;
// Loop Files
foreach (FileObject file in listFiles)
{
// Copy File
Globals.ResultType copyFileResult = file.Copy(destinationDirectoryObject, boolOverWrite, boolDeleteOriginal);
// Validation
copyResult = (copyFileResult != Globals.ResultType.Success) ? Globals.ResultType.Failure : Globals.ResultType.Success;
}
return(copyResult);
}
internal static decimal GetSize(this DirectoryObject directoryObject, FileInformation.FileSizeType fileSizeType, bool boolRecurse)
{
try
{
// Get Directory Files
FileObjectList listFiles = directoryObject.GetFiles(boolRecurse);
// Get Total Size
decimal decDirectorySize = listFiles.Select(file => (
(fileSizeType == FileInformation.FileSizeType.Bytes) ? file.Size.Bytes :
(fileSizeType == FileInformation.FileSizeType.KiloBytes) ? file.Size.KiloBytes :
(fileSizeType == FileInformation.FileSizeType.MegaBytes) ? file.Size.MegaBytes :
(fileSizeType == FileInformation.FileSizeType.GigaBytes) ? file.Size.GigaBytes : 0)).Sum();
return(decDirectorySize);
}
catch (Exception ex)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(ex.ToString());
return(-1);
}
}
internal List <FileObject> GetSearchFilesFiltered(FileObjectList fileObjectList)
{
List <FileObject> listFiles = new List <FileObject>(fileObjectList.ToArray());
#region Filter By Date
// Validation
if (this.UseDateInformation == true)
{
if (this.DateType == FileInformation.FileDatePropertyType.CreationDate)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.CreationDate > this.MinimumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.CreationDate < this.MaximumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.CreationDate > this.MinimumDate && file.CreationDate < this.MaximumDate).ToList();
}
}
else if (this.DateType == FileInformation.FileDatePropertyType.LastAccessedDate)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.LastAccessedDate > this.MinimumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.LastAccessedDate < this.MaximumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.LastAccessedDate > this.MinimumDate && file.LastAccessedDate < this.MaximumDate).ToList();
}
}
else if (this.DateType == FileInformation.FileDatePropertyType.LastWriteDate)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.LastWriteDate > this.MinimumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.LastWriteDate < this.MaximumDate).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.LastWriteDate > this.MinimumDate && file.LastWriteDate < this.MaximumDate).ToList();
}
}
}
#endregion
#region Filter By Size
// Validation
if (this.UseSizeInformation == true)
{
if (this.SizeType == FileInformation.FileSizeType.Bytes)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.Size.Bytes > this.MinimumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.Size.Bytes < this.MaximumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.Size.Bytes > this.MinimumSize && file.Size.Bytes < this.MaximumSize).ToList();
}
}
else if (this.SizeType == FileInformation.FileSizeType.KiloBytes)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.Size.KiloBytes > this.MinimumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.Size.KiloBytes < this.MaximumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.Size.KiloBytes > this.MinimumSize && file.Size.KiloBytes < this.MaximumSize).ToList();
}
}
else if (this.SizeType == FileInformation.FileSizeType.MegaBytes)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.Size.MegaBytes > this.MinimumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.Size.MegaBytes < this.MaximumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.Size.MegaBytes > this.MinimumSize && file.Size.MegaBytes < this.MaximumSize).ToList();
}
}
else if (this.SizeType == FileInformation.FileSizeType.GigaBytes)
{
if (this.DateSearchType == FileInformation.FileSearchType.GreaterThan)
{
listFiles = listFiles.Where(file => file.Size.GigaBytes > this.MinimumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.LessThan)
{
listFiles = listFiles.Where(file => file.Size.GigaBytes < this.MaximumSize).ToList();
}
else if (this.DateSearchType == FileInformation.FileSearchType.Between)
{
listFiles = listFiles
.Where(file => file.Size.GigaBytes > this.MinimumSize && file.Size.GigaBytes < this.MaximumSize).ToList();
}
}
}
#endregion
return(listFiles);
}
private FileObjectList GetFilesAsync(SearchInformation searchInformation, SearchInformation.SearchCallback callback,
ref FileObjectList fileObjectList, ref DirectoryObjectList directoriesSearched, ref DateTime lastDate, int intCallbackTimeoutSecounds = 10)
{
try
{
#region Get Files
// Get Directory Files - Top Level Only
List <string> listFileNames = System.IO.Directory.GetFiles(this.FilePath, searchInformation.SearchPattern, System.IO.SearchOption.TopDirectoryOnly).ToList();
// Create File List
FileObjectList listFiles = new FileObjectList(listFileNames);
// Validation
if (listFiles.Count > 0)
{
// Filter Files By Search Information
List <FileObject> filesToAdd = searchInformation.GetSearchFilesFiltered(listFiles);
// Create File List
fileObjectList.AddRange(filesToAdd.ToArray());
// Distinct List
fileObjectList = new FileObjectList(fileObjectList.Distinct().ToList());
}
// Add Directory To Searched List
directoriesSearched.Add(this);
#endregion
#region Recurse Sub Directories
// Loop SubDirectories
foreach (DirectoryObject directory in this.SubDirectories)
{
// Get Sub Directory Files
directory.GetFilesAsync(searchInformation, callback, ref fileObjectList, ref directoriesSearched, ref lastDate, intCallbackTimeoutSecounds);
}
#endregion
#region Invoke Callback
// Check Time For Callback
if (fileObjectList != null && DateTime.Now > lastDate.AddSeconds(intCallbackTimeoutSecounds))
{
// Invoke Callback
callback.Invoke(fileObjectList, directoriesSearched);
lastDate = DateTime.Now;
}
#endregion
return(fileObjectList);
}
catch (Exception ex)
{
// To Be Implemented: Throw Custom Exception...
Console.WriteLine(ex.ToString());
return(null);
}
}
