Folder structure for packages.

ILSpy/ILSpy.csproj

@@ -213,6 +213,7 @@
     <Compile Include="Metadata\MetadataProtocolHandler.cs" />
     <Compile Include="Metadata\MetadataTableTreeNode.cs" />
     <Compile Include="Metadata\DebugMetadataTreeNode.cs" />
+    <Compile Include="TreeNodes\PackageFolderTreeNode.cs" />
     <Compile Include="ViewModels\LegacyToolPaneModel.cs" />
     <Compile Include="ViewModels\ManageAssemblyListsViewModel.cs" />
     <Compile Include="ViewModels\ViewModelBase.cs" />

ILSpy/LoadedPackage.cs

@@ -20,6 +20,8 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
 
 using ICSharpCode.Decompiler.Metadata;
 
@@ -37,22 +39,80 @@ namespace ICSharpCode.ILSpy
 
 		public PackageKind Kind { get; }
 
-		public List<PackageEntry> Entries { get; } = new List<PackageEntry>();
+		/// <summary>
+		/// List of all entries, including those in sub-directories within the package.
+		/// </summary>
+		public IReadOnlyList<PackageEntry> Entries { get; }
 
-		public static LoadedPackage FromZipFile(string file)
+		internal IReadOnlyList<PackageEntry> TopLevelEntries { get; }
+		internal IReadOnlyList<PackageFolder> TopLevelFolders { get; }
+
+		public LoadedPackage(PackageKind kind, IEnumerable<PackageEntry> entries)
 		{
-			using (var archive = ZipFile.OpenRead(file))
+			this.Kind = kind;
+			this.Entries = entries.ToArray();
+			var topLevelEntries = new List<PackageEntry>();
+			var folders = new Dictionary<string, PackageFolder>();
+			var rootFolder = new PackageFolder("");
+			folders.Add("", rootFolder);
+			foreach (var entry in this.Entries)
 			{
-				LoadedPackage result = new LoadedPackage();
+				var (dirname, filename) = SplitName(entry.Name);
-				foreach (var entry in archive.Entries)
+				GetFolder(dirname).Entries.Add(new FolderEntry(filename, entry));
-				{
+			}
-					result.Entries.Add(new ZipFileEntry(file, entry));
+			this.TopLevelEntries = rootFolder.Entries;
-				}
+			this.TopLevelFolders = rootFolder.Folders;
+
+			static (string, string) SplitName(string filename)
+			{
+				int pos = filename.LastIndexOfAny(new char[] { '/', '\\' });
+				if (pos == -1)
+					return ("", filename); // file in root
+				else
+					return (filename.Substring(0, pos), filename.Substring(pos + 1));
+			}
+
+			PackageFolder GetFolder(string name)
+			{
+				if (folders.TryGetValue(name, out var result))
+					return result;
+				var (dirname, basename) = SplitName(name);
+				PackageFolder parent = GetFolder(dirname);
+				result = new PackageFolder(basename);
+				parent.Folders.Add(result);
+				folders.Add(name, result);
 				return result;
 			}
 		}
 
-		class ZipFileEntry : PackageEntry
+		public static LoadedPackage FromZipFile(string file)
+		{
+			using var archive = ZipFile.OpenRead(file);
+			return new LoadedPackage(PackageKind.Zip,
+				archive.Entries.Select(entry => new ZipFileEntry(file, entry)));
+		}
+
+		/// <summary>
+		/// Entry inside a package folder. Effectively renames the entry.
+		/// </summary>
+		sealed class FolderEntry : PackageEntry
+		{
+			readonly PackageEntry originalEntry;
+			public override string Name { get; }
+
+			public FolderEntry(string name, PackageEntry originalEntry)
+			{
+				this.Name = name;
+				this.originalEntry = originalEntry;
+			}
+
+			public override ManifestResourceAttributes Attributes => originalEntry.Attributes;
+			public override string FullName => originalEntry.FullName;
+			public override ResourceType ResourceType => originalEntry.ResourceType;
+			public override Stream TryOpenStream() => originalEntry.TryOpenStream();
+		}
+
+		sealed class ZipFileEntry : PackageEntry
 		{
 			readonly string zipFile;
 			public override string Name { get; }
@@ -67,19 +127,17 @@ namespace ICSharpCode.ILSpy
 			public override Stream TryOpenStream()
 			{
 				Debug.WriteLine("Decompress " + Name);
-				using (var archive = ZipFile.OpenRead(zipFile))
+				using var archive = ZipFile.OpenRead(zipFile);
+				var entry = archive.GetEntry(Name);
+				if (entry == null)
+					return null;
+				var memoryStream = new MemoryStream();
+				using (var s = entry.Open())
 				{
-					var entry = archive.GetEntry(Name);
+					s.CopyTo(memoryStream);
-					if (entry == null)
-						return null;
-					var memoryStream = new MemoryStream();
-					using (var s = entry.Open())
-					{
-						s.CopyTo(memoryStream);
-					}
-					memoryStream.Position = 0;
-					return memoryStream;
 				}
+				memoryStream.Position = 0;
+				return memoryStream;
 			}
 		}
 	}
@@ -96,4 +154,20 @@ namespace ICSharpCode.ILSpy
 		/// </summary>
 		public abstract string FullName { get; }
 	}
+
+	class PackageFolder
+	{
+		/// <summary>
+		/// Gets the short name of the folder.
+		/// </summary>
+		public string Name { get; }
+
+		public PackageFolder(string name)
+		{
+			this.Name = name;
+		}
+
+		public List<PackageFolder> Folders { get; } = new List<PackageFolder>();
+		public List<PackageEntry> Entries { get; } = new List<PackageEntry>();
+	}
 }

ILSpy/TreeNodes/AssemblyTreeNode.cs

@@ -20,7 +20,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Documents;
@@ -176,7 +175,8 @@ namespace ICSharpCode.ILSpy.TreeNodes
 			}
 			else if (loadResult.Package != null)
 			{
-				LoadChildrenForPackage(loadResult.Package);
+				var package = loadResult.Package;
+				this.Children.AddRange(PackageFolderTreeNode.LoadChildrenForFolder(package.TopLevelFolders, package.TopLevelEntries));
 			}
 		}
 
@@ -216,22 +216,6 @@ namespace ICSharpCode.ILSpy.TreeNodes
 			}
 		}
 
-		private void LoadChildrenForPackage(LoadedPackage package)
-		{
-			foreach (var entry in package.Entries.OrderBy(e => e.Name))
-			{
-				if (entry.Name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || entry.Name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
-				{
-					var stream = Task.Run(entry.TryOpenStream);
-					this.Children.Add(new AssemblyTreeNode(new LoadedAssembly(AssemblyList, entry.FullName, stream), entry.Name));
-					continue;
-				}
-				this.Children.Add(ResourceTreeNode.Create(entry));
-			}
-		}
-
-		public override bool CanExpandRecursively => true;
-
 		/// <summary>
 		/// Finds the node for a top-level type.
 		/// </summary>

ILSpy/TreeNodes/PackageFolderTreeNode.cs

@@ -0,0 +1,80 @@
+// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System.Collections.Generic;
+using System.Linq;
+
+using ICSharpCode.Decompiler;
+using ICSharpCode.TreeView;
+
+namespace ICSharpCode.ILSpy.TreeNodes
+{
+	/// <summary>
+	/// Lists the embedded resources in an assembly.
+	/// </summary>
+	sealed class PackageFolderTreeNode : ILSpyTreeNode
+	{
+		readonly PackageFolder folder;
+
+		public PackageFolderTreeNode(PackageFolder folder, string text = null)
+		{
+			this.folder = folder;
+			this.Text = text ?? folder.Name;
+			this.LazyLoading = true;
+		}
+
+		public override object Text { get; }
+
+		public override object Icon => Images.FolderClosed;
+
+		public override object ExpandedIcon => Images.FolderOpen;
+
+		protected override void LoadChildren()
+		{
+			this.Children.AddRange(LoadChildrenForFolder(folder.Folders, folder.Entries));
+		}
+
+		internal static IEnumerable<SharpTreeNode> LoadChildrenForFolder(IReadOnlyList<PackageFolder> folders, IReadOnlyList<PackageEntry> entries)
+		{
+			if (folders.Count == 1 && entries.Count == 0)
+			{
+
+			}
+			foreach (var folder in folders.OrderBy(f => f.Name))
+			{
+				string newName = folder.Name;
+				var subfolder = folder;
+				while (subfolder.Folders.Count == 1 && subfolder.Entries.Count == 0)
+				{
+					// special case: a folder that only contains a single sub-folder
+					subfolder = subfolder.Folders[0];
+					newName = $"{newName}/{subfolder.Name}";
+				}
+				yield return new PackageFolderTreeNode(subfolder, newName);
+			}
+			foreach (var entry in entries.OrderBy(e => e.Name))
+			{
+				yield return ResourceTreeNode.Create(entry);
+			}
+		}
+
+		public override void Decompile(Language language, ITextOutput output, DecompilationOptions options)
+		{
+		}
+	}
+}