More allocation cleanups

Author: javiercn

src/StaticWebAssetsSdk/Tasks/ApplyCompressionNegotiation.cs

@@ -27,66 +27,31 @@ public override bool Execute()
 
         var updatedEndpoints = new HashSet<StaticWebAssetEndpoint>(CandidateEndpoints.Length, StaticWebAssetEndpoint.RouteAndAssetComparer);
 
-        var preservedEndpoints = new Dictionary<(string, string), StaticWebAssetEndpoint>(CandidateEndpoints.Length);
-
-        var compressionHeadersByContentEncoding = new Dictionary<string, StaticWebAssetEndpointResponseHeader[]>(2);
+        var compressionHeadersByEncoding = new Dictionary<string, StaticWebAssetEndpointResponseHeader[]>(2);
 
         // Add response headers to compressed endpoints
-        foreach (var kvp in assetsById)
+        foreach (var compressedAsset in assetsById.Values)
         {
-            var key = kvp.Key;
-            var compressedAsset = kvp.Value;
-
             if (!string.Equals(compressedAsset.AssetTraitName, "Content-Encoding", StringComparison.Ordinal))
             {
                 continue;
             }
 
-            if (!assetsById.TryGetValue(compressedAsset.RelatedAsset, out var relatedAsset))
-            {
-                Log.LogWarning("Related asset not found for compressed asset: {0}", compressedAsset.Identity);
-                throw new InvalidOperationException($"Related asset not found for compressed asset: {compressedAsset.Identity}");
-            }
-
-            if (!endpointsByAsset.TryGetValue(compressedAsset.Identity, out var compressedEndpoints))
-            {
-                Log.LogWarning("Endpoints not found for compressed asset: {0} {1}", compressedAsset.RelativePath, compressedAsset.Identity);
-                throw new InvalidOperationException($"Endpoints not found for compressed asset: {compressedAsset.Identity}");
-            }
-
-            if (!endpointsByAsset.TryGetValue(relatedAsset.Identity, out var relatedAssetEndpoints))
-            {
-                Log.LogWarning("Endpoints not found for related asset: {0}", relatedAsset.Identity);
-                throw new InvalidOperationException($"Endpoints not found for related asset: {relatedAsset.Identity}");
-            }
+            var (compressedEndpoints, relatedAssetEndpoints) = ResolveEndpoints(assetsById, endpointsByAsset, compressedAsset);
 
             Log.LogMessage("Processing compressed asset: {0}", compressedAsset.Identity);
-            if (compressionHeadersByContentEncoding.TryGetValue(compressedAsset.AssetTraitValue, out var compressionHeaders))
-            {
-                compressionHeaders = [
-                    new()
-                    {
-                        Name = "Content-Encoding",
-                        Value = compressedAsset.AssetTraitValue
-                    },
-                    new()
-                    {
-                        Name = "Vary",
-                        Value = "Content-Encoding"
-                    }
-                ];
-                compressionHeadersByContentEncoding.Add(compressedAsset.AssetTraitValue, compressionHeaders);
-            }
+            var compressionHeaders = GetOrCreateCompressionHeaders(compressionHeadersByEncoding, compressedAsset);
 
             var quality = ResolveQuality(compressedAsset);
             foreach (var compressedEndpoint in compressedEndpoints)
             {
-                if (compressedEndpoint.Selectors.Any(s => string.Equals(s.Name, "Content-Encoding", StringComparison.Ordinal)))
+                if (HasContentEncodingSelector(compressedEndpoint))
                 {
-                    Log.LogMessage(MessageImportance.Low, $"  Skipping endpoint '{compressedEndpoint.Route}' since it already has a Content-Encoding selector");
+                    Log.LogMessage(MessageImportance.Low, "  Skipping endpoint '{0}' since it already has a Content-Encoding selector", compressedEndpoint.Route);
                     continue;
                 }
-                if (!compressedEndpoint.ResponseHeaders.Any(s => string.Equals(s.Name, "Content-Encoding", StringComparison.Ordinal)))
+
+                if (!HasContentEncodingResponseHeader(compressedEndpoint))
                 {
                     // Add the Content-Encoding and Vary headers
                     compressedEndpoint.ResponseHeaders = [
@@ -95,66 +60,29 @@ public override bool Execute()
                     ];
                 }
 
+                var compressedHeaders = GetCompressedHeaders(compressedEndpoint);
+
                 Log.LogMessage(MessageImportance.Low, "  Updated endpoint '{0}' with Content-Encoding and Vary headers", compressedEndpoint.Route);
                 updatedEndpoints.Add(compressedEndpoint);
 
-                var compressedHeaders = GetCompressedHeaders(compressedEndpoint);
                 foreach (var relatedEndpointCandidate in relatedAssetEndpoints)
                 {
                     if (!IsCompatible(compressedEndpoint, relatedEndpointCandidate))
                     {
                         continue;
                     }
-                    Log.LogMessage(MessageImportance.Low, "Processing related endpoint '{0}'", relatedEndpointCandidate.Route);
-                    var encodingSelector = new StaticWebAssetEndpointSelector
-                    {
-                        Name = "Content-Encoding",
-                        Value = compressedAsset.AssetTraitValue,
-                        Quality = quality
-                    };
-                    Log.LogMessage(MessageImportance.Low, "  Created Content-Encoding selector for compressed asset '{0}' with size '{1}' is '{2}'", encodingSelector.Value, encodingSelector.Quality, relatedEndpointCandidate.Route);
-                    var endpointCopy = new StaticWebAssetEndpoint
-                    {
-                        AssetFile = compressedAsset.Identity,
-                        Route = relatedEndpointCandidate.Route,
-                        Selectors = [
-                            ..relatedEndpointCandidate.Selectors,
-                            encodingSelector
-                        ],
-                        // Endpoint properties are never modified as part of this step, so we can just copy them and avoid extra work
-                        EndpointProperties = relatedEndpointCandidate.EndpointProperties
-                    };
-
-                    var headers = new List<StaticWebAssetEndpointResponseHeader>(7);
-
-                    ApplyCompressedEndpointHeaders(headers, compressedEndpoint, relatedEndpointCandidate.Route);
-                    ApplyRelatedEndpointCandidateHeaders(headers, relatedEndpointCandidate, compressedHeaders);
-                    endpointCopy.ResponseHeaders = [.. headers];
 
-                    // Update the endpoint
-                    Log.LogMessage(MessageImportance.Low, "  Updated related endpoint '{0}' with Content-Encoding selector '{1}={2}'", relatedEndpointCandidate.Route, encodingSelector.Value, encodingSelector.Quality);
+                    var endpointCopy = CreateUpdatedEndpoint(compressedAsset, quality, compressedEndpoint, compressedHeaders, relatedEndpointCandidate);
                     updatedEndpoints.Add(endpointCopy);
-
                     // Since we are going to remove the endpoints from the associated item group and the route is
                     // the ItemSpec, we want to add the original as well so that it gets re-added.
                     // The endpoint pointing to the uncompressed asset doesn't have a Content-Encoding selector and
                     // will use the default "identity" encoding during content negotiation.
-                    if (!preservedEndpoints.ContainsKey((relatedEndpointCandidate.Route, relatedEndpointCandidate.AssetFile)))
-                    {
-                        preservedEndpoints.Add(
-                            (relatedEndpointCandidate.Route, relatedEndpointCandidate.AssetFile),
-                            relatedEndpointCandidate);
-                    }
+                    updatedEndpoints.Add(relatedEndpointCandidate);
                 }
             }
         }
 
-        // Add the preserved endpoints to the list of updated endpoints.
-        foreach (var preservedEndpoint in preservedEndpoints.Values)
-        {
-            updatedEndpoints.Add(preservedEndpoint);
-        }
-
         // Before we return the updated endpoints we need to capture any other endpoint whose asset is not associated
         // with the compressed asset. This is because we are going to remove the endpoints from the associated item group
         // and the route is the ItemSpec, so it will cause those endpoints to be removed.
@@ -182,11 +110,11 @@ public override bool Execute()
         // We now have only endpoints that might have the same route but point to different assets
         // and we want to include them in the updated endpoints so that we don't incorrectly remove
         // them from the associated item group when we update the endpoints.
-        var endpointsByRoute = endpointsByAsset.Values.SelectMany(e => e).GroupBy(e => e.Route).ToDictionary(g => g.Key, g => g.ToList());
-
-        var updatedEndpointsByRoute = updatedEndpoints.Select(e => e.Route).ToArray();
-        foreach (var route in updatedEndpointsByRoute)
+        var endpointsByRoute = GetEndpointsByRoute(endpointsByAsset);
+        var additionalUpdatedEndpoints = new HashSet<StaticWebAssetEndpoint>(updatedEndpoints.Count, StaticWebAssetEndpoint.RouteAndAssetComparer);
+        foreach (var updatedEndpoint in updatedEndpoints)
         {
+            var route = updatedEndpoint.Route;
             Log.LogMessage(MessageImportance.Low, "Processing route '{0}'", route);
             if (endpointsByRoute.TryGetValue(route, out var endpoints))
             {
@@ -197,36 +125,187 @@ public override bool Execute()
                 }
                 foreach (var endpoint in endpoints)
                 {
-                    updatedEndpoints.Add(endpoint);
+                    additionalUpdatedEndpoints.Add(endpoint);
                 }
             }
         }
 
-        UpdatedEndpoints = updatedEndpoints.Distinct().Select(e => e.ToTaskItem()).ToArray();
+        updatedEndpoints.UnionWith(additionalUpdatedEndpoints);
+
+        UpdatedEndpoints = StaticWebAssetEndpoint.ToTaskItems(updatedEndpoints);
 
         return true;
     }
 
     private static HashSet<string> GetCompressedHeaders(StaticWebAssetEndpoint compressedEndpoint)
     {
-        var result = new HashSet<string>(compressedEndpoint.Selectors.Length, StringComparer.Ordinal);
+        var result = new HashSet<string>(compressedEndpoint.ResponseHeaders.Length, StringComparer.Ordinal);
         for (var i = 0; i < compressedEndpoint.ResponseHeaders.Length; i++)
         {
-            result.Add(compressedEndpoint.ResponseHeaders[i].Name);
+            var responseHeader = compressedEndpoint.ResponseHeaders[i];
+            result.Add(responseHeader.Name);
+        }
+
+        return result;
+    }
+
+    private static Dictionary<string, List<StaticWebAssetEndpoint>> GetEndpointsByRoute(
+        IDictionary<string, List<StaticWebAssetEndpoint>> endpointsByAsset)
+    {
+        var result = new Dictionary<string, List<StaticWebAssetEndpoint>>(endpointsByAsset.Count);
+
+        foreach (var endpointsList in endpointsByAsset.Values)
+        {
+            foreach (var endpoint in endpointsList)
+            {
+                if (!result.TryGetValue(endpoint.Route, out var routeEndpoints))
+                {
+                    routeEndpoints = new List<StaticWebAssetEndpoint>(5);
+                    result[endpoint.Route] = routeEndpoints;
+                }
+                routeEndpoints.Add(endpoint);
+            }
         }
+
         return result;
     }
 
+    private static StaticWebAssetEndpointResponseHeader[] GetOrCreateCompressionHeaders(Dictionary<string, StaticWebAssetEndpointResponseHeader[]> compressionHeadersByEncoding, StaticWebAsset compressedAsset)
+    {
+        if (!compressionHeadersByEncoding.TryGetValue(compressedAsset.AssetTraitValue, out var compressionHeaders))
+        {
+            compressionHeaders = CreateCompressionHeaders(compressedAsset);
+            compressionHeadersByEncoding.Add(compressedAsset.AssetTraitValue, compressionHeaders);
+        }
+
+        return compressionHeaders;
+    }
+
+    private static StaticWebAssetEndpointResponseHeader[] CreateCompressionHeaders(StaticWebAsset compressedAsset) =>
+        [
+            new()
+            {
+                Name = "Content-Encoding",
+                Value = compressedAsset.AssetTraitValue
+            },
+            new()
+            {
+                Name = "Vary",
+                Value = "Content-Encoding"
+            }
+        ];
+
+    private StaticWebAssetEndpoint CreateUpdatedEndpoint(
+        StaticWebAsset compressedAsset,
+        string quality,
+        StaticWebAssetEndpoint compressedEndpoint,
+        HashSet<string> compressedHeaders,
+        StaticWebAssetEndpoint relatedEndpointCandidate)
+    {
+        Log.LogMessage(MessageImportance.Low, "Processing related endpoint '{0}'", relatedEndpointCandidate.Route);
+        var encodingSelector = new StaticWebAssetEndpointSelector
+        {
+            Name = "Content-Encoding",
+            Value = compressedAsset.AssetTraitValue,
+            Quality = quality
+        };
+        Log.LogMessage(MessageImportance.Low, "  Created Content-Encoding selector for compressed asset '{0}' with size '{1}' is '{2}'", encodingSelector.Value, encodingSelector.Quality, relatedEndpointCandidate.Route);
+        var endpointCopy = new StaticWebAssetEndpoint
+        {
+            AssetFile = compressedAsset.Identity,
+            Route = relatedEndpointCandidate.Route,
+            Selectors = [
+                ..relatedEndpointCandidate.Selectors,
+                            encodingSelector
+            ],
+            EndpointProperties = relatedEndpointCandidate.EndpointProperties
+        };
+        var headers = new List<StaticWebAssetEndpointResponseHeader>(7);
+        ApplyCompressedEndpointHeaders(headers, compressedEndpoint, relatedEndpointCandidate.Route);
+        ApplyRelatedEndpointCandidateHeaders(headers, relatedEndpointCandidate, compressedHeaders);
+        endpointCopy.ResponseHeaders = [.. headers];
+
+        // Update the endpoint
+        Log.LogMessage(MessageImportance.Low, "  Updated related endpoint '{0}' with Content-Encoding selector '{1}={2}'", relatedEndpointCandidate.Route, encodingSelector.Value, encodingSelector.Quality);
+        return endpointCopy;
+    }
+
+    private static bool HasContentEncodingResponseHeader(StaticWebAssetEndpoint compressedEndpoint)
+    {
+        for (var i = 0; i < compressedEndpoint.ResponseHeaders.Length; i++)
+        {
+            var responseHeader = compressedEndpoint.ResponseHeaders[i];
+            if (string.Equals(responseHeader.Name, "Content-Encoding", StringComparison.Ordinal))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static bool HasContentEncodingSelector(StaticWebAssetEndpoint compressedEndpoint)
+    {
+        for (var i = 0; i < compressedEndpoint.Selectors.Length; i++)
+        {
+            var selector = compressedEndpoint.Selectors[i];
+            if (string.Equals(selector.Name, "Content-Encoding", StringComparison.Ordinal))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private (List<StaticWebAssetEndpoint> compressedEndpoints, List<StaticWebAssetEndpoint> relatedAssetEndpoints) ResolveEndpoints(
+        IDictionary<string, StaticWebAsset> assetsById,
+        IDictionary<string, List<StaticWebAssetEndpoint>> endpointsByAsset,
+        StaticWebAsset compressedAsset)
+    {
+        if (!assetsById.TryGetValue(compressedAsset.RelatedAsset, out var relatedAsset))
+        {
+            Log.LogWarning("Related asset not found for compressed asset: {0}", compressedAsset.Identity);
+            throw new InvalidOperationException($"Related asset not found for compressed asset: {compressedAsset.Identity}");
+        }
+
+        if (!endpointsByAsset.TryGetValue(compressedAsset.Identity, out var compressedEndpoints))
+        {
+            Log.LogWarning("Endpoints not found for compressed asset: {0} {1}", compressedAsset.RelativePath, compressedAsset.Identity);
+            throw new InvalidOperationException($"Endpoints not found for compressed asset: {compressedAsset.Identity}");
+        }
+
+        if (!endpointsByAsset.TryGetValue(relatedAsset.Identity, out var relatedAssetEndpoints))
+        {
+            Log.LogWarning("Endpoints not found for related asset: {0}", relatedAsset.Identity);
+            throw new InvalidOperationException($"Endpoints not found for related asset: {relatedAsset.Identity}");
+        }
+
+        return (compressedEndpoints, relatedAssetEndpoints);
+    }
+
     private static string ResolveQuality(StaticWebAsset compressedAsset) =>
         Math.Round(1.0 / (compressedAsset.FileLength + 1), 12).ToString("F12", CultureInfo.InvariantCulture);
 
     private static bool IsCompatible(StaticWebAssetEndpoint compressedEndpoint, StaticWebAssetEndpoint relatedEndpointCandidate)
     {
-        var compressedFingerprint = compressedEndpoint.EndpointProperties.FirstOrDefault(ep => ep.Name == "fingerprint");
-        var relatedFingerprint = relatedEndpointCandidate.EndpointProperties.FirstOrDefault(ep => ep.Name == "fingerprint");
+        var compressedFingerprint = ResolveFingerprint(compressedEndpoint);
+        var relatedFingerprint = ResolveFingerprint(relatedEndpointCandidate);
         return string.Equals(compressedFingerprint.Value, relatedFingerprint.Value, StringComparison.Ordinal);
     }
 
+    private static StaticWebAssetEndpointProperty ResolveFingerprint(StaticWebAssetEndpoint compressedEndpoint)
+    {
+        foreach (var property in compressedEndpoint.EndpointProperties)
+        {
+            if (string.Equals(property.Name, "fingerprint", StringComparison.Ordinal))
+            {
+                return property;
+            }
+        }
+        return default;
+    }
+
     private void ApplyCompressedEndpointHeaders(List<StaticWebAssetEndpointResponseHeader> headers, StaticWebAssetEndpoint compressedEndpoint, string relatedEndpointCandidateRoute)
     {
         foreach (var header in compressedEndpoint.ResponseHeaders)

src/StaticWebAssetsSdk/Tasks/Data/StaticWebAsset.cs

@@ -1251,26 +1251,6 @@ internal static StaticWebAsset[] FromTaskItemGroup(ITaskItem[] candidateAssets,
         return result;
     }
 
-    internal static IDictionary<string, List<StaticWebAssetEndpoint>> ToAssetFileDictionary(ITaskItem[] candidateEndpoints)
-    {
-        var result = new Dictionary<string, List<StaticWebAssetEndpoint>>(candidateEndpoints.Length / 2);
-
-        foreach (var candidate in candidateEndpoints)
-        {
-            var endpoint = FromTaskItem(candidate);
-            var assetFile = endpoint.AssetFile;
-            if (!result.TryGetValue(assetFile, out var endpoints))
-            {
-                endpoints = new List<StaticWebAssetEndpoint>(5);
-                result[assetFile] = endpoints;
-            }
-            endpoints.Add(endpoint);
-        }
-
-        return result;
-    }
-
-
     internal static Dictionary<string, (StaticWebAsset, List<StaticWebAsset>)> AssetsByTargetPath(ITaskItem[] assets, string source, string assetKind)
     {
         // We return either the selected asset or a list with all the candidates that were found to be ambiguous