public IEnumerable <RootAssembly> FindRootAssemblies()
{
var rootAssemblies = from specification in _specifications
let assembly = _assemblyLoader.TryLoadAssembly(specification.AssemblyName, specification.ToString())
where assembly != null
select new RootAssembly(assembly, specification.FollowReferences);
return(rootAssemblies.Distinct());
}
/// <summary>
/// Runs the specified setup information.
/// </summary>
/// <param name="setupInfo">The setup information.</param>
/// <returns></returns>
public object Run(PluginInvokeArgs setupInfo)
{
_assemblyLocation = setupInfo.AssemblyLocation;
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
if (!_assemblyLoader.TryLoadAssembly(setupInfo.AssemblyLocation, setupInfo.AssemblyName, out Assembly loadedAssembly))
{
return(null);
}
var methodToRun = TryExecutePlugin(setupInfo, loadedAssembly, out object pluginResult);
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
var formater = setupInfo.OutputFormatter;
if (formater != null)
{
pluginResult = AdjustPluginResult(pluginResult, methodToRun);
return(formater.Format(pluginResult).ToString());
}
pluginResult = JsonConvert.SerializeObject(pluginResult);
return(pluginResult);
}
private ICollection <Assembly> FindReferencedAssemblies(ICollection <RootAssembly> rootAssemblies)
{
s_log.Value.Debug("Finding referenced assemblies...");
using (StopwatchScope.CreateScope(s_log.Value, LogLevel.Debug, "Time spent for finding and loading referenced assemblies: {elapsed}."))
{
// referenced assemblies are added later in order to get their references as well
var referenceRoots = new ConcurrentQueue <Assembly> (
rootAssemblies.Where(r => r.FollowReferences).Select(r => r.Assembly).Distinct());
// used to prevent analyzing an assembly twice
// and to prevent analysis of root-assemblies marked as do-not-follow references
var processedAssemblies = new ConcurrentDictionary <Assembly, object> (
rootAssemblies.Select(r => r.Assembly).Distinct().Select(a => new KeyValuePair <Assembly, object> (a, null)));
// used to avoid loading assemblies twice.
var processedAssemblyNames = new HashSet <string> (processedAssemblies.Keys.Select(a => a.FullName));
var result = new ConcurrentBag <Assembly>();
Assembly currentRoot;
while (referenceRoots.TryDequeue(out currentRoot)) // Sequential loop because of 'processedAssemblyNames'-HashSet
{
var nonprocessedAssemblyNames = currentRoot.GetReferencedAssemblies().Where(a => !processedAssemblyNames.Contains(a.FullName)).ToList();
processedAssemblyNames.UnionWith(nonprocessedAssemblyNames.Select(a => a.FullName));
// Parallel starts here
foreach (var referencedAssemblyName in nonprocessedAssemblyNames.AsParallel())
{
var referencedAssembly = _assemblyLoader.TryLoadAssembly(referencedAssemblyName, currentRoot.FullName);
if (referencedAssembly != null) // might return null if filtered by the loader
{
if (processedAssemblies.TryAdd(referencedAssembly, null))
{
// store as a root in order to process references transitively
referenceRoots.Enqueue(referencedAssembly);
result.Add(referencedAssembly);
}
}
}
// Parallel ends here
}
return(result
.LogAndReturnItems(s_log.Value, LogLevel.Debug, count => string.Format("Found {0} referenced assemblies.", count))
.ToList());
}
}
public IEnumerable <RootAssembly> FindRootAssemblies()
{
s_log.Value.DebugFormat("Finding root assemblies based on specifications...");
var fileDescriptions = ConsolidateSpecifications();
using (StopwatchScope.CreateScope(
s_log.Value,
LogLevel.Debug,
"Loaded root assemblies based on specifications. Time taken: {elapsed}"))
{
var rootAssemblies =
from fileDescription in fileDescriptions.AsParallel()
let assembly = _assemblyLoader.TryLoadAssembly(fileDescription.FilePath)
where assembly != null
select new RootAssembly(assembly, fileDescription.FollowReferences);
return(rootAssemblies.ToList());
}
}
