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);
}
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 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);
}
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);
}
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);
}
/// <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);
}
}
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);
}
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);
}
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);
}
/// <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;
}
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;
});
}
/// <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())));
}
