fix(aspnetcore): add per-request de-dup and typed catch for reflection

- Add HttpContext.Items marker in ExceptionlessExceptionHandler to
  prevent duplicate event submission when DiagnosticListener also
  captures the same exception for a request.
- Replace generic catch with typed exception catches (TargetInvocation,
  AmbiguousMatch, Target, MethodAccess, Argument) in GetPropertyValue.
- Add tests for de-dup behavior (same exception skipped, different
  exception still submitted).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: niemyjski

src/Platforms/Exceptionless.AspNetCore/ExceptionlessDiagnosticListener.cs

@@ -58,6 +58,11 @@ private void SubmitException(object payload, string submissionMethod, bool isUnh
             if (httpContext == null || exception == null)
                 return;
 
+            // Skip if this exception was already submitted for this request by ExceptionlessExceptionHandler.
+            if (httpContext.Items.TryGetValue(ExceptionlessExceptionHandler.HttpContextSubmittedKey, out var submitted)
+                && ReferenceEquals(submitted, exception))
+                return;
+
             var contextData = new ContextData();
             if (isUnhandledError)
                 contextData.MarkAsUnhandledError();
@@ -74,7 +79,7 @@ private static object GetPropertyValue(object payload, string propertyName) {
                 return payload.GetType()
                     .GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.IgnoreCase)?
                     .GetValue(payload);
-            } catch {
+            } catch (Exception ex) when (ex is TargetInvocationException or AmbiguousMatchException or TargetException or MethodAccessException or ArgumentException) {
                 return null;
             }
         }

src/Platforms/Exceptionless.AspNetCore/ExceptionlessExceptionHandler.cs

@@ -13,6 +13,12 @@ public ExceptionlessExceptionHandler(ExceptionlessClient client) {
             _client = client ?? ExceptionlessClient.Default;
         }
 
+        /// <summary>
+        /// Key used in <see cref="HttpContext.Items"/> to track the exception already submitted for this request,
+        /// preventing duplicate submissions from the diagnostic listener.
+        /// </summary>
+        public const string HttpContextSubmittedKey = "Exceptionless:ExceptionSubmitted";
+
         public ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken) {
             if (cancellationToken.IsCancellationRequested)
                 return ValueTask.FromResult(false);
@@ -22,6 +28,7 @@ public ValueTask<bool> TryHandleAsync(HttpContext httpContext, Exception excepti
             contextData.SetSubmissionMethod(nameof(ExceptionlessExceptionHandler));
 
             exception.ToExceptionless(contextData, _client).SetHttpContext(httpContext).Submit();
+            httpContext.Items[HttpContextSubmittedKey] = exception;
 
             return ValueTask.FromResult(false);
         }

test/Exceptionless.Tests/Platforms/AspNetCoreExceptionCaptureTests.cs

@@ -137,6 +137,49 @@ public async Task Invoke_WhenNextDelegateThrows_RethrowsExceptionWithoutSubmitti
             Assert.Empty(submittingEvents);
         }
 
+        [Fact]
+        public async Task DiagnosticListener_WhenExceptionAlreadySubmittedByHandler_SkipsDuplicateSubmission() {
+            // Arrange
+            var submittingEvents = new List<EventSubmittingEventArgs>();
+            var client = CreateClient(submittingEvents);
+            var context = CreateHttpContext();
+            var exception = new InvalidOperationException("unhandled");
+            var handler = new ExceptionlessExceptionHandler(client);
+            var listener = new ExceptionlessDiagnosticListener(client);
+
+            // Act — handler submits first, then diagnostic listener sees the same exception
+            await handler.TryHandleAsync(context, exception, CancellationToken.None);
+            listener.OnNext(new KeyValuePair<string, object>("Microsoft.AspNetCore.Hosting.UnhandledException", new {
+                httpContext = context,
+                exception
+            }));
+
+            // Assert — only one submission
+            Assert.Single(submittingEvents);
+        }
+
+        [Fact]
+        public void DiagnosticListener_WhenExceptionDiffersFromSubmitted_SubmitsNewEvent() {
+            // Arrange
+            var submittingEvents = new List<EventSubmittingEventArgs>();
+            var client = CreateClient(submittingEvents);
+            var context = CreateHttpContext();
+            var listener = new ExceptionlessDiagnosticListener(client);
+
+            // Mark a different exception as already submitted
+            context.Items[ExceptionlessExceptionHandler.HttpContextSubmittedKey] = new InvalidOperationException("other");
+
+            // Act — diagnostic listener sees a different exception instance
+            var newException = new InvalidOperationException("different");
+            listener.OnNext(new KeyValuePair<string, object>("Microsoft.AspNetCore.Hosting.UnhandledException", new {
+                httpContext = context,
+                exception = newException
+            }));
+
+            // Assert — still submits because it's a different exception
+            Assert.Single(submittingEvents);
+        }
+
         private static ExceptionlessClient CreateClient(ICollection<EventSubmittingEventArgs> submittingEvents) {
             var client = new ExceptionlessClient(configuration => {
                 configuration.ApiKey = "test-api-key";