Exemple #1
0
        private Assembly?GetFirstResolvedAssemblyFromResolvingEvent(AssemblyName assemblyName)
        {
            Assembly?resolvedAssembly = null;

            Func <AssemblyLoadContext, AssemblyName, Assembly>?resolvingHandler = _resolving;

            if (resolvingHandler != null)
            {
                // Loop through the event subscribers and return the first non-null Assembly instance
                foreach (Func <AssemblyLoadContext, AssemblyName, Assembly> handler in resolvingHandler.GetInvocationList())
                {
                    resolvedAssembly = handler(this, assemblyName);
#if CORECLR
                    if (AssemblyLoadContext.IsTracingEnabled())
                    {
                        AssemblyLoadContext.TraceResolvingHandlerInvoked(
                            assemblyName.FullName,
                            handler.Method.Name,
                            this != AssemblyLoadContext.Default ? ToString() : Name,
                            resolvedAssembly?.FullName,
                            resolvedAssembly != null && !resolvedAssembly.IsDynamic ? resolvedAssembly.Location : null);
                    }
#endif // CORECLR
                    if (resolvedAssembly != null)
                    {
                        return(resolvedAssembly);
                    }
                }
            }

            return(null);
        }
Exemple #2
0
        private static RuntimeAssembly?InvokeResolveEvent(ResolveEventHandler?eventHandler, RuntimeAssembly assembly, string name)
        {
            if (eventHandler == null)
            {
                return(null);
            }

            var args = new ResolveEventArgs(name, assembly);

            foreach (ResolveEventHandler handler in eventHandler.GetInvocationList())
            {
                Assembly?asm = handler(AppDomain.CurrentDomain, args);
#if CORECLR
                if (eventHandler == AssemblyResolve && AssemblyLoadContext.IsTracingEnabled())
                {
                    AssemblyLoadContext.TraceAssemblyResolveHandlerInvoked(
                        name,
                        handler.Method.Name,
                        asm?.FullName,
                        asm != null && !asm.IsDynamic ? asm.Location : null);
                }
#endif // CORECLR
                RuntimeAssembly?ret = GetRuntimeAssembly(asm);
                if (ret != null)
                {
                    return(ret);
                }
            }

            return(null);
        }
        private Assembly?ResolveSatelliteAssembly(AssemblyName assemblyName)
        {
            // Called by native runtime when CultureName is not empty
            Debug.Assert(assemblyName.CultureName?.Length > 0);

            const string SatelliteSuffix = ".resources";

            if (assemblyName.Name == null || !assemblyName.Name.EndsWith(SatelliteSuffix, StringComparison.Ordinal))
            {
                return(null);
            }

            string parentAssemblyName = assemblyName.Name.Substring(0, assemblyName.Name.Length - SatelliteSuffix.Length);

            Assembly parentAssembly = LoadFromAssemblyName(new AssemblyName(parentAssemblyName));

            AssemblyLoadContext parentALC = GetLoadContext(parentAssembly) !;

            string?parentDirectory = Path.GetDirectoryName(parentAssembly.Location);

            if (parentDirectory == null)
            {
                return(null);
            }

            string assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName !, $"{assemblyName.Name}.dll");

            bool exists = System.IO.FileSystem.FileExists(assemblyPath);

            if (!exists && PathInternal.IsCaseSensitive)
            {
#if CORECLR
                if (AssemblyLoadContext.IsTracingEnabled())
                {
                    AssemblyLoadContext.TraceSatelliteSubdirectoryPathProbed(assemblyPath, HResults.COR_E_FILENOTFOUND);
                }
#endif // CORECLR
                assemblyPath = Path.Combine(parentDirectory, assemblyName.CultureName !.ToLowerInvariant(), $"{assemblyName.Name}.dll");
                exists       = System.IO.FileSystem.FileExists(assemblyPath);
            }

            Assembly?asm = exists ? parentALC.LoadFromAssemblyPath(assemblyPath) : null;
#if CORECLR
            if (AssemblyLoadContext.IsTracingEnabled())
            {
                AssemblyLoadContext.TraceSatelliteSubdirectoryPathProbed(assemblyPath, exists ? HResults.S_OK : HResults.COR_E_FILENOTFOUND);
            }
#endif // CORECLR

            return(asm);
        }