feat: add sort method to dictionary

src/Microsoft.OpenApi/Extensions/DictionaryExtensions.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.OpenApi.Extensions
+{
+    /// <summary>
+    /// Dictionary extension methods.
+    /// </summary>
+    public static class DictionaryExtensions
+    {
+        /// <summary>
+        /// Returns a new dictionary with entries sorted by key using the default comparer.
+        /// </summary>
+        public static SortedDictionary<TKey, TValue> Sort<TKey, TValue>(
+            this Dictionary<TKey, TValue> source)
+            where TKey : notnull
+        {
+            Utils.CheckArgumentNull(source);
+
+            return new SortedDictionary<TKey, TValue>(source);
+        }
+
+        /// <summary>
+        /// Returns a new dictionary with entries sorted by key using a custom comparer.
+        /// </summary>
+        public static SortedDictionary<TKey, TValue> Sort<TKey, TValue>(
+            this Dictionary<TKey, TValue> source,
+            IComparer<TKey> comparer)
+            where TKey : notnull
+        {
+            Utils.CheckArgumentNull(source);
+            Utils.CheckArgumentNull(comparer);
+
+            return new SortedDictionary<TKey, TValue>(source, comparer);
+        }
+    }
+}

test/Microsoft.OpenApi.Tests/Extensions/DictionaryExtensionsTests.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.OpenApi.Extensions;
+using Xunit;
+
+namespace Microsoft.OpenApi.Tests.Extensions
+{
+    public class DictionaryExtensionsTests
+    {
+        [Fact]
+        public void ShouldSortStringIntDictionaryInAscendingOrder()
+        {
+            var dict = new Dictionary<string, int> { { "b", 2 }, { "a", 1 } };
+            var result = dict.Sort();
+            Assert.Equal(["a", "b"], result.Keys);
+        }
+
+        [Fact]
+        public void ShouldReturnEmptyDictionaryWhenSourceIsEmpty()
+        {
+            var dict = new Dictionary<string, int>();
+            var result = dict.Sort();
+            Assert.Empty(result);
+        }
+
+        [Fact]
+        public void ShouldKeepOrderWhenDictionaryIsAlreadySorted()
+        {
+            var dict = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };
+            var result = dict.Sort();
+            Assert.Equal(["a", "b"], result.Keys);
+        }
+
+        [Fact]
+        public void ShouldSortNumericKeysNaturally()
+        {
+            var dict = new Dictionary<int, string> { { 10, "a" }, { 1, "b" } };
+            var result = dict.Sort();
+            Assert.Equal([1, 10], result.Keys);
+        }
+
+        [Fact]
+        public void ShouldSortDateTimeKeysInAscendingOrder()
+        {
+            var now = DateTime.Now;
+            var later = now.AddHours(1);
+
+            var dict = new Dictionary<DateTime, string>
+            {
+                [later] = "future",
+                [now] = "present"
+            };
+
+            var result = dict.Sort();
+            Assert.Equal([now, later], result.Keys);
+        }
+
+        [Fact]
+        public void ShouldSortWithCustomDescendingComparer()
+        {
+            var dict = new Dictionary<string, int> { { "a", 1 }, { "b", 2 } };
+            var result = dict.Sort(Comparer<string>.Create((x, y) => y.CompareTo(x)));
+            Assert.Equal(["b", "a"], result.Keys);
+        }
+
+        [Fact]
+        public void ShouldSortDictionaryWithComplexValueTypes()
+        {
+            var dict = new Dictionary<string, ISet<string>>
+        {
+            { "z", new HashSet<string> { "value1" } },
+            { "a", new HashSet<string> { "value2" } }
+        };
+
+            var result = dict.Sort();
+            Assert.Equal(["a", "z"], result.Keys);
+            Assert.Equal(new HashSet<string> { "value2" }, result["a"]);
+        }
+
+        [Fact]
+        public void ShouldSortDictionaryWithNullValues()
+        {
+            var dict = new Dictionary<string, string>
+        {
+            { "b", null },
+            { "a", "value" }
+        };
+
+            var result = dict.Sort();
+            Assert.Equal(["a", "b"], result.Keys);
+            Assert.Null(result["b"]);
+        }
+
+        [Fact]
+        public void ShouldSortDictionaryOfDictionariesByOuterKey()
+        {
+            var dict = new Dictionary<string, Dictionary<string, string>>
+            {
+                ["z"] = new Dictionary<string, string> { { "x", "1" } },
+                ["a"] = new Dictionary<string, string> { { "y", "2" } }
+            };
+
+            var result = dict.Sort();
+            Assert.Equal(["a", "z"], result.Keys);
+            Assert.Equal("2", result["a"]["y"]);
+        }
+    }
+}

test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt

@@ -142,6 +142,13 @@ namespace Microsoft.OpenApi.Expressions
 }
 namespace Microsoft.OpenApi.Extensions
 {
+    public static class DictionaryExtensions
+    {
+        public static System.Collections.Generic.SortedDictionary<TKey, TValue> Sort<TKey, TValue>(this System.Collections.Generic.Dictionary<TKey, TValue> source)
+            where TKey :  notnull { }
+        public static System.Collections.Generic.SortedDictionary<TKey, TValue> Sort<TKey, TValue>(this System.Collections.Generic.Dictionary<TKey, TValue> source, System.Collections.Generic.IComparer<TKey> comparer)
+            where TKey :  notnull { }
+    }
     public static class EnumExtensions
     {
         [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2075", Justification="Fields are never trimmed for enum types.")]