Getting started with Roslyn code analysis
Tags: dotnet, roslyn, codeanalysis, csharp
Published: 2021-09-18 13:37:29

---
title: Getting started with Roslyn code analysis
published: true
description: It was going to happen eventually &#8211; our research on C# dynamic features eventually ended up with an attempt to parse bits of source code. There are quite a few &hellip; Continue reading &#8220;Getting started with Roslyn code analysis&#8221;
tags: dotnet, roslyn, codeanalysis, csharp
canonical_url: https://blog.wiseowls.co.nz/index.php/2020/05/12/walking-code-with-roslyn/
cover_image: https://blog.wiseowls.co.nz/wp-content/uploads/2020/03/office-working-app-computer-97077_cr-scaled.jpg
---

It was going to happen eventually – our research on C# dynamic features eventually ended up with an attempt to parse bits of source code. There are [quite a few solutions](https://stackoverflow.com/a/81427/12339804) on the market, with NRefactory being our preferred tool over the years. There are however a few limitations: it does not support .NET core and C# 6.

It is a big deal
----------------

It might seem, that support for newer language spec is not critical. But in fact, it gets problematic very quickly even in more established projects. Luckily for us, Microsoft has chosen to open source [Roslyn](https://github.com/dotnet/roslyn) – the very engine that powers their compiler services. Their official documentation covers the platform pretty well and goes in great detail of writing Visual Studio code analysers. We however often have to deal with writing MSBuild tasks that load the whole solution and run analysis on class hierarchies (for example, to detect whether a single `SQL SELECT` statement is being called inside a `foreach` loop – we would fail the build and suggest to replace it with bulk select)

Installing
----------

Roslyn is available via NuGet as a number of **Microsoft.CodeAnalysis.\*** packages. We normally include these four:

```powershell
Install-Package Microsoft.CodeAnalysis.Workspaces.MSBuild
Install-Package Microsoft.CodeAnalysis
Install-Package Microsoft.CodeAnalysis.CSharp
Install-Package Microsoft.Build # these classes are needed to support MSBuild workspace when it starts to load solution
Install-Package Microsoft.Build.Utilities.Core # these classes are needed to support MSBuild workspace when it starts to load solution
Install-Package Microsoft.Build.Locator # this is a helper to locate correct MSBuild toolchain (in case the machine has more than one installed)
```


Sometimes the environment gets confused as to what version MSBuild to use, and this is why starting a project with something like this is pretty much a must since VS2015:

```csharp
// put this somewhere early in the program
if (!MSBuildLocator.IsRegistered) //MSBuildLocator.RegisterDefaults(); // ensures correct version is loaded up
{
    var vs2022 = MSBuildLocator.QueryVisualStudioInstances().Where(x => x.Name == "Visual Studio Community 2022").First(); // find the correct VS setup. There are namy ways to organise logic here, we'll just assume we want VS2022
    MSBuildLocator.RegisterInstance(vs2022); // register the selected instance
    var _ = typeof(Microsoft.CodeAnalysis.CSharp.Formatting.CSharpFormattingOptions); // this ensures library is referenced so the compiler would not try to optimise it away (if dynamically loading assemblies or doing other voodoo that can throw the compiler off) - probably less important than the above but we prefer to follow cargo cult here and leave it be
}
```


After initial steps, simplistic solution traversal would look something along these lines:

```csharp
async Task AnalyseSolution()
{
	using (var w = MSBuildWorkspace.Create())
	{
		var solution = await w.OpenSolutionAsync(@"MySolution.sln");		
		foreach (var project in solution.Projects)
		{			
			var docs = project.Documents; // allows for file-level document filtering
			var compilation = await project.GetCompilationAsync(); // allows for assembly-level analysis as well as SemanticModel 
			foreach (var doc in docs)
			{
				var walker = new CSharpSyntaxWalker(); // CSharpSyntaxWalker is an abstract class - we will need to define our own implementation for this to actually work
				walker.Visit(await doc.GetSyntaxRootAsync()); // traverse the syntax tree
			}
		}
	}
}
```


Syntax Tree Visitor
-------------------

As with pretty much every single mainstream syntax analyser, the easiest way to traverse syntax trees is by using a [Visitor Pattern](https://en.wikipedia.org/wiki/Visitor_pattern). It allows to decouple tree nodes and processing logic. Which will allow room for expansion on either side (easy to add new logic, easy to add new tree node types). Roslyn has stub [CSharpSyntaxWalker](https://docs.microsoft.com/en-us/dotnet/api/microsoft.codeanalysis.csharp.csharpsyntaxwalker?view=roslyn-dotnet) that allows us to only override required nodes for processing. It then takes care of everything else.

With basics out of the way, let’s look into classes that make up our platform here. Top of the hierarchy is MSBuild `Workspace` followed by `Solution`, `Project` and `Document`. Roslyn makes a distinction between parsing code and compiling it. Meaning some analytics will only be available in `Compilation` class that is available for project as well as for individual documents down the track.

Traversing the tree
-------------------

Just loading the solution is kind of pointless though. We’d need to come up with processing logic – and the best place to do it would be a `CSharpSyntaxWalker` subclass. Suppose, we’d like to determine whether class constructor contains `if` statements that are driven by parameters. This might mean we’ve got overly complex classes and could benefit from refactoring these out:

```csharp
public class ConstructorSyntaxWalker : CSharpSyntaxWalker
{
    public List<IParameterSymbol> Parameters { get; set; }
    public int IfConditions { get; set; }
    
    bool processingConstructor = false;

    SemanticModel sm;

    public ConstructorSyntaxWalker(SemanticModel sm)
    {
        this.sm = sm;
        Parameters = new List<IParameterSymbol>();
    }

    public override void VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
    {
        processingConstructor = true;
        base.VisitConstructorDeclaration(node);
        processingConstructor = false;
    }

    public override void VisitIfStatement(IfStatementSyntax node)
    {
        if (!processingConstructor) return; // we only want to keep traversing if we know we're inside constructor body
        Parameters.AddRange(sm.AnalyzeDataFlow(node).DataFlowsIn.Cast<IParameterSymbol>()); // .AnalyzeDataFlow() is one of the most commonly used parts of the platform: it requires a compilation to work off and allows tracking dependencies. We could then check if these parameters are supplied to constructor and make a call whether this is allowed 
        IfConditions++; // just count for now, nothing fancy
        base.VisitIfStatement(node);
    }
}
```


Then, somewhere in our solution (or any other solution, really) We have a class definition like so:

```csharp
public class TestClass
{
    public TestClass(int a, string o) 
    {
        if (a == 1) DoThis() else DoSomethingElse();
        if (o == "a") Foo() else Bar();
    }
}
```


If we wanted to throw an exception and halt the build we could invoke out `SyntaxWalker`:

```csharp
public static async Task Main()
{
    await AnalyseSolution();
}
...
async static Task AnalyseSolution()
{

    using (var w = MSBuildWorkspace.Create())
    {
        var solution = await w.OpenSolutionAsync(@"..\..\..\TestRoslyn.sln"); // let's analyse our own solution. But can be any file on disk
        foreach (var project in solution.Projects)
        {
            var docs = project.Documents; // allows for file-level document filtering
            var compilation = await project.GetCompilationAsync(); // allows for assembly-level analysis as well as SemanticModel 
            foreach (var doc in docs)
            {
                var walker = new ConstructorSyntaxWalker(await doc.GetSemanticModelAsync());
                walker.Visit(await doc.GetSyntaxRootAsync()); // traverse the syntax tree
                if (walker.IfConditions > 0 && walker.Parameters.Any()) throw new Exception("We do not allow branching in constructors.");
            }
        }
    }
}
```


And there we have it. This is a very simplistic example, but possibilities are endless!