Add metadata caches and package comparer (#519)

* Add metadata caches and package comparer

Add a global using for ConcurrentCollections and introduce PackageCacheKeyComparer to compare (package, NuGetVersion) tuple keys case-insensitively. Add two ConcurrentDictionary caches (metadataCache and latestVersionCache) to Updater and use them to short-circuit repository reads; cache entries (including null) are populated to avoid repeated package metadata/resolution calls.

* .

Author: SimonCropp

src/Directory.Build.props

@@ -1,7 +1,7 @@
 
 <Project>
   <PropertyGroup>
-    <Version>4.1.2</Version>
+    <Version>4.1.3</Version>
     <LangVersion>preview</LangVersion>
     <NoWarn>NU1608</NoWarn>
     <AssemblyVersion>1.0.0</AssemblyVersion>

src/PackageUpdate/GlobalUsings.cs

@@ -1,4 +1,6 @@
-global using System.Xml;
+global using System.Collections.Concurrent;
+global using System.Diagnostics;
+global using System.Xml;
 global using System.Xml.Linq;
 global using CommandLine;
 global using NuGet.Common;

src/PackageUpdate/PackageCacheKeyComparer.cs

@@ -0,0 +1,14 @@
+sealed class PackageCacheKeyComparer :
+    IEqualityComparer<(string Package, NuGetVersion Version)>
+{
+    public static PackageCacheKeyComparer Instance { get; } = new();
+
+    public bool Equals((string Package, NuGetVersion Version) x, (string Package, NuGetVersion Version) y) =>
+        string.Equals(x.Package, y.Package, StringComparison.OrdinalIgnoreCase) &&
+        EqualityComparer<NuGetVersion>.Default.Equals(x.Version, y.Version);
+
+    public int GetHashCode((string Package, NuGetVersion Version) obj) =>
+        HashCode.Combine(
+            StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Package),
+            EqualityComparer<NuGetVersion>.Default.GetHashCode(obj.Version));
+}

src/PackageUpdate/Program.cs

@@ -15,6 +15,7 @@ static async Task Inner(string directory, string? package, bool build)
         Environment.Exit(1);
     }
 
+    var totalStopwatch = Stopwatch.StartNew();
     using var cache = new SourceCacheContext
     {
         RefreshMemoryCache = true
@@ -28,6 +29,8 @@ static async Task Inner(string directory, string? package, bool build)
     {
         await DotnetStarter.Shutdown();
     }
+
+    Log.Information("Completed in {Elapsed}", totalStopwatch.Elapsed);
 }
 
 static async Task TryProcessSolution(SourceCacheContext cache, string solution, string? package, bool build)
@@ -67,7 +70,9 @@ static async Task ProcessSolution(SourceCacheContext cache, string solution, str
         return;
     }
 
+    var stopwatch = Stopwatch.StartNew();
     await Updater.Update(cache, props, package);
+    Log.Information("    Updated in {Elapsed}", stopwatch.Elapsed);
 
     if (build)
     {

src/PackageUpdate/Updater.cs

@@ -1,5 +1,8 @@
 public static class Updater
 {
+    static ConcurrentDictionary<(string Package, NuGetVersion Version), IPackageSearchMetadata?> metadataCache = new(PackageCacheKeyComparer.Instance);
+    static ConcurrentDictionary<(string Package, NuGetVersion CurrentVersion), IPackageSearchMetadata?> latestVersionCache = new(PackageCacheKeyComparer.Instance);
+
     public static async Task Update(
         SourceCacheContext cache,
         string directoryPackagesPropsPath,
@@ -179,6 +182,12 @@ public static async Task Update(
         List<PackageSource> sources,
         SourceCacheContext cache)
     {
+        var key = (package, currentVersion);
+        if (latestVersionCache.TryGetValue(key, out var cached))
+        {
+            return cached;
+        }
+
         IPackageSearchMetadata? latestMetadata = null;
 
         foreach (var source in sources)
@@ -212,6 +221,7 @@ public static async Task Update(
             }
         }
 
+        latestVersionCache[key] = latestMetadata;
         return latestMetadata;
     }
 
@@ -221,6 +231,12 @@ public static async Task Update(
         List<PackageSource> sources,
         SourceCacheContext cache)
     {
+        var key = (package, version);
+        if (metadataCache.TryGetValue(key, out var cached))
+        {
+            return cached;
+        }
+
         foreach (var source in sources)
         {
             var (_, metadataResource) = await RepositoryReader.Read(source);
@@ -233,10 +249,12 @@ public static async Task Update(
 
             if (metadata != null)
             {
+                metadataCache[key] = metadata;
                 return metadata;
             }
         }
 
+        metadataCache[key] = null;
         return null;
     }
 

src/Tests/PackageCacheKeyComparerTests.cs

@@ -0,0 +1,80 @@
+public class PackageCacheKeyComparerTests
+{
+    static PackageCacheKeyComparer comparer = PackageCacheKeyComparer.Instance;
+
+    [Fact]
+    public void Equals_SamePackageAndVersion()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+
+        Assert.True(comparer.Equals(x, y));
+    }
+
+    [Fact]
+    public void Equals_DifferentCase()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("newtonsoft.json", NuGetVersion.Parse("13.0.1"));
+
+        Assert.True(comparer.Equals(x, y));
+    }
+
+    [Fact]
+    public void Equals_DifferentVersion()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("Newtonsoft.Json", NuGetVersion.Parse("12.0.1"));
+
+        Assert.False(comparer.Equals(x, y));
+    }
+
+    [Fact]
+    public void Equals_DifferentPackage()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("NUnit", NuGetVersion.Parse("13.0.1"));
+
+        Assert.False(comparer.Equals(x, y));
+    }
+
+    [Fact]
+    public void GetHashCode_SameForDifferentCase()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("newtonsoft.json", NuGetVersion.Parse("13.0.1"));
+
+        Assert.Equal(comparer.GetHashCode(x), comparer.GetHashCode(y));
+    }
+
+    [Fact]
+    public void GetHashCode_DifferentForDifferentVersion()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("Newtonsoft.Json", NuGetVersion.Parse("12.0.1"));
+
+        Assert.NotEqual(comparer.GetHashCode(x), comparer.GetHashCode(y));
+    }
+
+    [Fact]
+    public void GetHashCode_DifferentForDifferentPackage()
+    {
+        var x = ("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"));
+        var y = ("NUnit", NuGetVersion.Parse("13.0.1"));
+
+        Assert.NotEqual(comparer.GetHashCode(x), comparer.GetHashCode(y));
+    }
+
+    [Fact]
+    public void WorksWithDictionary()
+    {
+        var dictionary = new Dictionary<(string Package, NuGetVersion Version), string>(comparer)
+        {
+            [("Newtonsoft.Json", NuGetVersion.Parse("13.0.1"))] = "first"
+        };
+
+        Assert.True(dictionary.ContainsKey(("newtonsoft.json", NuGetVersion.Parse("13.0.1"))));
+        Assert.True(dictionary.ContainsKey(("NEWTONSOFT.JSON", NuGetVersion.Parse("13.0.1"))));
+        Assert.False(dictionary.ContainsKey(("Newtonsoft.Json", NuGetVersion.Parse("12.0.1"))));
+    }
+}