protected override void LoadChildren() { this.Children.Add(new ReferenceFolderTreeNode(module, assemblyNode)); if (module.HasResources) this.Children.Add(new ResourceListTreeNode(module)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDefinition type in module.Types.OrderBy(t => t.FullName)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, assemblyNode); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) this.Children.Add(ns); } }
protected override void LoadChildren() { this.Children.Add(new ReferenceFolderTreeNode(module, assemblyNode)); if (module.HasResources) { this.Children.Add(new ResourceListTreeNode(module)); } foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDefinition type in module.Types.OrderBy(t => t.FullName)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, assemblyNode); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } }
internal void OnReadded(NamespaceTreeNode nsNode) { Debug.Assert(!namespaces.ContainsKey(nsNode.Name)); namespaces.Add(nsNode.Name, nsNode); foreach (TypeTreeNode typeNode in nsNode.Children) { OnReadded(typeNode); } }
public NamespaceTreeNodeCreator(string ns, AssemblyTreeNode asmNode) { Debug.Assert(asmNode.IsModule); if (!asmNode.IsModule) throw new InvalidOperationException(); this.asmNode = asmNode; this.nsNode = asmNode.FindNamespaceNode(ns); if (this.nsNode == null) { this.nsNode = new NamespaceTreeNode(ns); this.nsNodeCreated = true; } }
NamespaceTreeNode GetOrCreateNamespaceNode(string ns) { EnsureChildrenFiltered(); NamespaceTreeNode nsNode; if (namespaces.TryGetValue(ns, out nsNode)) { return(nsNode); } nsNode = new NamespaceTreeNode(ns); namespaces.Add(nsNode.Name, nsNode); AddToChildren(nsNode); return(nsNode); }
internal void OnRemoved(NamespaceTreeNode nsNode) { bool b = namespaces.Remove(nsNode.Name); Debug.Assert(b); if (!b) { throw new InvalidOperationException(); } foreach (TypeTreeNode typeNode in nsNode.Children) { OnRemoved(typeNode); } }
protected override void LoadChildren() { var module = LoadedAssembly.GetPEFileOrNull(); if (module == null) { // if we crashed on loading, then we don't have any children return; } typeSystem = LoadedAssembly.GetTypeSystemOrNull(DecompilerTypeSystem.GetOptions(new DecompilationOptions().DecompilerSettings)); var assembly = (MetadataModule)typeSystem.MainModule; var metadata = module.Metadata; this.Children.Add(new Metadata.MetadataTreeNode(module, this)); Decompiler.DebugInfo.IDebugInfoProvider debugInfo = LoadedAssembly.GetDebugInfoOrNull(); if (debugInfo is Decompiler.PdbProvider.PortableDebugInfoProvider ppdb) { this.Children.Add(new Metadata.DebugMetadataTreeNode(module, ppdb.IsEmbedded, ppdb.Provider.GetMetadataReader(), this)); } this.Children.Add(new ReferenceFolderTreeNode(module, this)); if (module.Resources.Any()) { this.Children.Add(new ResourceListTreeNode(module)); } foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (var type in assembly.TopLevelTypeDefinitions.OrderBy(t => t.ReflectionName, NaturalStringComparer.Instance)) { var escapedNamespace = Language.EscapeName(type.Namespace); if (!namespaces.TryGetValue(type.Namespace, out NamespaceTreeNode ns)) { ns = new NamespaceTreeNode(escapedNamespace); namespaces.Add(type.Namespace, ns); } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[(TypeDefinitionHandle)type.MetadataToken] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name, NaturalStringComparer.Instance)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } }
protected override void LoadChildren() { ModuleDef moduleDefinition = assembly.ModuleDefinition; if (moduleDefinition == null) { // if we crashed on loading, then we don't have any children return; } if (moduleDefinition is ModuleDefMD) { this.Children.Add(new ReferenceFolderTreeNode((ModuleDefMD)moduleDefinition, this)); } if (moduleDefinition.HasResources) { this.Children.Add(new ResourceListTreeNode(moduleDefinition)); } foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDef type in moduleDefinition.Types.OrderBy(t => t.FullName)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } }
void LoadModuleChildren(IPEImage peImage, ModuleDef module) { var asmListTreeNode = this.Ancestors().OfType <DnSpyFileListTreeNode>().FirstOrDefault(); Debug.Assert(asmListTreeNode != null); // Only show the PE node if it was loaded from a file. The hex document is always loaded // from a file, so if the PEImage wasn't loaded from the same file, conversion to/from // RVA/FileOffset won't work and the wrong data will be displayed, eg. in the .NET // storage stream nodes. if (DnSpyFile.LoadedFromFile && peImage != null) { this.Children.Add(new PETreeNode(peImage, module as ModuleDefMD)); } if (module != null) { this.Children.Add(new ReferenceFolderTreeNode(module, this, asmListTreeNode)); this.Children.Add(new ResourceListTreeNode(module)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDef type in module.Types.OrderBy(t => t.FullName, TypeStringComparer)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } } }
protected override void LoadChildren() { var module = LoadedAssembly.GetPEFileOrNull(); if (module == null) { // if we crashed on loading, then we don't have any children return; } typeSystem = LoadedAssembly.GetTypeSystemOrNull(); var assembly = (MetadataModule)typeSystem.MainModule; var metadata = module.Metadata; this.Children.Add(new ReferenceFolderTreeNode(module, this)); if (module.Resources.Any()) { this.Children.Add(new ResourceListTreeNode(module)); } foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (var type in assembly.TopLevelTypeDefinitions.OrderBy(t => t.ReflectionName, NaturalStringComparer.Instance)) { if (!namespaces.TryGetValue(type.Namespace, out NamespaceTreeNode ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[(TypeDefinitionHandle)type.MetadataToken] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name, NaturalStringComparer.Instance)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } }
void LoadModuleChildren(IPEImage peImage, ModuleDef module) { var asmListTreeNode = this.Ancestors().OfType <AssemblyListTreeNode>().FirstOrDefault(); Debug.Assert(asmListTreeNode != null); if (peImage != null) { this.Children.Add(new PETreeNode(peImage, module as ModuleDefMD)); } if (module != null) { if (module is ModuleDefMD) { this.Children.Add(new ReferenceFolderTreeNode((ModuleDefMD)module, this, asmListTreeNode)); } this.Children.Add(new ResourceListTreeNode(module)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDef type in module.Types.OrderBy(t => t.FullName, TypeStringComparer)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) { this.Children.Add(ns); } } } }
public void Restore(NamespaceTreeNode[] nodes, ILSpyTreeNode[] parents) { Debug.Assert(infos != null); if (infos == null) throw new InvalidOperationException(); Debug.Assert(infos.Length == nodes.Length); if (infos.Length != nodes.Length) throw new InvalidOperationException(); for (int i = infos.Length - 1; i >= 0; i--) { var info = infos[i]; for (int j = info.Types.Length - 1; j >= 0; j--) info.Module.Types.Insert(info.Indexes[j], info.Types[j]); } infos = null; }
void LoadModuleChildren(ModuleDef moduleDefinition) { var asmListTreeNode = this.Ancestors().OfType<AssemblyListTreeNode>().FirstOrDefault(); Debug.Assert(asmListTreeNode != null); if (moduleDefinition is ModuleDefMD) this.Children.Add(new ReferenceFolderTreeNode((ModuleDefMD)moduleDefinition, this, asmListTreeNode)); this.Children.Add(new ResourceListTreeNode(moduleDefinition)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDef type in moduleDefinition.Types.OrderBy(t => t.FullName, TypeStringComparer)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) this.Children.Add(ns); } }
internal void OnRemoved(NamespaceTreeNode nsNode) { bool b = namespaces.Remove(nsNode.Name); Debug.Assert(b); if (!b) throw new InvalidOperationException(); foreach (TypeTreeNode typeNode in nsNode.Children) OnRemoved(typeNode); }
internal void OnReadded(NamespaceTreeNode nsNode) { Debug.Assert(!namespaces.ContainsKey(nsNode.Name)); namespaces.Add(nsNode.Name, nsNode); foreach (TypeTreeNode typeNode in nsNode.Children) OnReadded(typeNode); }
void LoadModuleChildren(IPEImage peImage, ModuleDef module) { var asmListTreeNode = this.Ancestors().OfType<DnSpyFileListTreeNode>().FirstOrDefault(); Debug.Assert(asmListTreeNode != null); // Only show the PE node if it was loaded from a file. The hex document is always loaded // from a file, so if the PEImage wasn't loaded from the same file, conversion to/from // RVA/FileOffset won't work and the wrong data will be displayed, eg. in the .NET // storage stream nodes. if (DnSpyFile.LoadedFromFile && peImage != null) this.Children.Add(new PETreeNode(peImage, module as ModuleDefMD)); if (module != null) { this.Children.Add(new ReferenceFolderTreeNode(module, this, asmListTreeNode)); this.Children.Add(new ResourceListTreeNode(module)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDef type in module.Types.OrderBy(t => t.FullName, TypeStringComparer)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) this.Children.Add(ns); } } }
NamespaceTreeNode GetOrCreateNamespaceNode(string ns) { EnsureChildrenFiltered(); NamespaceTreeNode nsNode; if (namespaces.TryGetValue(ns, out nsNode)) return nsNode; nsNode = new NamespaceTreeNode(ns); namespaces.Add(nsNode.Name, nsNode); AddToChildren(nsNode); return nsNode; }
RenameNamespaceCommand(string newName, NamespaceTreeNode nsNode) { this.newName = newName; this.origName = nsNode.Name; this.nsNode = nsNode; this.existingNsNode = (NamespaceTreeNode)nsNode.Parent.Children.FirstOrDefault(a => a is NamespaceTreeNode && AssemblyTreeNode.NamespaceStringEqualsComparer.Equals(newName, ((NamespaceTreeNode)a).Name)); var module = ILSpyTreeNode.GetModule(nsNode); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); this.origParentNode = (ILSpyTreeNode)nsNode.Parent; this.origParentChildIndex = this.origParentNode.Children.IndexOf(nsNode); Debug.Assert(this.origParentChildIndex >= 0); if (this.origParentChildIndex < 0) throw new InvalidOperationException(); // Make sure the exact same namespace names are restored if we undo. The names are UTF8 // strings, but not necessarily canonicalized if it's an obfuscated assembly. nsNode.EnsureChildrenFiltered(); this.origChildren = nsNode.Children.Cast<TypeTreeNode>().ToArray(); this.typeNamespaces = new UTF8String[nsNode.Children.Count]; for (int i = 0; i < this.typeNamespaces.Length; i++) this.typeNamespaces[i] = origChildren[i].TypeDefinition.Namespace; this.typeRefInfos = GetTypeRefInfos(module, new[] { nsNode }); }
public void Delete(NamespaceTreeNode[] nodes, ILSpyTreeNode[] parents) { Debug.Assert(parents != null && nodes.Length == parents.Length); Debug.Assert(infos == null); if (infos != null) throw new InvalidOperationException(); infos = new ModuleInfo[nodes.Length]; for (int i = 0; i < infos.Length; i++) { var node = nodes[i]; var module = ILSpyTreeNode.GetModule(parents[i]); Debug.Assert(module != null); if (module == null) throw new InvalidOperationException(); var info = new ModuleInfo(module, node.Children.Count); infos[i] = info; for (int j = 0; j < node.Children.Count; j++) { var typeNode = (TypeTreeNode)node.Children[j]; int index = module.Types.IndexOf(typeNode.TypeDefinition); Debug.Assert(index >= 0); if (index < 0) throw new InvalidOperationException(); module.Types.RemoveAt(index); info.Types[j] = typeNode.TypeDefinition; info.Indexes[j] = index; } } }
DeleteNamespaceCommand(NamespaceTreeNode[] nodes) { this.parents = nodes.Select(a => (ILSpyTreeNode)a.Parent).ToArray(); this.nodes = new DeletableNodes<NamespaceTreeNode>(nodes); this.modelNodes = new DeleteModelNodes(); }
/// <summary> /// Fills the given node with the nodes necessary for the preview of the importing. This action requires a call to Scan() /// </summary> /// <param name="root"></param> public void BuildPreviewNodes(SharpTreeNode root) { //Checks that the root node isn't null if (root == null) throw new ArgumentNullException("root"); //Checks if Scan() has already been called if (!Scanned) throw new InvalidOperationException("Cannot build preview nodes before a call to Scan()"); //Gets the members needed by the import list and by this instance var members = GetMembersForPreview().ToArray(); //Checks that there's at least one element if (members.Length == 0) return; //Builds up to the type nodes var typeNodes = BuildTypeNodes(members); //Lists of the assembly and module nodes (needed for preview of assembly references) var asmNodes = new List<ILEditTreeNode>(); var moduleNodes = new List<ILEditTreeNode>(); //Groups by assembly, module and then namespace var grouped = typeNodes.GroupBy(x => x.Member.Module) .OrderBy(x => x.Key.Name) .Select(x => x.OrderBy(y => y.Text.ToString()).GroupBy(y => ((TypeDefinition)y.Member).Namespace).OrderBy(y => y.Key).GroupBy(y => x.Key).ElementAt(0)) .GroupBy(x => x.Key.Assembly) .OrderBy(x => x.Key.Name.Name) .Select(x => { //Assembly node var asmNode = new ILEditTreeNode(x.Key, true) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush }; foreach (var m in x) { //Module node var moduleNode = new ILEditTreeNode(m.Key, true) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush }; foreach (var n in m) { //Namespace node var namespaceNode = new NamespaceTreeNode(n.Key) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush }; foreach (var t in n) namespaceNode.Children.Add(t); moduleNode.Children.Add(namespaceNode); } moduleNodes.Add(moduleNode); asmNode.Children.Add(moduleNode); } asmNodes.Add(asmNode); return asmNode; }); //Clears the root root.Children.Clear(); //Adds the nodes to the root foreach (var x in grouped) root.Children.Add(x); //Groups the references by module var references = members.OfType<Importers.AssemblyReferenceImporter>() .GroupBy( x => (ModuleDefinition)x.Destination, x => (AssemblyNameReference)x.Member ); //Creates the references nodes foreach(var refs in references) { //Creates and populates the references node var refFolder = new ILEditTreeNode.ReferenceFolderNode(); foreach (var r in refs) refFolder.Children.Add(new ILEditTreeNode(r, true) { IsExpanded = true, Foreground = GlobalContainer.ModifiedNodesBrush }); //Finds the module node to add to var moduleNode = moduleNodes.FirstOrDefault(x => (ModuleDefinition)x.TokenProvider == refs.Key); if (moduleNode != null) { //Adds the references to the module node moduleNode.Children.Insert(0, refFolder); } else { //Finds or creates the assembly node var asmNode = asmNodes.FirstOrDefault(x => (AssemblyDefinition)x.TokenProvider == refs.Key.Assembly); if (asmNode != null) { //Adds a module node to the assembly asmNode.Children.Add(new ILEditTreeNode(refs.Key, true) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush, Children = { refFolder } }); } else { //Creates the nodes and adds it to the root root.Children.Add(new ILEditTreeNode(refs.Key.Assembly, true) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush, Children = { new ILEditTreeNode(refs.Key, true) { IsExpanded = true, Foreground = GlobalContainer.NormalNodesBrush, Children = { refFolder } } } }); } } } }
/// <summary> /// Loads the children /// </summary> protected override void LoadChildren() { //Checks if the children must be filled manually if (ManuallyFilledChildren) return; //IEnumerable containing the childrenot the node IEnumerable<IMetadataTokenProvider> children = null; //Assembly if (_tokenProvider is AssemblyDefinition) children = ((AssemblyDefinition)_tokenProvider).Modules; //Module else if (_tokenProvider is ModuleDefinition) { //Types IEnumerable<TypeDefinition> types = ((ModuleDefinition)_tokenProvider).Types; if (this.ChildrenFilter != null) types = types.Where(x => this.ChildrenFilter(x)); //Groups the types by namespace and adds foreach (var node in types.GroupBy(x => x.Namespace) .OrderBy(x => x.Key) .Select(x => { var n = new NamespaceTreeNode(x.Key); foreach (var t in x.OrderBy(y => y.Name)) n.Children.Add(new ILEditTreeNode(t, false) { ChildrenFilter = this.ChildrenFilter, Foreground = this.Foreground }); return n; })) { this.Children.Add(node); } //Returns return; } //Type else if (_tokenProvider is TypeDefinition) { var type = (TypeDefinition)_tokenProvider; children = type.NestedTypes.Cast<IMetadataTokenProvider>() .Concat(type.Fields) .Concat(type.Methods.Where(x => !(x.IsGetter || x.IsSetter || x.IsAddOn || x.IsRemoveOn || x.IsFire))) .Concat(type.Properties) .Concat(type.Events); } //Property else if (_tokenProvider is PropertyDefinition) { var prop = (PropertyDefinition)_tokenProvider; children = new IMetadataTokenProvider[] { prop.GetMethod, prop.SetMethod } .Where(x => x != null) .Concat(prop.HasOtherMethods ? prop.OtherMethods.Cast<IMetadataTokenProvider>() : new IMetadataTokenProvider[] { }); } //Event else if (_tokenProvider is EventDefinition) { var evt = (EventDefinition)_tokenProvider; children = new IMetadataTokenProvider[] { evt.AddMethod, evt.RemoveMethod, evt.InvokeMethod } .Where(x => x != null) .Concat(evt.HasOtherMethods ? evt.OtherMethods.Cast<IMetadataTokenProvider>() : new IMetadataTokenProvider[] { }); } //If there are no children returns if (children == null) return; //Applies the filtering if (ChildrenFilter != null) children = children.Where(x => ChildrenFilter(x)); //Adds the children foreach (var x in children) this.Children.Add(new ILEditTreeNode(x, false) { ChildrenFilter = this.ChildrenFilter, Foreground = this.Foreground }); }
protected override IMetadataTokenProvider ImportCore(MemberImportingOptions options, SharpTreeNode node) { //Checks that the task hasn't been canceled options.CancellationToken.ThrowIfCancellationRequested(); //Checks if the destination is a module or a type if (Destination is ModuleDefinition) { //Destination var dest = (ModuleDefinition)Destination; dest.Types.Add(typeClone); //Finds the correct namespace var ns = typeClone.Namespace; var moduleNode = Helpers.Tree.GetModuleNode((ModuleDefinition)Destination); var nsNode = moduleNode.Children.EnsureLazyChildren().OfType<NamespaceTreeNode>().FirstOrDefault(x => x.Name == ns); if (nsNode != null) nsNode.AddChildAndColorAncestors(new ILEditTreeNode(typeClone, false)); else { nsNode = new NamespaceTreeNode(typeClone.Namespace) { Foreground = GlobalContainer.ModifiedNodesBrush }; nsNode.Children.Add(new ILEditTreeNode(typeClone, false)); moduleNode.AddChildAndColorAncestors(nsNode); } } else { //Destination var dest = (TypeDefinition)Destination; dest.NestedTypes.Add(typeClone); node.AddChildAndColorAncestors(new ILEditTreeNode(typeClone, false)); } //Return return typeClone; }
MoveNamespaceTypesToEmptypNamespaceCommand(ILSpyTreeNode[] nodes) { var nsNodes = nodes.Where(a => ((NamespaceTreeNode)a).Name != string.Empty).Select(a => (NamespaceTreeNode)a).ToArray(); Debug.Assert(nsNodes.Length > 0); this.nodes = new DeletableNodes<NamespaceTreeNode>(nsNodes); this.nsTarget = GetTarget(); this.typeRefInfos = RenameNamespaceCommand.GetTypeRefInfos(ILSpyTreeNode.GetModule(nodes[0]), nsNodes); }
protected override void LoadChildren() { AssemblyDefinition assemblyDefinition = assembly.AssemblyDefinition; if (assemblyDefinition == null) { // if we crashed on loading, then we don't have any children return; } ModuleDefinition mainModule = assemblyDefinition.MainModule; this.Children.Add(new ReferenceFolderTreeNode(mainModule, this)); if (mainModule.HasResources) this.Children.Add(new ResourceListTreeNode(mainModule)); foreach (NamespaceTreeNode ns in namespaces.Values) { ns.Children.Clear(); } foreach (TypeDefinition type in mainModule.Types.OrderBy(t => t.FullName)) { NamespaceTreeNode ns; if (!namespaces.TryGetValue(type.Namespace, out ns)) { ns = new NamespaceTreeNode(type.Namespace); namespaces[type.Namespace] = ns; } TypeTreeNode node = new TypeTreeNode(type, this); typeDict[type] = node; ns.Children.Add(node); } foreach (NamespaceTreeNode ns in namespaces.Values.OrderBy(n => n.Name)) { if (ns.Children.Count > 0) this.Children.Add(ns); } }
string GetLinqPadClassName(NamespaceTreeNode namespaceTreeNode) { string linqpadGeneratedClassName = "UserQuery"; var classNode = namespaceTreeNode.Children.FirstOrDefault(c => Equals(c.Text, linqpadGeneratedClassName)); if (classNode == null) { string queryClassId = LinqPadUtil.GetQueryIdentifier(this.assemblyPath); var linqPadClass = namespaceTreeNode.Children.FirstOrDefault(c => c.Text.ToString().Contains(queryClassId)); if (linqPadClass != null) { return linqPadClass.Text.ToString(); } } else { return classNode.Text.ToString(); } // If the LINQPad query class cannot be found, select something so it loads. return namespaceTreeNode.Children.First().Text.ToString(); }