diff --git a/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp b/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp
index 5885be28f72..02d0766c4fe 100644
--- a/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp
+++ b/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp
@@ -1,89 +1,64 @@
+// <snippet2>
+#include <iostream>
+#using <System.dll>
 
-// The following code example shows how sorting with CompareOptions::StringSort differs 
-// from sorting with->Item[Out] CompareOptions::StringSort.
-// <snippet1>
 using namespace System;
-using namespace System::Collections;
+using namespace System::Collections::Generic;
 using namespace System::Globalization;
 
-// __gc public class SamplesCompareOptions {
-ref class MyStringComparer: public IComparer
+ref class StringSort
 {
 public:
+    static void Main()
+    {
+        auto wordList = gcnew List<String^> {
+            "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"
+        };
 
-   // Constructs a comparer using the specified CompareOptions.
-   CompareInfo^ myComp;
-   CompareOptions myOptions;
-   MyStringComparer( CompareInfo^ cmpi, CompareOptions options )
-      : myComp( cmpi ), myOptions( options )
-   {}
+        Console::WriteLine("Before sorting:");
+        for each (String^ word in wordList)
+        {
+            Console::WriteLine(word);
+        }
 
-   // Compares strings with the CompareOptions specified in the constructor.
-   virtual int Compare( Object^ a, Object^ b )
-   {
-      if ( a == b )
-            return 0;
+        Console::WriteLine(Environment::NewLine + "After sorting with CompareOptions::None:");
+        SortAndDisplay(wordList, CompareOptions::None);
 
-      if ( a == nullptr )
-            return  -1;
+        Console::WriteLine(Environment::NewLine + "After sorting with CompareOptions::StringSort:");
+        SortAndDisplay(wordList, CompareOptions::StringSort);
+    }
 
-      if ( b == nullptr )
-            return 1;
+private:
+    static void SortAndDisplay(List<String^>^ unsorted, CompareOptions options)
+    {
+        // Create a copy of the original list to sort.
+        auto words = gcnew List<String^>(unsorted);
+        // Define the CompareInfo to use to compare strings.
+        CompareInfo^ comparer = CultureInfo::InvariantCulture->CompareInfo;
 
-      String^ sa = dynamic_cast<String^>(a);
-      String^ sb = dynamic_cast<String^>(b);
-      if ( sa != nullptr && sb != nullptr )
-            return myComp->Compare( sa, sb, myOptions );
+        // Sort the copy with the supplied CompareOptions then display.
+        words->Sort(gcnew Comparison<String^>([comparer, options](String^ str1, String^ str2) {
+            return comparer->Compare(str1, str2, options);
+        }));
 
-      throw gcnew ArgumentException( "a and b should be strings." );
-   }
+        for each (String^ word in words)
+        {
+            Console::WriteLine(word);
+        }
+    }
 };
 
-int main()
+int main(array<System::String ^> ^args)
 {
-   
-   // Creates and initializes an array of strings to sort.
-   array<String^>^myArr = {"cant","bill's","coop","cannot","billet","can't","con","bills","co-op"};
-   Console::WriteLine( "\nInitially, " );
-   IEnumerator^ myEnum = myArr->GetEnumerator();
-   while ( myEnum->MoveNext() )
-   {
-      String^ myStr = safe_cast<String^>(myEnum->Current);
-      Console::WriteLine( myStr );
-   }
-
-   
-   // Creates and initializes a Comparer to use.
-   //CultureInfo* myCI = new CultureInfo(S"en-US", false);
-   MyStringComparer^ myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::None );
-   
-   // Sorts the array without StringSort.
-   Array::Sort( myArr, myComp );
-   Console::WriteLine( "\nAfter sorting without CompareOptions::StringSort:" );
-   myEnum = myArr->GetEnumerator();
-   while ( myEnum->MoveNext() )
-   {
-      String^ myStr = safe_cast<String^>(myEnum->Current);
-      Console::WriteLine( myStr );
-   }
-
-   
-   // Sorts the array with StringSort.
-   myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::StringSort );
-   Array::Sort( myArr, myComp );
-   Console::WriteLine( "\nAfter sorting with CompareOptions::StringSort:" );
-   myEnum = myArr->GetEnumerator();
-   while ( myEnum->MoveNext() )
-   {
-      String^ myStr = safe_cast<String^>(myEnum->Current);
-      Console::WriteLine( myStr );
-   }
+    StringSort::Main();
+    return 0;
 }
 
 /*
-This code produces the following output.
+CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
+in .NET 5 and later, but in prior versions, the output will be the following:
 
-Initially,
+Before sorting:
 cant
 bill's
 coop
@@ -94,7 +69,7 @@ con
 bills
 co-op
 
-After sorting without CompareOptions::StringSort:
+After sorting with CompareOptions.None:
 billet
 bills
 bill's
@@ -105,7 +80,7 @@ con
 coop
 co-op
 
-After sorting with CompareOptions::StringSort:
+After sorting with CompareOptions.StringSort:
 bill's
 billet
 bills
@@ -116,4 +91,4 @@ co-op
 con
 coop
 */
-// </snippet1>
+// </snippet2>
diff --git a/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/CPP/compareoptions_values.cpp b/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/CPP/compareoptions_values.cpp
new file mode 100644
index 00000000000..ef6239d58e9
--- /dev/null
+++ b/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/CPP/compareoptions_values.cpp
@@ -0,0 +1,111 @@
+// <snippet1>
+#include <iostream>
+#include <string>
+
+using namespace System;
+using namespace System::Globalization;
+
+public ref class CompareOptionsExample
+{
+public:
+    static void Main()
+    {
+        // Uppercase and lowercase characters are equivalent (according to the culture rules)
+        // when IgnoreCase is used.
+        TestStringEquality("ONE two", "one TWO", "Case sensitivity", CompareOptions::IgnoreCase);
+
+        // Punctuation is ignored with the IgnoreSymbols option.
+        TestStringEquality("hello world", "hello, world!", "Punctuation", CompareOptions::IgnoreSymbols);
+
+        // Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
+        TestStringEquality("3 + 5 = 8", "358", "Whitespace and mathematical symbols", CompareOptions::IgnoreSymbols);
+
+        // Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
+        // Parse strings containing numbers/currency and compare them numerically instead.
+        TestStringEquality("Total $15,000", "Total: £150.00", "Currency symbols, decimals and thousands separators", CompareOptions::IgnoreSymbols);
+
+        // Full width characters are common in East Asian languages. Use the IgnoreWidth
+        // option to treat full- and half-width characters as equal.
+        TestStringEquality("ａｂｃ，－", "abc,-", "Half width and full width characters", CompareOptions::IgnoreWidth);
+
+        // The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
+        TestStringEquality("ありがとう", "アリガトウ", "Hiragana and Katakana strings", CompareOptions::IgnoreKanaType);
+
+        // When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
+        TestStringEquality("café", "cafe", "Diacritical marks", CompareOptions::IgnoreNonSpace);
+
+        // Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
+        // Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
+        TestStringEquality("straße œuvre cæsar", "strasse oeuvre caesar", "Ligature characters", CompareOptions::IgnoreNonSpace);
+    }
+
+private:
+    static void TestStringEquality(String^ str1, String^ str2, String^ description, CompareOptions options)
+    {
+        Console::WriteLine(Environment::NewLine + description + ":");
+        // First test with the default CompareOptions then with the provided options
+        TestStringEquality(str1, str2, CompareOptions::None);
+        TestStringEquality(str1, str2, options);
+    }
+
+    static void TestStringEquality(String^ str1, String^ str2, CompareOptions options)
+    {
+        Console::Write("  When using CompareOptions." + options + ", \"" + str1 + "\" and \"" + str2 + "\" are ");
+        if (String::Compare(str1, str2, CultureInfo::InvariantCulture, options) != 0)
+        {
+            Console::Write("not ");
+        }
+        Console::WriteLine("equal.");
+    }
+};
+
+int main(array<System::String ^> ^args)
+{
+    CompareOptionsExample::Main();
+    return 0;
+}
+
+/*
+In .NET 5 and later, the output will be the following:
+ 
+Case sensitivity:
+  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
+  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.
+
+Punctuation:
+  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
+  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.
+
+Whitespace and mathematical symbols:
+  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
+  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.
+
+Currency symbols, decimals and thousands separators:
+  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
+  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.
+
+Half width and full width characters:
+  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
+  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.
+
+Hiragana and Katakana strings:
+  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
+  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.
+
+Diacritical marks:
+  When using CompareOptions.None, "café" and "cafe" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+
+
+Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
+non-ligature counterparts by default, so the last test will output as follows:
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+*/
+// </snippet1>
diff --git a/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs b/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs
index b8fc19680cf..65efc20e8ce 100644
--- a/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs
+++ b/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs
@@ -1,67 +1,52 @@
-// The following code example shows how sorting with CompareOptions.StringSort differs from sorting without CompareOptions.StringSort.
-
-// <snippet1>
+// <snippet2>
 using System;
-using System.Collections;
+using System.Collections.Generic;
 using System.Globalization;
 
-public class SamplesCompareOptions  {
-
-   private class MyStringComparer: IComparer {
-      private CompareInfo myComp;
-      private CompareOptions myOptions = CompareOptions.None;
-
-      // Constructs a comparer using the specified CompareOptions.
-      public MyStringComparer( CompareInfo cmpi, CompareOptions options )  {
-         myComp = cmpi;
-         this.myOptions = options;
-      }
-
-      // Compares strings with the CompareOptions specified in the constructor.
-      public int Compare(Object a, Object b) {
-         if (a == b) return 0;
-         if (a == null) return -1;
-         if (b == null) return 1;
-
-         String sa = a as String;
-         String sb = b as String;
-         if (sa != null && sb != null)
-            return myComp.Compare(sa, sb, myOptions);
-         throw new ArgumentException("a and b should be strings.");
-      }
-   }
-
-   public static void Main()  {
-
-      // Creates and initializes an array of strings to sort.
-      String[] myArr = new String[9] { "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op" };
-      Console.WriteLine( "\nInitially," );
-      foreach ( String myStr in myArr )
-         Console.WriteLine( myStr );
-
-      // Creates and initializes a Comparer to use.
-      //CultureInfo myCI = new CultureInfo( "en-US", false );
-      MyStringComparer myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None);
-
-      // Sorts the array without StringSort.
-      Array.Sort( myArr, myComp );
-      Console.WriteLine( "\nAfter sorting without CompareOptions.StringSort:" );
-      foreach ( String myStr in myArr )
-         Console.WriteLine( myStr );
-
-      // Sorts the array with StringSort.
-      myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort);
-      Array.Sort( myArr, myComp );
-      Console.WriteLine( "\nAfter sorting with CompareOptions.StringSort:" );
-      foreach ( String myStr in myArr )
-         Console.WriteLine( myStr );
-   }
+public class StringSort
+{
+    public static void Main()
+    {
+        var wordList = new List<string>
+        {
+            "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"
+        };
+
+        Console.WriteLine("Before sorting:");
+        foreach (string word in wordList)
+        {
+            Console.WriteLine(word);
+        }
+
+        Console.WriteLine(Environment.NewLine + "After sorting with CompareOptions.None:");
+        SortAndDisplay(wordList, CompareOptions.None);
+
+        Console.WriteLine(Environment.NewLine + "After sorting with CompareOptions.StringSort:");
+        SortAndDisplay(wordList, CompareOptions.StringSort);
+    }
+
+    // Sort the list of words with the supplied CompareOptions.
+    private static void SortAndDisplay(List<string> unsorted, CompareOptions options)
+    {
+        // Create a copy of the original list to sort.
+        var words = new List<string>(unsorted);
+        // Define the CompareInfo to use to compare strings.
+        var comparer = CultureInfo.InvariantCulture.CompareInfo;
+
+        // Sort the copy with the supplied CompareOptions then display.
+        words.Sort((str1, str2) => comparer.Compare(str1, str2, options));
+        foreach (string word in words)
+        {
+            Console.WriteLine(word);
+        }
+    }
 }
 
 /*
-This code produces the following output.
+CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
+in .NET 5 and later, but in prior versions, the output will be the following:
 
-Initially,
+Before sorting:
 cant
 bill's
 coop
@@ -72,7 +57,7 @@ This code produces the following output.
 bills
 co-op
 
-After sorting without CompareOptions.StringSort:
+After sorting with CompareOptions.None:
 billet
 bills
 bill's
@@ -93,6 +78,5 @@ This code produces the following output.
 co-op
 con
 coop
-
 */
-// </snippet1>
+// </snippet2>
diff --git a/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_values.cs b/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_values.cs
new file mode 100644
index 00000000000..99927dd7f5f
--- /dev/null
+++ b/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_values.cs
@@ -0,0 +1,100 @@
+// <snippet1>
+using System;
+using System.Globalization;
+
+public class CompareOptionsExample
+{
+    public static void Main()
+    {
+        // Uppercase and lowercase characters are equivalent (according to the culture rules)
+        // when IgnoreCase is used.
+        TestStringEquality("ONE two", "one TWO", "Case sensitivity", CompareOptions.IgnoreCase);
+
+        // Punctuation is ignored with the IgnoreSymbols option.
+        TestStringEquality("hello world", "hello, world!", "Punctuation", CompareOptions.IgnoreSymbols);
+
+        // Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
+        TestStringEquality("3 + 5 = 8", "358", "Whitespace and mathematical symbols", CompareOptions.IgnoreSymbols);
+
+        // Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
+        // Parse strings containing numbers/currency and compare them numerically instead.
+        TestStringEquality("Total $15,000", "Total: £150.00", "Currency symbols, decimals and thousands separators", CompareOptions.IgnoreSymbols);
+
+        // Full width characters are common in East Asian languages. Use the IgnoreWidth
+        // option to treat full- and half-width characters as equal.
+        TestStringEquality("ａｂｃ，－", "abc,-", "Half width and full width characters", CompareOptions.IgnoreWidth);
+
+        // The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
+        TestStringEquality("ありがとう", "アリガトウ", "Hiragana and Katakana strings", CompareOptions.IgnoreKanaType);
+
+        // When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
+        TestStringEquality("café", "cafe", "Diacritical marks", CompareOptions.IgnoreNonSpace);
+
+        // Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
+        // Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
+        TestStringEquality("straße œuvre cæsar", "strasse oeuvre caesar", "Ligature characters", CompareOptions.IgnoreNonSpace);
+    }
+
+    private static void TestStringEquality(string str1, string str2, string description, CompareOptions options)
+    {
+        Console.WriteLine(Environment.NewLine + description + ":");
+        // First test with the default CompareOptions then with the provided options
+        TestStringEquality(str1, str2, CompareOptions.None);
+        TestStringEquality(str1, str2, options);
+    }
+
+    private static void TestStringEquality(string str1, string str2, CompareOptions options)
+    {
+        Console.Write($"  When using CompareOptions.{options}, \"{str1}\" and \"{str2}\" are ");
+        if (string.Compare(str1, str2, CultureInfo.InvariantCulture, options) != 0)
+        {
+            Console.Write("not ");
+        }
+        Console.WriteLine("equal.");
+    }
+}
+
+/*
+In .NET 5 and later, the output will be the following:
+ 
+Case sensitivity:
+  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
+  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.
+
+Punctuation:
+  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
+  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.
+
+Whitespace and mathematical symbols:
+  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
+  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.
+
+Currency symbols, decimals and thousands separators:
+  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
+  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.
+
+Half width and full width characters:
+  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
+  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.
+
+Hiragana and Katakana strings:
+  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
+  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.
+
+Diacritical marks:
+  When using CompareOptions.None, "café" and "cafe" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+
+
+Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
+non-ligature counterparts by default, so the last test will output as follows:
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+*/
+// </snippet1>
\ No newline at end of file
diff --git a/snippets/fsharp/System.Globalization/compareoptions_stringsort.fs b/snippets/fsharp/System.Globalization/compareoptions_stringsort.fs
new file mode 100644
index 00000000000..b47864e0755
--- /dev/null
+++ b/snippets/fsharp/System.Globalization/compareoptions_stringsort.fs
@@ -0,0 +1,67 @@
+// <snippet2>
+open System
+open System.Collections.Generic
+open System.Globalization
+
+let sortAndDisplay (unsorted: List<string>) (options: CompareOptions) =
+    let words = new List<string>(unsorted)
+    let comparer = CultureInfo.InvariantCulture.CompareInfo
+    words.Sort((fun str1 str2 -> comparer.Compare(str1, str2, options)))
+    for word in words do
+        printfn "%s" word
+
+[<EntryPoint>]
+let main argv =
+    let wordList = new List<string>(
+        ["cant"; "bill's"; "coop"; "cannot"; "billet"; "can't"; "con"; "bills"; "co-op"])
+    
+    printfn "Before sorting:"
+    for word in wordList do
+        printfn "%s" word
+    
+    printfn "\nAfter sorting with CompareOptions.None:"
+    sortAndDisplay wordList CompareOptions.None
+    
+    printfn "\nAfter sorting with CompareOptions.StringSort:"
+    sortAndDisplay wordList CompareOptions.StringSort
+    
+    0 // return an integer exit code
+
+(*
+CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
+in .NET 5 and later, but in prior versions, the output will be the following:
+
+Before sorting:
+cant
+bill's
+coop
+cannot
+billet
+can't
+con
+bills
+co-op
+
+After sorting with CompareOptions.None:
+billet
+bills
+bill's
+cannot
+cant
+can't
+con
+coop
+co-op
+
+After sorting with CompareOptions.StringSort:
+bill's
+billet
+bills
+can't
+cannot
+cant
+co-op
+con
+coop
+*)
+// </snippet2>
diff --git a/snippets/fsharp/System.Globalization/compareoptions_values.fs b/snippets/fsharp/System.Globalization/compareoptions_values.fs
new file mode 100644
index 00000000000..d80b46ca732
--- /dev/null
+++ b/snippets/fsharp/System.Globalization/compareoptions_values.fs
@@ -0,0 +1,90 @@
+// <snippet1>
+open System
+open System.Globalization
+
+let testStringEquality (str1: string) (str2: string) (description: string) (options: CompareOptions) =
+    printfn "\n%s:" description
+    
+    let compareAndPrint opts =
+        let result = String.Compare(str1, str2, CultureInfo.InvariantCulture, opts)
+        let equalityStatus = if result = 0 then "equal" else "not equal"
+        printfn "  When using CompareOptions.%A, \"%s\" and \"%s\" are %s." opts str1 str2 equalityStatus
+
+    compareAndPrint CompareOptions.None
+    compareAndPrint options
+
+[<EntryPoint>]
+let main argv =
+    // Uppercase and lowercase characters are equivalent (according to the culture rules) when IgnoreCase is used.
+    testStringEquality "ONE two" "one TWO" "Case sensitivity" CompareOptions.IgnoreCase
+
+    // Punctuation is ignored with the IgnoreSymbols option.
+    testStringEquality "hello world" "hello, world!" "Punctuation" CompareOptions.IgnoreSymbols
+
+    // Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
+    testStringEquality "3 + 5 = 8" "358" "Whitespace and mathematical symbols" CompareOptions.IgnoreSymbols
+
+    // Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
+    // Parse strings containing numbers/currency and compare them numerically instead.
+    testStringEquality "Total $15,000" "Total: £150.00" "Currency symbols, decimals and thousands separators" CompareOptions.IgnoreSymbols
+
+    // Full width characters are common in East Asian languages. Use the IgnoreWidth
+    // option to treat full- and half-width characters as equal.
+    testStringEquality "ａｂｃ，－" "abc,-" "Half width and full width characters" CompareOptions.IgnoreWidth
+
+    // The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
+    testStringEquality "ありがとう" "アリガトウ" "Hiragana and Katakana strings" CompareOptions.IgnoreKanaType
+
+    // When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
+    testStringEquality "café" "cafe" "Diacritical marks" CompareOptions.IgnoreNonSpace
+
+    // Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
+    // Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
+    testStringEquality "straße œuvre cæsar" "strasse oeuvre caesar" "Ligature characters" CompareOptions.IgnoreNonSpace
+    
+    0 // return an integer exit code
+
+(*
+In .NET 5 and later, the output will be the following:
+ 
+Case sensitivity:
+  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
+  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.
+
+Punctuation:
+  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
+  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.
+
+Whitespace and mathematical symbols:
+  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
+  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.
+
+Currency symbols, decimals and thousands separators:
+  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
+  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.
+
+Half width and full width characters:
+  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
+  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.
+
+Hiragana and Katakana strings:
+  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
+  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.
+
+Diacritical marks:
+  When using CompareOptions.None, "café" and "cafe" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+
+
+Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
+non-ligature counterparts by default, so the last test will output as follows:
+
+Ligature characters:
+  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+*)
+// </snippet1>
\ No newline at end of file
diff --git a/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb b/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb
index da1c2c9195e..5e8e0feed0a 100644
--- a/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb
+++ b/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb
@@ -1,87 +1,47 @@
-' The following code example shows how sorting with CompareOptions.StringSort differs from sorting without CompareOptions.StringSort.
-
-' <snippet1>
-Imports System.Collections
+'// <snippet2>
+Imports System
+Imports System.Collections.Generic
 Imports System.Globalization
 
-Public Class SamplesCompareOptions
-
-   Private Class MyStringComparer
-      Implements IComparer
-
-      Private myComp As CompareInfo
-      Private myOptions As CompareOptions = CompareOptions.None
-      
-      ' Constructs a comparer using the specified CompareOptions.
-      Public Sub New(cmpi As CompareInfo, options As CompareOptions)
-         myComp = cmpi
-         Me.myOptions = options
-      End Sub
-      
-      ' Compares strings with the CompareOptions specified in the constructor.
-      Public Function Compare(a As [Object], b As [Object]) As Integer Implements IComparer.Compare
-         If a = b Then
-            Return 0
-         End If
-         If a Is Nothing Then
-            Return - 1
-         End If
-         If b Is Nothing Then
-            Return 1
-         End If 
-
-         Dim sa As [String] = a
-         Dim sb As [String] = b
-         If Not (sa Is Nothing) And Not (sb Is Nothing) Then
-            Return myComp.Compare(sa, sb, myOptions)
-         End If
-         Throw New ArgumentException("a and b should be strings.")
-
-      End Function 'Compare 
+Public Class StringSort
+    Public Shared Sub Main()
+        Dim wordList As New List(Of String) From {
+            "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"
+        }
 
-   End Class
+        Console.WriteLine("Before sorting:")
+        For Each word In wordList
+            Console.WriteLine(word)
+        Next
 
+        Console.WriteLine(Environment.NewLine & "After sorting with CompareOptions.None:")
+        SortAndDisplay(wordList, CompareOptions.None)
 
-   Public Shared Sub Main()
-      
-      ' Creates and initializes an array of strings to sort.
-      Dim myArr() As [String] = {"cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"}
-      Console.WriteLine()
-      Console.WriteLine("Initially,")
-      Dim myStr As [String]
-      For Each myStr In  myArr
-         Console.WriteLine(myStr)
-      Next myStr 
+        Console.WriteLine(Environment.NewLine & "After sorting with CompareOptions.StringSort:")
+        SortAndDisplay(wordList, CompareOptions.StringSort)
+    End Sub
 
-      ' Creates and initializes a Comparer to use.
-      'CultureInfo myCI = new CultureInfo( "en-US", false );
-      Dim myComp As New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None)
-      
-      ' Sorts the array without StringSort.
-      Array.Sort(myArr, myComp)
-      Console.WriteLine()
-      Console.WriteLine("After sorting without CompareOptions.StringSort:")
-      For Each myStr In  myArr
-         Console.WriteLine(myStr)
-      Next myStr 
+    ' Sort the list of words with the supplied CompareOptions.
+    Private Shared Sub SortAndDisplay(unsorted As List(Of String), options As CompareOptions)
+        ' Create a copy of the original list to sort.
+        Dim words As New List(Of String)(unsorted)
 
-      ' Sorts the array with StringSort.
-      myComp = New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort)
-      Array.Sort(myArr, myComp)
-      Console.WriteLine()
-      Console.WriteLine("After sorting with CompareOptions.StringSort:")
-      For Each myStr In  myArr
-         Console.WriteLine(myStr)
-      Next myStr 
+        ' Define the CompareInfo to use to compare strings.
+        Dim comparer As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
 
-   End Sub
+        ' Sort the copy with the supplied CompareOptions then display.
+        words.Sort(Function(str1, str2) comparer.Compare(str1, str2, options))
 
+        For Each word In words
+            Console.WriteLine(word)
+        Next
+    End Sub
 End Class
 
-
-'This code produces the following output.
+' CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
+' in .NET 5 And later, but in prior versions, the output will be the following:
 '
-'Initially,
+'Before sorting
 'cant
 'bill's
 'coop
@@ -91,8 +51,8 @@ End Class
 'con
 'bills
 'co-op
-'
-'After sorting without CompareOptions.StringSort:
+
+'After sorting with CompareOptions.None
 'billet
 'bills
 'bill's
@@ -102,8 +62,8 @@ End Class
 'con
 'coop
 'co-op
-'
-'After sorting with CompareOptions.StringSort:
+
+'After sorting with CompareOptions.StringSort
 'bill's
 'billet
 'bills
@@ -114,4 +74,4 @@ End Class
 'con
 'coop
 
-' </snippet1>
\ No newline at end of file
+'// </snippet2>
diff --git a/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/VB/compareoptions_values.vb b/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/VB/compareoptions_values.vb
new file mode 100644
index 00000000000..8c25841cfc6
--- /dev/null
+++ b/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/VB/compareoptions_values.vb
@@ -0,0 +1,94 @@
+' <snippet1>
+Imports System
+Imports System.Globalization
+
+Module CompareOptionsExample
+    Sub Main()
+        ' Uppercase and lowercase characters are equivalent (according to the culture rules)
+        ' when IgnoreCase is used.
+        TestStringEquality("ONE two", "one TWO", "Case sensitivity", CompareOptions.IgnoreCase)
+
+        ' Punctuation is ignored with the IgnoreSymbols option.
+        TestStringEquality("hello world", "hello, world!", "Punctuation", CompareOptions.IgnoreSymbols)
+
+        ' Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
+        TestStringEquality("3 + 5 = 8", "358", "Whitespace and mathematical symbols", CompareOptions.IgnoreSymbols)
+
+        ' Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
+        ' Parse strings containing numbers/currency and compare them numerically instead.
+        TestStringEquality("Total $15,000", "Total: £150.00", "Currency symbols, decimals and thousands separators", CompareOptions.IgnoreSymbols)
+
+        ' Full width characters are common in East Asian languages. Use the IgnoreWidth
+        ' option to treat full- and half-width characters as equal.
+        TestStringEquality("ａｂｃ，－", "abc,-", "Half width and full width characters", CompareOptions.IgnoreWidth)
+
+        ' The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
+        TestStringEquality("ありがとう", "アリガトウ", "Hiragana and Katakana strings", CompareOptions.IgnoreKanaType)
+
+        ' When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
+        TestStringEquality("café", "cafe", "Diacritical marks", CompareOptions.IgnoreNonSpace)
+
+        ' Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
+        ' Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
+        TestStringEquality("straße œuvre cæsar", "strasse oeuvre caesar", "Ligature characters", CompareOptions.IgnoreNonSpace)
+    End Sub
+
+    Private Sub TestStringEquality(str1 As String, str2 As String, description As String, options As CompareOptions)
+        Console.WriteLine(Environment.NewLine & description & ":")
+        ' First test with the default CompareOptions then with the provided options
+        TestStringEqualityWithOptions(str1, str2, CompareOptions.None)
+        TestStringEqualityWithOptions(str1, str2, options)
+    End Sub
+
+    Private Sub TestStringEqualityWithOptions(str1 As String, str2 As String, options As CompareOptions)
+        Console.Write($"  When using CompareOptions.{options}, ""{str1}"" and ""{str2}"" are ")
+        If String.Compare(str1, str2, CultureInfo.InvariantCulture, options) <> 0 Then
+            Console.Write("not ")
+        End If
+        Console.WriteLine("equal.")
+    End Sub
+End Module
+
+' In .NET 5 and later, the output will be the following:
+'
+'Case sensitivity : 
+'  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
+'  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.
+'
+'Punctuation:
+'  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
+'  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.
+'
+'Whitespace And mathematical symbols:
+'  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
+'  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.
+'
+'Currency symbols, decimals And thousands separators:
+'  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
+'  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.
+'
+'Half width And full width characters:
+'  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
+'  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.
+'
+'Hiragana And Katakana strings:
+'  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
+'  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.
+'
+'Diacritical marks : 
+'  When using CompareOptions.None, "café" and "cafe" are not equal.
+'  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.
+'
+'Ligature characters : 
+'  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
+'  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+'
+'
+' Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
+' non-ligature counterparts by default, so the last test will output as follows:
+'
+'Ligature characters : 
+'  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+'  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
+
+' </snippet1>
diff --git a/xml/System.Globalization/CompareOptions.xml b/xml/System.Globalization/CompareOptions.xml
index 5bd6fa0ea24..af4b060ebfb 100644
--- a/xml/System.Globalization/CompareOptions.xml
+++ b/xml/System.Globalization/CompareOptions.xml
@@ -68,15 +68,44 @@
     </Attribute>
   </Attributes>
   <Docs>
-    <summary>Defines the string comparison options to use with <see cref="T:System.Globalization.CompareInfo" />.</summary>
-    <remarks>For more information about this API, see <see href="/dotnet/fundamentals/runtime-libraries/system-globalization-compareoptions">Supplemental API remarks for CompareOptions</see>.</remarks>
+    <summary>
+      Defines the string comparison options to use with <see cref="T:System.Globalization.CompareInfo" />.
+    </summary>
+    <remarks>
+      <format type="text/markdown">
+        <![CDATA[
+      In .NET 5 and later, the cross-platform ICU (International Components for Unicode) library is used for string processing. This introduced changes in string comparison behaviour, including:
+      
+      - The default option `None` is now equivalent to the `StringSort` option. The previous functionality of `None`, where equal weighting was given to alphanumeric and non-alphanumeric characters, is no longer available when using the ICU library.
+      - Ligatures (combined characters like "æ" and "œ") are now seen as distinct from their expanded forms ("ae", "oe") in string comparisons by default. To treat ligatures and their expanded forms as equivalent, use the `IgnoreNonSpace` option.
+      
+      For more information about the change, including how to restore the previous Unicode handler, see [this article](/dotnet/core/extensions/globalization-icu).
+
+      For more information about this API, see [Supplemental API remarks for CompareOptions](/dotnet/fundamentals/runtime-libraries/system-globalization-compareoptions).
+      ]]></format>
+    </remarks>
+    <example>
+      The following code example shows how each of the CompareOptions values affect string comparisons.
+      <format type="text/markdown">
+        <![CDATA[
+    :::code language="cpp" source="~/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/CPP/compareoptions_values.cpp" id="Snippet1":::
+    :::code language="csharp" source="~/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_values.cs" interactive="try-dotnet" id="Snippet1":::
+    :::code language="fsharp" source="~/snippets/fsharp/System.Globalization/compareoptions_values.fs" id="Snippet1":::
+    :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.Values/VB/compareoptions_values.vb" id="Snippet1":::
+        ]]>
+      </format>
+    </example>
     <example>
       The following code example shows how sorting with StringSort differs from sorting without StringSort.
-      <format type="text/markdown"><![CDATA[
-        :::code language="cpp" source="~/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp" id="Snippet1":::
-        :::code language="csharp" source="~/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs" interactive="try-dotnet" id="Snippet1":::
-        :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb" id="Snippet1":::
-      ]]></format></example>
+      <format type="text/markdown">
+        <![CDATA[
+    :::code language="cpp" source="~/snippets/cpp/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/CPP/compareoptions_stringsort.cpp" id="Snippet2":::
+    :::code language="csharp" source="~/snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs" interactive="try-dotnet" id="Snippet2":::
+    :::code language="fsharp" source="~/snippets/fsharp/System.Globalization/compareoptions_stringsort.fs" id="Snippet2":::
+    :::code language="vb" source="~/snippets/visualbasic/VS_Snippets_CLR_System/system.Globalization.CompareOptions.StringSort/VB/compareoptions_stringsort.vb" id="Snippet2":::
+        ]]>
+      </format>
+    </example>
     <related type="Article" href="/dotnet/standard/base-types/basic-string-operations">Basic String Operations in .NET</related>
   </Docs>
   <Members>
@@ -121,7 +150,7 @@
       </ReturnValue>
       <MemberValue>1</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must ignore case.</summary>
+        <summary>Indicates that the string comparison ignores case differences.</summary>
       </Docs>
     </Member>
     <Member MemberName="IgnoreKanaType">
@@ -165,7 +194,7 @@
       </ReturnValue>
       <MemberValue>8</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must ignore the Kana type. Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". A phonetic sound can be expressed in both hiragana and katakana. If this value is selected, the hiragana character for one sound is considered equal to the katakana character for the same sound.</summary>
+        <summary>Indicates that the string comparison ignores the Kana type. Kana type refers to Japanese Hiragana and Katakana characters, which represent phonetic sounds. Hiragana is used for native Japanese words, while Katakana is used for loanwords and foreign names. With this option, Hiragana and Katakana characters representing the same sound are considered equal.</summary>
       </Docs>
     </Member>
     <Member MemberName="IgnoreNonSpace">
@@ -209,7 +238,7 @@
       </ReturnValue>
       <MemberValue>2</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. The <see href="https://go.microsoft.com/fwlink/?linkid=37123">Unicode Standard</see> defines combining characters as characters that are combined with base characters to produce a new character. Nonspacing combining characters do not occupy a spacing position by themselves when rendered.</summary>
+        <summary>Indicates that the string comparison ignores non-spacing combining characters, such as diacritics. Non-spacing characters modify base characters without occupying their own space. The <see href="https://go.microsoft.com/fwlink/?linkid=37123">Unicode Standard</see> defines these characters.</summary>
       </Docs>
     </Member>
     <Member MemberName="IgnoreSymbols">
@@ -253,7 +282,7 @@
       </ReturnValue>
       <MemberValue>4</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must ignore symbols, such as white-space characters, punctuation, currency symbols, the percent sign, mathematical symbols, the ampersand, and so on.</summary>
+        <summary>Indicates that the string comparison ignores symbols, including whitespace, punctuation, currency symbols, the percent sign, mathematical symbols, the ampersand, and similar characters.</summary>
       </Docs>
     </Member>
     <Member MemberName="IgnoreWidth">
@@ -297,7 +326,7 @@
       </ReturnValue>
       <MemberValue>16</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must ignore the character width. For example, Japanese katakana characters can be written as full-width or half-width. If this value is selected, the katakana characters written as full-width are considered equal to the same characters written as half-width.</summary>
+        <summary>Indicates that the string comparison ignores character width. For example, full-width and half-width forms of Japanese Katakana characters are considered equal with this option.</summary>
       </Docs>
     </Member>
     <Member MemberName="None">
@@ -385,7 +414,7 @@
       </ReturnValue>
       <MemberValue>1073741824</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must use successive Unicode UTF-16 encoded values of the string (code unit by code unit comparison), leading to a fast comparison but one that is culture-insensitive. A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. This value cannot be combined with other <see cref="T:System.Globalization.CompareOptions" /> values and must be used alone.</summary>
+        <summary>Indicates that the string comparison uses the Unicode UTF-16 encoded values of the strings, comparing them code unit by code unit. This results in a fast, culture-insensitive comparison where strings are ordered based only on their binary values. This option cannot be combined with other <see cref="T:System.Globalization.CompareOptions" /> values and must be used alone.</summary>
       </Docs>
     </Member>
     <Member MemberName="OrdinalIgnoreCase">
@@ -428,7 +457,7 @@
       </ReturnValue>
       <MemberValue>268435456</MemberValue>
       <Docs>
-        <summary>String comparison must ignore case, then perform an ordinal comparison. This technique is equivalent to converting the string to uppercase using the invariant culture and then performing an ordinal comparison on the result.</summary>
+        <summary>Indicates that the string comparison ignores case and then performs an ordinal comparison. This is equivalent to converting both strings to uppercase using the invariant culture before performing the comparison.</summary>
       </Docs>
     </Member>
     <Member MemberName="StringSort">
@@ -472,7 +501,7 @@
       </ReturnValue>
       <MemberValue>536870912</MemberValue>
       <Docs>
-        <summary>Indicates that the string comparison must use the string sort algorithm. In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.</summary>
+        <summary>Indicates that the string comparison uses the string sort algorithm, where non-alphanumeric symbols (such as hyphens and apostrophes) are sorted before alphanumeric characters.</summary>
       </Docs>
     </Member>
   </Members>