How to manage nuget packages globally for all projects in a solution using Visual Studio 2022?

user_6241544 0
Viewed 2055

I have a solution created in .NET 6.0 using Visual Studio 2022 which has many projects.

Each project has so many nuget package references in the .csproj file as below.

Is it possible to manage all nuget packages in a single location / globally in the solution (instead of for each project)?

This will make sure all projects in the solution are using the same version of the package (no more version conflicts between the projects for the same nuget package).

Updating the package once at the central location will ensure all projects are referring to the same updated version. No need to update the package for every project.

Thanks for your help.

  <ItemGroup>
    <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="10.0.1" />
    <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.20.0" />
    <PackageReference Include="Microsoft.ApplicationInsights.Kubernetes" Version="2.0.2" />
    <PackageReference Include="Microsoft.ApplicationInsights.Kubernetes.HostingStartup" Version="2.0.2" />
    <PackageReference Include="Microsoft.AspNetCore.Authentication.OpenIdConnect" Version="6.0.1" />
    <PackageReference Include="Microsoft.Azure.ServiceBus" Version="5.2.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="6.0.1" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="6.0.1">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.Extensions.Configuration.UserSecrets" Version="6.0.0" />
    <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="6.0.0" />
    <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.14.0" />
    <PackageReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="6.0.1" />
    <PackageReference Include="System.Collections" Version="4.3.0" />
    <PackageReference Include="System.Runtime" Version="4.3.1" />
  </ItemGroup>
visual-studio-2022 .net-6.0 nuget-package-restore nuget c#
2 Answers

There's a few approaches to doing this. Currently (at the time of this edit), only NuGet's Central Package Version Management supports managing transitive package dependencies.

Manually, with a .targets file

Have a .targets file with all the packages you reference but use <PackageReference Update= instead of Include=. Include this in your Directory.Build.targets file, so that it will be applied at the end of each project file.

The biggest downside to this is that any time a new PackageReference is added to any project, you'll need to also remember to update the .targets file to include an entry to update that package version.

This will ensure that all of your <PackageReference> entries will unify to the same versions. However, it does not impact transitive references, i.e. if you have Project1 -> Package1 -> Package2, but only have a PackageReference to Package1, you won't be able to affect the referenced version of Package2. This may create conflicts if Project2 -> Package2 at a different version than what Package1 references.

Use the Central Package Versions MSBuild SDK (CPV)

The manual process can be error-prone, so there's a 3rd party SDK to help make the process smoother. You can find it at Central Package Versions. This also provides enforcement that users do not specify a version in the project (because they should be using the central one instead!) so it will be more consistent than using the manual technique.

This also does not resolve transitive dependency issues in any way.

Use Nuget Central Package Version Management (CPVM)

This is the NuGet team's solution to the issue. It's explained in this blog post, or you can find the original documentation at Centrally managing NuGet package versions.

Have a file named Directory.Packages.props in your root folder, and enable the feature by adding:

  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>

Now, similar to the CPV SDK, you should remove all versions from the <PackageReference> elements, and put them in <PackageVersion> elements in your Directory.Packages.props files. If you need to override a version there are two methods:

  1. On the <PackageReference> item, add a VersionOveride=1.2.3.4 attribute.
  2. In the .csproj add <PackageVersion Update="PackageName" Version="DifferentVersion" /> (this is because Directory.Packages.props is imported via the .NET SDKs .props file, which is before the content of the .csproj is evaluated).

This by itself does not help with transitive references. You can additionally add <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled> to enable pinning for transitive packages. What this basically does is to determine if any of your direct or indirect (transitive) PackageReferences has a matching PackageVersion, and if so it promotes that as though it were a direct reference (meaning anything that depends on it will also get the pinned version). Transitive pinning support requires at least NuGet 6.2, VS 2022 17.2, or the .NET SDK 6.0.300.

Jimmy_250710

The new CPM feature was mentioned, but I thought I'd include a full example too.

You could use nuget's new "Central Package Management" feature.

Example problem:

Suppose you have monorepo (i.e. VS "solution" or VSCode "workspace") with multiple projects.

ProjectA.csproj:

<ItemGroup>
  <PackageReference Include="Foo.Bar.Baz" Version="1.0.0" />
  <PackageReference Include="Spam.Ham.Eggs" Version="4.0.0" />
</ItemGroup>

ProjectB.csproj:

<ItemGroup>
  <PackageReference Include="Foo.Bar.Qux" Version="1.2.3" />
  <PackageReference Include="Spam.Ham.Eggs" Version="4.5.6" />
</ItemGroup>

Some items are the same whereas others differ. And you need to remember to keep the versions in sync - the example shows that you forgot to do that!

Step 1: remove the versions

ProjectA.csproj:

<ItemGroup>
  <PackageReference Include="Foo.Bar.Baz" />
  <PackageReference Include="Spam.Ham.Eggs" />
</ItemGroup>

ProjectB.csproj:

<ItemGroup>
  <PackageReference Include="Foo.Bar.Qux" />
  <PackageReference Include="Spam.Ham.Eggs" Version="4.0.0" />  <!-- note version override for this project -->
</ItemGroup>

Step 2: add file named Directory.Packages.props to your repo's root

<Project>
  <PropertyGroup>
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
    <!-- use 'PackageVersion' rather than 'PackageReference' -->
    <PackageVersion Include="Foo.Bar.Baz" Version="1.2.3" />
    <PackageVersion Include="Foo.Bar.Qux" Version="1.2.3" />
    <PackageVersion Include="Spam.Ham.Eggs" Version="4.5.6" />
  </ItemGroup>
</Project>

Step 3: restore

For each project:

  • clear build output: dotnet clean
  • restore packages: dotnet restore

All your projects will now use the versions you've specified in the config file.

There are more options, like version overrides, and transitive dependency pinining - read the docs for more.

user_99714040
Related