Example #1
0
        protected Dictionary <string, string> GetReferences(Microsoft.CodeAnalysis.Project parentProject)
        {
            var dict = new Dictionary <string, string>();

            foreach (var reference in parentProject.MetadataReferences)
            {
                using (var assemblyDef = AssemblyDefinition.ReadAssembly(reference.Display)) {
                    if (IsReferenceAssembly(assemblyDef))
                    {
                        dict.Add(assemblyDef.Name.Name, GacInterop.FindAssemblyInNetGac(assemblyDef.Name));
                    }
                    else
                    {
                        dict.Add(assemblyDef.Name.Name, reference.Display);
                    }
                }
            }
            foreach (var projectReference in parentProject.ProjectReferences)
            {
                var roslynProject = owner.Workspace.CurrentSolution.GetProject(projectReference.ProjectId);
                var project       = owner.DTE.Solution.Projects.OfType <EnvDTE.Project>().FirstOrDefault(p => p.FileName == roslynProject.FilePath);
                if (roslynProject != null && project != null)
                {
                    dict.Add(roslynProject.AssemblyName, GetProjectOutputPath(project, roslynProject));
                }
            }
            return(dict);
        }
Example #2
0
        protected Dictionary <string, DetectedReference> GetReferences(Microsoft.CodeAnalysis.Project parentProject)
        {
            var dict = new Dictionary <string, DetectedReference>();

            foreach (var reference in parentProject.MetadataReferences)
            {
                using (var assemblyDef = AssemblyDefinition.ReadAssembly(reference.Display)) {
                    string assemblyName = assemblyDef.Name.Name;
                    if (IsReferenceAssembly(assemblyDef))
                    {
                        string resolvedAssemblyFile = GacInterop.FindAssemblyInNetGac(assemblyDef.Name);
                        dict.Add(assemblyName,
                                 new DetectedReference(assemblyName, resolvedAssemblyFile, false));
                    }
                    else
                    {
                        dict.Add(assemblyName,
                                 new DetectedReference(assemblyName, reference.Display, false));
                    }
                }
            }
            foreach (var projectReference in parentProject.ProjectReferences)
            {
                var roslynProject = owner.Workspace.CurrentSolution.GetProject(projectReference.ProjectId);
                var project       = FindProject(owner.DTE.Solution.Projects.OfType <EnvDTE.Project>(), roslynProject.FilePath);
                if (roslynProject != null && project != null)
                {
                    dict.Add(roslynProject.AssemblyName,
                             new DetectedReference(roslynProject.AssemblyName, Utils.GetProjectOutputAssembly(project, roslynProject), true));
                }
            }
            return(dict);
        }
Example #3
0
        private void OpenReferenceInILSpyCallback(object sender, EventArgs e)
        {
            var explorer = ((EnvDTE80.DTE2)GetGlobalService(typeof(EnvDTE.DTE))).ToolWindows.SolutionExplorer;
            var items    = (object[])explorer.SelectedItems;

            foreach (EnvDTE.UIHierarchyItem item in items)
            {
                var reference = GetReference(item.Object);
                if (reference == null)
                {
                    ShowMessage("No reference information was found in the selection!");
                    continue;
                }
                string path = null;
                if (!string.IsNullOrEmpty(reference.PublicKeyToken))
                {
                    var token = Utils.HexStringToBytes(reference.PublicKeyToken);
                    path = GacInterop.FindAssemblyInNetGac(new AssemblyNameReference(reference.Name, reference.Version)
                    {
                        PublicKeyToken = token
                    });
                }
                if (path == null)
                {
                    path = reference.Path;
                }
                OpenAssembliesInILSpy(new[] { path });
            }
        }
Example #4
0
        /// <summary>
        /// If possible retrieves parameters to use for launching ILSpy instance.
        /// </summary>
        /// <returns>Parameters object or <c>null, if not applicable.</c></returns>
        public ILSpyParameters GetILSpyParameters()
        {
            if (resolvedPath != null)
            {
                return(new ILSpyParameters(new[] { $"{resolvedPath}" }));
            }
            else if (!string.IsNullOrWhiteSpace(fusionName))
            {
                return(new ILSpyParameters(new string[] { GacInterop.FindAssemblyInNetGac(Decompiler.Metadata.AssemblyNameReference.Parse(fusionName)) }));
            }

            return(null);
        }
Example #5
0
        protected override void OnExecute(object sender, EventArgs e)
        {
            var explorer = owner.DTE.ToolWindows.SolutionExplorer;
            var item     = ((object[])explorer.SelectedItems).FirstOrDefault() as UIHierarchyItem;

            if (item == null)
            {
                return;
            }
            if (item.Object is Reference reference)
            {
                var project       = reference.ContainingProject;
                var roslynProject = owner.Workspace.CurrentSolution.Projects.FirstOrDefault(p => p.FilePath == project.FileName);
                var references    = GetReferences(roslynProject);
                if (references.TryGetValue(reference.Name, out var path))
                {
                    OpenAssembliesInILSpy(new[] { path });
                }
                else
                {
                    owner.ShowMessage("Could not find reference '{0}', please ensure the project and all references were built correctly!", reference.Name);
                }
            }
            else
            {
                dynamic referenceObject = item.Object;
                var     values          = GetProperties(referenceObject.Properties, "Type", "FusionName", "ResolvedPath");
                if (values[0] == "Package")
                {
                    values = GetProperties(referenceObject.Properties, "Name", "Version", "Path");
                    if (values[0] != null && values[1] != null && values[2] != null)
                    {
                        OpenAssembliesInILSpy(new[] { $"{values[2]}\\{values[0]}.{values[1]}.nupkg" });
                        return;
                    }
                }
                else if (values[2] != null)
                {
                    OpenAssembliesInILSpy(new[] { $"{values[2]}" });
                    return;
                }
                else if (!string.IsNullOrWhiteSpace(values[1]))
                {
                    OpenAssembliesInILSpy(new string[] { GacInterop.FindAssemblyInNetGac(AssemblyNameReference.Parse(values[1])) });
                    return;
                }
                owner.ShowMessage("Could not find reference '{0}', please ensure the project and all references were built correctly!", referenceObject.Name);
            }
        }
Example #6
0
        /// <summary>
        /// This function is the callback used to execute a command when the a menu item is clicked.
        /// See the Initialize method to see how the menu item is associated to this function using
        /// the OleMenuCommandService service and the MenuCommand class.
        /// </summary>
        private void OpenInILSpyCallback(object sender, EventArgs e)
        {
            var explorer = ((EnvDTE80.DTE2)GetGlobalService(typeof(EnvDTE.DTE))).ToolWindows.SolutionExplorer;
            var items    = (object[])explorer.SelectedItems;

            foreach (EnvDTE.UIHierarchyItem item in items)
            {
                dynamic reference = item.Object;
                string  path      = null;
                if (reference.PublicKeyToken != "")
                {
                    var token = Utils.HexStringToBytes(reference.PublicKeyToken);
                    path = GacInterop.FindAssemblyInNetGac(new AssemblyNameReference(reference.Identity, new Version(reference.Version))
                    {
                        PublicKeyToken = token
                    });
                }
                if (path == null)
                {
                    path = reference.Path;
                }
                OpenAssemblyInILSpy(path);
            }
        }
Example #7
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));
        }

        DnSpyFile ResolveNormal(IAssembly assembly, ModuleDef sourceModule, bool delayLoad)
        {
            var existingFile = fileList.FindAssembly(assembly);

            if (existingFile != null)
            {
                return(existingFile);
            }

            var file = LookupFromSearchPaths(assembly, sourceModule, true);

            if (file != null)
            {
                return(fileList.AddFile(file, fileList.AssemblyLoadEnabled, delayLoad));
            }

            if (fileList.UseGAC)
            {
                var gacFile = GacInterop.FindAssemblyInNetGac(assembly);
                if (gacFile != null)
                {
                    return(fileList.GetOrCreate(gacFile, fileList.AssemblyLoadEnabled, true, delayLoad));
                }
                foreach (var path in GacInfo.OtherGacPaths)
                {
                    file = TryLoadFromDir(assembly, true, path);
                    if (file != null)
                    {
                        return(fileList.AddFile(file, fileList.AssemblyLoadEnabled, delayLoad));
                    }
                }
            }

            file = LookupFromSearchPaths(assembly, sourceModule, false);
            if (file != null)
            {
                return(fileList.AddFile(file, fileList.AssemblyLoadEnabled, delayLoad));
            }

            return(null);
        }

        DnSpyFile LookupFromSearchPaths(IAssembly asmName, ModuleDef sourceModule, bool exactCheck)
        {
            DnSpyFile file;
            string    sourceModuleDir = null;

            if (sourceModule != null && File.Exists(sourceModule.Location))
            {
                sourceModuleDir = Path.GetDirectoryName(sourceModule.Location);
                file            = TryLoadFromDir(asmName, exactCheck, sourceModuleDir);
                if (file != null)
                {
                    return(file);
                }
            }
            var ary = asmSearchPathsArray;

            foreach (var path in ary)
            {
                file = TryLoadFromDir(asmName, exactCheck, path);
                if (file != null)
                {
                    return(file);
                }
            }

            return(null);
        }

        DnSpyFile TryLoadFromDir(IAssembly asmName, bool exactCheck, string dirPath)
        {
            string baseName;

            try {
                baseName = Path.Combine(dirPath, asmName.Name);
            }
            catch (ArgumentException) {             // eg. invalid chars in asmName.Name
                return(null);
            }
            return(TryLoadFromDir2(asmName, exactCheck, baseName + ".dll") ??
                   TryLoadFromDir2(asmName, exactCheck, baseName + ".exe"));
        }

        DnSpyFile TryLoadFromDir2(IAssembly asmName, bool exactCheck, string filename)
        {
            if (!File.Exists(filename))
            {
                return(null);
            }

            DnSpyFile file  = null;
            bool      error = true;

            try {
                file = fileList.CreateDnSpyFile(filename);
                file.IsAutoLoaded = true;
                var asm = file.AssemblyDef;
                if (asm == null)
                {
                    return(null);
                }
                bool b = exactCheck ?
                         AssemblyNameComparer.CompareAll.Equals(asmName, asm) :
                         AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(asmName, asm);
                if (!b)
                {
                    return(null);
                }

                error = false;
                return(file);
            }
            finally {
                if (error)
                {
                    if (file != null)
                    {
                        file.Dispose();
                    }
                }
            }
        }

        DnSpyFile ResolveWinMD(IAssembly assembly, ModuleDef sourceModule, bool delayLoad)
        {
            var existingFile = fileList.FindAssembly(assembly);

            if (existingFile != null)
            {
                return(existingFile);
            }

            foreach (var winmdPath in GacInfo.WinmdPaths)
            {
                string file;
                try {
                    file = Path.Combine(winmdPath, assembly.Name + ".winmd");
                }
                catch (ArgumentException) {
                    continue;
                }
                if (File.Exists(file))
                {
                    return(fileList.GetOrCreate(file, fileList.AssemblyLoadEnabled, true, delayLoad));
                }
            }
            return(null);
        }
    }
Example #8
0
 static string FindAssemblyFromGAC(AssemblyDefinition assemblyDefinition)
 {
     return(GacInterop.FindAssemblyInNetGac(assemblyDefinition.Name));
 }
Example #9
0
 static string FindAssemblyFromGAC(AssemblyDefinition assemblyDefinition)
 {
     return(GacInterop.FindAssemblyInNetGac(Decompiler.Metadata.AssemblyNameReference.Parse(assemblyDefinition.Name.FullName)));
 }