fix: duplicated config items issue (#2954)

filzrev · web-flow · commit 2df50ada7cfd · 2026-01-04T17:25:15.000-05:00
diff --git a/src/BenchmarkDotNet/Columns/ColumnHidingByIdRule.cs b/src/BenchmarkDotNet/Columns/ColumnHidingByIdRule.cs
@@ -1,14 +1,30 @@
 ﻿using JetBrains.Annotations;
+using System;
 
 namespace BenchmarkDotNet.Columns
 {
     [PublicAPI]
-    public class ColumnHidingByIdRule: IColumnHidingRule
+    public sealed class ColumnHidingByIdRule : IColumnHidingRule, IEquatable<ColumnHidingByIdRule>
     {
         public string Id { get; }
 
         public ColumnHidingByIdRule(IColumn column) => Id = column.Id;
 
         public bool NeedToHide(IColumn column) => column.Id == Id;
+
+        public bool Equals(ColumnHidingByIdRule? other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+            return Id == other.Id;
+        }
+
+        public override bool Equals(object? obj)
+            => Equals(obj as ColumnHidingByIdRule);
+
+        public override int GetHashCode()
+            => HashCode.Combine(Id);
     }
-}
+}
diff --git a/src/BenchmarkDotNet/Columns/ColumnHidingByNameRule.cs b/src/BenchmarkDotNet/Columns/ColumnHidingByNameRule.cs
@@ -1,14 +1,31 @@
 ﻿using JetBrains.Annotations;
+using System;
 
 namespace BenchmarkDotNet.Columns
 {
     [PublicAPI]
-    public class ColumnHidingByNameRule: IColumnHidingRule
+    public sealed class ColumnHidingByNameRule : IColumnHidingRule, IEquatable<ColumnHidingByNameRule>
     {
         public string Name { get; }
 
         public ColumnHidingByNameRule(string name) => Name = name;
 
         public bool NeedToHide(IColumn column) => column.ColumnName == Name;
+
+        public bool Equals(ColumnHidingByNameRule? other)
+        {
+            if (ReferenceEquals(null, other))
+                return false;
+            if (ReferenceEquals(this, other))
+                return true;
+
+            return Name == other.Name;
+        }
+
+        public override bool Equals(object? obj)
+            => Equals(obj as ColumnHidingByNameRule);
+
+        public override int GetHashCode()
+            => HashCode.Combine(Name);
     }
-}
+}
diff --git a/src/BenchmarkDotNet/Configs/ManualConfig.cs b/src/BenchmarkDotNet/Configs/ManualConfig.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
 using BenchmarkDotNet.Analysers;
@@ -118,49 +117,49 @@ public ManualConfig WithWakeLock(WakeLockType wakeLockType)
 
         public ManualConfig AddColumn(params IColumn[] newColumns)
         {
-            columnProviders.AddRange(newColumns.Select(c => c.ToProvider()));
+            columnProviders.AddRangeDistinct(newColumns.Select(c => c.ToProvider()));
             return this;
         }
 
         public ManualConfig AddColumnProvider(params IColumnProvider[] newColumnProviders)
         {
-            columnProviders.AddRange(newColumnProviders);
+            columnProviders.AddRangeDistinct(newColumnProviders);
             return this;
         }
 
         public ManualConfig AddExporter(params IExporter[] newExporters)
         {
-            exporters.AddRange(newExporters);
+            exporters.AddRangeDistinct(newExporters);
             return this;
         }
 
         public ManualConfig AddLogger(params ILogger[] newLoggers)
         {
-            loggers.AddRange(newLoggers);
+            loggers.AddRangeDistinct(newLoggers);
             return this;
         }
 
         public ManualConfig AddDiagnoser(params IDiagnoser[] newDiagnosers)
         {
-            diagnosers.AddRange(newDiagnosers);
+            diagnosers.AddRangeDistinct(newDiagnosers);
             return this;
         }
 
         public ManualConfig AddAnalyser(params IAnalyser[] newAnalysers)
         {
-            analysers.AddRange(newAnalysers);
+            analysers.AddRangeDistinct(newAnalysers);
             return this;
         }
 
         public ManualConfig AddValidator(params IValidator[] newValidators)
         {
-            validators.AddRange(newValidators);
+            validators.AddRangeDistinct(newValidators);
             return this;
         }
 
         public ManualConfig AddJob(params Job[] newJobs)
         {
-            jobs.AddRange(newJobs.Select(j => j.Freeze())); // DONTTOUCH: please DO NOT remove .Freeze() call.
+            jobs.AddRangeDistinct(newJobs.Select(j => j.Freeze())); // DONTTOUCH: please DO NOT remove .Freeze() call.
             return this;
         }
 
@@ -172,68 +171,63 @@ public ManualConfig AddHardwareCounters(params HardwareCounter[] newHardwareCoun
 
         public ManualConfig AddFilter(params IFilter[] newFilters)
         {
-            filters.AddRange(newFilters);
+            filters.AddRangeDistinct(newFilters);
             return this;
         }
 
         public ManualConfig AddLogicalGroupRules(params BenchmarkLogicalGroupRule[] rules)
         {
-            foreach (var rule in rules)
-            {
-                if (logicalGroupRules.Contains(rule))
-                    logicalGroupRules.Remove(rule);
-                logicalGroupRules.Add(rule);
-            }
+            logicalGroupRules.AddRangeDistinct(rules);
             return this;
         }
 
         public ManualConfig AddEventProcessor(params EventProcessor[] newEventProcessors)
         {
-            this.eventProcessors.AddRange(newEventProcessors);
+            eventProcessors.AddRangeDistinct(newEventProcessors);
             return this;
         }
 
         [PublicAPI]
         public ManualConfig HideColumns(params string[] columnNames)
         {
-            columnHidingRules.AddRange(columnNames.Select(c => new ColumnHidingByNameRule(c)));
+            columnHidingRules.AddRangeDistinct(columnNames.Select(c => new ColumnHidingByNameRule(c)));
             return this;
         }
 
         [PublicAPI]
         public ManualConfig HideColumns(params IColumn[] columns)
         {
-            columnHidingRules.AddRange(columns.Select(c => new ColumnHidingByIdRule(c)));
+            columnHidingRules.AddRangeDistinct(columns.Select(c => new ColumnHidingByIdRule(c)));
             return this;
         }
 
         [PublicAPI]
         public ManualConfig HideColumns(params IColumnHidingRule[] rules)
         {
-            columnHidingRules.AddRange(rules);
+            columnHidingRules.AddRangeDistinct(rules);
             return this;
         }
 
         [PublicAPI]
         public void Add(IConfig config)
         {
-            columnProviders.AddRange(config.GetColumnProviders());
-            exporters.AddRange(config.GetExporters());
-            loggers.AddRange(config.GetLoggers());
-            diagnosers.AddRange(config.GetDiagnosers());
-            analysers.AddRange(config.GetAnalysers());
-            jobs.AddRange(config.GetJobs());
-            validators.AddRange(config.GetValidators());
+            columnProviders.AddRangeDistinct(config.GetColumnProviders());
+            exporters.AddRangeDistinct(config.GetExporters());
+            loggers.AddRangeDistinct(config.GetLoggers());
+            diagnosers.AddRangeDistinct(config.GetDiagnosers());
+            analysers.AddRangeDistinct(config.GetAnalysers());
+            jobs.AddRangeDistinct(config.GetJobs());
+            validators.AddRangeDistinct(config.GetValidators());
             hardwareCounters.AddRange(config.GetHardwareCounters());
-            filters.AddRange(config.GetFilters());
-            eventProcessors.AddRange(config.GetEventProcessors());
+            filters.AddRangeDistinct(config.GetFilters());
+            eventProcessors.AddRangeDistinct(config.GetEventProcessors());
             Orderer = config.Orderer ?? Orderer;
             CategoryDiscoverer = config.CategoryDiscoverer ?? CategoryDiscoverer;
             ArtifactsPath = config.ArtifactsPath ?? ArtifactsPath;
             CultureInfo = config.CultureInfo ?? CultureInfo;
             SummaryStyle = config.SummaryStyle ?? SummaryStyle;
-            logicalGroupRules.AddRange(config.GetLogicalGroupRules());
-            columnHidingRules.AddRange(config.GetColumnHidingRules());
+            logicalGroupRules.AddRangeDistinct(config.GetLogicalGroupRules());
+            columnHidingRules.AddRangeDistinct(config.GetColumnHidingRules());
             Options |= config.Options;
             BuildTimeout = GetBuildTimeout(BuildTimeout, config.BuildTimeout);
             WakeLock = GetWakeLock(WakeLock, config.WakeLock);
diff --git a/src/BenchmarkDotNet/Extensions/CommonExtensions.cs b/src/BenchmarkDotNet/Extensions/CommonExtensions.cs
@@ -45,6 +45,16 @@ public static void AddRange<T>(this HashSet<T> hashSet, IEnumerable<T> collectio
                 hashSet.Add(item);
         }
 
+        public static void AddRangeDistinct<T>(this List<T> list, IEnumerable<T> items, IEqualityComparer<T>? comparer = null)
+        {
+            var hashSet = new HashSet<T>(list, comparer);
+            foreach (var item in items)
+            {
+                if (hashSet.Add(item))
+                    list.Add(item);
+            }
+        }
+
 #if NETSTANDARD2_0
         public static TValue? GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
             => dictionary.TryGetValue(key, out var value) ? value : default;
diff --git a/src/BenchmarkDotNet/Order/DefaultOrderer.cs b/src/BenchmarkDotNet/Order/DefaultOrderer.cs
@@ -4,6 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Parameters;
 using BenchmarkDotNet.Reports;
@@ -110,8 +111,7 @@ public string GetLogicalGroupKey(ImmutableArray<BenchmarkCase> allBenchmarksCase
             }
 
             var rules = new List<BenchmarkLogicalGroupRule>(explicitRules);
-            foreach (var rule in implicitRules.Where(rule => !rules.Contains(rule)))
-                rules.Add(rule);
+            rules.AddRangeDistinct(implicitRules);
 
             var keys = new List<string>();
             foreach (var rule in rules)

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.ComponentModel;`
`4`	`3`	`using System.Globalization;`
`5`	`4`	`using System.Linq;`
`6`	`5`	`using BenchmarkDotNet.Analysers;`
`@@ -118,49 +117,49 @@ public ManualConfig WithWakeLock(WakeLockType wakeLockType)`
`118`	`117`
`119`	`118`	`public ManualConfig AddColumn(params IColumn[] newColumns)`
`120`	`119`	`{`
`121`		`- columnProviders.AddRange(newColumns.Select(c => c.ToProvider()));`
	`120`	`+ columnProviders.AddRangeDistinct(newColumns.Select(c => c.ToProvider()));`
`122`	`121`	`return this;`
`123`	`122`	`}`
`124`	`123`
`125`	`124`	`public ManualConfig AddColumnProvider(params IColumnProvider[] newColumnProviders)`
`126`	`125`	`{`
`127`		`- columnProviders.AddRange(newColumnProviders);`
	`126`	`+ columnProviders.AddRangeDistinct(newColumnProviders);`
`128`	`127`	`return this;`
`129`	`128`	`}`
`130`	`129`
`131`	`130`	`public ManualConfig AddExporter(params IExporter[] newExporters)`
`132`	`131`	`{`
`133`		`- exporters.AddRange(newExporters);`
	`132`	`+ exporters.AddRangeDistinct(newExporters);`
`134`	`133`	`return this;`
`135`	`134`	`}`
`136`	`135`
`137`	`136`	`public ManualConfig AddLogger(params ILogger[] newLoggers)`
`138`	`137`	`{`
`139`		`- loggers.AddRange(newLoggers);`
	`138`	`+ loggers.AddRangeDistinct(newLoggers);`
`140`	`139`	`return this;`
`141`	`140`	`}`
`142`	`141`
`143`	`142`	`public ManualConfig AddDiagnoser(params IDiagnoser[] newDiagnosers)`
`144`	`143`	`{`
`145`		`- diagnosers.AddRange(newDiagnosers);`
	`144`	`+ diagnosers.AddRangeDistinct(newDiagnosers);`
`146`	`145`	`return this;`
`147`	`146`	`}`
`148`	`147`
`149`	`148`	`public ManualConfig AddAnalyser(params IAnalyser[] newAnalysers)`
`150`	`149`	`{`
`151`		`- analysers.AddRange(newAnalysers);`
	`150`	`+ analysers.AddRangeDistinct(newAnalysers);`
`152`	`151`	`return this;`
`153`	`152`	`}`
`154`	`153`
`155`	`154`	`public ManualConfig AddValidator(params IValidator[] newValidators)`
`156`	`155`	`{`
`157`		`- validators.AddRange(newValidators);`
	`156`	`+ validators.AddRangeDistinct(newValidators);`
`158`	`157`	`return this;`
`159`	`158`	`}`
`160`	`159`
`161`	`160`	`public ManualConfig AddJob(params Job[] newJobs)`
`162`	`161`	`{`
`163`		`- jobs.AddRange(newJobs.Select(j => j.Freeze())); // DONTTOUCH: please DO NOT remove .Freeze() call.`
	`162`	`+ jobs.AddRangeDistinct(newJobs.Select(j => j.Freeze())); // DONTTOUCH: please DO NOT remove .Freeze() call.`
`164`	`163`	`return this;`
`165`	`164`	`}`
`166`	`165`
`@@ -172,68 +171,63 @@ public ManualConfig AddHardwareCounters(params HardwareCounter[] newHardwareCoun`
`172`	`171`
`173`	`172`	`public ManualConfig AddFilter(params IFilter[] newFilters)`
`174`	`173`	`{`
`175`		`- filters.AddRange(newFilters);`
	`174`	`+ filters.AddRangeDistinct(newFilters);`
`176`	`175`	`return this;`
`177`	`176`	`}`
`178`	`177`
`179`	`178`	`public ManualConfig AddLogicalGroupRules(params BenchmarkLogicalGroupRule[] rules)`
`180`	`179`	`{`
`181`		`- foreach (var rule in rules)`
`182`		`- {`
`183`		`- if (logicalGroupRules.Contains(rule))`
`184`		`- logicalGroupRules.Remove(rule);`
`185`		`- logicalGroupRules.Add(rule);`
`186`		`- }`
	`180`	`+ logicalGroupRules.AddRangeDistinct(rules);`
`187`	`181`	`return this;`
`188`	`182`	`}`
`189`	`183`
`190`	`184`	`public ManualConfig AddEventProcessor(params EventProcessor[] newEventProcessors)`
`191`	`185`	`{`
`192`		`- this.eventProcessors.AddRange(newEventProcessors);`
	`186`	`+ eventProcessors.AddRangeDistinct(newEventProcessors);`
`193`	`187`	`return this;`
`194`	`188`	`}`
`195`	`189`
`196`	`190`	`[PublicAPI]`
`197`	`191`	`public ManualConfig HideColumns(params string[] columnNames)`
`198`	`192`	`{`
`199`		`- columnHidingRules.AddRange(columnNames.Select(c => new ColumnHidingByNameRule(c)));`
	`193`	`+ columnHidingRules.AddRangeDistinct(columnNames.Select(c => new ColumnHidingByNameRule(c)));`
`200`	`194`	`return this;`
`201`	`195`	`}`
`202`	`196`
`203`	`197`	`[PublicAPI]`
`204`	`198`	`public ManualConfig HideColumns(params IColumn[] columns)`
`205`	`199`	`{`
`206`		`- columnHidingRules.AddRange(columns.Select(c => new ColumnHidingByIdRule(c)));`
	`200`	`+ columnHidingRules.AddRangeDistinct(columns.Select(c => new ColumnHidingByIdRule(c)));`
`207`	`201`	`return this;`
`208`	`202`	`}`
`209`	`203`
`210`	`204`	`[PublicAPI]`
`211`	`205`	`public ManualConfig HideColumns(params IColumnHidingRule[] rules)`
`212`	`206`	`{`
`213`		`- columnHidingRules.AddRange(rules);`
	`207`	`+ columnHidingRules.AddRangeDistinct(rules);`
`214`	`208`	`return this;`
`215`	`209`	`}`
`216`	`210`
`217`	`211`	`[PublicAPI]`
`218`	`212`	`public void Add(IConfig config)`
`219`	`213`	`{`
`220`		`- columnProviders.AddRange(config.GetColumnProviders());`
`221`		`- exporters.AddRange(config.GetExporters());`
`222`		`- loggers.AddRange(config.GetLoggers());`
`223`		`- diagnosers.AddRange(config.GetDiagnosers());`
`224`		`- analysers.AddRange(config.GetAnalysers());`
`225`		`- jobs.AddRange(config.GetJobs());`
`226`		`- validators.AddRange(config.GetValidators());`
	`214`	`+ columnProviders.AddRangeDistinct(config.GetColumnProviders());`
	`215`	`+ exporters.AddRangeDistinct(config.GetExporters());`
	`216`	`+ loggers.AddRangeDistinct(config.GetLoggers());`
	`217`	`+ diagnosers.AddRangeDistinct(config.GetDiagnosers());`
	`218`	`+ analysers.AddRangeDistinct(config.GetAnalysers());`
	`219`	`+ jobs.AddRangeDistinct(config.GetJobs());`
	`220`	`+ validators.AddRangeDistinct(config.GetValidators());`
`227`	`221`	`hardwareCounters.AddRange(config.GetHardwareCounters());`
`228`		`- filters.AddRange(config.GetFilters());`
`229`		`- eventProcessors.AddRange(config.GetEventProcessors());`
	`222`	`+ filters.AddRangeDistinct(config.GetFilters());`
	`223`	`+ eventProcessors.AddRangeDistinct(config.GetEventProcessors());`
`230`	`224`	`Orderer = config.Orderer ?? Orderer;`
`231`	`225`	`CategoryDiscoverer = config.CategoryDiscoverer ?? CategoryDiscoverer;`
`232`	`226`	`ArtifactsPath = config.ArtifactsPath ?? ArtifactsPath;`
`233`	`227`	`CultureInfo = config.CultureInfo ?? CultureInfo;`
`234`	`228`	`SummaryStyle = config.SummaryStyle ?? SummaryStyle;`
`235`		`- logicalGroupRules.AddRange(config.GetLogicalGroupRules());`
`236`		`- columnHidingRules.AddRange(config.GetColumnHidingRules());`
	`229`	`+ logicalGroupRules.AddRangeDistinct(config.GetLogicalGroupRules());`
	`230`	`+ columnHidingRules.AddRangeDistinct(config.GetColumnHidingRules());`
`237`	`231`	`Options \|= config.Options;`
`238`	`232`	`BuildTimeout = GetBuildTimeout(BuildTimeout, config.BuildTimeout);`
`239`	`233`	`WakeLock = GetWakeLock(WakeLock, config.WakeLock);`