In
my previous post I've shown the Package Visualizer tool. Unfortunately, it's only available in the Ultimate version of Visual Studio. But all is not lost because even with a Pro version with can open
DGML files.
I've created a
LinqPad query that analyse packages.config files and create a DGML diagram like Package Visualizer does. I've also added things like GAC libraries and normal file based library to the mix. You can get the full
Gist here. Now let's take a look at some code…
Main
Here we set a few options for our query: some file extensions to ignore when scanning for projects and more importantly the root folder path to start scanning for project files.
private string[] projectExtensionExclusions = new[] { ".vdproj", ".ndproj" };
private string rootFolder = @"C:\Users\Pascal\Dev\MyProject";
void Main()
{
LoadAllProjects();
LoadAllPackagesConfig();
GenerateDGML(Path.Combine(rootFolder, "Dependencies.dgml"));
}
Data structures to uses
Then we define some fields and basic classes to help us gather the information
private List<Project> projects = new List<Project>();
private List<Package> packages = new List<Package>();
private List<Library> libraries = new List<Library>();
public class Project
{
public Project()
{
this.Projects = new List<Project>();
this.Libraries = new List<Library>();
this.Packages = new List<Package>();
}
public string Path { get; set; }
public string Name { get; set; }
public List<Project> Projects { get; private set; }
public List<Library> Libraries { get; private set; }
public List<Package> Packages { get; private set; }
}
public class Package
{
public string Name { get; set; }
public string Version { get; set; }
}
public class Library
{
public string Name { get; set; }
public bool IsGAC { get; set; }
}
LoadAllProjects
Now we can start scanning for projects to load. Next we open each project files and extract all dependencies like other project, a local library or a GAC reference. We keep all this info in the project instances for later.
private void LoadAllProjects()
{
XNamespace ns = "http://schemas.microsoft.com/developer/msbuild/2003";
var projectFiles = Directory.GetFiles(rootFolder, "*.*proj",
SearchOption.AllDirectories)
.Where (pf => !projectExtensionExclusions.Any(ex => pf.EndsWith(ex)));
foreach (var pf in projectFiles)
this.projects.Add(
new Project { Path = pf, Name = Path.GetFileNameWithoutExtension(pf) });
// Get all projects, local libraries and GAC references
foreach (var project in this.projects)
{
var projectDoc = XDocument.Load(project.Path);
foreach (var pr in projectDoc.Descendants(ns + "ProjectReference"))
{
var prj = projects.SingleOrDefault(p =>
p.Name == pr.Element(ns + "Name").Value);
if (prj != null)
project.Projects.Add(prj);
else
(pr.Element(ns + "Name").Value
+ " project reference not found in file " + project.Path).Dump();
}
foreach (var r in projectDoc.Descendants(ns + "Reference")
.Where (r => !r.Value.Contains(@"\packages\")))
project.Libraries.Add(GetOrCreateLibrary(
r.Attribute("Include").Value, !r.Elements(ns + "HintPath").Any()));
}
}
LoadAllPackagesConfig
Finally we scan for packages.config files, the ones responsible for maintaining the NuGet packages dependencies for a project. Again we extract the dependencies information from the files and keep it for later.
private void LoadAllPackagesConfig()
{
foreach (var pk in Directory.GetFiles(rootFolder, "packages.config",
SearchOption.AllDirectories)
.Where (pc => !pc.Contains(".nuget")))
{
var project = this.projects.SingleOrDefault(p =>
Path.GetDirectoryName(p.Path) == Path.GetDirectoryName(pk));
if (project == null)
("Project not found in same folder than package " + pk).Dump();
else
{
foreach (var pr in XDocument.Load(pk).Descendants("package"))
{
var package = GetOrCreatePackage(
pr.Attribute("id").Value, pr.Attribute("version").Value);
project.Packages.Add(package);
}
}
}
}
GenerateDGML
Here we generate the final DGML file which is simply an XML file. The
schema is quite simple: a root element DirectedGraph, a Nodes section and a Links section, all of which are mandatory. We also add a Styles section to colorize the different kind of nodes: projects, packages, libraries and GAC libraries.
private XNamespace dgmlns = "http://schemas.microsoft.com/vs/2009/dgml";
private void GenerateDGML(string filename)
{
var graph = new XElement(dgmlns + "DirectedGraph",
new XAttribute("GraphDirection", "LeftToRight"),
new XElement(dgmlns + "Nodes",
this.projects.Select (p => CreateNode(p.Name, "Project")),
this.libraries.Select (l => CreateNode(l.Name,
l.IsGAC ? "GAC Library" : "Library", l.Name.Split(',')[0])),
this.packages.Select (p => CreateNode(p.Name + " " + p.Version, "Package")),
CreateNode("AllProjects", "Project", label: "All Projects", @group: "Expanded"),
CreateNode("AllPackages", "Package", label: "All Packages", @group: "Expanded"),
CreateNode("LocalLibraries", "Library", label: "Local Libraries", @group: "Expanded"),
CreateNode("GlobalAssemblyCache", "GAC Library", label: "Global Assembly Cache", @group: "Collapsed")),
new XElement(dgmlns + "Links",
this.projects.SelectMany(p => p.Projects.Select(pr => new { Source = p, Target = pr } ))
.Select (l => CreateLink(l.Source.Name, l.Target.Name, "Project Reference")),
this.projects.SelectMany(p => p.Libraries.Select(l => new { Source = p, Target = l } ))
.Select (l => CreateLink(l.Source.Name, l.Target.Name, "Library Reference")),
this.projects.SelectMany(p => p.Packages.Select(pa => new { Source = p, Target = pa } ))
.Select (l => CreateLink(l.Source.Name, l.Target.Name + " " + l.Target.Version, "Installed Package")),
this.projects.Select (p => CreateLink("AllProjects", p.Name, "Contains")),
this.packages.Select (p => CreateLink("AllPackages", p.Name + " " + p.Version, "Contains")),
this.libraries.Where (l => !l.IsGAC).Select (l => CreateLink("LocalLibraries", l.Name, "Contains")),
this.libraries.Where (l => l.IsGAC).Select (l => CreateLink("GlobalAssemblyCache", l.Name, "Contains"))),
// No need to declare Categories, auto generated
new XElement(dgmlns + "Styles",
CreateStyle("Project", "Blue"),
CreateStyle("Package", "Purple"),
CreateStyle("Library", "Green"),
CreateStyle("GAC Library", "LightGreen")));
var doc = new XDocument(graph);
doc.Save(filename);
}
Conclusion
All that is left is to open the Dependencies.dgml file in Visual Studio
I've left a few utility methods out of the inline code in this post but you can get all the code from the
Gist. Feel free to grab a copy of the file and adapt it to your heart's content. It would be easy to create a small Console Application and call it from command line if you don't like LinqPad.
There is still a lot more I could add to the query like extracting projects and library versions from the DLL, dependencies between NuGet packages from .nupkg files and highlighting duplicates NuGet packages with different version. Still, it's enough for me in it's current form.
I hope this will help you figure out your NuGet packages usage and dependencies in your solution.