Synchronize access to System.ComponentModel.DataAnnotations.Validator

src/Polly.Core/ResiliencePipelineBuilderBase.cs

@@ -18,6 +18,9 @@ namespace Polly;
 public abstract class ResiliencePipelineBuilderBase
 #pragma warning restore S1694 // An abstract class should have both abstract and concrete methods
 {
+    // Workaround for https://github.com/dotnet/runtime/issues/110917
+    private static readonly object ValidatorLock = new();
+
     private readonly List<Entry> _entries = [];
     private bool _used;
 
@@ -105,7 +108,14 @@ internal void AddPipelineComponent(Func<StrategyBuilderContext, PipelineComponen
         Guard.NotNull(factory);
         Guard.NotNull(options);
 
-        Validator(new ResilienceValidationContext(options, $"The '{TypeNameFormatter.Format(options.GetType())}' are invalid."));
+        var validationContext = new ResilienceValidationContext(
+            options,
+            $"The '{TypeNameFormatter.Format(options.GetType())}' are invalid.");
+
+        lock (ValidatorLock)
+        {
+            Validator(validationContext);
+        }
 
         if (_used)
         {

test/Polly.Core.Tests/ResiliencePipelineBuilderTests.cs

@@ -351,6 +351,26 @@ public void AddPipeline_CombinePipelines_Ok()
         executions.Should().HaveCount(7);
     }
 
+    /// <summary>
+    /// Test for <see href="https://github.com/App-vNext/Polly/issues/2412">validator concurrency issue</see>.
+    /// </summary>
+    [Fact]
+    public void AddStrategy_DoesNotValidateOptionsConcurrently()
+    {
+        var detector = new ConcurrencyDetector();
+
+        Parallel.For(
+            0,
+            2,
+            index =>
+            {
+                new ResiliencePipelineBuilder()
+                    .AddStrategy(_ => new TestResilienceStrategy(), new ConcurrencyResiliencePipelineOptions(detector));
+            });
+
+        detector.InvokedConcurrently.Should().BeFalse();
+    }
+
     [Fact]
     public void Build_EnsureCorrectContext()
     {
@@ -500,9 +520,37 @@ private class InvalidResiliencePipelineOptions : ResilienceStrategyOptions
         public string? RequiredProperty { get; set; }
     }
 
+    private class ConcurrencyResiliencePipelineOptions(ConcurrencyDetector detector)
+        : ResilienceStrategyOptions, IValidatableObject
+    {
+        public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+        {
+            detector.Execute();
+            yield break;
+        }
+    }
+
     private class InvalidResiliencePipelineBuilder : ResiliencePipelineBuilderBase
     {
         [Required]
         public string? RequiredProperty { get; set; }
     }
+
+    private class ConcurrencyDetector
+    {
+        private int _count;
+
+        public bool InvokedConcurrently { get; private set; }
+
+        public void Execute()
+        {
+            if (Interlocked.Increment(ref _count) > 1)
+            {
+                InvokedConcurrently = true;
+            }
+
+            Thread.Sleep(1);
+            Interlocked.Decrement(ref _count);
+        }
+    }
 }