IDnSpyFile[] Open(bool many)
{
var dialog = new OpenFileDialog()
{
Filter = PickFilenameConstants.DotNetAssemblyOrModuleFilter,
RestoreDirectory = true,
Multiselect = many,
};
if (dialog.ShowDialog() != DialogResult.OK)
{
return(Array.Empty <IDnSpyFile>());
}
var list = new List <IDnSpyFile>(dialog.FileNames.Length);
foreach (var filename in dialog.FileNames)
{
var info = DnSpyFileInfo.CreateFile(filename);
var file = fileManager.TryGetOrCreate(info);
if (file != null)
{
list.Add(file);
}
}
return(list.ToArray());
}
static void Execute(Lazy <IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes)
{
if (!AddNetModuleToAssemblyCommand.CanExecute(nodes))
{
return;
}
var asmNode = (IDnSpyFileNode)nodes[0];
if (asmNode is IModuleFileNode)
{
asmNode = (IAssemblyFileNode)asmNode.TreeNode.Parent.Data;
}
var win = new NetModuleOptionsDlg();
var data = new NetModuleOptionsVM(asmNode.DnSpyFile.ModuleDef);
win.DataContext = data;
win.Owner = appWindow.MainWindow;
if (win.ShowDialog() != true)
{
return;
}
var options = data.CreateNetModuleOptions();
var newModule = ModuleUtils.CreateNetModule(options.Name, options.Mvid, options.ClrVersion);
var newFile = DnSpyDotNetFile.CreateModule(DnSpyFileInfo.CreateFile(string.Empty), newModule, appWindow.FileTreeView.FileManager.Settings.LoadPDBFiles);
var newModNode = asmNode.Context.FileTreeView.CreateModule(newFile);
var cmd = new AddNewNetModuleToAssemblyCommand(undoCommandManager.Value, (IDnSpyFileNode)nodes[0], newModNode);
undoCommandManager.Value.Add(cmd);
appWindow.FileTabManager.FollowReference(cmd.modNode);
}
static Tuple <DefaultFileList, bool> ReadDefaultFileList(string filename)
{
try {
var doc = XDocument.Load(filename, LoadOptions.None);
var root = doc.Root;
if (root.Name != "FileList")
{
return(null);
}
var name = (string)root.Attribute("name");
if (string.IsNullOrWhiteSpace(name))
{
return(null);
}
bool?isDefault = (bool?)root.Attribute("default");
var l = new DefaultFileList(name);
foreach (var sect in root.Elements("File"))
{
var asmFullName = (string)sect.Attribute("name");
if (string.IsNullOrWhiteSpace(asmFullName))
{
return(null);
}
l.Add(DnSpyFileInfo.CreateGacFile(asmFullName));
}
return(Tuple.Create(l, isDefault ?? false));
}
catch {
Debug.Fail("Exception");
}
return(null);
}
IDnSpyFile ResolveWinMD(IAssembly assembly, ModuleDef sourceModule)
{
var existingFile = fileManager.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(fileManager.TryGetOrCreateInternal(DnSpyFileInfo.CreateFile(file), true, true));
}
}
return(null);
}
void OnDropFiles(int index, string[] filenames)
{
if (!context.CanDragAndDrop)
{
return;
}
var existingFiles = new HashSet <string>(fileManager.GetFiles().Select(a => a.Filename ?? string.Empty), StringComparer.OrdinalIgnoreCase);
filenames = filenames.Where(a => File.Exists(a) && !existingFiles.Contains(a)).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
ITreeNodeData newSelectedNode = null;
for (int i = 0, j = 0; i < filenames.Length; i++)
{
var file = fileManager.TryCreateOnly(DnSpyFileInfo.CreateFile(filenames[i]));
if (file == null)
{
continue;
}
var node = CreateNode(null, file);
fileManager.ForceAdd(file, false, new AddFileInfo(node, index + j++));
if (newSelectedNode == null)
{
newSelectedNode = node;
}
}
if (newSelectedNode != null)
{
treeView.SelectItems(new[] { newSelectedNode });
}
}
protected override void OnPropertyChanged(string propName)
{
base.OnPropertyChanged(propName);
if (propName == "Filename")
{
fileInfo = DnSpyFileInfo.CreateFile(Filename);
}
}
public static void Save(ISettingsSection section, DnSpyFileInfo info)
{
section.Attribute(FILEINFO_NAME_ATTR, info.Name);
if (info.Type != FileConstants.FILETYPE_FILE)
{
section.Attribute(FILEINFO_TYPE_ATTR, info.Type);
}
}
CreateNetModuleCommand(Lazy <IUndoCommandManager> undoCommandManager, IFileTreeView fileTreeView, NetModuleOptions options)
{
this.undoCommandManager = undoCommandManager;
var module = ModuleUtils.CreateNetModule(options.Name, options.Mvid, options.ClrVersion);
var file = DnSpyDotNetFile.CreateModule(DnSpyFileInfo.CreateFile(string.Empty), module, fileTreeView.FileManager.Settings.LoadPDBFiles);
this.fileNodeCreator = RootDnSpyFileNodeCreator.CreateModule(fileTreeView, file);
}
public DnSpyFileInfo ToDnSpyFileInfo()
{
if (string.IsNullOrEmpty(Filename))
{
return(DnSpyFileInfo.CreateGacFile(AssemblyFullName));
}
return(DnSpyFileInfo.CreateReferenceAssembly(AssemblyFullName, Filename));
}
public IDnSpyFile Create(IFileManager fileManager, DnSpyFileInfo fileInfo)
{
var filename = GetFilename(fileInfo);
if (filename != null)
{
return(FileManager.CreateDnSpyFileFromFile(fileInfo, filename, fileManager.Settings.UseMemoryMappedIO, fileManager.Settings.LoadPDBFiles, fileManager.AssemblyResolver));
}
return(null);
}
CreateAssemblyCommand(IUndoCommandManager undoCommandManager, IFileTreeView fileTreeView, ModuleDef newModule, AssemblyOptions options)
{
this.undoCommandManager = undoCommandManager;
var module = Module.ModuleUtils.CreateModule(options.Name, Guid.NewGuid(), options.ClrVersion, ModuleKind.Dll, newModule);
options.CreateAssemblyDef(module).Modules.Add(module);
var file = DnSpyDotNetFile.CreateAssembly(DnSpyFileInfo.CreateFile(string.Empty), module, fileTreeView.FileManager.Settings.LoadPDBFiles);
this.fileNodeCreator = RootDnSpyFileNodeCreator.CreateAssembly(fileTreeView, file);
}
public IDnSpyFilenameKey CreateKey(IFileManager fileManager, DnSpyFileInfo fileInfo)
{
var filename = GetFilename(fileInfo);
if (filename != null)
{
return(new FilenameKey(filename));
}
return(null);
}
string GetDescription(DnSpyFileInfo info)
{
if (info.Type == FileConstants.FILETYPE_REFASM)
{
int index = info.Name.LastIndexOf(FileConstants.REFERENCE_ASSEMBLY_SEPARATOR);
if (index >= 0)
{
return(info.Name.Substring(0, index));
}
}
return(info.Name);
}
FileTabReferenceResult CreateMemberRefResult(IFileTabManager fileTabManager, object @ref)
{
var resolvedRef = ResolveMemberDef(@ref as IMemberRef);
if (!IsSupportedReference(resolvedRef))
{
return(null);
}
var newRef = GetReference(@ref);
var node = fileTabManager.FileTreeView.FindNode(newRef);
if (node == null)
{
// If it's eg. a TypeDef, its assembly has been removed from the file list or it
// was never inserted because adding an assembly had been temporarily disabled.
// Add the assembly to the list again. Next time the user clicks on the link,
// FindNode() above will succeed.
var def = @ref as IMemberDef;
if (def != null)
{
DnSpyFile file = null;
var mod = def.Module;
if (mod != null && mod.Assembly != null)
{
file = DnSpyDotNetFile.CreateAssembly(DnSpyFileInfo.CreateFile(mod.Location), mod, false);
}
else if (mod != null)
{
file = DnSpyDotNetFile.CreateModule(DnSpyFileInfo.CreateFile(mod.Location), mod, false);
}
if (file != null)
{
var existingFile = fileTabManager.FileTreeView.FileManager.GetOrAdd(file);
if (existingFile != file)
{
fileTabManager.FileTreeView.FileManager.ForceAdd(file, true, null);
}
}
}
return(null);
}
var content = decompileFileTabContentFactory.Create(new IFileTreeNodeData[] { node });
return(new FileTabReferenceResult(content, null, a => {
if (a.Success && !a.HasMovedCaret)
{
GoToReference(content, resolvedRef);
a.HasMovedCaret = true;
}
}));
}
public IDnSpyFilenameKey CreateKey(IFileManager fileManager, DnSpyFileInfo fileInfo)
{
if (fileInfo.Type == MyDnSpyFile.THE_GUID)
{
return(new FilenameKey(fileInfo.Name)); // Must match the key in MyDnSpyFile.Key
}
// Also check for normal files
if (fileInfo.Type == FileConstants.FILETYPE_FILE && IsSupportedFile(fileInfo.Name))
{
return(new FilenameKey(fileInfo.Name)); // Must match the key in MyDnSpyFile.Key
}
return(null);
}
public IDnSpyFile Create(IFileManager fileManager, DnSpyFileInfo fileInfo)
{
if (fileInfo.Type == MyDnSpyFile.THE_GUID)
{
return(MyDnSpyFile.TryCreate(fileInfo.Name));
}
// Also check for normal files
if (fileInfo.Type == FileConstants.FILETYPE_FILE && IsSupportedFile(fileInfo.Name))
{
return(MyDnSpyFile.TryCreate(fileInfo.Name));
}
return(null);
}
static Tuple <DefaultFileList, bool> ReadDefaultFileList(string filename)
{
try {
var doc = XDocument.Load(filename, LoadOptions.None);
var root = doc.Root;
if (root.Name != "FileList")
{
return(null);
}
var name = (string)root.Attribute("name");
if (string.IsNullOrWhiteSpace(name))
{
return(null);
}
bool?isDefault = (bool?)root.Attribute("default");
var l = new DefaultFileList(name);
foreach (var sect in root.Elements("File"))
{
var name2 = (string)sect.Attribute("name");
if (string.IsNullOrWhiteSpace(name2))
{
return(null);
}
var type = (string)sect.Attribute("type") ?? "gac";
var guidStr = (string)sect.Attribute("guid");
Guid guid = Guid.Empty;
bool hasGuid = guidStr != null && Guid.TryParse(guidStr, out guid);
if (type.Equals("file"))
{
l.Add(DnSpyFileInfo.CreateFile(name2));
}
else if (type.Equals("refasm"))
{
l.Add(new DnSpyFileInfo(name2, FileConstants.FILETYPE_REFASM));
}
else if (type.Equals("user-file") && hasGuid)
{
l.Add(new DnSpyFileInfo(name2, guid));
}
else // should be "gac"
{
l.Add(DnSpyFileInfo.CreateGacFile(name2));
}
}
return(Tuple.Create(l, isDefault ?? false));
}
catch {
Debug.Fail("Exception");
}
return(null);
}
static string GetFilename(DnSpyFileInfo fileInfo)
{
if (fileInfo.Type == FileConstants.FILETYPE_FILE)
{
return(fileInfo.Name);
}
if (fileInfo.Type == FileConstants.FILETYPE_GAC)
{
return(GetGacFilename(fileInfo.Name));
}
if (fileInfo.Type == FileConstants.FILETYPE_REFASM)
{
return(GetRefFileFilename(fileInfo.Name));
}
return(null);
}
public static void OpenFiles(IFileTreeView fileTreeView, Window ownerWindow, IEnumerable <string> filenames, bool selectFile = true)
{
var fileLoader = new FileLoader(fileTreeView.FileManager, ownerWindow);
var loadedFiles = fileLoader.Load(filenames.Select(a => new FileToLoad(DnSpyFileInfo.CreateFile(a))));
var file = loadedFiles.Length == 0 ? null : loadedFiles[loadedFiles.Length - 1];
if (selectFile && file != null)
{
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => {
var node = fileTreeView.FindNode(file);
if (node != null)
{
fileTreeView.TreeView.SelectItems(new IFileTreeNodeData[] { node });
}
}));
}
}
internal IDnSpyFile TryCreateDnSpyFile(DnSpyFileInfo info)
{
foreach (var provider in dnSpyFileProviders)
{
try {
var file = provider.Create(this, info);
if (file != null)
{
return(file);
}
}
catch (Exception ex) {
Debug.WriteLine($"{nameof(IDnSpyFileProvider)} ({provider.GetType()}) failed with an exception: {ex.Message}");
}
}
return(null);
}
internal IDnSpyFile TryCreateDnSpyFile(DnSpyFileInfo info)
{
foreach (var creator in dnSpyFileCreators)
{
try {
var file = creator.Create(this, info);
if (file != null)
{
return(file);
}
}
catch (Exception ex) {
Debug.WriteLine(string.Format("IDnSpyFileCreator ({0}) failed with an exception: {1}", creator.GetType(), ex.Message));
}
}
return(null);
}
IDnSpyFilenameKey TryCreateKey(DnSpyFileInfo info)
{
foreach (var creator in dnSpyFileCreators)
{
try {
var key = creator.CreateKey(this, info);
if (key != null)
{
return(key);
}
}
catch (Exception ex) {
Debug.WriteLine(string.Format("IDnSpyFileCreator ({0}) failed with an exception: {1}", creator.GetType(), ex.Message));
}
}
return(null);
}
IDnSpyFilenameKey TryCreateKey(DnSpyFileInfo info)
{
foreach (var provider in dnSpyFileProviders)
{
try {
var key = provider.CreateKey(this, info);
if (key != null)
{
return(key);
}
}
catch (Exception ex) {
Debug.WriteLine($"{nameof(IDnSpyFileProvider)} ({provider.GetType()}) failed with an exception: {ex.Message}");
}
}
return(null);
}
IDnSpyFile TryLoadFromDir2(IAssembly asmName, bool exactCheck, string filename)
{
if (!File.Exists(filename))
{
return(null);
}
IDnSpyFile file = null;
bool error = true;
try {
file = fileManager.TryCreateDnSpyFile(DnSpyFileInfo.CreateFile(filename));
if (file == null)
{
return(null);
}
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 is IDisposable)
{
((IDisposable)file).Dispose();
}
}
}
}
static void Execute(Lazy <IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IFileTreeNodeData[] nodes)
{
if (!AddNetModuleToAssemblyCommand.CanExecute(nodes))
{
return;
}
var dialog = new System.Windows.Forms.OpenFileDialog()
{
Filter = PickFilenameConstants.NetModuleFilter,
RestoreDirectory = true,
};
if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK)
{
return;
}
if (string.IsNullOrEmpty(dialog.FileName))
{
return;
}
var fm = appWindow.FileTreeView.FileManager;
var file = DnSpyFile.CreateDnSpyFileFromFile(DnSpyFileInfo.CreateFile(dialog.FileName), dialog.FileName, fm.Settings.UseMemoryMappedIO, fm.Settings.LoadPDBFiles, fm.AssemblyResolver, true);
if (file.ModuleDef == null || file.AssemblyDef != null || !(file is IDnSpyDotNetFile))
{
Shared.App.MsgBox.Instance.Show(string.Format(dnSpy_AsmEditor_Resources.Error_NotNetModule, file.Filename), MsgBoxButton.OK);
var id = file as IDisposable;
if (id != null)
{
id.Dispose();
}
return;
}
var node = (IDnSpyFileNode)nodes[0];
var newModNode = node.Context.FileTreeView.CreateModule((IDnSpyDotNetFile)file);
var cmd = new AddExistingNetModuleToAssemblyCommand(undoCommandManager.Value, node, newModNode);
undoCommandManager.Value.Add(cmd);
appWindow.FileTabManager.FollowReference(cmd.modNode);
}
public static IDnSpyFile CreateDnSpyFileFromFile(DnSpyFileInfo fileInfo, string filename, bool useMemoryMappedIO, bool loadPDBFiles, IAssemblyResolver asmResolver, bool isModule)
{
try {
// Quick check to prevent exceptions from being thrown
if (!File.Exists(filename))
{
return(new DnSpyUnknownFile(filename));
}
IPEImage peImage;
if (useMemoryMappedIO)
{
peImage = new PEImage(filename);
}
else
{
peImage = new PEImage(File.ReadAllBytes(filename), filename);
}
var dotNetDir = peImage.ImageNTHeaders.OptionalHeader.DataDirectories[14];
bool isDotNet = dotNetDir.VirtualAddress != 0 && dotNetDir.Size >= 0x48;
if (isDotNet)
{
try {
var options = new ModuleCreationOptions(DnSpyDotNetFileBase.CreateModuleContext(asmResolver));
if (isModule)
{
return(DnSpyDotNetFile.CreateModule(fileInfo, ModuleDefMD.Load(peImage, options), loadPDBFiles));
}
return(DnSpyDotNetFile.CreateAssembly(fileInfo, ModuleDefMD.Load(peImage, options), loadPDBFiles));
}
catch {
}
}
return(new DnSpyPEFile(peImage));
}
catch {
}
return(new DnSpyUnknownFile(filename));
}
void OnDropFiles(int index, string[] filenames)
{
if (!context.CanDragAndDrop)
{
return;
}
var origFilenames = filenames;
var existingFiles = new HashSet <string>(FileManager.GetFiles().Select(a => a.Filename ?? string.Empty), StringComparer.OrdinalIgnoreCase);
filenames = filenames.Where(a => File.Exists(a) && !existingFiles.Contains(a)).Distinct(StringComparer.OrdinalIgnoreCase).OrderBy(a => Path.GetFileNameWithoutExtension(a), StringComparer.CurrentCultureIgnoreCase).ToArray();
ITreeNodeData newSelectedNode = null;
for (int i = 0, j = 0; i < filenames.Length; i++)
{
var file = FileManager.TryCreateOnly(DnSpyFileInfo.CreateFile(filenames[i]));
if (file == null)
{
continue;
}
var node = CreateNode(null, file);
FileManager.ForceAdd(file, false, new AddFileInfo(node, index + j++));
if (newSelectedNode == null)
{
newSelectedNode = node;
}
}
if (newSelectedNode == null)
{
var filename = origFilenames.FirstOrDefault(a => File.Exists(a));
if (filename != null)
{
var key = new FilenameKey(filename);
var file = FileManager.GetFiles().FirstOrDefault(a => key.Equals(a.Key));
newSelectedNode = FindNode(file);
}
}
if (newSelectedNode != null)
{
TreeView.SelectItems(new[] { newSelectedNode });
}
}
IDnSpyFile ResolveNormal(IAssembly assembly, ModuleDef sourceModule)
{
var existingFile = fileManager.FindAssembly(assembly);
if (existingFile != null)
{
return(existingFile);
}
var file = LookupFromSearchPaths(assembly, sourceModule, true);
if (file != null)
{
return(fileManager.GetOrAddCanDispose(file));
}
if (fileManager.Settings.UseGAC)
{
var gacFile = GacInfo.FindInGac(assembly);
if (gacFile != null)
{
return(fileManager.TryGetOrCreateInternal(DnSpyFileInfo.CreateFile(gacFile), true, true));
}
foreach (var path in GacInfo.OtherGacPaths)
{
file = TryLoadFromDir(assembly, true, path);
if (file != null)
{
return(fileManager.GetOrAddCanDispose(file));
}
}
}
file = LookupFromSearchPaths(assembly, sourceModule, false);
if (file != null)
{
return(fileManager.GetOrAddCanDispose(file));
}
return(null);
}
protected override List <IDnSpyFile> CreateChildren()
{
var asm = AssemblyDef;
var list = new List <IDnSpyFile>(asm == null ? 1 : asm.Modules.Count);
if (isAsmNode && asm != null)
{
bool foundThis = false;
foreach (var module in asm.Modules)
{
if (this.module == module)
{
Debug.Assert(!foundThis);
foundThis = true;
}
list.Add(new DnSpyDotNetFile(DnSpyFileInfo.CreateFile(module.Location), module, loadedSymbols, false));
}
Debug.Assert(foundThis);
}
return(list);
}
public IDnSpyFile Open()
{
var dialog = new OpenFileDialog()
{
Filter = PickFilenameConstants.DotNetAssemblyOrModuleFilter,
RestoreDirectory = true,
};
if (dialog.ShowDialog() != DialogResult.OK)
{
return(null);
}
if (string.IsNullOrEmpty(dialog.FileName))
{
return(null);
}
var info = DnSpyFileInfo.CreateFile(dialog.FileName);
return(fileManager.TryGetOrCreate(info));
}
