src/NLog/LogEventBuilder.cs (1)

123-139: Use the returned dictionary instead of _logEvent.Properties to avoid unused-local and match the span overload

dictionary is currently assigned but never used, which will raise an “assigned but never used” warning and is inconsistent with the ReadOnlySpan<(string, object?)> overload below that writes through the returned dictionary. You can both remove the warning and be consistent by writing through dictionary:

-            if (_logEvent != null)
-            {
-                var dictionary = _logEvent.CreatePropertiesInternal(initialCapacity: properties.Count);
-                foreach (var property in properties)
-                    _logEvent.Properties[property.Key] = property.Value;
-            }
+            if (_logEvent != null)
+            {
+                var dictionary = _logEvent.CreatePropertiesInternal(initialCapacity: properties.Count);
+                foreach (var property in properties)
+                    dictionary[property.Key] = property.Value;
+            }

(Optionally, the existing IEnumerable<KeyValuePair<string, object?>> overload could detect IReadOnlyCollection<> and delegate to this overload for the same pre-sizing benefits, but that’s not required for this change.)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/NLog/LogEventBuilder.cs (1)

123-139: Tighten null/Count check and actually use the preallocated dictionary

Nice addition for pre-sizing based on IReadOnlyCollection.Count. Two small tweaks would make this consistent with the other overload and avoid an “assigned but never used” local:

• After Guard.ThrowIfNull(properties);, the properties?.Count null-conditional is redundant and inconsistent with the IEnumerable overload.
• You allocate dictionary via CreatePropertiesInternal but then write through _logEvent.Properties; prefer using the local as in the span-based overload.

Suggested change:

-        public LogEventBuilder Properties(IReadOnlyCollection<KeyValuePair<string, object?>> properties)
-        {
-            Guard.ThrowIfNull(properties);
-            if (_logEvent != null && properties?.Count > 0)
-            {
-                var dictionary = _logEvent.CreatePropertiesInternal(initialCapacity: properties.Count);
-                foreach (var property in properties)
-                    _logEvent.Properties[property.Key] = property.Value;
-            }
-            return this;
-        }
+        public LogEventBuilder Properties(IReadOnlyCollection<KeyValuePair<string, object?>> properties)
+        {
+            Guard.ThrowIfNull(properties);
+            if (_logEvent != null && properties.Count > 0)
+            {
+                var dictionary = _logEvent.CreatePropertiesInternal(initialCapacity: properties.Count);
+                foreach (var property in properties)
+                    dictionary[property.Key] = property.Value;
+            }
+            return this;
+        }

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/NLog/LogEventBuilder.cs (1)

123-139: Good optimization with pre-allocation!

The new overload provides a nice performance improvement by pre-sizing the internal dictionary. The implementation is correct and consistent with the ReadOnlySpan overload.

One minor simplification: Line 131 uses properties?.Count with a null-conditional operator, but since Guard.ThrowIfNull(properties) on line 130 guarantees that properties is not null, you can simplify it to properties.Count.

Apply this diff to remove the redundant null check:

-            if (_logEvent != null && properties?.Count > 0)
+            if (_logEvent != null && properties.Count > 0)

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/NLog/LogEventBuilder.cs (1)

123-139: IReadOnlyCollection overload looks correct and efficiently uses Count for pre-allocation

The new LogEventBuilder.Properties(IReadOnlyCollection<KeyValuePair<string, object?>> properties) overload is consistent with the existing API, uses Guard.ThrowIfNull, and safely short-circuits on _logEvent != null && properties.Count > 0 so Count is only accessed when needed. Pre-sizing via CreatePropertiesInternal(initialCapacity: properties.Count) plus a single enumeration is a nice optimization, and overload resolution will naturally route IReadOnlyCollection-typed callers here without affecting existing IEnumerable-based call sites.

As a minor, optional enhancement, the IEnumerable overload could forward to this one when properties is IReadOnlyCollection<KeyValuePair<string, object?>> ro to reuse the pre-allocation path, but that’s not required for this PR.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro