public bool isModuleCached(string ModuleName, string ModuleFilepath)
{
// Do not process twice the same item
ModuleCacheKey ModuleKey = new ModuleCacheKey(ModuleName, ModuleFilepath);
return(ModulesCache.ContainsKey(ModuleKey));
}
public PeDependencyItem GetModuleItem(string ModuleName, string ModuleFilepath, ModuleSearchStrategy SearchStrategy, int RecursionLevel)
{
// Do not process twice the same item
ModuleCacheKey ModuleKey = new ModuleCacheKey(ModuleName, ModuleFilepath);
if (!ModulesCache.ContainsKey(ModuleKey))
{
ModulesCache[ModuleKey] = new PeDependencyItem(this, ModuleName, ModuleFilepath, SearchStrategy, RecursionLevel);
}
return(ModulesCache[ModuleKey]);
}
public bool VisitModule(string ModuleName, string ModuleFilepath)
{
ModuleCacheKey ModuleKey = new ModuleCacheKey(ModuleName, ModuleFilepath);
// do not visit recursively the same node (in order to prevent stack overflow)
if (ModulesVisited.ContainsKey(ModuleKey))
{
return(false);
}
ModulesVisited[ModuleKey] = true;
return(true);
}
public PE LoadImport(string ModuleName, DisplayModuleInfo CurrentModule = null, bool DelayLoad = false)
{
if (CurrentModule == null)
{
CurrentModule = this._SelectedModule;
}
Tuple <ModuleSearchStrategy, PE> ResolvedModule = BinaryCache.ResolveModule(
this.Pe,
ModuleName,
this.SxsEntriesCache,
this.CustomSearchFolders,
this.WorkingDirectory
);
string ModuleFilepath = (ResolvedModule.Item2 != null) ? ResolvedModule.Item2.Filepath : null;
ModuleCacheKey ModuleKey = new ModuleCacheKey(ModuleName, ModuleFilepath);
if ((ModuleFilepath != null) && !this.ProcessedModulesCache.ContainsKey(ModuleKey))
{
ModuleFlag DelayLoadFlag = (DelayLoad) ? ModuleFlag.DelayLoad : 0;
if (ResolvedModule.Item1 == ModuleSearchStrategy.ApiSetSchema)
{
var ApiSetContractModule = new DisplayModuleInfo(
BinaryCache.LookupApiSetLibrary(ModuleName),
ResolvedModule.Item2,
ResolvedModule.Item1,
DelayLoadFlag & ModuleFlag.ApiSet
);
var NewModule = new ApiSetModuleInfo(ModuleName, ref ApiSetContractModule);
this.ProcessedModulesCache[ModuleKey] = NewModule;
}
else
{
var NewModule = new DisplayModuleInfo(
ModuleName,
ResolvedModule.Item2,
ResolvedModule.Item1,
DelayLoadFlag
);
this.ProcessedModulesCache[ModuleKey] = NewModule;
}
// add it to the module list
this.ModulesList.AddModule(this.ProcessedModulesCache[ModuleKey]);
}
return(ResolvedModule.Item2);
}
private void ConstructDependencyTree(ModuleTreeViewItem RootNode, PE CurrentPE, int RecursionLevel = 0)
{
// "Closured" variables (it 's a scope hack really).
Dictionary <string, ImportContext> NewTreeContexts = new Dictionary <string, ImportContext>();
BackgroundWorker bw = new BackgroundWorker();
bw.WorkerReportsProgress = true; // useless here for now
bw.DoWork += (sender, e) => {
ProcessPe(NewTreeContexts, CurrentPE);
};
bw.RunWorkerCompleted += (sender, e) =>
{
TreeBuildingBehaviour.DependencyTreeBehaviour SettingTreeBehaviour = Dependencies.TreeBuildingBehaviour.GetGlobalBehaviour();
List <ModuleTreeViewItem> PeWithDummyEntries = new List <ModuleTreeViewItem>();
List <BacklogImport> PEProcessingBacklog = new List <BacklogImport>();
// Important !
//
// This handler is executed in the STA (Single Thread Application)
// which is authorized to manipulate UI elements. The BackgroundWorker is not.
//
foreach (ImportContext NewTreeContext in NewTreeContexts.Values)
{
ModuleTreeViewItem childTreeNode = new ModuleTreeViewItem();
DependencyNodeContext childTreeNodeContext = new DependencyNodeContext();
childTreeNodeContext.IsDummy = false;
string ModuleName = NewTreeContext.ModuleName;
string ModuleFilePath = NewTreeContext.PeFilePath;
ModuleCacheKey ModuleKey = new ModuleCacheKey(ModuleName, ModuleFilePath);
// Newly seen modules
if (!this.ProcessedModulesCache.ContainsKey(ModuleKey))
{
// Missing module "found"
if ((NewTreeContext.PeFilePath == null) || !NativeFile.Exists(NewTreeContext.PeFilePath))
{
this.ProcessedModulesCache[ModuleKey] = new NotFoundModuleInfo(ModuleName);
}
else
{
if (NewTreeContext.IsApiSet)
{
var ApiSetContractModule = new DisplayModuleInfo(NewTreeContext.ApiSetModuleName, NewTreeContext.PeProperties, NewTreeContext.ModuleLocation, NewTreeContext.Flags);
var NewModule = new ApiSetModuleInfo(NewTreeContext.ModuleName, ref ApiSetContractModule);
this.ProcessedModulesCache[ModuleKey] = NewModule;
if (SettingTreeBehaviour == TreeBuildingBehaviour.DependencyTreeBehaviour.Recursive)
{
PEProcessingBacklog.Add(new BacklogImport(childTreeNode, ApiSetContractModule.ModuleName));
}
}
else
{
var NewModule = new DisplayModuleInfo(NewTreeContext.ModuleName, NewTreeContext.PeProperties, NewTreeContext.ModuleLocation, NewTreeContext.Flags);
this.ProcessedModulesCache[ModuleKey] = NewModule;
switch (SettingTreeBehaviour)
{
case TreeBuildingBehaviour.DependencyTreeBehaviour.RecursiveOnlyOnDirectImports:
if ((NewTreeContext.Flags & ModuleFlag.DelayLoad) == 0)
{
PEProcessingBacklog.Add(new BacklogImport(childTreeNode, NewModule.ModuleName));
}
break;
case TreeBuildingBehaviour.DependencyTreeBehaviour.Recursive:
PEProcessingBacklog.Add(new BacklogImport(childTreeNode, NewModule.ModuleName));
break;
}
}
}
// add it to the module list
this.ModulesList.AddModule(this.ProcessedModulesCache[ModuleKey]);
}
// Since we uniquely process PE, for thoses who have already been "seen",
// we set a dummy entry in order to set the "[+]" icon next to the node.
// The dll dependencies are actually resolved on user double-click action
// We can't do the resolution in the same time as the tree construction since
// it's asynchronous (we would have to wait for all the background to finish and
// use another Async worker to resolve).
if ((NewTreeContext.PeProperties != null) && (NewTreeContext.PeProperties.GetImports().Count > 0))
{
ModuleTreeViewItem DummyEntry = new ModuleTreeViewItem();
DependencyNodeContext DummyContext = new DependencyNodeContext()
{
ModuleInfo = new WeakReference(new NotFoundModuleInfo("Dummy")),
IsDummy = true
};
DummyEntry.DataContext = DummyContext;
DummyEntry.Header = "@Dummy : if you see this header, it's a bug.";
DummyEntry.IsExpanded = false;
childTreeNode.Items.Add(DummyEntry);
childTreeNode.Expanded += ResolveDummyEntries;
}
// Add to tree view
childTreeNodeContext.ModuleInfo = new WeakReference(this.ProcessedModulesCache[ModuleKey]);
childTreeNode.DataContext = childTreeNodeContext;
childTreeNode.Header = childTreeNode.GetTreeNodeHeaderName(Dependencies.Properties.Settings.Default.FullPath);
RootNode.Items.Add(childTreeNode);
}
// Process next batch of dll imports
if (SettingTreeBehaviour != TreeBuildingBehaviour.DependencyTreeBehaviour.ChildOnly)
{
foreach (var ImportNode in PEProcessingBacklog)
{
ConstructDependencyTree(ImportNode.Item1, ImportNode.Item2, RecursionLevel + 1); // warning : recursive call
}
}
};
bw.RunWorkerAsync();
}