// Loads the Assembly with the specified name at the specified optional location.
//
// assemblyName is either short name or full name.
// assemblyPath is either full file path or null.
//
private static Assembly LoadAssemblyHelper(string assemblyGivenName, string assemblyPath)
{
AssemblyName assemblyName = new AssemblyName(assemblyGivenName);
string assemblyShortName = assemblyName.Name;
assemblyShortName = assemblyShortName.ToUpper(CultureInfo.InvariantCulture);
// Check if the assembly has already been loaded.
Assembly retassem = (Assembly)_loadedAssembliesHash[assemblyShortName];
if (retassem != null)
{
if (assemblyName.Version != null)
{
AssemblyName cachedName = new AssemblyName(retassem.FullName);
if (!AssemblyName.ReferenceMatchesDefinition(assemblyName, cachedName))
{
string request = assemblyName.ToString();
string found = cachedName.ToString();
throw new InvalidOperationException(SR.Get(SRID.ParserAssemblyLoadVersionMismatch, request, found));
}
}
}
else
{
// Check if the current AppDomain has this assembly loaded for some other reason.
// If so, then just use that assembly and don't attempt to load another copy of it.
// Only do this if no path is provided.
if (String.IsNullOrEmpty(assemblyPath))
{
retassem = SafeSecurityHelper.GetLoadedAssembly(assemblyName);
}
if (retassem == null)
{
if (!String.IsNullOrEmpty(assemblyPath))
{
// assemblyPath is set, Load the assembly from this specified place.
// the path must be full file path which contains directory, file name and extension.
Debug.Assert(!assemblyPath.EndsWith("\\", StringComparison.Ordinal), "the assembly path should be a full file path containing file extension");
// LoadFile will only override your request only if it is in the GAC
retassem = Assembly.LoadFile(assemblyPath);
}
//
// At compile time, the build task should always pass the full path of the referenced assembly, even if it
// comes from GAC. But below code snippet can run if parser wants to try loading an assembly w/o a path.
// This also makes run-time assembly load consistent with compile-time semantics.
else
{
try
{
retassem = Assembly.Load(assemblyGivenName);
}
catch (System.IO.FileNotFoundException)
{
// This may be a locally defined assembly that has not been created yet.
// To support these cases, just set a null assembly and return. This
// will fail downstream if it really was an assembly miss.
retassem = null;
}
}
}
// Cache the assembly
if (retassem != null)
{
_loadedAssembliesHash[assemblyShortName] = retassem;
}
}
return(retassem);
}
private static void PreLoad()
{
var files = new List <string>();
var p = AppDomain.CurrentDomain.BaseDirectory;
//files.AddRange(Directory.GetFiles(p, "db2app64.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "IBM.Data.DB2.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "MySql.Data.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "Npgsql.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "Mono.Security.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "System.Data.SQLite.dll", SearchOption.TopDirectoryOnly).ToList());
files.AddRange(Directory.GetFiles(p, "Oracle.ManagedDataAccess.dll", SearchOption.TopDirectoryOnly).ToList());
foreach (var s in files)
{
AssemblyName a = null;
try
{
a = AssemblyName.GetAssemblyName(s);
}
catch
{
string info = string.Format("AppDomain can't load file {0}", s);
LogHelper.LogWarning(info);
continue;
}
if (!AppDomain.CurrentDomain.GetAssemblies().Any(
assembly
=>
AssemblyName.ReferenceMatchesDefinition(assembly.GetName(), a))
)
{
try
{
Assembly assembly;
if (Path.GetFileName(s) == "System.Data.SQLite.dll")
{
assembly = Assembly.UnsafeLoadFrom(s);
}
else
{
assembly = Assembly.LoadFrom(s);
}
var assemblyName = assembly.FullName.Split(',')[0];
if (assemblyName == "System.Data.SQLite")
{
Drivers.Add(DataBaseNames.Sqlite, assembly);
}
else if (assemblyName == "Npgsql")
{
Drivers.Add(DataBaseNames.PostgreSql, assembly);
}
else if (assemblyName == "MySql.Data")
{
Drivers.Add(DataBaseNames.MySql, assembly);
}
else if (assemblyName == "IBM.Data.DB2")
{
Drivers.Add(DataBaseNames.Db2, assembly);
}
else if (assemblyName == "Oracle.ManagedDataAccess")
{
Drivers.Add(DataBaseNames.Oracle, assembly);
}
}
catch
{
string info = string.Format("AppDomain can't load file {0}", s);
LogHelper.LogWarning(info);
}
}
}
}
public override ICollection <Assembly> GetAssemblies()
{
List <string> assemblyNames = new List <string>()
{
"FSTWebApi.dll"
};
if (null != assemblyNames)
{
foreach (var item in assemblyNames)
{
AssemblyName assemblyName = AssemblyName.GetAssemblyName(item);
if (!AppDomain.CurrentDomain.GetAssemblies().Any <Assembly>(assembly => AssemblyName.ReferenceMatchesDefinition(assembly.GetName(), assemblyName)))
{
AppDomain.CurrentDomain.Load(assemblyName);
}
}
}
return(base.GetAssemblies());
}
// Token: 0x060008FC RID: 2300 RVA: 0x00040D1C File Offset: 0x0003EF1C
private void ProcessAssembly(string fileName)
{
PluginsFactory <T> .log.DebugFormat("Loading plugins from {0}", fileName);
AssemblyName assemblyName = AssemblyName.GetAssemblyName(fileName);
Assembly assembly = null;
foreach (Assembly assembly2 in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies())
{
if (AssemblyName.ReferenceMatchesDefinition(assembly2.GetName(), assemblyName))
{
assembly = assembly2;
try
{
string fullPath = Path.GetFullPath(new Uri(assembly.CodeBase).LocalPath);
if (!StringComparer.OrdinalIgnoreCase.Equals(fileName, fullPath))
{
PluginsFactory <T> .log.WarnFormat("inspecting [{0}] at '{1}' as [{2}] at '{3}'", new object[]
{
assemblyName,
fileName,
assembly,
fullPath
});
}
break;
}
catch (Exception ex)
{
PluginsFactory <T> .log.WarnFormat("inspecting [{0}] at '{1}' as [{2}]. {3}", new object[]
{
assemblyName,
fileName,
assembly,
ex
});
break;
}
}
}
if (assembly == null)
{
assembly = Assembly.ReflectionOnlyLoadFrom(fileName);
}
List <Type> list = PluginsFactory <T> .FindDerivedTypes <T>(assembly);
if (list.Count != 0)
{
list = PluginsFactory <T> .FindDerivedTypes <T>(Assembly.LoadFrom(fileName));
}
foreach (Type type in list)
{
PluginsFactory <T> .log.DebugFormat("Creating plugin for {0}", type);
T t = (T)((object)Activator.CreateInstance(type));
this.Plugins.Add(t);
string text = string.Empty;
PropertyInfo property = t.GetType().GetProperty("FlagName");
if (property != null)
{
text = (string)property.GetValue(t, null);
}
if (PluginsFactory <T> .log.IsInfoEnabled)
{
PluginsFactory <T> .log.InfoFormat("Loaded plugin {0} for {1} from {2}", type, text, fileName);
}
}
}
/// <summary>
/// Return a list of all referenced assemblies
/// </summary>
/// <param name="entry"></param>
/// <param name="set"></param>
/// <returns></returns>
private static HashSet <Assembly> GetUniqueNestedReferencedAssemblies(Assembly entry, AssemblyName executing, HashSet <Assembly> set = null)
{
if (set == null)
{
set = new HashSet <Assembly>();
}
if (set.Add(entry))
{
foreach (Assembly child in entry.GetReferencedAssemblies().Where(an => AssemblyName.ReferenceMatchesDefinition(an, executing) || Assembly.Load(an).GetReferencedAssemblies().Any(nan => AssemblyName.ReferenceMatchesDefinition(nan, executing))).Select(an => Assembly.Load(an)))
{
AssemblyHelper.GetUniqueNestedReferencedAssemblies(child, executing, set);
}
}
return(set);
}
public static void ReferenceMatchesDefinition(AssemblyName a1, AssemblyName a2, bool expected)
{
Assert.Equal(expected, AssemblyName.ReferenceMatchesDefinition(a1, a2));
}
private static void PreLoadAssemblies()
{
var entry = Assembly.GetEntryAssembly();
var referencedAssemblies = entry.GetReferencedAssemblies();
var microAssembly = typeof(MicroServiceCollectionExtension).Assembly;
var microAssemblyName = microAssembly.GetName();
var loadedAssemblyNames = _allAssemblies.Select(a => a.GetName());
var assemblyFiles = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.dll", SearchOption.AllDirectories);
var assemblyFilesAndNames = new List <dynamic>();
foreach (var file in assemblyFiles)
{
try
{
var name = AssemblyName.GetAssemblyName(file);
var p = file;
assemblyFilesAndNames.Add(new { Name = name, Path = p });
}
catch
{
}
}
var assembliesToLoad = assemblyFilesAndNames.Where(f => !loadedAssemblyNames.Any(lf => AssemblyName.ReferenceMatchesDefinition(lf, f.Name))).ToList();
foreach (var assembly in assembliesToLoad)
{
try
{
Assembly.LoadFrom(assembly.Path);
}
catch
{
}
}
}
private bool StrictReferenceMatchesDefinition(AssemblyName reference, AssemblyName definition)
{
return(AssemblyName.ReferenceMatchesDefinition(reference, definition) &&
reference.Version.Equals(definition.Version) &&
Enumerable.SequenceEqual(reference.GetPublicKeyToken(), definition.GetPublicKeyToken()));
}
static Assemblies()
{
List <Assembly> all = new List <Assembly>();
foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies())
{
//这里只加载了当前运行所需要的程序集，未必是全部。
AddAssembly(all, a);
}
if (HttpContext.Current != null)
{
foreach (Assembly a in BuildManager.GetReferencedAssemblies())
{
if (!all.Any(loaded =>
AssemblyName.ReferenceMatchesDefinition(loaded.GetName(), a.GetName())))
{
AddAssembly(all, a);
}
}
string binDir = HttpRuntime.BinDirectory;
if (!string.IsNullOrEmpty(binDir))
{
string[] files = Directory.GetFiles(binDir, "*.dll", SearchOption.TopDirectoryOnly);
foreach (string file in files)
{
if (file.StartsWith("WebApi", StringComparison.OrdinalIgnoreCase))
{
AssemblyName name = AssemblyName.GetAssemblyName(file);
Assembly a = Assembly.Load(name);
if (!all.Any(loaded =>
AssemblyName.ReferenceMatchesDefinition(loaded.GetName(), name)))
{
AddAssembly(all, a);
}
}
}
}
}
else
{
//为了单元测试
var dir = AppDomain.CurrentDomain.BaseDirectory;
if (!string.IsNullOrEmpty(dir))
{
var dirInfo = new DirectoryInfo(dir);
var files = dirInfo.GetFiles("*.dll", SearchOption.TopDirectoryOnly);
foreach (var file in files)
{
if (file.Name.StartsWith("WebApi", StringComparison.OrdinalIgnoreCase))
{
AssemblyName name = AssemblyName.GetAssemblyName(file.Name);
Assembly a = Assembly.Load(name);
if (!all.Any(loaded =>
AssemblyName.ReferenceMatchesDefinition(loaded.GetName(), name)))
{
AddAssembly(all, a);
}
}
}
}
}
_all = new ReadOnlyCollection <Assembly>(all);
}
/// <inheritdoc />
protected override Assembly?Load(AssemblyName assemblyName)
{
Assembly?a = null;
// if the assembly is in SharedAssembies then we use that assembly first
a = ALCContext.SharedAssemblies
.Where(x => AssemblyName.ReferenceMatchesDefinition(x.GetName(), assemblyName))
.FirstOrDefault();
if (a != null)
{
return(a);
}
// if the assembly is in dependented plugins
// then we use the assembly in the assembly in dependented plugin
// ========= [mark] =============================
// should we only use the plugin's entryAssemlby?
// or we add [ExportedAssemlby] in PluginInfo
// or we use some attribute like [ExportAttribute] to detect all it's dependented assembly
// ===============================================
foreach (var alc in ALCContext.Plugins)
{
a = alc.Value.LoadFromAssemblyName(assemblyName);
if (a != null)
{
return(a);
}
}
// load the dependency from our only
var path = Resolver?.ResolveAssemblyToPath(assemblyName);
if (path != null)
{
return(LoadFromAssemblyPath(path));
}
// fallback to local folder first
System.Diagnostics.Debug.WriteLine(assemblyName);
var file = PluginInfo.PluginFolder + assemblyName.Name + ".dll";
if (File.Exists(file))
{
return(LoadFromAssemblyPath(file));
}
// fallback to Host AssemlbyLoadContext
a = ALCContext.HostLoadContext.LoadFromAssemblyName(assemblyName);
if (a != null)
{
return(a);
}
// fallback to AssemblyLoadContext.Default
return(base.Load(assemblyName));
}
Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
var name = new AssemblyName(args.Name);
return(AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => AssemblyName.ReferenceMatchesDefinition(name, a.GetName())));
}
private IEnumerable <Assembly> GetTestsAssemblies()
{
var assemblies = new List <Assembly>();
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var assembliesDirectoryInfo = new DirectoryInfo(path);
var assemblyFiles = assembliesDirectoryInfo.GetFiles("terminal*.dll",
SearchOption.TopDirectoryOnly).Select(f => f.FullName).ToList();
assemblyFiles.Add(Path.Combine(path, "HubTests.dll"));
foreach (var assemblyFile in assemblyFiles)
{
var assemblyName = AssemblyName.GetAssemblyName(assemblyFile);
if (!AppDomain.CurrentDomain.GetAssemblies().Any(a =>
AssemblyName.ReferenceMatchesDefinition(assemblyName, a.GetName())))
{
var assembly = Assembly.Load(assemblyName);
assemblies.Add(assembly);
}
else
{
var assembly = AppDomain.CurrentDomain.GetAssemblies().First(a => AssemblyName.ReferenceMatchesDefinition(assemblyName, a.GetName()));
assemblies.Add(assembly);
}
//Add HM assembly since here are defined the tasks which are run like tests (e.g. MetricMonitor)
assemblies.Add(Assembly.GetExecutingAssembly());
}
return(assemblies);
}
private bool IsAssemblyReferencedBy(Assembly referenced, Assembly origin)
{
return(origin.GetReferencedAssemblies()
.Where(assemblyName => AssemblyName.ReferenceMatchesDefinition(assemblyName, referenced.GetName()))
.Any());
}
private static AssemblyName ArgReferenceMatchesDefinition(Assembly referencedAssembly)
{
return(Arg <AssemblyName> .Matches(name => AssemblyName.ReferenceMatchesDefinition(name, referencedAssembly.GetName())));
}
private Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
AssemblyName assemblyName = new AssemblyName(args.Name);
AssemblyInfo assemblyInfo = this.registeredAssemblies.FirstOrDefault(a => AssemblyName.ReferenceMatchesDefinition(assemblyName, a.AssemblyName));
if (assemblyInfo != null)
{
if (assemblyInfo.Assembly == null)
{
assemblyInfo.Assembly = Assembly.LoadFrom(assemblyInfo.AssemblyUri.LocalPath);
}
return(assemblyInfo.Assembly);
}
return(null);
}
public Type Build(AssemblyBuilderHelper assemblyBuilder)
{
if (assemblyBuilder == null)
{
throw new ArgumentNullException("assemblyBuilder");
}
// Check InternalsVisibleToAttributes of the source type's assembly.
// Even if the sourceType is public, it may have internal fields and props.
//
_friendlyAssembly = false;
// Usually, there is no such attribute in the source assembly.
// Therefore we do not cache the result.
//
object[] attributes = _originalType.Type.Assembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), true);
foreach (InternalsVisibleToAttribute visibleToAttribute in attributes)
{
AssemblyName an = new AssemblyName(visibleToAttribute.AssemblyName);
if (AssemblyName.ReferenceMatchesDefinition(assemblyBuilder.AssemblyName, an))
{
_friendlyAssembly = true;
break;
}
}
if (!_originalType.Type.IsVisible && !_friendlyAssembly)
#if FW3
{ return(typeof(ExprTypeAccessor <,>).MakeGenericType(_type, _originalType)); }
#else
{ throw new TypeBuilderException(string.Format("Can not build type accessor for non-public type '{0}'.", _originalType.FullName)); }
#endif
string typeName = GetTypeName();
_typeBuilder = assemblyBuilder.DefineType(typeName, _accessorType);
_typeBuilder.DefaultConstructor.Emitter
.ldarg_0
.call(TypeHelper.GetDefaultConstructor(_accessorType))
;
BuildCreateInstanceMethods();
BuildTypeProperties();
BuildMembers();
BuildObjectFactory();
_typeBuilder.DefaultConstructor.Emitter
.ret()
;
Type result = _typeBuilder.Create();
foreach (TypeBuilderHelper tb in _nestedTypes)
{
tb.Create();
}
return(result);
}
private IEnumerable <Assembly> LoadSpeckleReferencingAssemblies(IEnumerable <Assembly> loadedAssemblies)
{
var assemblies = new HashSet <Assembly>();
var loadedSpeckleReferencingAssemblyNames = loadedAssemblies.Select(assembly => assembly.GetName()).ToArray();
var directories = Directory.GetDirectories(SpeckleKitsDirectory);
var currDomain = AppDomain.CurrentDomain;
foreach (var directory in directories)
{
foreach (var assemblyPath in System.IO.Directory.EnumerateFiles(directory, "*.dll"))
{
var unloadedAssemblyName = SafeGetAssemblyName(assemblyPath);
if (unloadedAssemblyName == null)
{
continue;
}
if (!loadedSpeckleReferencingAssemblyNames.Any(loadedSpeckleReferencingAssemblyName => AssemblyName.ReferenceMatchesDefinition(loadedSpeckleReferencingAssemblyName, unloadedAssemblyName)))
{
//var relfectionLoadAssembly = Assembly.ReflectionOnlyLoadFrom( assemblyPath );
var relfectionLoadAssembly = Assembly.LoadFrom(assemblyPath);
var isReferencingCore = relfectionLoadAssembly.IsReferencing(SpeckleAssemblyName);
if (isReferencingCore)
{
Debug.WriteLine("Load converter: " + unloadedAssemblyName);
var assembly = SafeLoadAssembly(AppDomain.CurrentDomain, unloadedAssemblyName);
if (assembly != null)
{
var res = assembly.GetTypes();
var copy = res;
assemblies.Add(assembly);
}
}
}
}
}
return(assemblies.ToArray());
}
// Token: 0x060008FB RID: 2299 RVA: 0x00040AF8 File Offset: 0x0003ECF8
private static Assembly CurrentDomain_ReflectionOnlyAssemblyResolve(object sender, ResolveEventArgs args)
{
AssemblyName assemblyName = new AssemblyName(args.Name);
Assembly requestingAssembly = args.RequestingAssembly;
List <Exception> list = new List <Exception>();
try
{
Assembly assembly = Assembly.ReflectionOnlyLoad(args.Name);
PluginsFactory <T> .ReportReflectionLoad(assemblyName, assembly, requestingAssembly);
return(assembly);
}
catch (Exception item)
{
list.Add(item);
}
foreach (Assembly assembly2 in AppDomain.CurrentDomain.ReflectionOnlyGetAssemblies())
{
if (AssemblyName.ReferenceMatchesDefinition(assembly2.GetName(), assemblyName))
{
PluginsFactory <T> .ReportReflectionLoad(assemblyName, assembly2, requestingAssembly);
return(assembly2);
}
}
if (requestingAssembly != null)
{
try
{
Uri uri = new Uri(requestingAssembly.CodeBase);
if (uri.IsAbsoluteUri)
{
string text = Path.Combine(Path.GetDirectoryName(uri.LocalPath) ?? string.Empty, assemblyName.Name + ".dll");
if (File.Exists(text))
{
AssemblyName assemblyName2 = AssemblyName.GetAssemblyName(text);
if (AssemblyName.ReferenceMatchesDefinition(assemblyName, assemblyName2))
{
Assembly assembly3 = Assembly.ReflectionOnlyLoadFrom(text);
PluginsFactory <T> .ReportReflectionLoad(assemblyName, assembly3, requestingAssembly);
return(assembly3);
}
}
}
}
catch (Exception item2)
{
list.Add(item2);
}
}
try
{
Assembly[] array = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < array.Length; i++)
{
AssemblyName name = array[i].GetName();
if (AssemblyName.ReferenceMatchesDefinition(name, assemblyName))
{
Uri uri2 = new Uri(name.CodeBase);
if (uri2.IsAbsoluteUri)
{
Assembly assembly4 = Assembly.ReflectionOnlyLoadFrom(uri2.LocalPath);
PluginsFactory <T> .ReportReflectionLoad(assemblyName, assembly4, requestingAssembly);
return(assembly4);
}
}
}
}
catch (Exception item3)
{
list.Add(item3);
}
if (!PluginsFactory <T> .log.IsErrorEnabled)
{
return(null);
}
AggregateException ex = new AggregateException(new StringBuilder("inspecting [").Append(args.Name).Append(']').Append(PluginsFactory <T> .FormatRequest(requestingAssembly)).Append('.').ToString(), list);
PluginsFactory <T> .log.WarnFormat("{0}", ex);
return(null);
}
private static void RegisterAssembly(Assembly assembly)
{
AssemblyName[] refAsm = new AssemblyName[0];
try {
refAsm = assembly.GetReferencedAssemblies();
} catch { }
if (NeedProcess(assembly) && (assembly == typeof(SPModel).Assembly || refAsm.Any(v => AssemblyName.ReferenceMatchesDefinition(v, SelfAssemblyName))))
{
bool requireLock = !enteredLock;
if (requireLock)
{
Monitor.Enter(syncLock);
enteredLock = true;
}
try {
RegisterAssemblyRecursive(assembly);
} finally {
if (requireLock)
{
enteredLock = false;
Monitor.Exit(syncLock);
}
}
}
}
public static Assembly[] GetAssemblies(Type?entryType = null)
{
var checkedAssemblies = new HashSet <Assembly>();
var entryAssembly = entryType?.Assembly ?? Assembly.GetEntryAssembly() !;
var entryAssemblyFirstPrefix = entryAssembly.GetName().Name !.Split(separator: ".").First();
var toCheck = new Queue <Assembly>(collection: new[] { entryAssembly });
while (toCheck.Count > 0)
{
var assembly = toCheck.Dequeue();
checkedAssemblies.Add(item: assembly);
var loaded = assembly.GetReferencedAssemblies()
.Where(predicate: x => x.Name?.StartsWith(value: entryAssemblyFirstPrefix) ?? false)
.Where(predicate: x => !checkedAssemblies.Any(predicate: chx => AssemblyName.ReferenceMatchesDefinition(reference: x, definition: chx.GetName())))
.Where(predicate: x => !toCheck.Any(predicate: chx => AssemblyName.ReferenceMatchesDefinition(reference: x, definition: chx.GetName())))
.Select(selector: Assembly.Load);
foreach (var loadedAssembly in loaded)
{
toCheck.Enqueue(item: loadedAssembly);
}
}
var allReferencedAssemblies = checkedAssemblies.ToArray();
if (allReferencedAssemblies.Length == 0)
{
throw new InvalidOperationException(message: "Entry Assembly not loaded properly");
}
return(allReferencedAssemblies);
}
