CentralNuGetUpdater 1.3.0

Central NuGet Package Updater

A console application that helps you manage and update NuGet packages in .NET projects using Central Package Management (Directory.Packages.props). The tool respects your nuget.config source rules and provides an interactive interface to select which packages to update.

Features

• ✅ Central Package Management Support: Works with Directory.Packages.props files
• ✅ NuGet.config Compliance: Respects package sources and configuration from nuget.config
• ✅ Seamless Authentication: Uses the same credential providers as dotnet restore
• ✅ Interactive Selection: Choose which packages to update with a beautiful console UI
• ✅ Update Preview: See current vs. latest versions before updating
• ✅ Dry Run Mode: Preview what would be updated without making changes
• ✅ Prerelease Support: Optionally include prerelease versions
• ✅ Conditional Package Support: Handles framework-specific conditional packages
• ✅ GlobalPackageReference Support: Manages global analyzer and tool packages
• ✅ Framework-Aware Updates: Suggests appropriate versions per target framework
• ✅ Detailed Information: Shows package descriptions and publish dates
• ✅ Error Handling: Graceful handling of network issues and missing packages

Prerequisites

• .NET 8.0 or later
• An existing .NET project using Central Package Management

Installation

Option 1: Global .NET Tool (Recommended)

Install as a global .NET tool for easy access from anywhere:

dotnet tool install -g CentralNuGetUpdater

Then use it anywhere:

cpup --help

Option 2: Build from Source

1. Clone or download this repository

2. Navigate to the project directory

3. Build the application:

   dotnet build -c Release
   

4. Run the application:

   dotnet run -- [options]
   

Option 3: Publish as Self-Contained

1. Publish the application for your platform:

   # Windows
   dotnet publish -c Release -r win-x64 --self-contained
   
   # macOS
   dotnet publish -c Release -r osx-x64 --self-contained
   
   # Linux
   dotnet publish -c Release -r linux-x64 --self-contained
   

2. The executable will be in bin/Release/net8.0/[runtime]/publish/

Usage

Basic Usage

Navigate to your .NET solution directory (containing Directory.Packages.props) and run:

# If installed as global tool
cpup

# If running from source
dotnet run

Command Line Options

Central NuGet Package Updater - Check and update packages in Directory.Packages.props

Usage:
  cpup [options]

Options:
  -p, --path <path>        Path to Directory.Packages.props file or the directory containing it [default: current directory]
  -c, --config <config>    Path to nuget.config file (optional)
  --pre, --prerelease      Include prerelease versions when checking for updates [default: False]
  -d, --dry-run           Show what would be updated without making changes [default: False]
  --version               Show version information
  -?, -h, --help          Show help and usage information

Examples

Check for updates in current directory

# Global tool
cpup

# From source
dotnet run

Check specific directory or file

# Using directory path
cpup --path "C:\MyProject"

# Using direct file path
cpup --path "C:\MyProject\Directory.Packages.props"

# With custom nuget.config
cpup --path "C:\MyProject" --config "C:\MyProject\nuget.config"

Include prerelease versions

cpup --prerelease

Dry run (preview only)

cpup --dry-run

Combine options

cpup --path "C:\MyProject" --prerelease --dry-run

Central Package Management Setup

If your project doesn't use Central Package Management yet, you need to:

1. Create a Directory.Packages.props file in your solution root:

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

  <ItemGroup>
    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
    
  </ItemGroup>
</Project>

2. Update your project files (.csproj) to remove version attributes:

<PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0" />


<PackageReference Include="Microsoft.Extensions.Logging" />

GlobalPackageReference Support

The tool fully supports GlobalPackageReference items, which are used for packages that should be applied to all projects in a solution (typically analyzers, code style tools, and build tools).

Global Package Management

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

  <ItemGroup>
    
    <GlobalPackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0" PrivateAssets="All" />
    <GlobalPackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="All" />
    <GlobalPackageReference Include="SonarAnalyzer.CSharp" Version="9.0.0" PrivateAssets="All" />
  </ItemGroup>

  <ItemGroup>
    
    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>
</Project>

Global Package Features

• Automatic Detection: Global packages are automatically identified and labeled as "(Global)" in the UI
• Update Management: Global packages can be updated just like regular packages
• Mixed Support: Works seamlessly alongside regular PackageVersion items
• Analyzer Focus: Perfect for managing code analyzers, style checkers, and build tools

Example Output with Global Packages

Packages with available updates:
┌──────────────────────────────────────────────┬─────────────────┬────────────────┐
│ Package                                      │ Current Version │ Latest Version │
├──────────────────────────────────────────────┼─────────────────┼────────────────┤
│ Microsoft.Extensions.Logging                 │ 8.0.0           │ 8.0.1          │
│ Microsoft.CodeAnalysis.NetAnalyzers (Global) │ 8.0.0           │ 9.0.0          │
│ SonarAnalyzer.CSharp (Global)                │ 9.0.0           │ 10.11.0        │
└──────────────────────────────────────────────┴─────────────────┴────────────────┘

Conditional Package Support

The tool supports conditional packages with framework-specific conditions, which is especially useful for multi-targeting projects.

Framework-Specific Packages

For projects that target multiple frameworks (e.g., net8.0 and net9.0), you can use conditional packages:

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

  <ItemGroup>
    
    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Condition="'$(TargetFramework)' == 'net8.0'" Version="8.0.15" />
    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Condition="'$(TargetFramework)' != 'net8.0'" Version="9.0.4" />
    
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Condition="'$(TargetFramework)' == 'net8.0'" Version="8.0.16" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore" Condition="'$(TargetFramework)' != 'net8.0'" Version="9.0.5" />
    
    
    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>
</Project>

Framework-Aware Version Selection

The tool provides intelligent framework-aware updates:

• For net8.0 packages: Suggests the latest 8.x version (e.g., 8.0.15 → 8.0.16)
• For net9.0 packages: Suggests the latest 9.x version (e.g., 9.0.4 → 9.0.5)
• Prevents incompatible updates: Won't suggest .NET 9 versions for .NET 8-specific conditions

Example Output with Conditional Packages

Packages with available updates:
┌───────────────────────────────────────────────┬─────────────────┬────────────────┬───────────────────┐
│ Package                                       │ Current Version │ Latest Version │ Target Frameworks │
├───────────────────────────────────────────────┼─────────────────┼────────────────┼───────────────────┤
│ Microsoft.AspNetCore.Authorization            │ 8.0.15          │ 8.0.16         │ net8.0            │
│ ('$(TargetFramework)' == 'net8.0')            │                 │                │                   │
│ Microsoft.AspNetCore.Authorization            │ 9.0.4           │ 9.0.5          │ net9.0            │
│ ('$(TargetFramework)' != 'net8.0')            │                 │                │                   │
└───────────────────────────────────────────────┴─────────────────┴────────────────┴───────────────────┘

Supported Condition Patterns

The tool supports the most common condition patterns:

• Equality: Condition="'$(TargetFramework)' == 'net8.0'"
• Inequality: Condition="'$(TargetFramework)' != 'net8.0'"
• More complex conditions: Parsed and evaluated appropriately

Why Use Conditional Packages?

1. Multi-targeting projects: Use the optimal package version for each target framework
2. Migration scenarios: Gradually migrate from .NET 8 to .NET 9 while maintaining compatibility
3. Framework-specific features: Use framework-specific APIs and optimizations
4. Dependency compatibility: Ensure packages are compatible with specific .NET versions

NuGet.config Support

The tool automatically discovers and uses your nuget.config file. It supports:

• Package Sources: Respects enabled/disabled sources
• Source Mapping: Uses package source mapping rules
• Authentication: Works with authenticated feeds
• Fallback Sources: Uses fallback feeds when configured

Example nuget.config:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <clear />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
    <add key="MyCompanyFeed" value="https://pkgs.dev.azure.com/company/_packaging/feed/nuget/v3/index.json" />
  </packageSources>
</configuration>

Authentication Support

The tool uses the same credential providers as dotnet restore, ensuring seamless authentication with private NuGet feeds without any additional setup.

🔐 How Authentication Works

1. Automatic Integration: The tool integrates with NuGet's built-in credential provider system
2. Zero Configuration: If dotnet restore works with your private feeds, this tool will work too
3. Same Credentials: Uses existing Azure Artifacts Credential Provider, AWS CodeArtifact, MyGet, and other installed credential providers
4. Silent Authentication: No interactive prompts - authentication happens transparently

✅ Supported Authentication Methods

The tool automatically supports any authentication method that dotnet restore supports:

• Azure DevOps Artifacts - Uses Azure Artifacts Credential Provider
• GitHub Packages - Uses stored PATs or GitHub CLI authentication
• AWS CodeArtifact - Uses AWS credential providers
• MyGet - Uses stored API keys or credential providers
• Corporate NuGet feeds - Uses domain authentication or configured credentials
• Any credential provider - Supports NuGet's extensible credential provider system

🚀 Quick Setup for Azure DevOps

If you're using Azure DevOps and haven't set up authentication yet:

1. Install Azure Artifacts Credential Provider:

   # Using dotnet tool (recommended)
   dotnet tool install -g Azure.Artifacts.CredentialProvider
   
   # Or download from: https://github.com/microsoft/artifacts-credprovider
   

2. Test with dotnet restore:

   dotnet restore --interactive
   

3. Run this tool - it will work automatically!

🎯 Authentication Flow

✓ Credential service configured - will use same authentication as 'dotnet restore'
ℹ Loaded 2 package source(s)
ℹ   - nuget.org: https://api.nuget.org/v3/index.json
ℹ   - MyCompanyFeed: https://pkgs.dev.azure.com/company/_packaging/feed/nuget/v3/index.json
ℹ Checking for updates for 25 packages...

That's it! No interactive prompts, no manual credential entry - just seamless authentication using your existing setup.

🔒 Security & Credentials

• Existing Credentials: Uses credentials already configured for dotnet restore
• No Storage: The tool doesn't store or manage credentials directly
• Secure: Leverages NuGet's secure credential provider infrastructure
• Consistent: Same security model as all other .NET CLI tools

How It Works

1. Discovery: Finds Directory.Packages.props in the specified directory
2. Parsing: Extracts all PackageVersion elements
3. Configuration: Loads NuGet sources from nuget.config
4. Authentication: Automatically uses the same credential providers as dotnet restore
5. Version Check: Queries each configured source for the latest version
6. Interactive Selection: Presents packages with updates for user selection (all selected by default)
7. Update: Modifies Directory.Packages.props with selected updates

Output Example

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
                         Central NuGet Package Updater
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

✓ Found 8 packages

Packages with available updates:
┌─────────────────────────────────────────┬─────────────────┬───────────────┬────────────┐
│ Package                                 │ Current Version │ Latest Version│ Published  │
├─────────────────────────────────────────┼─────────────────┼───────────────┼────────────┤
│ Microsoft.Extensions.DependencyInjection│ 7.0.0          │ 8.0.0         │ 2023-11-14 │
│ Newtonsoft.Json                         │ 13.0.1         │ 13.0.3        │ 2023-03-17 │
│ Serilog                                 │ 3.0.1          │ 3.1.1         │ 2023-10-16 │
└─────────────────────────────────────────┴─────────────────┴───────────────┴────────────┘

Select packages to update:
? Which packages would you like to update? 
  [X] Microsoft.Extensions.DependencyInjection (7.0.0 → 8.0.0)  ← All selected by default
  [X] Newtonsoft.Json (13.0.1 → 13.0.3)
  [X] Serilog (3.0.1 → 3.1.1)

Publishing as Global Tool

To publish updates to NuGet.org:

1. Update version in CentralNuGetUpdater.csproj

2. Create package:

   dotnet pack -c Release
   

3. Publish to NuGet.org:

   dotnet nuget push bin/Release/CentralNuGetUpdater.*.nupkg --api-key YOUR_API_KEY --source https://api.nuget.org/v3/index.json
   

Contributing

Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Troubleshooting

Common Issues

1. "Directory.Packages.props not found"

   • Ensure you're running the command in the correct directory
   • Use the --path option to specify the correct path

2. "No packages found"

   • Check that your Directory.Packages.props contains PackageVersion elements
   • Verify the XML format is correct

3. "Failed to check version for package"

   • Check your internet connection
   • Verify your nuget.config sources are accessible
   • Some corporate networks may require proxy configuration

4. Authentication issues with private feeds

   • Ensure dotnet restore works with your private feeds first
   • The tool uses the same credential providers and configuration as dotnet restore
   • Install the appropriate credential provider (e.g., Azure Artifacts Credential Provider for Azure DevOps)

5. Corporate proxy issues

   • Ensure your corporate proxy settings are configured in your NuGet configuration
   • Some corporate environments may require additional certificate configuration

Getting Help

If you encounter issues:

1. Check the troubleshooting section above
2. Run with --dry-run to see what would happen without making changes
3. Verify your nuget.config is properly configured
4. For authentication issues, ensure dotnet restore works with your feeds first
5. Open an issue with details about your setup and the error message