Compare both Id and Name for equity.

Author: andrii-babanin-sym

src/Serilog.Extensions.Logging/Extensions/Logging/EventIdPropertyCache.cs

@@ -10,63 +10,94 @@ internal sealed class EventIdPropertyCache
     {
         private readonly object _createLock = new();
         private readonly int _maxCapacity;
-        private readonly Dictionary<int, LogEventProperty> _propertyCache;
+        private readonly Dictionary<EventKey, LogEventProperty> _propertyCache;
 
         private int count;
 
         public EventIdPropertyCache(int maxCapacity)
         {
-            this._maxCapacity = maxCapacity;
-            this._propertyCache = new Dictionary<int, LogEventProperty>(capacity: maxCapacity);
+            _maxCapacity = maxCapacity;
+            _propertyCache = new Dictionary<EventKey, LogEventProperty>(capacity: maxCapacity);
         }
 
         public LogEventProperty GetOrCreateProperty(in EventId eventId)
         {
-            if (_propertyCache.TryGetValue(eventId.Id, out var cachedProperty))
+            var eventKey = new EventKey(eventId);
+
+            if (_propertyCache.TryGetValue(eventKey, out var cachedProperty))
             {
                 return cachedProperty;
             }
 
             lock (_createLock)
             {
-                return GetOrCreateSynchronized(in eventId);
+                // Double check under lock
+                if (_propertyCache.TryGetValue(eventKey, out cachedProperty))
+                {
+                    return cachedProperty;
+                }
+
+                cachedProperty = CreateCore(in eventKey);
+
+                if (count < _maxCapacity)
+                {
+                    _propertyCache[eventKey] = cachedProperty;
+                    count++;
+                }
+
+                return cachedProperty;
             }
         }
 
-        private static LogEventProperty CreateCore(in EventId eventId)
+        private static LogEventProperty CreateCore(in EventKey eventKey)
         {
             var properties = new List<LogEventProperty>(2);
 
-            if (eventId.Id != 0)
+            if (eventKey.Id != 0)
             {
-                properties.Add(new LogEventProperty("Id", new ScalarValue(eventId.Id)));
+                properties.Add(new LogEventProperty("Id", new ScalarValue(eventKey.Id)));
             }
 
-            if (eventId.Name != null)
+            if (eventKey.Name != null)
             {
-                properties.Add(new LogEventProperty("Name", new ScalarValue(eventId.Name)));
+                properties.Add(new LogEventProperty("Name", new ScalarValue(eventKey.Name)));
             }
 
             return new LogEventProperty("EventId", new StructureValue(properties));
         }
 
-        private LogEventProperty GetOrCreateSynchronized(in EventId eventId)
+        private readonly struct EventKey : IEquatable<EventKey>
         {
-            // Double check under lock
-            if (_propertyCache.TryGetValue(eventId.Id, out var cachedProperty))
+            
+            public EventKey(EventId eventId)
             {
-                return cachedProperty;
+                Id = eventId.Id;
+                Name = eventId.Name;
             }
 
-            cachedProperty = CreateCore(in eventId);
+            public int Id { get; }
 
-            if (count < _maxCapacity)
+            public string? Name { get; }
+
+            /// <inheritdoc />
+            public override int GetHashCode()
             {
-                _propertyCache[eventId.Id] = cachedProperty;
-                count++;
+                unchecked
+                {
+                    var hashCode = 17;
+
+                    hashCode = (hashCode * 397) ^ this.Id;
+                    hashCode = (hashCode * 397) ^ (this.Name?.GetHashCode() ?? 0);
+
+                    return hashCode;
+                }
             }
-            
-            return cachedProperty;
+
+            /// <inheritdoc />
+            public bool Equals(EventKey other) => this.Id == other.Id && this.Name == other.Name;
+
+            /// <inheritdoc />
+            public override bool Equals(object? obj) => obj is EventKey other && Equals(other);
         }
     }
 }