Refactor to use primary constructors and update targets

Refactored multiple classes to use C# 9.0 primary constructors, simplifying initialization and improving readability. Updated project files to target .NET 9.0 and included new package references. Suppressed specific style warnings and added XML documentation to various classes. Enhanced thread-safety and nullability handling in several methods. Improved test classes with modern C# features and updated array initializations.

Author: electricessence

.editorconfig

@@ -226,6 +226,8 @@ dotnet_diagnostic.IDE0057.severity = silent
 dotnet_diagnostic.CS1591.severity = suggestion
 csharp_style_prefer_method_group_conversion = true:silent
 csharp_style_prefer_top_level_statements = true:silent
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_prefer_system_threading_lock = true:suggestion
 #dotnet_diagnostic.SA0001.severity = suggestion
 [*.{cs,vb}]
 dotnet_style_coalesce_expression = true:warning
@@ -234,4 +236,10 @@ tab_width = 4
 indent_size = 4
 end_of_line = crlf
 dotnet_style_null_propagation = true:warning
-indent_style = tab
+indent_style = tab
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+dotnet_style_prefer_auto_properties = true:suggestion
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:warning
+dotnet_diagnostic.CA2007.severity = error

Trie/ConcurrentTrie.cs

@@ -6,22 +6,13 @@ namespace Open.Collections;
 /// <summary>
 /// A generic Trie collection.
 /// </summary>
-public sealed class ConcurrentTrie<TKey, TValue>
-	: TrieBase<TKey, TValue>
+public sealed class ConcurrentTrie<TKey, TValue>(
+	IEqualityComparer<TKey>? equalityComparer = null)
+	: TrieBase<TKey, TValue>(() => new Node(equalityComparer))
 	where TKey : notnull
 {
-	/// <summary>
-	/// Constructs a <see cref="ConcurrentTrie{TKey, TValue}"/>.
-	/// </summary>
-	public ConcurrentTrie(IEqualityComparer<TKey>? equalityComparer = null)
-		: base(() => new Node(equalityComparer))
-	{ }
-
-	private sealed class Node : NodeBase
+	private sealed class Node(IEqualityComparer<TKey>? equalityComparer) : NodeBase
 	{
-		public Node(IEqualityComparer<TKey>? equalityComparer)
-			=> _equalityComparer = equalityComparer;
-
 		private readonly object _valueSync = new();
 
 		protected override void SetValue(TValue value)
@@ -31,7 +22,7 @@ protected override void SetValue(TValue value)
 
 		private readonly object _childSync = new();
 
-		private readonly IEqualityComparer<TKey>? _equalityComparer;
+		private readonly IEqualityComparer<TKey>? _equalityComparer = equalityComparer;
 		private ConcurrentDictionary<TKey, ITrieNode<TKey, TValue>>? _children;
 
 		protected override void UpdateRecent(TKey key, ITrieNode<TKey, TValue> child)

Trie/Open.Collections.Trie.csproj

@@ -26,6 +26,7 @@
 		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
 		<PackageIcon>logo.png</PackageIcon>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
+		<NoWarn>IDE0130;</NoWarn>
 	</PropertyGroup>
 
 	<ItemGroup>
@@ -44,11 +45,11 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
+		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="8.0.0" PrivateAssets="All" />
 	</ItemGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
-		<PackageReference Include="System.Memory" Version="4.5.1" />
+		<PackageReference Include="System.Memory" Version="4.6.0" />
 	</ItemGroup>
 
 </Project>

Trie/StringJoinPool.cs

@@ -12,22 +12,12 @@ namespace Open.Collections;
 /// <remarks>
 /// Useful for (re)generating cache keys.
 /// </remarks>
-public class StringJoinPool
+public class StringJoinPool(
+	ITrie<string, string> pool, ReadOnlyMemory<char> separator)
 {
-	private readonly ReadOnlyMemory<char> _separator;
-	private readonly ITrie<string, string> _pool;
+	private readonly ITrie<string, string> _pool = pool ?? throw new ArgumentNullException(nameof(pool));
 	private StringBuilder? _reusableBuilder;
 
-	/// <summary>
-	/// Constructs a <see cref="StringJoinPool"/>.
-	/// </summary>
-	/// <exception cref="ArgumentNullException">If the supplied pool is null.</exception>
-	public StringJoinPool(ITrie<string, string> pool, ReadOnlyMemory<char> separator)
-	{
-		_pool = pool ?? throw new ArgumentNullException(nameof(pool));
-		_separator = separator;
-	}
-
 	/// <inheritdoc cref="StringJoinPool(ITrie{string, string}, ReadOnlyMemory{char})"/>
 	public StringJoinPool(ITrie<string, string> pool, string? separator = null)
 		: this(pool, separator is null ? ReadOnlyMemory<char>.Empty : separator.AsMemory())
@@ -75,7 +65,7 @@ string Build(ReadOnlySpan<string> segments)
 			int len = segments.Length;
 			try
 			{
-				if (_separator.IsEmpty)
+				if (separator.IsEmpty)
 				{
 					for (int i = 0; i < len; i++)
 						AppendSegment(sb, segments[i]);
@@ -85,7 +75,7 @@ string Build(ReadOnlySpan<string> segments)
 				Debug.Assert(segments.Length != 0);
 
 				AppendSegment(sb, segments[0]);
-				var sepSpan = _separator.Span;
+				var sepSpan = separator.Span;
 				int sLen = sepSpan.Length;
 
 				for (int i = 1; i < len; i++)

Trie/System.Diagnostics.CodeAnalysis/MaybeNullWhenAttribute.cs

@@ -1,23 +1,21 @@
 #if NETSTANDARD2_0
+
 namespace System.Diagnostics.CodeAnalysis;
 
 // Use a shim for simplicity.
 
 /// <summary>
 /// Indicates that the output may be null even if the corresponding type disallows it.
 /// </summary>
+/// <remarks>
+/// Constructs a <see cref="MaybeNullWhenAttribute"/>.
+/// </remarks>
 [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
-internal sealed class MaybeNullWhenAttribute : Attribute
+internal sealed class MaybeNullWhenAttribute(bool returnValue) : Attribute
 {
-	/// <summary>
-	/// Constructs a <see cref="MaybeNullWhenAttribute"/>.
-	/// </summary>
-	public MaybeNullWhenAttribute(bool returnValue)
-		=> ReturnValue = returnValue;
-
 	/// <summary>
 	/// The return value condition.
 	/// </summary>
-	public bool ReturnValue { get; }
+	public bool ReturnValue { get; } = returnValue;
 }
 #endif

Trie/Trie.cs

@@ -4,34 +4,25 @@ namespace Open.Collections;
 /// <summary>
 /// A generic Trie collection.
 /// </summary>
-public sealed class Trie<TKey, TValue>
-	: TrieBase<TKey, TValue>
+public sealed class Trie<TKey, TValue>(
+	IEqualityComparer<TKey>? equalityComparer = null)
+	: TrieBase<TKey, TValue>(() => new Node(equalityComparer))
 	where TKey : notnull
 {
-	/// <summary>
-	/// Constructs a <see cref="Trie{TKey, TValue}"/>.
-	/// </summary>
-	public Trie(IEqualityComparer<TKey>? equalityComparer = null)
-		: base(() => new Node(equalityComparer))
-	{ }
-
-	private sealed class Node : NodeBase
+	private sealed class Node(IEqualityComparer<TKey>? equalityComparer)
+		: NodeBase
 	{
-		private readonly IEqualityComparer<TKey>? _equalityComparer;
 		private Dictionary<TKey, ITrieNode<TKey, TValue>>? _children;
 
-		public Node(IEqualityComparer<TKey>? equalityComparer)
-			=> _equalityComparer = equalityComparer;
-
 		public override ITrieNode<TKey, TValue> GetOrAddChild(TKey key)
 		{
 			var children = _children;
 			if (children is null)
-				Children = _children = children = _equalityComparer is null ? new() : new(_equalityComparer);
+				Children = _children = children = equalityComparer is null ? new() : new(equalityComparer);
 			else if (TryGetChildFrom(children, key, out var c))
 				return c;
 
-			var child = new Node(_equalityComparer);
+			var child = new Node(equalityComparer);
 			children[key] = child;
 			return child;
 		}

Trie/TrieBase.cs

@@ -221,34 +221,23 @@ internal abstract class NodeBase : ITrieNode<TKey, TValue>
 	{
 		protected IDictionary<TKey, ITrieNode<TKey, TValue>>? Children;
 
-		private readonly struct ValueContainer
+		private readonly struct ValueContainer(bool isSet, TValue value)
 		{
-			public ValueContainer(bool isSet, TValue value)
-			{
-				IsSet = isSet;
-				Value = value;
-			}
-
 			public ValueContainer(TValue value)
 				: this(true, value) { }
 
-			public bool IsSet { get; }
-			public TValue Value { get; }
+			public bool IsSet { get; } = isSet;
+			public TValue Value { get; } = value;
 		}
 
 		private ValueContainer _value;
 
-		private readonly struct Recent
+		private readonly struct Recent(
+			bool exists, TKey key, ITrieNode<TKey, TValue> child)
 		{
-			public Recent(bool exists, TKey key, ITrieNode<TKey, TValue> child)
-			{
-				Exists = exists;
-				Key = key;
-				Child = child;
-			}
-			public bool Exists { get; }
-			public TKey Key { get; }
-			public ITrieNode<TKey, TValue> Child { get; }
+			public bool Exists { get; } = exists;
+			public TKey Key { get; } = key;
+			public ITrieNode<TKey, TValue> Child { get; } = child;
 		}
 
 		// It's not uncommon to have a 'hot path' that will be requested frequently.

benchmarking/Benchmarks/CollectionBenchmark.cs

@@ -72,13 +72,9 @@ protected override IEnumerable<TimedResult> TestOnceInternal()
 	}
 }
 
-public class CollectionBenchmark : CollectionBenchmark<object>
+public class CollectionBenchmark(
+	uint size, uint repeat, Func<ICollection<object>> factory) : CollectionBenchmark<object>(size, repeat, factory, _ => new object())
 {
-	public CollectionBenchmark(uint size, uint repeat, Func<ICollection<object>> factory)
-		: base(size, repeat, factory, _ => new object())
-	{
-	}
-
 	public static TimedResult[] Results<T>(uint size, uint repeat, Func<ICollection<T>> factory, Func<int, T> itemFactory)
 		=> new CollectionBenchmark<T>(size, repeat, factory, itemFactory).Result;
 

benchmarking/Benchmarks/CollectionParallelBenchmark.cs

@@ -6,12 +6,10 @@
 
 namespace Open.Collections;
 
-public class CollectionParallelBenchmark<T> : CollectionBenchmark<T>
+public class CollectionParallelBenchmark<T>(
+	uint size, uint repeat, Func<ICollection<T>> factory, Func<int, T> itemFactory)
+	: CollectionBenchmark<T>(size, repeat, factory, itemFactory)
 {
-	public CollectionParallelBenchmark(uint size, uint repeat, Func<ICollection<T>> factory, Func<int, T> itemFactory) : base(size, repeat, factory, itemFactory)
-	{
-	}
-
 	protected override IEnumerable<TimedResult> TestOnceInternal()
 	{
 		ICollection<T> c = Param();
@@ -115,13 +113,10 @@ protected override IEnumerable<TimedResult> TestOnceInternal()
 	}
 }
 
-public class CollectionParallelBenchmark : CollectionParallelBenchmark<object>
+public class CollectionParallelBenchmark(
+	uint size, uint repeat, Func<ICollection<object>> factory)
+	: CollectionParallelBenchmark<object>(size, repeat, factory, _ => new object())
 {
-	public CollectionParallelBenchmark(uint size, uint repeat, Func<ICollection<object>> factory)
-		: base(size, repeat, factory, _ => new object())
-	{
-	}
-
 	public static TimedResult[] Results<T>(uint size, uint repeat, Func<ICollection<T>> factory, Func<int, T> itemFactory)
 		=> new CollectionParallelBenchmark<T>(size, repeat, factory, itemFactory).Result;
 

benchmarking/Benchmarks/DictionaryParallelBenchmark.cs

@@ -7,13 +7,10 @@
 
 namespace Open.Collections;
 
-public class DictionaryParallelBenchmark : CollectionParallelBenchmark<KeyValuePair<int, object>>
+public class DictionaryParallelBenchmark(
+	uint size, uint repeat, Func<IDictionary<int, object>> factory)
+	: CollectionParallelBenchmark<KeyValuePair<int, object>>(size, repeat, factory, i => new KeyValuePair<int, object>(i, new object()))
 {
-	public DictionaryParallelBenchmark(uint size, uint repeat, Func<IDictionary<int, object>> factory)
-		: base(size, repeat, factory, i => new KeyValuePair<int, object>(i, new object()))
-	{
-	}
-
 	protected override IEnumerable<TimedResult> TestOnceInternal()
 	{
 		//foreach (TimedResult t in base.TestOnceInternal())