Reduce AOT file-size by changing LogFactory PurgeObsoleteLoggers to clone Dictionary instead of ToList - #6177

src/NLog/LogFactory.cs (1)

1180-1186: ⚡ Quick win

Prefer collecting only keys instead of key-value pairs.

The aotFriendlyRemoval dictionary stores both keys and values (WeakReference instances), but line 1190 only uses removeLogger.Key. The values are never accessed, making their storage wasteful.

♻️ Refactor to collect only keys

-                var aotFriendlyRemoval = new Dictionary<LoggerCacheKey, WeakReference>();
+                var aotFriendlyRemoval = new List<LoggerCacheKey>();
                 foreach (var item in _loggerCache)
                 {
                     var logger = Retrieve(item.Key);
                     if (logger is null)
-                        aotFriendlyRemoval[item.Key] = item.Value;
+                        aotFriendlyRemoval.Add(item.Key);
                 }
 
                 foreach (var removeLogger in aotFriendlyRemoval)
                 {
-                    _loggerCache.Remove(removeLogger.Key);
+                    _loggerCache.Remove(removeLogger);
                 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/NLog/LogFactory.cs` around lines 1180 - 1186, The aotFriendlyRemoval
currently stores key/value pairs (Dictionary<LoggerCacheKey, WeakReference>) but
only the keys are used; change it to collect just keys (e.g.,
List<LoggerCacheKey> or HashSet<LoggerCacheKey>) instead of a Dictionary, add
item.Key to that collection when Retrieve(item.Key) returns null, and then
iterate that keys collection to remove entries from _loggerCache; update
references to aotFriendlyRemoval accordingly (variables: aotFriendlyRemoval,
LoggerCacheKey, _loggerCache, Retrieve, removeLogger.Key).

src/NLog/LogFactory.cs (1)

1180-1191: ⚡ Quick win

Eliminate redundant dictionary lookups during purge.

Line 1183 calls Retrieve(item.Key), which performs a dictionary lookup to access the WeakReference, but the iteration already provides item.Value as the WeakReference. Directly checking item.Value.Target is null eliminates O(n) redundant lookups.

Additionally, since only keys are needed for removal, consider using List<LoggerCacheKey> instead of Dictionary<LoggerCacheKey, WeakReference> to simplify the code and reduce allocations.

♻️ Proposed refactor

 public void PurgeObsoleteLoggers()
 {
-    var aotFriendlyRemoval = new Dictionary<LoggerCacheKey, WeakReference>();
+    var aotFriendlyRemoval = new List<LoggerCacheKey>();
     foreach (var item in _loggerCache)
     {
-        var logger = Retrieve(item.Key);
-        if (logger is null)
-            aotFriendlyRemoval[item.Key] = item.Value;
+        if (item.Value.Target is null)
+            aotFriendlyRemoval.Add(item.Key);
     }

-    foreach (var removeLogger in aotFriendlyRemoval)
+    foreach (var removeKey in aotFriendlyRemoval)
     {
-        _loggerCache.Remove(removeLogger.Key);
+        _loggerCache.Remove(removeKey);
     }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/NLog/LogFactory.cs` around lines 1180 - 1191, The current purge loop
redundantly calls Retrieve(item.Key) causing extra dictionary lookups; instead
check the iterated WeakReference directly by testing item.Value.Target == null
and collect only keys to remove (use a List<LoggerCacheKey> removeKeys). Replace
the Dictionary<LoggerCacheKey, WeakReference> aotFriendlyRemoval with
List<LoggerCacheKey> removeKeys, add item.Key to removeKeys when
item.Value.Target is null, and then iterate removeKeys to call
_loggerCache.Remove(key); this eliminates redundant lookups and reduces
allocations while keeping the removal logic around _loggerCache and types
LoggerCacheKey and WeakReference intact.

src/NLog/LogFactory.cs (1)

1180-1185: ⚡ Quick win

Consider using List instead of Dictionary for the removal collection.

The aotFriendlyRemoval dictionary stores WeakReference values that are never used—only the keys are needed in the removal loop at line 1189. Using List<LoggerCacheKey> would be more efficient and clearer.

♻️ Proposed refactor

-var aotFriendlyRemoval = new Dictionary<LoggerCacheKey, WeakReference>();
+var aotFriendlyRemoval = new List<LoggerCacheKey>();
 foreach (var item in _loggerCache)
 {
     if (item.Value.Target is null)
-        aotFriendlyRemoval[item.Key] = item.Value;
+        aotFriendlyRemoval.Add(item.Key);
 }

 foreach (var removeLogger in aotFriendlyRemoval)
 {
-    _loggerCache.Remove(removeLogger.Key);
+    _loggerCache.Remove(removeLogger);
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/NLog/LogFactory.cs` around lines 1180 - 1185, Replace the temporary
Dictionary aotFriendlyRemoval with a List<LoggerCacheKey> since only keys are
used: while iterating _loggerCache, add item.Key to the list when
item.Value.Target is null (use the existing LoggerCacheKey type), then iterate
that List<LoggerCacheKey> to remove entries from _loggerCache; update references
to aotFriendlyRemoval accordingly in the removal loop to improve clarity and
performance.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes