public CoreClrAnalyzerAssemblyLoader() { _loadContext = AssemblyLoadContext.GetLoadContext(typeof(CoreClrAnalyzerAssemblyLoader).GetTypeInfo().Assembly); _loadContext.Resolving += (context, name) => { Debug.Assert(ReferenceEquals(context, _loadContext)); return Load(name.FullName); }; }
public LoadContextWrapper(AssemblyLoadContext assemblyLoadContext) { _assemblyLoadContext = assemblyLoadContext; var typeInfo = _assemblyLoadContext.GetType().GetTypeInfo(); var loaderFileMethod = typeInfo.GetDeclaredMethod("LoadFile"); var loadStreamMethod = typeInfo.GetDeclaredMethod("LoadStream"); _loadFile = (Func<string, Assembly>)loaderFileMethod.CreateDelegate(typeof(Func<string, Assembly>), _assemblyLoadContext); _loadStream = (Func<Stream, Stream, Assembly>)loadStreamMethod.CreateDelegate(typeof(Func<Stream, Stream, Assembly>), _assemblyLoadContext); }
public static void LoadLazyAssemblyInALC(string asm_base64, string pdb_base64) { var context = new System.Runtime.Loader.AssemblyLoadContext("testContext", true); byte[] asm_bytes = Convert.FromBase64String(asm_base64); byte[] pdb_bytes = null; if (pdb_base64 != null) { pdb_bytes = Convert.FromBase64String(pdb_base64); } loadedAssembly = context.LoadFromStream(new System.IO.MemoryStream(asm_bytes), new System.IO.MemoryStream(pdb_bytes)); Console.WriteLine($"Loaded - {loadedAssembly}"); }
// This will be used to set the AssemblyLoadContext for DefaultContext, for the AppDomain, // by a host. Once set, the runtime will invoke the LoadFromAssemblyName method against it to perform // assembly loads for the DefaultContext. // // This method will throw if the Default AssemblyLoadContext is already set or the Binding model is already locked. public static void InitializeDefaultContext(AssemblyLoadContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Try to override the default assembly load context if (!AssemblyLoadContext.OverrideDefaultAssemblyLoadContextForCurrentDomain(context.m_pNativeAssemblyLoadContext)) { throw new InvalidOperationException(Environment.GetResourceString("AppDomain_BindingModelIsLocked")); } // Update the managed side as well. s_DefaultAssemblyLoadContext = context; }
private static void Assembly_Unloading(Runtime.Loader.AssemblyLoadContext obj) { }
public HomeController(AssemblyLoadContext accessor) { _accessor = accessor; }
private Assembly Load(AssemblyLoadContext loadContext, AssemblyName assemblyName) { lock (_guard) { // Try and grab assembly using standard load Assembly assembly = AppContextLoad(assemblyName); if (assembly != null) { return assembly; } string fullName = assemblyName.FullName; if (_namesToAssemblies.TryGetValue(fullName, out assembly)) { return assembly; } AssemblyIdentity requestedIdentity; if (!AssemblyIdentity.TryParseDisplayName(fullName, out requestedIdentity)) { return null; } foreach (var candidatePath in _dependencyPaths) { if (IsAssemblyAlreadyLoaded(candidatePath) || !FileMatchesAssemblyName(candidatePath, requestedIdentity.Name)) { continue; } var candidateIdentity = TryGetAssemblyIdentity(candidatePath); if (requestedIdentity.Equals(candidateIdentity)) { return LoadAndCache(candidatePath); } } return null; } }
/// <summary> /// The handler for the Resolving event /// </summary> private Assembly Resolve(AssemblyLoadContext loadContext, AssemblyName assemblyName) { // Probe the assembly cache Assembly asmLoaded; if (TryGetAssemblyFromCache(assemblyName, out asmLoaded)) return asmLoaded; // Prepare to load the assembly lock (s_syncObj) { // Probe the cache again in case it's already loaded if (TryGetAssemblyFromCache(assemblyName, out asmLoaded)) return asmLoaded; // Search the specified assembly in probing paths, and load it through 'LoadFromAssemblyPath' if the file exists and matches the requested AssemblyName. // If the CultureName of the requested assembly is not NullOrEmpty, then it's a resources.dll and we need to search corresponding culture sub-folder. bool isAssemblyFileFound = false, isAssemblyFileMatching = false; string asmCultureName = assemblyName.CultureName ?? string.Empty; string asmFilePath = null; for (int i = 0; i < _probingPaths.Count; i++) { string probingPath = _probingPaths[i]; string asmCulturePath = Path.Combine(probingPath, asmCultureName); for (int k = 0; k < _extensions.Length; k++) { string asmFileName = assemblyName.Name + _extensions[k]; asmFilePath = Path.Combine(asmCulturePath, asmFileName); if (File.Exists(asmFilePath)) { isAssemblyFileFound = true; AssemblyName asmNameFound = GetAssemblyName(asmFilePath); if (IsAssemblyMatching(assemblyName, asmNameFound)) { isAssemblyFileMatching = true; break; } } } if (isAssemblyFileFound && isAssemblyFileMatching) { break; } } // We failed to find the assembly file; or we found the file, but the assembly file doesn't match the request. // In this case, return null so that other Resolving event handlers can kick in to resolve the request. if (!isAssemblyFileFound || !isAssemblyFileMatching) { return null; } asmLoaded = asmFilePath.EndsWith(".ni.dll", StringComparison.OrdinalIgnoreCase) ? loadContext.LoadFromNativeImagePath(asmFilePath, null) : loadContext.LoadFromAssemblyPath(asmFilePath); if (asmLoaded != null) { // Add the loaded assembly to the cache s_assemblyCache.TryAdd(assemblyName.Name, asmLoaded); } } // Raise AssemblyLoad event OnAssemblyLoaded(asmLoaded); return asmLoaded; }
public AssemblyLoader() { Context = new CustomAssemblyLoadContext(); }
// This method is invoked by the VM when using the host-provided assembly load context // implementation. private static IntPtr ResolveUnmanagedDll(String unmanagedDllName, IntPtr gchManagedAssemblyLoadContext) { AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target); return(context.LoadUnmanagedDll(unmanagedDllName)); }
public AlekseyDelegateALC(System.Runtime.Loader.AssemblyLoadContext d) { Console.WriteLine("Created a1"); this.d = d; }
// This method is invoked by the VM when using the host-provided assembly load context // implementation. private static Assembly Resolve(IntPtr gchManagedAssemblyLoadContext, AssemblyName assemblyName) { AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target); return(context.ResolveUsingLoad(assemblyName)); }
// This method is invoked by the VM to resolve a native library using the ResolvingUnmanagedDll event // after trying all other means of resolution. private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchManagedAssemblyLoadContext) { AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target) !; return(context.GetResolvedUnmanagedDll(assembly, unmanagedDllName)); }
private static void MonoResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchManagedAssemblyLoadContext, ref IntPtr dll) { AssemblyLoadContext context = GetAssemblyLoadContext(gchManagedAssemblyLoadContext); dll = context.GetResolvedUnmanagedDll(assembly, unmanagedDllName); }
private static void MonoResolveUnmanagedDll(string unmanagedDllName, IntPtr gchManagedAssemblyLoadContext, ref IntPtr dll) { AssemblyLoadContext context = GetAssemblyLoadContext(gchManagedAssemblyLoadContext); dll = context.LoadUnmanagedDll(unmanagedDllName); }
// Invoked by Mono to resolve requests to load satellite assemblies. private static Assembly?MonoResolveUsingResolveSatelliteAssembly(IntPtr gchALC, string assemblyName) { AssemblyLoadContext context = GetAssemblyLoadContext(gchALC); return(context.ResolveSatelliteAssembly(new AssemblyName(assemblyName))); }