Solving Transitive Dependency Issues in .NET Core

Posted by

The more things change the more they stay the same, as the old adage goes. Problems with transitive dependencies have been around since the early days of .NET and NuGet. There have been many improvements made to reduce the occurrence of these errors, but they’re impossible to eliminate completely.

I recently ran into a problem with an Azure Function that turned out to be a transitive issue, even if I only realized it once I started digging deeper. This post explores how I went about identifying the source of the problem and the steps I took to resolve it. The process I describe below can be applied whether the problem is with an Azure Function, a ASP.NET Core project or any other .NET project for that matter.

Identifying Transitive Dependency Issues

The odds of having a transitive dependency issue increase as you add more packages to a solution. If you’re unlucky, it can also happen in a smaller project with mismatched dependencies. Regardless, they always seem to rear their head when you least expect it.

Visual Studio helps you to identify potential problems by detecting dependency conflicts and surfacing an error that looks like this:

Detected package downgrade: System.Diagnostics.Debug from 4.3.0 to 4.0.11

The package name and version will vary, but it provides you a clear indication that two different versions of a package are being referenced and need to be resolved.

Other times, the source of the problem is not so obvious. Here’s the error I was getting from the Azure Functions runtime when starting the project:

System.MissingMethodException: Method not found: 'Microsoft.Extensions.DependencyInjection.IServiceCollection Microsoft.Azure.WebJobs.IWebJobsBuilder.get_Services()

Google gave me many hits for this error, but none quite fit my scenario nor pointed to the fact that there was a transitive dependency conflict. That’s why I took a step back to evaluate what’s happening, rather than digging to the recesses of StackOverflow, as these were likely to be red herrings.

I took a look at the recent history of changes in the CSPROJ files in the solution. Any change in package or project references is a clue that there is something going on with the dependencies. That’s when I noticed that some of the packages had been updated to a later version, and hinted at the core problem.

I could have also run the dotnet list packages --include-transitive command to get an output of all the packages in the solution. I find the output of the command to be difficult to interpret, and only use it as a last resort.

Solving Transitive Dependency Issues

My approach to solving problems with dependencies isn’t very scientific. It works well more often than not, so I’ve stuck with it over the years.

I start by having a look at the different packages in use to see if anything obvious stands out. In the case of my Azure Function issue, I noticed the problem immediately: there was a reference to a .NET 5.0 assembly when my project is clearly targeting .NET 3.1. Problem solved.

Otherwise, if nothing stands out, the next step is to reset the branch to a commit before any changes to project or package references and see if the application runs as expected (be sure to clean and rebuild otherwise some package versions may not restore properly). If the application runs, it means there’s a problem between then and now. Re-apply the project and package references until the offender is found and the project no longer runs.

That’s when you’ll need to experiment with package versions to discover the combination that allows the application to run properly. Once you’ve found a version that doesn’t cause conflict, your work is done.

Dependency Issues Are Here To Stay

There is no one-step-fix-all for transitive dependency problems. Identifying such a problem often comes down to realizing there have been changes to the referenced packages, and adjusting versions to ensure that everything in the project is compatible.

The ecosystem of packages for .NET continues to grow, and as such these issues will continue to crop up. Learning how to identify and solve these problems continues to be of importance for junior and senior developers alike.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s