public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule)
{
var resolver = Resolver;
if (resolver == null)
{
resolver = GetDefaultResolver();
}
AssemblyDef result = resolver.Resolve(assembly, sourceModule);
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
AssemblyDef cachedResult;
if (!LoadedAssemblies.TryGetValue(new AssemblyNameInfo(result), out cachedResult))
{
Debug.Assert(!string.IsNullOrEmpty(result.ManifestModule.Location));
// Resolving assemblies must be done in non-UI thread, or else Wait() will deadlock.
Debug.Assert(Manager.InvokeRequired);
Manager.LoadModule(result.ManifestModule.Location).Wait();
cachedResult = LoadedAssemblies[new AssemblyNameInfo(result)];
ResolveNetModules(cachedResult);
}
return(cachedResult);
}
void RewriteClass(XamlContext ctx, XElement elem)
{
var type = elem.Annotation <XamlType>();
if (type == null || type.ResolvedType == null)
{
return;
}
var typeDef = type.ResolvedType.ResolveTypeDef();
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
if (typeDef == null || !comparer.Equals(typeDef.DefinitionAssembly, ctx.Module.Assembly))
{
return;
}
var newType = typeDef.BaseType;
var xamlType = new XamlType(newType.DefinitionAssembly, newType.ReflectionNamespace, newType.Name);
xamlType.ResolveNamespace(elem, ctx);
elem.Name = xamlType.ToXName(ctx);
var attrName = ctx.GetXamlNsName("Class", elem);
var attrs = elem.Attributes().ToList();
attrs.Insert(0, new XAttribute(attrName, type.ResolvedType.ReflectionFullName));
elem.ReplaceAttributes(attrs);
}
public bool Match(string assemblyFile)
{
#if !SILVERLIGHT
var asmName = AssemblyName.GetAssemblyName(assemblyFile);
#else
var asmName = new AssemblyName(assemblyFile);
#endif
if (!AssemblyNameComparer.Equals(SourceName, asmName, false))
{
return(false);
}
var item = new AssemblyNameResult {
AssemblyFile = assemblyFile, AssemblyName = asmName
};
if (SourceName.Version != null && SourceName.Version.Equals(asmName.Version))
{
FullMatchedResult = item;
return(true);
}
else if (!IncludeVersion)
{
FullMatchedResult = item;
return(true);
}
Results.Add(item);
return(false);
}
IDsDocument TryLoadFromDir2(IAssembly asmName, bool checkVersion, bool checkPublicKeyToken, string filename) {
if (!File.Exists(filename))
return null;
IDsDocument document = null;
bool error = true;
try {
document = documentService.TryCreateDocument(DsDocumentInfo.CreateDocument(filename));
if (document == null)
return null;
document.IsAutoLoaded = true;
var asm = document.AssemblyDef;
if (asm == null)
return null;
var flags = AssemblyNameComparerFlags.All & ~(AssemblyNameComparerFlags.Version | AssemblyNameComparerFlags.PublicKeyToken);
if (checkVersion)
flags |= AssemblyNameComparerFlags.Version;
if (checkPublicKeyToken)
flags |= AssemblyNameComparerFlags.PublicKeyToken;
bool b = new AssemblyNameComparer(flags).Equals(asmName, asm);
if (!b)
return null;
error = false;
return document;
}
finally {
if (error) {
if (document is IDisposable)
((IDisposable)document).Dispose();
}
}
}
public bool CheckFileExistence(AssemblyName assemblyName, string searchPattern, bool caching, bool checkForBaseDir, bool checkForArchitectPlatfrom = true)
{
AssemblyName assemblyNameFromStorage;
if (TryGetAssemblyNameDefinition(searchPattern, caching, assemblyName.TargetArchitecture, out assemblyNameFromStorage, checkForArchitectPlatfrom))
{
var areEquals = /*Telerik Authorship*/ AssemblyNameComparer.AreVersionEquals(assemblyNameFromStorage.Version, assemblyName.Version) &&
/*Telerik Authorship*/ AssemblyNameComparer.ArePublicKeyEquals(assemblyNameFromStorage.PublicKeyToken, assemblyName.PublicKeyToken) &&
assemblyName.TargetArchitecture.CanReference(assemblyNameFromStorage.TargetArchitecture) &&
(!checkForBaseDir || AreDefaultDirEqual(assemblyName, assemblyNameFromStorage));
if (areEquals && caching)
{
/*Telerik Authorship*/
ModuleDefinition module = AssemblyDefinition.ReadAssembly(searchPattern, readerParameters).MainModule;
SpecialTypeAssembly special = module.IsReferenceAssembly() ? SpecialTypeAssembly.Reference : SpecialTypeAssembly.None;
AssemblyStrongNameExtended assemblyKey = new AssemblyStrongNameExtended(assemblyName.FullName, assemblyName.TargetArchitecture, special);
pathRepository.AssemblyPathName.Add(assemblyKey, searchPattern);
if (!pathRepository.AssemblyPathArchitecture.ContainsKey(searchPattern))
{
TargetArchitecture architecture = module.GetModuleArchitecture();
pathRepository.AssemblyPathArchitecture.Add(new KeyValuePair <string, TargetArchitecture>(searchPattern, architecture));
}
}
return(areEquals);
}
return(false);
}
public IDsDocument FindAssembly(IAssembly assembly)
{
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
rwLock.EnterReadLock();
try {
foreach (var info in documents)
{
if (comparer.Equals(info.Document.AssemblyDef, assembly))
{
return(info.Document);
}
}
foreach (var info in documents)
{
if (info.IsAlternativeAssemblyName(assembly))
{
return(info.Document);
}
}
}
finally {
rwLock.ExitReadLock();
}
lock (tempCache) {
foreach (var document in tempCache)
{
if (comparer.Equals(document.AssemblyDef, assembly))
{
return(document);
}
}
}
return(null);
}
public string LookupXmlns(IAssembly asm, string clrNs)
{
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var map in piMappings)
{
if (comparer.Equals(map.Value.Assembly, asm) && map.Value.CLRNamespace == clrNs)
{
return(map.Key);
}
}
var scope = CurrentScope;
while (scope != null)
{
foreach (var ns in scope)
{
if (comparer.Equals(ns.Assembly, asm) && ns.CLRNamespace == clrNs)
{
return(ns.XMLNamespace);
}
}
scope = scope.PreviousScope;
}
return(null);
}
void RewriteClass(XamlContext ctx, XElement elem) {
var type = elem.Annotation<XamlType>();
if (type == null || type.ResolvedType == null)
return;
var typeDef = type.ResolvedType.ResolveTypeDef();
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
if (typeDef == null || !comparer.Equals(typeDef.DefinitionAssembly, ctx.Module.Assembly))
return;
var newType = typeDef.BaseType;
var xamlType = new XamlType(newType.DefinitionAssembly, newType.ReflectionNamespace, newType.Name);
xamlType.ResolveNamespace(elem, ctx);
elem.Name = xamlType.ToXName(ctx);
var attrName = ctx.GetXamlNsName("Class", elem);
var attrs = elem.Attributes().ToList();
if (typeDef.IsNotPublic) {
var classModifierName = ctx.GetXamlNsName("ClassModifier", elem);
attrs.Insert(0, new XAttribute(classModifierName, ctx.BamlDecompilerOptions.InternalClassModifier));
}
attrs.Insert(0, new XAttribute(attrName, type.ResolvedType.ReflectionFullName));
elem.ReplaceAttributes(attrs);
}
/// <summary>
///
/// </summary>
/// <param name="aname"></param>
/// <returns></returns>
public Assembly Resolve(AssemblyName aname)
{
if (Assemblys == null)
{
return(null);
}
return(Assemblys.FirstOrDefault(a => AssemblyNameComparer.Equals(aname, a.GetName(), IncludeVersion)));
}
/// <summary>
/// 解析Assembly
/// </summary>
/// <param name="anme"></param>
/// <returns></returns>
public Assembly Resolve(AssemblyName anme)
{
var asmName = Gac.GetAssemblyNames().FirstOrDefault(a => AssemblyNameComparer.Equals(anme, a));
if (asmName != null)
{
return(Assembly.Load(asmName));
}
return(null);
}
public string LookupXmlns(IAssembly asm, string clrNs)
{
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var ns in this)
{
if (comparer.Equals(ns.Assembly, asm) && ns.CLRNamespace == clrNs)
{
return(ns.XMLNamespace);
}
}
return(null);
}
public DnSpyFile FindAssembly(IAssembly assembly)
{
lock (lockObj) {
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var file in files)
{
if (comparer.Equals(file.AssemblyDef, assembly))
{
return(file);
}
}
return(null);
}
}
IEnumerable <ModuleDefMD> GetModules(IApp app, object targetItem)
{
var type = targetItem as TypeDef;
if (type == null)
{
type = ((IMemberDef)targetItem).DeclaringType;
}
var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var module in app.Modules.GetModules())
{
if (module.GlobalType == null)
{
continue;
}
bool hasRef = asmComparer.Equals(module.Assembly, type.DefinitionAssembly);
if (!hasRef)
{
foreach (var reference in module.GetAssemblyRefs())
{
if (asmComparer.Equals(reference, type.DefinitionAssembly))
{
hasRef = true;
break;
}
}
}
if (!hasRef)
{
continue;
}
if (type.Module == module)
{
yield return(module);
}
else
{
checker.UserType = module.GlobalType;
if (checker.CanAccess(type) ?? true)
{
yield return(module);
}
}
}
}
public void BreakOnLoadAssembly(IAssembly assembly, Action <IDebuggerAssembly> action, AssemblyNameComparerFlags flags)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
assembly = assembly.ToAssemblyRef(); // Prevent storing AssemblyDef refs
// Use the LoadModule event since without a module, we won't know the full assembly name
CreateBreakpoint(DebugEventKind.LoadModule, (bp, ctx) => {
var c = (ModuleEventContext)ctx;
var comparer = new AssemblyNameComparer(flags);
var asm = c.Module.Assembly;
if (!comparer.Equals(assembly, new AssemblyNameInfo(asm.FullName)))
{
return(false);
}
bp.Remove();
action?.Invoke(asm);
return(true);
});
}
public static bool ReferencesModule(ModuleDef sourceModule, ModuleDef targetModule)
{
if (targetModule == null)
{
return(false);
}
if (sourceModule == targetModule)
{
return(true);
}
var targetAssembly = targetModule.Assembly;
if (targetAssembly != null)
{
// Don't compare version, there could be binding redirects
var asmComparer = new AssemblyNameComparer(AssemblyNameComparerFlags.Name | AssemblyNameComparerFlags.PublicKeyToken | AssemblyNameComparerFlags.Culture | AssemblyNameComparerFlags.ContentType);
foreach (var asmRef in sourceModule.GetAssemblyRefs())
{
if (asmComparer.Equals(asmRef, targetAssembly))
{
return(true);
}
}
if (targetAssembly == sourceModule.Assembly)
{
foreach (var modRef in sourceModule.GetModuleRefs())
{
if (StringComparer.OrdinalIgnoreCase.Equals(modRef.Name.String, targetModule.Name.String))
{
return(true);
}
}
}
}
return(false);
}
public IDsDocument FindAssembly(IAssembly assembly)
{
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
lock (lockObj) {
foreach (var document in documents)
{
if (comparer.Equals(document.AssemblyDef, assembly))
{
return(document);
}
}
}
lock (tempCache) {
foreach (var document in tempCache)
{
if (comparer.Equals(document.AssemblyDef, assembly))
{
return(document);
}
}
}
return(null);
}
void RewriteClass(XamlContext ctx, XElement elem)
{
var type = elem.Annotation <XamlType>();
if (type is null || type.ResolvedType is null)
{
return;
}
var typeDef = type.ResolvedType.ResolveTypeDef();
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
if (typeDef is null || !comparer.Equals(typeDef.DefinitionAssembly, ctx.Module.Assembly))
{
return;
}
var newType = typeDef.BaseType;
var xamlType = new XamlType(newType.DefinitionAssembly, newType.ReflectionNamespace, newType.Name);
xamlType.ResolveNamespace(elem, ctx);
elem.Name = xamlType.ToXName(ctx);
var attrName = ctx.GetKnownNamespace("Class", XamlContext.KnownNamespace_Xaml, elem);
var attrs = elem.Attributes().ToList();
if (typeDef.IsNotPublic)
{
var classModifierName = ctx.GetKnownNamespace("ClassModifier", XamlContext.KnownNamespace_Xaml, elem);
attrs.Insert(0, new XAttribute(classModifierName, ctx.BamlDecompilerOptions.InternalClassModifier));
}
attrs.Insert(0, new XAttribute(attrName, type.ResolvedType.ReflectionFullName));
elem.ReplaceAttributes(attrs);
}
public TargetPlatform GetTargetPlatform(string assemblyFilePath, ModuleDefinition moduleDef)
{
TargetPlatform targetPlatform = this.DefaultTargetPlatform;
if (string.IsNullOrEmpty(assemblyFilePath))
{
return(targetPlatform);
}
if (this.assemblyFrameworkResolverCache.AssemblyPathToTargetPlatform.ContainsKey(assemblyFilePath))
{
return(this.assemblyFrameworkResolverCache.AssemblyPathToTargetPlatform[assemblyFilePath]);
}
else
{
Task <TargetPlatform> targetPlatformFromDepsJson = null;
string moduleLocation = moduleDef.FullyQualifiedName ?? moduleDef.FilePath;
string depsJsonLocation = Directory.GetFiles(Path.GetDirectoryName(moduleLocation), "*.deps.json").FirstOrDefault();
if (File.Exists(depsJsonLocation))
{
targetPlatformFromDepsJson = Task.Factory.StartNew(() =>
{
return(this.GetPlatformTargetFromDepsJson(moduleLocation));
});
}
///*Telerik Authorship*/
if (moduleDef.Assembly != null)
{
targetPlatform = this.GetTargetPlatform(moduleDef);
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
return(targetPlatform);
}
}
AssemblyNameReference msCorlib = moduleDef.AssemblyReferences.FirstOrDefault(a => a.Name == "mscorlib");
if (msCorlib == null)
{
AssemblyNameReference systemRuntimeReference = moduleDef.AssemblyReferences.FirstOrDefault(x => x.Name == "System.Runtime");
targetPlatform = this.GetTargetPlatform(systemRuntimeReference);
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
this.assemblyFrameworkResolverCache.AddAssemblySystemRuntimeReference(assemblyFilePath, systemRuntimeReference);
return(targetPlatform);
}
// the next line is only to keep the old functionality
msCorlib = moduleDef.Assembly.Name;
}
if (moduleDef.Assembly != null && moduleDef.Assembly.Name.IsWindowsRuntime || msCorlib.IsFakeMscorlibReference())
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, TargetPlatform.WinRT);
return(TargetPlatform.WinRT);
}
/*AssemblyName assemblyName = new AssemblyName(msCorlib.Name,
* msCorlib.FullName,
* msCorlib.Version,
* msCorlib.PublicKeyToken,
* Path.GetDirectoryName(assemliyFilePath)) { TargetArchitecture = moduleDef.GetModuleArchitecture() };
* IEnumerable<string> foundPaths = GetAssemblyPaths(assemblyName);
*
* return GetTargetPlatform(foundPaths.FirstOrDefault());*/
/*Telerik Authorship*/
if (targetPlatformFromDepsJson != null)
{
targetPlatformFromDepsJson.Wait();
targetPlatform = targetPlatformFromDepsJson.Result;
if (targetPlatform != this.DefaultTargetPlatform)
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, targetPlatform);
return(targetPlatform);
}
}
/*Telerik Authorship*/
TargetArchitecture moduleArchitecture = moduleDef.GetModuleArchitecture();
/*Telerik Authorship*/
foreach (KeyValuePair <AssemblyName, TargetPlatform> pair in Mscorlibs)
{
if (AssemblyNameComparer.AreVersionEquals(pair.Key.Version, msCorlib.Version) &&
AssemblyNameComparer.ArePublicKeyEquals(pair.Key.PublicKeyToken, msCorlib.PublicKeyToken) &&
moduleArchitecture.CanReference(pair.Key.TargetArchitecture))
{
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, pair.Value);
return(pair.Value);
}
}
/*Telerik Authorship*/
this.assemblyFrameworkResolverCache.AddAssemblyTargetPlatformToCache(assemblyFilePath, this.DefaultTargetPlatform);
return(this.DefaultTargetPlatform);
}
}
/// <summary>
/// 解析Assembly
/// </summary>
/// <param name="aname"></param>
/// <returns></returns>
public Assembly Resolve(AssemblyName aname)
{
return(AppDomain.CurrentDomain
.GetAssemblies().FirstOrDefault(a => AssemblyNameComparer.Equals(aname, a.GetName())));
}
/// <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;
}
public DnSpyFile FindAssembly(IAssembly assembly) {
lock (lockObj) {
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
foreach (var file in files) {
if (comparer.Equals(file.AssemblyDef, assembly))
return file;
}
return null;
}
}
public void BreakOnLoadAssembly(IAssembly assembly, Action<IDebuggerAssembly> action, AssemblyNameComparerFlags flags) {
if (assembly == null)
throw new ArgumentNullException(nameof(assembly));
assembly = assembly.ToAssemblyRef();// Prevent storing AssemblyDef refs
// Use the LoadModule event since without a module, we won't know the full assembly name
CreateBreakpoint(DebugEventKind.LoadModule, (bp, ctx) => {
var c = (ModuleEventContext)ctx;
var comparer = new AssemblyNameComparer(flags);
var asm = c.Module.Assembly;
if (!comparer.Equals(assembly, new AssemblyNameInfo(asm.FullName)))
return false;
bp.Remove();
action?.Invoke(asm);
return true;
});
}
public AssemblyDef Resolve(IAssembly assembly, ModuleDef sourceModule) {
var resolver = Resolver;
if (resolver == null)
resolver = GetDefaultResolver();
AssemblyDef result = resolver.Resolve(assembly, sourceModule);
var comparer = new AssemblyNameComparer(AssemblyNameComparerFlags.All);
AssemblyDef cachedResult;
if (!LoadedAssemblies.TryGetValue(new AssemblyNameInfo(result), out cachedResult)) {
Debug.Assert(!string.IsNullOrEmpty(result.ManifestModule.Location));
// Resolving assemblies must be done in non-UI thread, or else Wait() will deadlock.
Debug.Assert(Manager.InvokeRequired);
Manager.LoadModule(result.ManifestModule.Location).Wait();
cachedResult = LoadedAssemblies[new AssemblyNameInfo(result)];
ResolveNetModules(cachedResult);
}
return cachedResult;
}
