diff --git a/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetInCSharp.csproj b/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetInCSharp.csproj
index 74abf5c976..dfb40caafc 100644
--- a/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetInCSharp.csproj
+++ b/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetInCSharp.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>
diff --git a/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetMethods.cs b/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetMethods.cs
index 027bfde0d9..ddd69edadb 100644
--- a/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetMethods.cs
+++ b/collections-csharp/SortedSetInCSharp/SortedSetInCSharp/SortedSetMethods.cs
@@ -1,29 +1,28 @@
-namespace SortedSetInCSharp
+namespace SortedSetInCSharp;
+
+public class SortedSetMethods
 {
-    public class SortedSetMethods
-    {
-        public SortedSet<string> ProgrammingLanguages() 
-        { 
-            var languages = new SortedSet<string>(); 
+    public SortedSet<string> ProgrammingLanguages() 
+    { 
+        var languages = new SortedSet<string>(); 
 
-            languages.Add("C"); 
-            languages.Add("C++"); 
-            languages.Add("C#"); 
-            languages.Add("Java"); 
-            languages.Add("Scala"); 
-            languages.Add("TypeScript"); 
-            languages.Add("Python"); 
-            languages.Add("JavaScript"); 
-            languages.Add("Rust");
-            
-            return languages;
-        }
+        languages.Add("C"); 
+        languages.Add("C++"); 
+        languages.Add("C#"); 
+        languages.Add("Java"); 
+        languages.Add("Scala"); 
+        languages.Add("TypeScript"); 
+        languages.Add("Python"); 
+        languages.Add("JavaScript"); 
+        languages.Add("Rust");
+        
+        return languages;
+    }
 
-        public SortedSet<string> RemoveElement(SortedSet<string> sortedSet, string valueToRemove)
-        {
-            sortedSet.Remove(valueToRemove);
+    public SortedSet<string> RemoveElement(SortedSet<string> sortedSet, string valueToRemove)
+    {
+        sortedSet.Remove(valueToRemove);
 
-            return sortedSet;
-        }
+        return sortedSet;
     }
 }
diff --git a/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpTests.csproj b/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpTests.csproj
index 414d4ed5b8..515a55bdae 100644
--- a/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpTests.csproj
+++ b/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpTests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 
@@ -9,10 +9,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
-    <PackageReference Include="MSTest.TestAdapter" Version="2.2.8" />
-    <PackageReference Include="MSTest.TestFramework" Version="2.2.8" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.11.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="4.5.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="4.5.2" />
+    <PackageReference Include="coverlet.collector" Version="10.1.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpUnitTests.cs b/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpUnitTests.cs
index 913f180dd2..c29f62c727 100644
--- a/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpUnitTests.cs
+++ b/collections-csharp/SortedSetInCSharp/SortedSetInCSharpTests/SortedSetInCSharpUnitTests.cs
@@ -1,184 +1,269 @@
 using SortedSetInCSharp;
 
-namespace SortedSetInCSharpTests
+namespace SortedSetInCSharpTests;
+
+[TestClass]
+public class SortedSetInCSharpUnitTests
 {
-    [TestClass]
-    public class SortedSetInCSharpUnitTests
+    private readonly SortedSetMethods _sortedSet;
+    private readonly SortedSet<string> _languages;
+
+    public SortedSetInCSharpUnitTests()
     {
-        private readonly SortedSetMethods _sortedSet; 
-        private readonly SortedSet<string> _languages;
+        _sortedSet = new SortedSetMethods();
+        _languages = _sortedSet.ProgrammingLanguages();
+    }
 
-        public SortedSetInCSharpUnitTests()
-        {
-            _sortedSet = new SortedSetMethods();
-            _languages = _sortedSet.ProgrammingLanguages();
-        }
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyCountAndContains()
+    {
+        Assert.IsInstanceOfType(_languages, typeof(SortedSet<string>));
+        Assert.AreEqual(9, _languages.Count);
+        Assert.IsTrue(_languages.Contains("Java"));
+        Assert.AreEqual("C", _languages.First());
+    }
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyCountAndContains()
-        {
-            Assert.IsInstanceOfType(_languages, typeof(SortedSet<string>));
-            Assert.AreEqual(_languages.Count(), 9);
-            Assert.IsTrue(_languages.Contains("Java"));
-            Assert.AreEqual(_languages.First(), "C");
-        }
-
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyHasNoDuplicates()
-        {
-            _languages.Add("C");
-            _languages.Add("C++");
-            _languages.Add("C#");
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyHasNoDuplicates()
+    {
+        _languages.Add("C");
+        _languages.Add("C++");
+        _languages.Add("C#");
 
-            Assert.IsInstanceOfType(_languages, typeof(SortedSet<string>));
-            Assert.AreEqual(_languages.Count(), 9);
-        }
+        Assert.IsInstanceOfType(_languages, typeof(SortedSet<string>));
+        Assert.AreEqual(9, _languages.Count);
+    }
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyOverlapsSuccessful()
-        {
-            var commonLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "TypeScript", "Python", "JavaScript", "Rust", "Assembly", "Pascal" };
-            var differentLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+    [TestMethod]
+    public void GivenASortedSet_WhenAddingADuplicate_ThenAddReturnsFalse()
+    {
+        Assert.IsFalse(_languages.Add("Java"));
+        Assert.IsTrue(_languages.Add("Go"));
+    }
 
-            Assert.IsTrue(commonLanguages.Overlaps(_languages));
-            Assert.IsTrue(differentLanguages.Overlaps(commonLanguages));
-            Assert.IsFalse(differentLanguages.Overlaps(_languages));
-        }
+    [TestMethod]
+    public void GivenASortedSetOfStrings_WhenAddingNull_ThenNullIsTheFirstElement()
+    {
+        SortedSet<string?> languages = new(_languages);
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyAnElementRemoved()
+        Assert.IsTrue(languages.Add(null));
+        Assert.IsFalse(languages.Add(null));
+        Assert.AreEqual(10, languages.Count);
+        Assert.IsNull(languages.Min);
+    }
+
+    [TestMethod]
+    public void GivenAComparerByYear_WhenTwoLanguagesShareAYear_ThenTheSecondIsDropped()
+    {
+        var byYear = Comparer<(string Name, int Year)>.Create(
+            (x, y) => x.Year.CompareTo(y.Year));
+
+        var languages = new SortedSet<(string Name, int Year)>(byYear)
         {
-            var elementToRemove = "Java";
+            ("Python", 1991), ("Java", 1995), ("C", 1972), ("JavaScript", 1995)
+        };
 
-            var updatedLanguages = _sortedSet.RemoveElement(_languages, elementToRemove);
+        Assert.AreEqual(3, languages.Count);
+        Assert.AreEqual(("C", 1972), languages.Min);
+        Assert.IsFalse(languages.Any(l => l.Name == "JavaScript"));
+    }
 
-            Assert.IsFalse(updatedLanguages.Contains(elementToRemove));
-            Assert.AreEqual(_languages.Count(), 8);
-        }
+    [TestMethod]
+    public void GivenAComparerByYearThenName_WhenTwoLanguagesShareAYear_ThenBothAreKept()
+    {
+        var byYearThenName = Comparer<(string Name, int Year)>.Create(
+            (x, y) => x.Year != y.Year
+                ? x.Year.CompareTo(y.Year)
+                : string.CompareOrdinal(x.Name, y.Name));
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyRemoveWhereWorks()
+        var languages = new SortedSet<(string Name, int Year)>(byYearThenName)
         {
-            _languages.RemoveWhere(element => element.StartsWith("C"));
+            ("Python", 1991), ("Java", 1995), ("C", 1972), ("JavaScript", 1995)
+        };
 
-            Assert.IsFalse(_languages.Contains("C"));
-            Assert.IsFalse(_languages.Contains("C++"));
-            Assert.IsFalse(_languages.Contains("C#"));
-        }
+        Assert.AreEqual(4, languages.Count);
+        Assert.AreEqual(("JavaScript", 1995), languages.Max);
+    }
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyElementsReversed()
-        {
-            var reversedSet = _languages.Reverse();
-            var firstElement = reversedSet.First();
-            var lastElement = reversedSet.Last();
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyMinAndMax()
+    {
+        Assert.AreEqual("C", _languages.Min);
+        Assert.AreEqual("TypeScript", _languages.Max);
+    }
 
-            Assert.IsInstanceOfType(reversedSet, typeof(IEnumerable<string>));
-            Assert.AreEqual(firstElement, "TypeScript");
-            Assert.AreEqual(lastElement, "C");
-        }
+    [TestMethod]
+    public void GivenASortedSet_WhenGettingAViewBetweenTwoValues_ThenTheViewTracksTheSet()
+    {
+        var view = _languages.GetViewBetween("C", "Java");
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyAllElementsCleared()
-        {
-            _languages.Clear();
+        CollectionAssert.AreEqual(new[] { "C", "C#", "C++", "Java" }, view.ToArray());
 
-            Assert.AreEqual(0, _languages.Count());
-            Assert.IsNull(_languages.FirstOrDefault());
-        }
+        _languages.Add("Go");
+        view.Add("F#");
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyAllElementsCopied()
-        {
-            var languagesArray = new string[9];
+        CollectionAssert.AreEqual(new[] { "C", "C#", "C++", "F#", "Go", "Java" }, view.ToArray());
+        Assert.IsTrue(_languages.Contains("F#"));
+        Assert.ThrowsExactly<ArgumentOutOfRangeException>(() => view.Add("Rust"));
+    }
 
-            _languages.CopyTo(languagesArray);
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyOverlapsSuccessful()
+    {
+        var commonLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "TypeScript", "Python", "JavaScript", "Rust", "Assembly", "Pascal" };
+        var differentLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
 
-            Assert.AreEqual(languagesArray.Count(), 9);
-            Assert.AreEqual(languagesArray[0], "C");
-            Assert.AreEqual(languagesArray[8], "TypeScript");
-            Assert.IsNotNull(languagesArray);
-        }
+        Assert.IsTrue(commonLanguages.Overlaps(_languages));
+        Assert.IsTrue(differentLanguages.Overlaps(commonLanguages));
+        Assert.IsFalse(differentLanguages.Overlaps(_languages));
+    }
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyProperSubset()
-        {
-            var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "TypeScript", "Python", "JavaScript", "Rust", "Assembly", "Pascal" };
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyAnElementRemoved()
+    {
+        var elementToRemove = "Java";
 
-            Assert.IsTrue(_languages.IsSubsetOf(moreLanguages));
-            Assert.IsTrue(_languages.IsProperSubsetOf(moreLanguages));
-            Assert.IsTrue(moreLanguages.IsSupersetOf(_languages));
-            Assert.IsTrue(moreLanguages.IsProperSupersetOf(_languages));
-        }
+        var updatedLanguages = _sortedSet.RemoveElement(_languages, elementToRemove);
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyUnionWithSuccessful()
-        {
-            var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+        Assert.IsFalse(updatedLanguages.Contains(elementToRemove));
+        Assert.AreEqual(8, _languages.Count);
+    }
 
-            _languages.UnionWith(moreLanguages);
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyRemoveWhereWorks()
+    {
+        _languages.RemoveWhere(element => element.StartsWith("C"));
 
-            Assert.AreEqual(_languages.Count(), 14);
-        }
+        Assert.IsFalse(_languages.Contains("C"));
+        Assert.IsFalse(_languages.Contains("C++"));
+        Assert.IsFalse(_languages.Contains("C#"));
+    }
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifyIntersectWithSuccessful()
-        {
-            var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyElementsReversed()
+    {
+        var reversedSet = _languages.Reverse();
+        var firstElement = reversedSet.First();
+        var lastElement = reversedSet.Last();
 
-            _languages.IntersectWith(moreLanguages);
+        Assert.IsInstanceOfType(reversedSet, typeof(IEnumerable<string>));
+        Assert.AreEqual("TypeScript", firstElement);
+        Assert.AreEqual("C", lastElement);
+    }
 
-            Assert.AreEqual(_languages.Count(), 5);
-            Assert.IsTrue(_languages.Contains("C"));
-            Assert.IsTrue(_languages.Contains("C++"));
-            Assert.IsTrue(_languages.Contains("C#"));
-            Assert.IsTrue(_languages.Contains("Java"));
-            Assert.IsTrue(_languages.Contains("Scala"));
-            Assert.IsFalse(_languages.Contains("Assembly"));
-        }
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyAllElementsCleared()
+    {
+        _languages.Clear();
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_ExceptWithSuccessful()
-        {
-            var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+        Assert.AreEqual(0, _languages.Count);
+        Assert.IsNull(_languages.FirstOrDefault());
+    }
 
-            _languages.ExceptWith(moreLanguages);
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyAllElementsCopied()
+    {
+        var languagesArray = new string[9];
 
-            Assert.AreEqual(_languages.Count(), 4);
-            Assert.IsTrue(_languages.Contains("TypeScript"));
-            Assert.IsTrue(_languages.Contains("Python"));
-            Assert.IsTrue(_languages.Contains("JavaScript"));
-            Assert.IsTrue(_languages.Contains("Rust"));
-            Assert.IsFalse(_languages.Contains("Assembly"));
-        }
+        _languages.CopyTo(languagesArray);
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifySetEqualsSuccessful()
-        {
-            var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
-            var languagesCopy = _languages;
+        Assert.AreEqual(9, languagesArray.Length);
+        Assert.AreEqual("C", languagesArray[0]);
+        Assert.AreEqual("TypeScript", languagesArray[8]);
+        Assert.IsNotNull(languagesArray);
+    }
 
-            Assert.IsFalse(_languages.SetEquals(moreLanguages));
-            Assert.IsTrue(_languages.SetEquals(languagesCopy));
-        }
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyProperSubset()
+    {
+        var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "TypeScript", "Python", "JavaScript", "Rust", "Assembly", "Pascal" };
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_VerifySymmetricExceptWithSuccessful()
-        {
-            var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+        Assert.IsTrue(_languages.IsSubsetOf(moreLanguages));
+        Assert.IsTrue(_languages.IsProperSubsetOf(moreLanguages));
+        Assert.IsTrue(moreLanguages.IsSupersetOf(_languages));
+        Assert.IsTrue(moreLanguages.IsProperSupersetOf(_languages));
+    }
 
-            _languages.SymmetricExceptWith(moreLanguages);
+    [TestMethod]
+    public void GivenTwoEqualSets_WhenCheckingSubsets_ThenOnlyTheNonProperChecksPass()
+    {
+        var sameLanguages = new SortedSet<string>(_languages);
+
+        Assert.IsTrue(_languages.IsSubsetOf(sameLanguages));
+        Assert.IsFalse(_languages.IsProperSubsetOf(sameLanguages));
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyUnionWithSuccessful()
+    {
+        var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
 
-            Assert.AreEqual(_languages.Count(), 14);
-        }
+        _languages.UnionWith(moreLanguages);
+
+        Assert.AreEqual(14, _languages.Count);
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifyIntersectWithSuccessful()
+    {
+        var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "Assembly", "Pascal", "HTML", "CSS", "PHP" };
 
-        [TestMethod]
-        public void GivenASortedSet_WhenNotEmpty_TryToGetValue()
+        _languages.IntersectWith(moreLanguages);
+
+        Assert.AreEqual(5, _languages.Count);
+        Assert.IsTrue(_languages.Contains("C"));
+        Assert.IsTrue(_languages.Contains("C++"));
+        Assert.IsTrue(_languages.Contains("C#"));
+        Assert.IsTrue(_languages.Contains("Java"));
+        Assert.IsTrue(_languages.Contains("Scala"));
+        Assert.IsFalse(_languages.Contains("Assembly"));
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_ExceptWithSuccessful()
+    {
+        var moreLanguages = new SortedSet<string> { "C", "C++", "C#", "Java", "Scala", "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+
+        _languages.ExceptWith(moreLanguages);
+
+        Assert.AreEqual(4, _languages.Count);
+        Assert.IsTrue(_languages.Contains("TypeScript"));
+        Assert.IsTrue(_languages.Contains("Python"));
+        Assert.IsTrue(_languages.Contains("JavaScript"));
+        Assert.IsTrue(_languages.Contains("Rust"));
+        Assert.IsFalse(_languages.Contains("Assembly"));
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifySetEqualsSuccessful()
+    {
+        var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+        var sameLanguagesInAList = new List<string>
         {
-            Assert.IsTrue(_languages.TryGetValue("C#", out _));
-            Assert.IsTrue(_languages.Contains("C#"));
-            Assert.IsFalse(_languages.TryGetValue("Assembly", out _));
-            Assert.IsFalse(_languages.Contains("Assembly"));
-        }
+            "Rust", "Java", "C", "C#", "C++", "Scala", "TypeScript", "Python", "JavaScript", "Java"
+        };
+
+        Assert.IsFalse(_languages.SetEquals(moreLanguages));
+        Assert.IsTrue(_languages.SetEquals(sameLanguagesInAList));
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_VerifySymmetricExceptWithSuccessful()
+    {
+        var moreLanguages = new SortedSet<string> { "Assembly", "Pascal", "HTML", "CSS", "PHP" };
+
+        _languages.SymmetricExceptWith(moreLanguages);
+
+        Assert.AreEqual(14, _languages.Count);
+    }
+
+    [TestMethod]
+    public void GivenASortedSet_WhenNotEmpty_TryToGetValue()
+    {
+        Assert.IsTrue(_languages.TryGetValue("C#", out var found));
+        Assert.AreEqual("C#", found);
+        Assert.IsTrue(_languages.Contains("C#"));
+        Assert.IsFalse(_languages.TryGetValue("Assembly", out _));
+        Assert.IsFalse(_languages.Contains("Assembly"));
     }
-}
\ No newline at end of file
+}