public ReferenceFolderTreeNode(ModuleDefMD module, AssemblyTreeNode parentAssembly, AssemblyListTreeNode assemblyListTreeNode)
 {
     this.module = module;
     this.parentAssembly = parentAssembly;
     this.assemblyListTreeNode = assemblyListTreeNode;
     this.LazyLoading = true;
 }

		public TreeViewUpdater(CorModuleDefFile cmdf, AssemblyTreeNode node, HashSet<uint> modifiedTypes, HashSet<uint> loadedClassTokens) {
			Debug.Assert(node.DnSpyFile == cmdf);
			this.CorModuleDefFile = cmdf;
			this.ModuleNode = node;
			this.modifiedTypes = new HashSet<uint>(modifiedTypes);
			this.loadedClassTokens = loadedClassTokens;
			this.checkedTypes = new HashSet<TypeDef>();
			this.modNode = node;
		}

        public ModuleTreeNode(ModuleDefinition moduleDefinition, AssemblyTreeNode parentAssemblyNode)
        {
            if (moduleDefinition == null)
                throw new ArgumentNullException("moduleDefiniton");
            module = moduleDefinition;
            assemblyNode = parentAssemblyNode;

            this.LazyLoading = true;
        }

		public TypeTreeNode(TypeDef type, AssemblyTreeNode parentAssemblyNode) {
			if (parentAssemblyNode == null)
				throw new ArgumentNullException("parentAssemblyNode");
			if (type == null)
				throw new ArgumentNullException("type");
			this.type = type;
			this.parentAssemblyNode = parentAssemblyNode;
			this.LazyLoading = true;
		}

        AssemblySettingsCommand(AssemblyTreeNode asmNode, AssemblyOptions newOptions)
        {
            this.asmNode = asmNode;
            this.newOptions = newOptions;
            this.origOptions = new AssemblyOptions(asmNode.LoadedAssembly.AssemblyDefinition);

            if (newOptions.Name != origOptions.Name)
                this.assemblyRefInfos = RefFinder.FindAssemblyRefsToThisModule(asmNode.LoadedAssembly.ModuleDefinition).Where(a => AssemblyNameComparer.NameAndPublicKeyTokenOnly.Equals(a, asmNode.LoadedAssembly.AssemblyDefinition)).Select(a => new AssemblyRefInfo(a)).ToArray();
        }

		public AssemblyReferenceTreeNode(AssemblyNameReference r, AssemblyTreeNode parentAssembly)
		{
			if (parentAssembly == null)
				throw new ArgumentNullException("parentAssembly");
			if (r == null)
				throw new ArgumentNullException("r");
			this.r = r;
			this.parentAssembly = parentAssembly;
			this.LazyLoading = true;
		}

		public TypeTreeNode(TypeDefinition type, AssemblyTreeNode parentAssemblyNode)
		{
			if (parentAssemblyNode == null)
				throw new ArgumentNullException("parentAssemblyNode");
			if (type == null)
				throw new ArgumentNullException("type");
			this.type = type;
			this.parentAssemblyNode = parentAssemblyNode;
			this.LazyLoading = true;
            this.Foreground = IsPublicAPI ? NodeBrushes.Normal : NodeBrushes.Private;
		}

		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;
			}
		}

		internal AssemblyReferenceTreeNode(AssemblyRef r, AssemblyTreeNode parentAssembly, DnSpyFileListTreeNode dnSpyFileListTreeNode) {
			if (parentAssembly == null)
				throw new ArgumentNullException("parentAssembly");
			if (dnSpyFileListTreeNode == null)
				throw new ArgumentNullException("dnSpyFileListTreeNode");
			if (r == null)
				throw new ArgumentNullException("r");
			this.r = r;
			this.dnSpyFileListTreeNode = dnSpyFileListTreeNode;
			this.parentAssembly = parentAssembly;
			this.LazyLoading = true;
		}

 public void RegisterCached(LoadedAssembly asm, AssemblyTreeNode asmNode)
 {
     CachedAssemblyTreeNode cachedInfo;
     if (!cachedAsmTreeNodes.TryGetValue(asm, out cachedInfo))
         cachedAsmTreeNodes.Add(asm, cachedInfo = new CachedAssemblyTreeNode(asmNode));
     else {
         Debug.Assert(cachedInfo.AssemblyTreeNode == asmNode);
         if (cachedInfo.AssemblyTreeNode != asmNode)
             throw new InvalidOperationException();
     }
     cachedInfo.Counter++;
 }

 public CachedAssemblyTreeNode(AssemblyTreeNode asmNode)
 {
     this.AssemblyTreeNode = asmNode;
 }

 static void OnFileNameChangedInternal(AssemblyTreeNode node)
 {
     node.RaisePropertyChanged("Text");
     node.RaisePropertyChanged("ToolTip");
 }

 static IEnumerable<AssemblyTreeNode> GetAllRelatedNodes(AssemblyTreeNode node)
 {
     if (node.Parent is AssemblyTreeNode)
         node = (AssemblyTreeNode)node.Parent;
     yield return node;
     foreach (var child in node.Children) {
         var asmChild = child as AssemblyTreeNode;
         if (asmChild != null)
             yield return asmChild;
     }
 }

 RemoveNetModuleFromAssemblyCommand(AssemblyTreeNode modNode)
 {
     this.asmNode = (AssemblyTreeNode)modNode.Parent;
     Debug.Assert(this.asmNode != null);
     this.modNode = modNode;
     this.removeIndex = asmNode.Children.IndexOf(modNode);
     Debug.Assert(this.removeIndex > 0);
     Debug.Assert(asmNode.LoadedAssembly.AssemblyDefinition != null &&
         asmNode.LoadedAssembly.AssemblyDefinition.Modules.IndexOf(modNode.LoadedAssembly.ModuleDefinition) == this.removeIndex);
 }

        /// <summary>
        /// Called when it's been converted to an assembly
        /// </summary>
        /// <param name="modNode">Old child as returned by <see cref="OnConvertedToNetModule()"/></param>
        internal void OnConvertedToAssembly(AssemblyTreeNode modNode = null)
        {
            Debug.Assert(Children.Count == 0 || !(Children[0] is AssemblyTreeNode));
            Debug.Assert(!(Parent is AssemblyTreeNode));

            SharpTreeNode[] oldChildren = null;
            if (!LazyLoading) {
                // Children already loaded
                oldChildren = Children.ToArray();
                Children.Clear();
            }
            Debug.Assert(Children.Count == 0);
            if (Children.Count != 0)
                throw new InvalidOperationException();

            var newChild = modNode ?? new AssemblyTreeNode(assembly);
            Debug.Assert(newChild.Parent == null);
            if (newChild.Parent != null)
                throw new InvalidOperationException();
            Children.Add(newChild);
            newChild.LazyLoading = LazyLoading;
            LazyLoading = false;

            if (oldChildren != null) {
                newChild.Children.AddRange(oldChildren);
                newChild.typeDict.AddRange(typeDict);
                typeDict.Clear();
                newChild.namespaces.AddRange(namespaces);
                namespaces.Clear();
            }
            Debug.Assert(typeDict.Count == 0);
            Debug.Assert(namespaces.Count == 0);
            RaiseUIPropsChanged();
        }

		RemoveAssemblyCommand(AssemblyTreeNode[] asmNodes)
		{
			this.savedStates = new AssemblyTreeNodeCreator[asmNodes.Length];
			try {
				for (int i = 0; i < this.savedStates.Length; i++)
					this.savedStates[i] = new AssemblyTreeNodeCreator(asmNodes[i]);
			}
			catch {
				Dispose();
				throw;
			}
		}

 public static bool AskUserToSaveIfModified(AssemblyTreeNode asmNode)
 {
     return AskUserToSaveIfModified(new[] { asmNode.LoadedAssembly });
 }

 AssemblyTreeNodeCreator(LoadedAssembly asm, AssemblyTreeNode asmNode, bool restoreIndex)
 {
     this.asmNode = asmNode ?? new AssemblyTreeNode(asm);
     this.restoreIndex = restoreIndex;
     MainWindow.Instance.AssemblyListTreeNode.RegisterCached(asm, this.asmNode);
 }

 AddExistingNetModuleToAssemblyCommand(AssemblyTreeNode asmNode, LoadedAssembly asm)
     : base(asmNode, new AssemblyTreeNode(asm), false)
 {
 }

 public ReferenceFolderTreeNode(ModuleDefinition module, AssemblyTreeNode parentAssembly)
 {
     this.module = module;
     this.parentAssembly = parentAssembly;
     this.LazyLoading = true;
 }