public IEnumerable <IDirectory> Directories()
{
lock (ChildDirectories)
{
return(ChildDirectories.Where(x => x.Exists).Cast <IDirectory>().ToList());
}
}
public IDirectory GetDirectory(string directoryName)
{
if (Path.IsPathRooted(directoryName))
{
return(FileSystem.GetDirectory(directoryName));
}
InMemoryDirectory inMemoryDirectory;
lock (ChildDirectories)
{
inMemoryDirectory = ChildDirectories.FirstOrDefault(x => x.Name.Equals(directoryName, _stringComparison));
if (inMemoryDirectory == null)
{
inMemoryDirectory = new InMemoryDirectory(_fileSystem, System.IO.Path.Combine(Path.FullPath, directoryName))
{
Parent = this
};
ChildDirectories.Add(inMemoryDirectory);
}
}
return(inMemoryDirectory);
}
public IEnumerable <IDirectory> Directories(string filter, SearchScope scope)
{
var path = new Path(filter);
// if it's a rooted or it's a in the form of e.g. "C:"
if (path.IsRooted || Regex.IsMatch(filter, "[A-Z]{1,3}:", RegexOptions.IgnoreCase))
{
var directory = FileSystem.GetDirectory(path.Segments.First());
return(path.Segments.Count() == 1
? new[] { directory }
: directory.Directories(string.Join("\\", path.Segments.Skip(1)
.DefaultIfEmpty("*")
.ToArray())));
}
var filterRegex = filter.Wildcard();
lock (ChildDirectories)
{
var immediateChildren = ChildDirectories.Where(x => x.Exists && filterRegex.IsMatch(x.Name)).Cast <IDirectory>();
return(scope == SearchScope.CurrentOnly
? immediateChildren.ToList()
: immediateChildren
.Concat(ChildDirectories.SelectMany(x => x.Directories(filter, scope))).ToList());
}
}
private void GetDirInfo()
{
var di = new DirectoryInfo(FullPath);
Name = di.Name;
Created = di.CreationTime;
LastWrite = di.LastWriteTime;
var dirs = Directory.EnumerateDirectories(FullPath).AsParallel();
var files = Directory.EnumerateFiles(FullPath);
if (dirs.Count() == 0 && files.Count() == 0)
{
TerminalLeaf = true;
}
if (dirs.Count() > 0)
{
foreach (var d in dirs)
{
ChildDirectories.Add(Path.GetFileName(d));
}
}
if (files.Count() > 0)
{
foreach (var f in files)
{
ChildFiles.Add(Path.GetFileName(f));
}
}
}
public void Delete()
{
if (!IsHardLink)
{
foreach (var childDirectory in ChildDirectories.Copy())
{
childDirectory.Delete();
}
}
Exists = false;
}
public IEnumerable <IFile> Files(string filter, SearchScope searchScope)
{
lock (ChildFiles)
lock (ChildDirectories)
{
var filterRegex = filter.Wildcard();
var immediateChildren = ChildFiles.Where(x => x.Exists && filterRegex.IsMatch(x.Name)).Cast <IFile>();
return(searchScope == SearchScope.CurrentOnly
? immediateChildren.ToList()
: immediateChildren.Concat(ChildDirectories.SelectMany(x => x.Files(filter, searchScope))).ToList());
}
}
//constructor takes a directory and a parent and gets its size and name and creates a new treefile for all of its subdirectories
// the parent is used to get the percent of parent parameter
public Treefile(DirectoryInfo d, long parent)
{
Name = d.Name;
numberoffiles = 0;
numberofdirectories = 0;
Size = getSize(d);
myDir = d;
this.parent = parent;
this.percentsize = calculatepercent();
foreach (var child in d.EnumerateDirectories())
{
this.numberofdirectories += 1;
Treefile childtree = new Treefile(child, this.Size);
ChildDirectories.Add(childtree);
}
foreach (var c in myDir.EnumerateFiles())
{
this.numberoffiles += 1;
Childfiles.Add(c);
}
}
/// <summary>
/// Scans the tree to find all images, and all shortcuts to images.
/// </summary>
/// <param name="token"></param>
public void Populate(CancellationToken token)
{
ScanStarted?.Invoke(new DirectoryScanInfo {
Directory = DirectoryInfo
});
if (token.IsCancellationRequested)
{
return;
}
try
{
EnsureShortcutUtility();
List <ImageItem> children = new List <ImageItem>();
ImageItem child;
foreach (var file in DirectoryInfo.EnumerateFilesByExtensions(Constants.IMAGE_FILE_EXTENSIONS_PLUS_LINK))
{
if (token.IsCancellationRequested)
{
return;
}
child = new ImageItem(file, ShortcutUtility);
if (child.IsImage)
{
children.Add(child);
}
}
if (token.IsCancellationRequested)
{
return;
}
AddDescendants(children, 0);
EnsureBlacklist();
foreach (var subDir in DirectoryInfo.EnumerateDirectories())
{
if (token.IsCancellationRequested)
{
return;
}
if (!BlacklistExcludes(subDir.FullName) && !subDir.Attributes.HasFlag(FileAttributes.System))
{
var subTreeDir = new ImageTreeDirectory(subDir, this)
{
Blacklist = Blacklist,
ShortcutUtility = ShortcutUtility
};
subTreeDir.ScanStarted += ScanStarted;
subTreeDir.ScanFailed += ScanFailed;
subTreeDir.Populate(token);
if (token.IsCancellationRequested)
{
return;
}
ChildDirectories.Add(subTreeDir);
}
}
IsPopulated = true;
}
catch (Exception ex)
{
ScanFailed?.Invoke(new DirectoryScanInfo {
Directory = DirectoryInfo, Exception = ex
});
}
}
internal void RemoveDirectory(ApplicationDirectoryState state)
{
ChildDirectories.Remove(state);
}
internal void AddDirectory(ApplicationDirectoryState state)
{
ChildDirectories.Add(state);
}
public int CountChildFiles()
{
return(ChildFiles.Count + ChildDirectories.Select(d => d.CountChildFiles()).Sum());
}
/// <summary> /// Get all the files within all the dirs /// </summary> /// <returns></returns> public List <string> GetAllChildFiles() => ChildDirectories .SelectMany(x => x.ChildFiles) .ToList();