Fix reflection based destructuring for redefined property

Source/Serilog.Exceptions/Core/ExceptionPropertiesBag.cs

@@ -7,9 +7,16 @@ namespace Serilog.Exceptions.Core
     /// <inheritdoc />
     internal class ExceptionPropertiesBag : IExceptionPropertiesBag
     {
+        /// <summary>
+        /// In theory there should not be any properties with same names passed
+        /// but just as a defensive and robustness measure, we allow small amount
+        /// so that library can keep working in case of minor error (or unexpected
+        /// scenario) on the properties provider side.
+        /// </summary>
+        private const int AcceptableNumberOfSameNameProperties = 5;
         private readonly Exception exception;
         private readonly IExceptionPropertyFilter? filter;
-        private readonly Dictionary<string, object?> properties = new();
+        private readonly Dictionary<string, object?> properties = new ();
 
         /// <summary>
         /// We keep a note on whether the results were collected to be sure that after that there are no changes. This
@@ -56,10 +63,46 @@ public void AddProperty(string key, object? value)
                 }
             }
 
-            this.properties.Add(key, value);
+            this.AddPairToProperties(key, value);
         }
 
         /// <inheritdoc />
         public bool ContainsProperty(string key) => this.properties.ContainsKey(key);
+
+        /// <summary>
+        /// We want to be as robust as possible
+        /// so even in case of multiple properties with the same name
+        /// we want to at least try carrying on and keep working.
+        /// </summary>
+        private void AddPairToProperties(string key, object? value)
+        {
+#if NET5_0
+            var i = 0;
+            while (!this.properties.TryAdd(key, value) && i < AcceptableNumberOfSameNameProperties)
+            {
+                key += "$";
+                i++;
+            }
+#else
+            key = this.MakeSureKeyIsUnique(key);
+
+            this.properties.Add(key, value);
+#endif
+        }
+
+#if !NET5_0
+
+        private string MakeSureKeyIsUnique(string key)
+        {
+            var i = 0;
+            while (this.properties.ContainsKey(key) && i < AcceptableNumberOfSameNameProperties)
+            {
+                key += "$";
+                i++;
+            }
+
+            return key;
+        }
+#endif
     }
 }

Tests/Serilog.Exceptions.Test/Destructurers/ReflectionBasedDestructurerTest.cs

@@ -9,6 +9,7 @@ namespace Serilog.Exceptions.Test.Destructurers
     using Serilog.Exceptions.Core;
     using Serilog.Exceptions.Destructurers;
     using Xunit;
+    using Xunit.Abstractions;
     using static LogJsonOutputUtils;
 
     public class ReflectionBasedDestructurerTest
@@ -384,6 +385,18 @@ public void CanDestructureObjectWithHiddenProperty()
             Assert.Equal(baseClass.HiddenProperty, info?[$"{typeof(BaseClass).FullName}.{nameof(BaseClass.HiddenProperty)}"]);
         }
 
+        [Fact]
+        public void CanDestructureObjectWithRedefinedProperty()
+        {
+            var exception = new TestExceptionClassWithNewDefinition() { PublicProperty = 20 };
+
+            var propertiesBag = new ExceptionPropertiesBag(exception);
+            CreateReflectionBasedDestructurer().Destructure(exception, propertiesBag, EmptyDestructurer());
+
+            var properties = propertiesBag.GetResultDictionary();
+            var info = properties[nameof(TestExceptionClassWithNewDefinition.PublicProperty)];
+        }
+
         private static void Test_ResultOfReflectionDestructurerShouldBeEquivalentToCustomOne(
             Exception exception,
             IExceptionDestructurer customDestructurer)
@@ -578,6 +591,11 @@ internal class TestClass
             public string? ReferenceType { get; set; }
         }
 
+        internal class TestExceptionClassWithNewDefinition : TestException
+        {
+            public new int PublicProperty { get; set; }
+        }
+
         internal class BaseClass
         {
             public virtual int HiddenProperty { get; set; }