Roslyn method survey - Loading a solution with MsBuild

I wanted to survey all method signatures in a codebase. I split the problem into two: loading the solution; and indexing all methods. The first turned out to be a complete rabbit hole. The documentation around MsBuild is a morass of partially-incomplete, somewhat misleading treacle; I’ve summarised some points here. MsBuild is also passive aggressive at best. If something doesn’t work, it won’t tell you - you have to know how to ask it.

MsBuild

Using MsBuild from C# is relatively easy; however, a lot of information out there concerns itself with finding a version of MsBuild to use from code that mostly relates to older versions of MsBuild - and which are actively obstructive today. Nowadays you can just include a dependency on the NuGet Microsoft.Build.Locator. If you’re using Rider, as I am, you might not have installed the Microsoft build tools, but they can be downloaded as a standalone installer from Microsoft’s all MsBuild downloads page.

So, to cut to the solution create a CSharp executable project, add NuGet packages:

Microsoft.Build.Framework
Microsoft.Build.Tasks.Core
Microsoft.Build
Microsoft.CodeAnalysis.Workspaces.MSBuildWorkspace
Microsoft.CodeAnalysis.CSharp
Microsoft.CodeAnalysis.CSharp.Workspaces

and then, importantly, initialise the MsBuildLocator before calling any methods that use it; a small, but interesting wrinkle that I didn’t get immediately. This example from Microsoft was crtically useful in getting me (re)started.

	using Microsoft.Build.Locator;


	namespace CleanAnalysis
	{
	class Program
	{
	static void Main(string[] args)
	{
	MSBuildLocator.RegisterDefaults();

	// TODO: stuff here, importantly, in a method call
	}
	}
	}

view raw init-msbuildlocator.cs hosted with ❤ by GitHub

Then add a method that we can use to load all syntax-api-supporting documents in the solution … with some NuGets and helpful comments along the way:

NuGet.Frameworks
NuGet.ProjectModel
NuGet.Packaging

	using System;
	using System.Collections.Generic;
	using System.Collections.Immutable;
	using System.IO;
	using System.Linq;
	using Microsoft.Build.Locator;
	using Microsoft.CodeAnalysis;
	using Microsoft.CodeAnalysis.MSBuild;
	using Document = Microsoft.CodeAnalysis.Document;


	namespace CleanAnalysis
	{
	class Program
	{
	public static IEnumerable<Document> LoadSolution(string solutionDir)
	{
	var solutionFilePath = Path.GetFullPath(solutionDir);

	var documents = new List<Document>();

	// Getting hold of the right MSBuild is a nightmare. You can install old
	// versions without VS, from
	// https://visualstudio.microsoft.com/vs/older-downloads
	using var workspace = MSBuildWorkspace.Create();

	var solution = workspace.OpenSolutionAsync(solutionFilePath).Result;

	// If you forget nuget Microsoft.CodeAnalysis.CSharp and
	// Microsoft.CodeAnalysis.CSharp.Workspaces you'll silently get an empty list
	// of projects here and have no idea why
	foreach (var projectId in solution.ProjectIds)
	{
	var project = solution.GetProject(projectId);

	// ARGH THIS BL**DY STUFF IS SO UNCOMMUNICATIVE
	// Turns out you can find a list of diagnostics messages here to google
	ImmutableList<WorkspaceDiagnostic> diagnostics = workspace.Diagnostics;
	foreach(var diagnostic in diagnostics)
	{
	Console.WriteLine($"Diagnostics: {diagnostic.ToString()}");
	}

	// Here - no documentIds. At all. And spurious Microsoft.NET.Sdk errors,
	// until I started using Microsoft.Build.Locator.
	foreach (var documentId in project.DocumentIds)
	{
	Console.WriteLine(documentId);
	Document document = solution.GetDocument(documentId);
	if (document.SupportsSyntaxTree) documents.Add(document);
	}
	}

	return documents;
	}

	static void Main(string[] args)
	{
	MSBuildLocator.RegisterDefaults();

	var documents = LoadSolution(@"C:\code\Sandbox\CleanAnalysis.sln");
	}
	}
	}

view raw load-documents.cs hosted with ❤ by GitHub

Finally - you need to mark the Microsoft.Build.* assets with ExcludeRuntime=true tags in your project file - this avoids having MsBuild assemblies copied to your build directory and allows the locator to reference them indirectly:

	<Project Sdk="Microsoft.NET.Sdk">

	<PropertyGroup>
	<OutputType>Exe</OutputType>
	<TargetFramework>netcoreapp3.1</TargetFramework>
	</PropertyGroup>

	<ItemGroup>
	<PackageReference Include="Microsoft.Build" Version="16.6.0" ExcludeAssets="runtime" />
	<PackageReference Include="Microsoft.Build.Framework" Version="16.6.0" ExcludeAssets="runtime" />
	<PackageReference Include="Microsoft.Build.Locator" Version="1.2.6" />
	<PackageReference Include="Microsoft.Build.Tasks.Core" Version="16.6.0" ExcludeAssets="runtime" />
	<PackageReference Include="Microsoft.CodeAnalysis.Workspaces.MSBuild" Version="3.7.0-4.final" />
	</ItemGroup>

	</Project>

view raw exclude-assets.xml hosted with ❤ by GitHub

and you’re there: congratulations! In a few minutes you’ve achieved what took me a number of grinding, painful hours :)