Example #1
0
 private void AddToList(AssemblyList list, string FullName)
 {
     AssemblyNameInfo reference = new AssemblyNameInfo(FullName);
     string file = GacInterop.FindAssemblyInNetGac(reference);
     if (file != null)
         list.OpenAssembly(file);
 }
		IEnumerable<IAssembly> GetAssemblyRefs(ModuleDef module, IEnumerable<string> extraAssemblyReferences) {
			foreach (var a in module.GetAssemblyRefs())
				yield return a;
			foreach (var s in extraAssemblyReferences) {
				var info = new AssemblyNameInfo(s);
				if (info.Version != null)
					yield return info;
			}
		}
		public override void Create(DecompileContext ctx) {
			IList<string> refs;
			using (var stream = File.Create(Filename))
				refs = decompileBaml(bamlData, stream);
			foreach (var asmRef in refs) {
				var a = new AssemblyNameInfo(asmRef);
				if (!UTF8String.IsNullOrEmpty(a.Name))
					asmRefs.Add(a);
			}
		}
Example #4
0
		string TypeNameConverter(Type type) {
			var newAsm = new AssemblyNameInfo(type.Assembly.GetName());
			IAssembly oldAsm;
			if (!newToOldAsm.TryGetValue(newAsm, out oldAsm))
				return type.AssemblyQualifiedName;
			if (type.IsGenericType)
				return type.AssemblyQualifiedName;
			if (AssemblyNameComparer.CompareAll.Equals(oldAsm, newAsm))
				return type.AssemblyQualifiedName;
			return string.Format("{0}, {1}", type.FullName, oldAsm.FullName);
		}
Example #5
0
		public DnSpyFile Resolve(IAssembly assembly, ModuleDef sourceModule = null, bool delayLoad = false) {
			FrameworkRedirect.ApplyFrameworkRedirect(ref assembly, sourceModule);

			if (assembly.IsContentTypeWindowsRuntime)
				return ResolveWinMD(assembly, sourceModule, delayLoad);

			// WinMD files have a reference to mscorlib but its version is always 255.255.255.255
			// since mscorlib isn't really loaded. The resolver only loads exact versions, so
			// we must change the version or the resolve will fail.
			if (assembly.Name == "mscorlib" && assembly.Version == invalidMscorlibVersion)
				assembly = new AssemblyNameInfo(assembly) { Version = newMscorlibVersion };

			return ResolveNormal(assembly, sourceModule, delayLoad);
		}
		public IEnumerable<ModuleDef> GetSatelliteAssemblies(ModuleDef module) {
			var asm = module.Assembly;
			if (asm == null)
				yield break;
			var satAsmName = new AssemblyNameInfo(asm);
			satAsmName.Name = asm.Name + ".resources";
			foreach (var filename in GetFiles(asm, module)) {
				if (!File.Exists(filename))
					continue;
				var satAsm = TryOpenAssembly(filename);
				if (satAsm == null || !AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(satAsmName, satAsm))
					continue;
				yield return satAsm.ManifestModule;
			}
		}
Example #7
0
        /// <summary>
        /// Gets the file name for an assembly stored in the GAC.
        /// </summary>
        public static string FindAssemblyInNetGac(AssemblyNameInfo reference)
        {
            // without public key, it can't be in the GAC
            if (reference.PublicKeyOrToken.IsNullOrEmpty)
                return null;

            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < gacs.Length; j++) {
                    var gac = Path.Combine (gac_paths [i], gacs [j]);
                    var file = GetAssemblyFile (reference, prefixes [i], gac);
                    if (File.Exists (file))
                        return file;
                }
            }

            return null;
        }
Example #8
0
		/// <summary>
		/// Gets the names of all assemblies in the GAC.
		/// </summary>
		public static IEnumerable<AssemblyNameInfo> GetGacAssemblyFullNames() {
			IApplicationContext applicationContext = null;
			IAssemblyEnum assemblyEnum = null;
			IAssemblyName assemblyName = null;

			Fusion.CreateAssemblyEnum(out assemblyEnum, null, null, 2, 0);
			while (assemblyEnum.GetNextAssembly(out applicationContext, out assemblyName, 0) == 0) {
				uint nChars = 0;
				assemblyName.GetDisplayName(null, ref nChars, 0);

				StringBuilder name = new StringBuilder((int)nChars);
				assemblyName.GetDisplayName(name, ref nChars, 0);

				var r = new AssemblyNameInfo(name.ToString());
				if (r.Version != null)
					yield return r;
			}
		}
Example #9
0
        public void Run(XamlContext ctx, XDocument document)
        {
            var xClass = document.Root.Elements().First().Attribute(ctx.GetXamlNsName("Class"));
            if (xClass == null)
                return;

            var type = ctx.Module.Find(xClass.Value, true);
            if (type == null)
                return;

            var wbAsm = new AssemblyNameInfo("WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35").ToAssemblyRef();
            var ifaceRef = new TypeRefUser(ctx.Module, "System.Windows.Markup", "IComponentConnector", wbAsm);
            var iface = ctx.Module.Context.Resolver.ResolveThrow(ifaceRef);

            var connect = iface.FindMethod("Connect");

            foreach (MethodDef method in type.Methods) {
                if (Impl(method, connect)) {
                    connect = method;
                    iface = null;
                    break;
                }
            }
            if (iface != null)
                return;

            Dictionary<int, Action<XamlContext, XElement>> connIds = null;
            try {
                connIds = ExtractConnectionId(ctx, connect);
            }
            catch {
            }

            if (connIds == null) {
                var msg = dnSpy_BamlDecompiler_Resources.Error_IComponentConnectorConnetCannotBeParsed;
                document.Root.AddBeforeSelf(new XComment(string.Format(msg, type.ReflectionFullName)));
                return;
            }

            foreach (var elem in document.Elements()) {
                ProcessElement(ctx, elem, connIds);
            }
        }
Example #10
0
		public bool AddModuleDef(ModuleDefMD module, out ModuleDefMD cached) {
			module.EnableTypeDefFindCache = true;
			if (module.Assembly == null) {
				foreach (var assembly in LoadedAssemblies) {
					foreach (var m in assembly.Value.Modules)
						if (m.Name == module.Name) {
							cached = (ModuleDefMD)m;
							return false;
						}

					var asmModule = (ModuleDefMD)assembly.Value.ManifestModule;
					var rows = asmModule.TablesStream.FileTable.Rows;
					for (uint i = 1; i <= rows; i++) {
						var file = asmModule.TablesStream.ReadFileRow(i);
						var name = asmModule.StringsStream.ReadNoNull(file.Name);
						if (name == module.Name) {
							assembly.Value.Modules.Add(module);
							Modules.Add(module);
							cached = null;
							return true;
						}
					}
				}
				cached = null;
				if (NetModules.ContainsKey(module.Name)) {
					return false;
				}
				NetModules.Add(module.Name, module);
				Modules.Add(module);
				return true;
			}
			var asmName = new AssemblyNameInfo(module.Assembly);
			AssemblyDef cachedAsm;
			if (LoadedAssemblies.TryGetValue(asmName, out cachedAsm)) {
				cached = (ModuleDefMD)cachedAsm.ManifestModule;
				return false;
			}
			LoadedAssemblies[asmName] = module.Assembly;
			Modules.Add(module);
			cached = null;
			return true;
		}
Example #11
0
		public IAssembly ResolveAssembly(ushort id) {
			id &= 0xfff;
			IAssembly assembly;
			if (!assemblyMap.TryGetValue(id, out assembly)) {
				AssemblyInfoRecord assemblyRec;
				if (AssemblyIdMap.TryGetValue(id, out assemblyRec)) {
					var assemblyName = new AssemblyNameInfo(assemblyRec.AssemblyFullName);

					if (assemblyName.Name == Module.Assembly.Name)
						assembly = Module.Assembly;
					else
						assembly = Module.Context.AssemblyResolver.Resolve(assemblyName, Module);

					if (assembly == null)
						assembly = assemblyName;
				}
				else
					assembly = null;

				assemblyMap[id] = assembly;
			}
			return assembly;
		}
Example #12
0
		/// <summary>
		/// Checks whether this assembly is a friend assembly of <paramref name="targetAsm"/>
		/// </summary>
		/// <param name="targetAsm">Target assembly</param>
		public bool IsFriendAssemblyOf(AssemblyDef targetAsm) {
			if (targetAsm == null)
				return false;
			if (this == targetAsm)
				return true;

			// Both must be unsigned or both must be signed according to the
			// InternalsVisibleToAttribute documentation.
			if (PublicKeyBase.IsNullOrEmpty2(publicKey) != PublicKeyBase.IsNullOrEmpty2(targetAsm.PublicKey))
				return false;

			foreach (var ca in targetAsm.CustomAttributes.FindAll("System.Runtime.CompilerServices.InternalsVisibleToAttribute")) {
				if (ca.ConstructorArguments.Count != 1)
					continue;
				var arg = ca.ConstructorArguments.Get(0, default(CAArgument));
				if (arg.Type.GetElementType() != ElementType.String)
					continue;
				var asmName = arg.Value as UTF8String;
				if (UTF8String.IsNull(asmName))
					continue;

				var asmInfo = new AssemblyNameInfo(asmName);
				if (asmInfo.Name != name)
					continue;
				if (!PublicKeyBase.IsNullOrEmpty2(publicKey)) {
					if (!PublicKey.Equals(asmInfo.PublicKeyOrToken as PublicKey))
						continue;
				}
				else if (!PublicKeyBase.IsNullOrEmpty2(asmInfo.PublicKeyOrToken))
					continue;

				return true;
			}

			return false;
		}
Example #13
0
        AssemblyDef FindClosestAssembly(AssemblyNameInfo assembly, AssemblyDef closest, IEnumerable <string> paths, ModuleContext moduleContext)
        {
            if (paths == null)
            {
                return(closest);
            }
            var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);

            foreach (var path in paths)
            {
                ModuleDefMD mod = null;
                try {
                    mod = ModuleDefMD.Load(path, moduleContext);
                    var asm = mod.Assembly;
                    if (asm != null && asmComparer.CompareClosest(assembly, new AssemblyNameInfo(closest), new AssemblyNameInfo(asm)) == 1)
                    {
                        if (!IsCached(closest) && closest != null && closest.ManifestModule != null)
                        {
                            closest.ManifestModule.Dispose();
                        }
                        closest = asm;
                        mod     = null;
                    }
                }
                catch {
                }
                finally {
                    if (mod != null)
                    {
                        mod.Dispose();
                    }
                }
            }

            return(closest);
        }
 /// <summary>
 /// Finds an assembly that exactly matches the requested assembly
 /// </summary>
 /// <param name="assembly">Assembly name to find</param>
 /// <param name="paths">Search paths or <c>null</c> if none</param>
 /// <param name="moduleContext">Module context</param>
 /// <returns>An <see cref="AssemblyDef"/> instance or <c>null</c> if an exact match
 /// couldn't be found.</returns>
 AssemblyDef FindExactAssembly(AssemblyNameInfo assembly, IEnumerable<string> paths, ModuleContext moduleContext)
 {
     if (paths == null)
         return null;
     var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
     foreach (var path in paths) {
         ModuleDefMD mod = null;
         try {
             mod = ModuleDefMD.Load(path, moduleContext);
             var asm = mod.Assembly;
             if (asm != null && asmComparer.Equals(assembly, new AssemblyNameInfo(asm))) {
                 mod = null;
                 return asm;
             }
         }
         catch {
         }
         finally {
             if (mod != null)
                 mod.Dispose();
         }
     }
     return null;
 }
        AssemblyDef FindClosestAssembly(AssemblyNameInfo assembly, AssemblyDef closest, IEnumerable<string> paths, ModuleContext moduleContext)
        {
            if (paths == null)
                return closest;
            var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
            foreach (var path in paths) {
                ModuleDefMD mod = null;
                try {
                    mod = ModuleDefMD.Load(path, moduleContext);
                    var asm = mod.Assembly;
                    if (asm != null && asmComparer.CompareClosest(assembly, new AssemblyNameInfo(closest), new AssemblyNameInfo(asm)) == 1) {
                        if (!IsCached(closest) && closest != null && closest.ManifestModule != null)
                            closest.ManifestModule.Dispose();
                        closest = asm;
                        mod = null;
                    }
                }
                catch {
                }
                finally {
                    if (mod != null)
                        mod.Dispose();
                }
            }

            return closest;
        }
 /// <summary>
 /// Finds the closest assembly from the already cached assemblies
 /// </summary>
 /// <param name="assembly">Assembly name to find</param>
 /// <returns>The closest <see cref="AssemblyDef"/> or <c>null</c> if none found</returns>
 AssemblyDef FindClosestAssembly(AssemblyNameInfo assembly)
 {
     AssemblyDef closest = null;
     var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
     foreach (var asm in cachedAssemblies.Values) {
         if (asm == null)
             continue;
         if (asmComparer.CompareClosest(assembly, new AssemblyNameInfo(closest), new AssemblyNameInfo(asm)) == 1)
             closest = asm;
     }
     return closest;
 }
 IEnumerable<string> FindAssembliesModuleSearchPaths(AssemblyNameInfo assembly, ModuleDef sourceModule, bool matchExactly)
 {
     string asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
     var searchPaths = GetSearchPaths(sourceModule);
     foreach (var ext in assemblyExtensions) {
         foreach (var path in searchPaths) {
             for (int i = 0; i < 2; i++) {
                 string path2;
                 if (i == 0)
                     path2 = Path.Combine(path, asmSimpleName + ext);
                 else
                     path2 = Path.Combine(Path.Combine(path, asmSimpleName), asmSimpleName + ext);
                 if (File.Exists(path2))
                     yield return path2;
             }
         }
     }
 }
 IEnumerable<string> FindAssembliesGacExactly(GacInfo gacInfo, AssemblyNameInfo assembly, ModuleDef sourceModule)
 {
     var pkt = PublicKeyBase.ToPublicKeyToken(assembly.PublicKeyOrToken);
     if (gacInfo != null && pkt != null) {
         string pktString = pkt.ToString();
         string verString = Utils.CreateVersionWithNoUndefinedValues(assembly.Version).ToString();
         var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
         foreach (var subDir in gacInfo.subDirs) {
             var baseDir = Path.Combine(gacInfo.path, subDir);
             baseDir = Path.Combine(baseDir, asmSimpleName);
             baseDir = Path.Combine(baseDir, string.Format("{0}{1}__{2}", gacInfo.prefix, verString, pktString));
             var pathName = Path.Combine(baseDir, asmSimpleName + ".dll");
             if (File.Exists(pathName))
                 yield return pathName;
         }
     }
 }
Example #19
0
 public LoadedAssembly LookupReferencedAssembly(IAssembly asmRef, ModuleDef sourceModule = null, bool delay = false)
 {
     FrameworkRedirect.ApplyFrameworkRedirect(ref asmRef, sourceModule);
     if (asmRef == null)
         throw new ArgumentNullException("name");
     if (asmRef.IsContentTypeWindowsRuntime) {
         return assemblyList.winRTMetadataLookupCache.GetOrAdd(asmRef.Name, n => LookupWinRTMetadata(n, delay));
     } else {
         // WinMD files have a reference to mscorlib but its version is always 255.255.255.255
         // since mscorlib isn't really loaded. The resolver only loads exact versions, so
         // we must change the version or the resolve will fail.
         if (asmRef.Name == "mscorlib" && asmRef.Version == invalidMscorlibVersion)
             asmRef = new AssemblyNameInfo(asmRef) { Version = newMscorlibVersion };
         return LookupReferencedAssembly2(asmRef, sourceModule, delay);
     }
 }
Example #20
0
 static string GetAssemblyNameKey(AssemblyNameInfo asmName)
 {
     // Make sure the name contains PublicKeyToken= and not PublicKey=
     return(asmName.FullNameToken.ToUpperInvariant());
 }
 IEnumerable<string> FindAssembliesGac(AssemblyNameInfo assembly, ModuleDef sourceModule, bool matchExactly)
 {
     if (matchExactly)
         return FindAssembliesGacExactly(assembly, sourceModule);
     return FindAssembliesGacAny(assembly, sourceModule);
 }
		/// <summary>
		/// Constructor
		/// </summary>
		/// <param name="asmName">Assembly name info</param>
		/// <exception cref="ArgumentNullException">If <paramref name="asmName"/> is <c>null</c></exception>
		public AssemblyRefUser(AssemblyNameInfo asmName) {
			if (asmName == null)
				throw new ArgumentNullException("asmName");

			this.version = asmName.Version ?? new Version(0, 0, 0, 0);
			this.publicKeyOrToken = asmName.PublicKeyOrToken;
			this.name = UTF8String.IsNullOrEmpty(asmName.Name) ? UTF8String.Empty : asmName.Name;
			this.locale = asmName.Locale;
			this.flags = publicKeyOrToken is PublicKey ? AssemblyAttributes.PublicKey : AssemblyAttributes.None;
		}
        /// <inheritdoc/>
        public AssemblyDef Resolve(AssemblyNameInfo assembly, ModuleDef sourceModule)
        {
            if (assembly == null)
                return null;

            AssemblyDef resolvedAssembly = Resolve2(assembly, sourceModule);
            if (resolvedAssembly == null) {
                string asmName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
                string asmNameTrimmed = asmName.Trim();
                if (asmName != asmNameTrimmed) {
                    assembly = new AssemblyNameInfo {
                        Name = asmNameTrimmed,
                        Version = assembly.Version,
                        PublicKeyOrToken = assembly.PublicKeyOrToken,
                        Locale = assembly.Locale,
                    };
                    resolvedAssembly = Resolve2(assembly, sourceModule);
                }
            }

            if (resolvedAssembly == null) {
                // Make sure we don't search for this assembly again. This speeds up callers who
                // keep asking for this assembly when trying to resolve many different TypeRefs
                cachedAssemblies[GetAssemblyNameKey(assembly)] = null;
                return null;
            }

            var key1 = GetAssemblyNameKey(new AssemblyNameInfo(resolvedAssembly));
            var key2 = GetAssemblyNameKey(assembly);
            AssemblyDef asm1, asm2;
            cachedAssemblies.TryGetValue(key1, out asm1);
            cachedAssemblies.TryGetValue(key2, out asm2);

            if (asm1 != resolvedAssembly && asm2 != resolvedAssembly) {
                // This assembly was just resolved
                if (enableTypeDefCache) {
                    foreach (var module in resolvedAssembly.Modules)
                        module.EnableTypeDefFindCache = true;
                }
            }

            bool inserted = false;
            if (!cachedAssemblies.ContainsKey(key1)) {
                cachedAssemblies.Add(key1, resolvedAssembly);
                inserted = true;
            }
            if (!cachedAssemblies.ContainsKey(key2)) {
                cachedAssemblies.Add(key2, resolvedAssembly);
                inserted = true;
            }
            if (inserted || asm1 == resolvedAssembly || asm2 == resolvedAssembly)
                return resolvedAssembly;

            // Dupe assembly. Don't insert it.
            if (resolvedAssembly.ManifestModule != null)
                resolvedAssembly.ManifestModule.Dispose();
            return asm1 ?? asm2;
        }
Example #24
0
		static string GetAssemblyFilename(string moduleFilename, string assemblyFullName, bool moduleNameOnly) {
			if (string.IsNullOrEmpty(moduleFilename) || (string.IsNullOrEmpty(assemblyFullName) && !moduleNameOnly))
				return null;
			if (moduleNameOnly)
				return moduleFilename;
			try {
				var asm = new AssemblyNameInfo(assemblyFullName);
				if (Path.GetFileName(asm.Name) != asm.Name || asm.Name.Length == 0)
					return null;
				var fn = Path.Combine(Path.GetDirectoryName(moduleFilename), asm.Name);
				var fnDll = fn + ".dll";
				if (File.Exists(fnDll))
					return fnDll;
				var fnExe = fn + ".exe";
				if (File.Exists(fnExe))
					return fnExe;
			}
			catch {
			}
			return null;
		}
        AssemblyDef Resolve2(AssemblyNameInfo assembly, ModuleDef sourceModule)
        {
            AssemblyDef resolvedAssembly;

            if (cachedAssemblies.TryGetValue(GetAssemblyNameKey(assembly), out resolvedAssembly))
                return resolvedAssembly;

            var moduleContext = defaultModuleContext;
            if (moduleContext == null && sourceModule != null)
                moduleContext = sourceModule.Context;

            resolvedAssembly = FindExactAssembly(assembly, PreFindAssemblies(assembly, sourceModule, true), moduleContext) ??
                    FindExactAssembly(assembly, FindAssemblies(assembly, sourceModule, true), moduleContext) ??
                    FindExactAssembly(assembly, PostFindAssemblies(assembly, sourceModule, true), moduleContext);
            if (resolvedAssembly != null)
                return resolvedAssembly;

            if (!findExactMatch) {
                resolvedAssembly = FindClosestAssembly(assembly);
                resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, PreFindAssemblies(assembly, sourceModule, false), moduleContext);
                resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, FindAssemblies(assembly, sourceModule, false), moduleContext);
                resolvedAssembly = FindClosestAssembly(assembly, resolvedAssembly, PostFindAssemblies(assembly, sourceModule, false), moduleContext);
            }

            return resolvedAssembly;
        }
 IEnumerable<string> FindAssembliesGacAny(GacInfo gacInfo, AssemblyNameInfo assembly, ModuleDef sourceModule)
 {
     if (gacInfo != null) {
         var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
         foreach (var subDir in gacInfo.subDirs) {
             var baseDir = Path.Combine(gacInfo.path, subDir);
             baseDir = Path.Combine(baseDir, asmSimpleName);
             foreach (var dir in GetDirs(baseDir)) {
                 var pathName = Path.Combine(dir, asmSimpleName + ".dll");
                 if (File.Exists(pathName))
                     yield return pathName;
             }
         }
     }
 }
Example #27
0
 public GacEntry(AssemblyNameInfo r, string fileName)
 {
     this.r = r;
     this.fileName = fileName;
 }
 IEnumerable<string> FindAssembliesGacExactly(AssemblyNameInfo assembly, ModuleDef sourceModule)
 {
     foreach (var path in FindAssembliesGacExactly(gac2Info, assembly, sourceModule))
         yield return path;
     foreach (var path in FindAssembliesGacExactly(gac4Info, assembly, sourceModule))
         yield return path;
 }
 /// <summary>
 /// Called before <see cref="FindAssemblies"/>
 /// </summary>
 /// <param name="assembly">Simple assembly name</param>
 /// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
 /// <param name="matchExactly">We're trying to find an exact match</param>
 /// <returns><c>null</c> or an enumerable of full paths to try</returns>
 protected virtual IEnumerable<string> PreFindAssemblies(AssemblyNameInfo assembly, ModuleDef sourceModule, bool matchExactly)
 {
     foreach (var path in FindAssemblies2(assembly, preSearchPaths))
         yield return path;
 }
Example #30
0
        LoadedAssembly LookupReferencedAssemblyInternal(string fullName, ModuleDef sourceModule, bool delay)
        {
            var asm = assemblyList.FindAssemblyByAssemblyName(fullName);
            if (asm != null)
                return asm;

            var name = new AssemblyNameInfo(fullName);
            var loadedAsm = LookupFromSearchPaths(name, sourceModule, true);
            if (loadedAsm != null)
                return assemblyList.AddAssembly(loadedAsm, assemblyLoadDisableCount == 0, delay);

            if (assemblyList.UseGAC) {
                var file = GacInterop.FindAssemblyInNetGac(name);
                if (file != null)
                    return assemblyList.OpenAssemblyInternal(file, assemblyLoadDisableCount == 0, true, delay);
                foreach (var path in otherGacPaths) {
                    loadedAsm = TryLoadFromDir(name, true, path);
                    if (loadedAsm != null)
                        return assemblyList.AddAssembly(loadedAsm, assemblyLoadDisableCount == 0, delay);
                }
            }

            loadedAsm = LookupFromSearchPaths(name, sourceModule, false);
            if (loadedAsm != null)
                return assemblyList.AddAssembly(loadedAsm, assemblyLoadDisableCount == 0, delay);

            return null;
        }
Example #31
0
        /// <inheritdoc/>
        public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule)
        {
            if (assembly == null)
            {
                return(null);
            }

#if THREAD_SAFE
            theLock.EnterWriteLock(); try {
#endif
            AssemblyDef resolvedAssembly = Resolve2(assembly, sourceModule);
            if (resolvedAssembly == null)
            {
                string asmName        = UTF8String.ToSystemStringOrEmpty(assembly.Name);
                string asmNameTrimmed = asmName.Trim();
                if (asmName != asmNameTrimmed)
                {
                    assembly = new AssemblyNameInfo {
                        Name             = asmNameTrimmed,
                        Version          = assembly.Version,
                        PublicKeyOrToken = assembly.PublicKeyOrToken,
                        Culture          = assembly.Culture,
                    };
                    resolvedAssembly = Resolve2(assembly, sourceModule);
                }
            }

            if (resolvedAssembly == null)
            {
                // Make sure we don't search for this assembly again. This speeds up callers who
                // keep asking for this assembly when trying to resolve many different TypeRefs
                cachedAssemblies[GetAssemblyNameKey(assembly)] = null;
                return(null);
            }

            var key1 = GetAssemblyNameKey(resolvedAssembly);
            var key2 = GetAssemblyNameKey(assembly);
            AssemblyDef asm1, asm2;
            cachedAssemblies.TryGetValue(key1, out asm1);
            cachedAssemblies.TryGetValue(key2, out asm2);

            if (asm1 != resolvedAssembly && asm2 != resolvedAssembly)
            {
                // This assembly was just resolved
                if (enableTypeDefCache)
                {
                    foreach (var module in resolvedAssembly.Modules.GetSafeEnumerable())
                    {
                        if (module != null)
                        {
                            module.EnableTypeDefFindCache = true;
                        }
                    }
                }
            }

            bool inserted = false;
            if (!cachedAssemblies.ContainsKey(key1))
            {
                cachedAssemblies.Add(key1, resolvedAssembly);
                inserted = true;
            }
            if (!cachedAssemblies.ContainsKey(key2))
            {
                cachedAssemblies.Add(key2, resolvedAssembly);
                inserted = true;
            }
            if (inserted || asm1 == resolvedAssembly || asm2 == resolvedAssembly)
            {
                return(resolvedAssembly);
            }

            // Dupe assembly. Don't insert it.
            var dupeModule = resolvedAssembly.ManifestModule;
            if (dupeModule != null)
            {
                dupeModule.Dispose();
            }
            return(asm1 ?? asm2);

#if THREAD_SAFE
        }

        finally { theLock.ExitWriteLock(); }
#endif
        }
 static string GetAssemblyNameKey(AssemblyNameInfo asmName)
 {
     // Make sure the name contains PublicKeyToken= and not PublicKey=
     return asmName.FullNameToken.ToUpperInvariant();
 }
		/// <summary>
		/// Finds and returns an <see cref="AssemblyDef"/>
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="assembly">The assembly to find</param>
		/// <param name="sourceModule">The module that needs to resolve an assembly or <c>null</c></param>
		/// <returns>An <see cref="AssemblyDef"/> instance owned by the assembly resolver</returns>
		/// <exception cref="AssemblyResolveException">If the assembly couldn't be found.</exception>
		public static AssemblyDef ResolveThrow(this IAssemblyResolver self, AssemblyNameInfo assembly, ModuleDef sourceModule) {
			if (assembly == null)
				return null;
			var asm = self.Resolve(assembly, sourceModule);
			if (asm != null)
				return asm;
			throw new AssemblyResolveException(string.Format("Could not resolve assembly: {0}", assembly));
		}
 IEnumerable<string> FindAssemblies2(AssemblyNameInfo assembly, IEnumerable<string> paths)
 {
     if (paths != null) {
         var asmSimpleName = UTF8String.ToSystemStringOrEmpty(assembly.Name);
         foreach (var ext in assemblyExtensions) {
             foreach (var path in paths) {
                 var fullPath = Path.Combine(path, asmSimpleName + ext);
                 if (File.Exists(fullPath))
                     yield return fullPath;
             }
         }
     }
 }