public IAssembly TryLoad(string dll, string pdb, string version = null)
{
if (string.IsNullOrWhiteSpace(dll))
{
throw new ArgumentException(nameof(dll));
}
if (string.IsNullOrWhiteSpace(pdb))
{
throw new ArgumentException(nameof(pdb));
}
// Find version if it wasn't provided
if (string.IsNullOrWhiteSpace(version))
{
var assemblyName = _AssemblyNameReader.GetAssemblyName(dll);
if (assemblyName != null)
{
version = assemblyName.Version.ToString();
}
}
// Used cached assembly if it is already loaded and cached
IAssembly assembly = _AssemblyCache.FindAlreadyLoadedAssembly(dll, version);
if (assembly != null)
{
return(assembly);
}
// Load the assembly
assembly = _AppDomain.TryLoad(dll, pdb);
if (assembly == null)
{
return(null);
}
var assemblyVersion = assembly.GetName()?.Version?.ToString();
// Cache the loaded assembly (even if it is the wrong version)
// Also, for threadsafety, get the cached assembly back, in case two threads loaded at the same time
assembly = _AssemblyCache.Add(dll, assemblyVersion, assembly);
// Make sure the version matches the requested version
if (assemblyVersion != version)
{
return(null);
}
// If configured to do so, load all dependent assemblies immediately,
if (_Settings.LoadDependenciesProactively)
{
var dir = Path.GetDirectoryName(dll);
if (!dir.EndsWith("bin"))
{
ProactivelyLoadDependencies(Path.Combine(dir, "bin"));
}
}
return(assembly);
}
/// <summary>
/// Gets all referenced assemblies.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <param name="pattern">The pattern.</param>
/// <param name="excludePattern">The exclude pattern.</param>
/// <param name="marked">The marked.</param>
/// <param name="assemblies">The assemblies.</param>
/// <returns></returns>
// ReSharper disable once ExcessiveIndentation
private static IAssembly[] GetAllReferencedAssemblies(IAssembly assembly, string pattern, string excludePattern,
HashSet <string> marked, Dictionary <string, IAssembly> assemblies)
{
var name = assembly.GetName().Name;
marked.Add(name);
if (!assembly.IsFrameworkAssembly())
{
if (CheckPattern(assembly, pattern, excludePattern))
{
if (!assemblies.ContainsKey(name))
{
assemblies.Add(name, assembly);
}
}
foreach (var assemblyName in assembly.GetReferencedAssemblies())
{
if (assemblyName.FullName.Contains(pattern))
{
if (!assemblyName.FullName.Contains("Unit"))
{
if (!marked.Contains(assemblyName.Name))
{
var referenced = Assembly.Load(assemblyName).Adapt();
GetAllReferencedAssemblies(referenced, pattern, excludePattern, marked, assemblies);
}
}
}
}
}
return(assemblies.Values.ToArray());
}
/// <summary>
/// Gets the public key token of an assembly.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <returns></returns>
/// <remarks>Borrowed heavily from http://dhvik.blogspot.com/2009/05/assemblynamegetpublickeytoken-tostring.html </remarks>
public static string get_public_key_token(this IAssembly assembly)
{
if (assembly == null)
{
return(string.Empty);
}
return(assembly.GetName().get_public_key_token());
}
public void GetAssemblyVersion_test()
{
IAssembly assemblyStub = Substitute.For <IAssembly>();
IAssemblySystem assemblySystemStub = Substitute.For <IAssemblySystem>();
IAssemblyName assemblyNameStub = Substitute.For <IAssemblyName>();
assemblySystemStub.GetExecutingAssembly().Returns(assemblyStub);
assemblyStub.GetName().Returns(assemblyNameStub);
assemblyNameStub.Version = new Version(1, 2, 3, 4);
Assert.AreEqual("1.2.3.4", new AssemblySample(assemblyStub, assemblySystemStub).GetAssemblyVersion());
}
/// <summary>
/// Gets the public key token of an assembly.
/// </summary>
/// <param name="assembly">The assembly.</param>
/// <returns></returns>
/// <remarks>Borrowed heavily from http://dhvik.blogspot.com/2009/05/assemblynamegetpublickeytoken-tostring.html </remarks>
public static string get_public_key_token(this IAssembly assembly)
{
if (assembly == null)
{
return(string.Empty);
}
byte[] publicKeyToken = assembly.GetName().GetPublicKeyToken();
if (publicKeyToken == null || publicKeyToken.Length == 0)
{
return(string.Empty);
}
return(publicKeyToken.Select(x => x.ToString("x2")).Aggregate((x, y) => x + y));
}
public List <Dependency> AnalyseAssembly(IAssembly currentAssembly, string outputPath)
{
var assemblyName = currentAssembly.GetName();
if (!IsAlreadyAnalysed(assemblyName))
{
foreach (AssemblyName referencedName in currentAssembly.GetReferencedAssemblies())
{
var assemblyInLib = _assemblyLoader.LoadAssembly(Path.Combine(outputPath, referencedName.Name + ".dll"));
if (assemblyInLib != null)
{
AssemblyName assemblyInLibName = assemblyInLib.GetName();
AddToDependencyList(assemblyName, referencedName, assemblyInLibName);
AnalyseAssembly(assemblyInLib, outputPath);
}
}
}
return(_dependencies);
}
public IAssembly Add(string dll, string assemblyVersion, IAssembly assembly)
{
if (string.IsNullOrWhiteSpace(dll))
{
throw new ArgumentException(nameof(dll));
}
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
if (string.IsNullOrWhiteSpace(assemblyVersion))
{
assemblyVersion = assembly.GetName().Version?.ToString();
}
var key = GetKey(dll, assemblyVersion);
Assemblies.TryAdd(key, assembly); // Since it is a ConcurrentDictionary another assembly could already be added by another thread.
Assemblies.TryGetValue(key, out assembly); // Get the loaded assembly in case a different thread loaded one.
return(assembly);
}
public string GetAssemblyVersion()
{
_assembly = _assemblySystem.GetExecutingAssembly();
return _assembly.GetName().Version.ToString();
}
private void FindReferencesOf(IAssembly assembly)
{
foreach (AssemblyName referenceName in assembly.GetReferencedAssemblies()) {
Analyse(assembly.GetName(), referenceName);
}
}
public string GetAssemblyVersion()
{
_assembly = _assemblySystem.GetExecutingAssembly();
return(_assembly.GetName().Version.ToString());
}
