System.Globalization.CompareOptions update

snippets/csharp/System.Globalization/CompareOptions/Overview/Program.cs

@@ -0,0 +1,2 @@
+CompareOptionsExample.Run();
+StringSort.Run();

snippets/csharp/System.Globalization/CompareOptions/Overview/Project.csproj

@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <OutputType>Library</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
   </PropertyGroup>
 
 </Project>

snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_stringsort.cs

@@ -1,67 +1,51 @@
-// The following code example shows how sorting with CompareOptions.StringSort differs from sorting without CompareOptions.StringSort.
-
-// <snippet1>
-using System;
-using System.Collections;
+using System;
+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 Run()
+    {
+        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.
+        CompareInfo 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 is the following:
 
-Initially,
+Before sorting:
 cant
 bill's
 coop
@@ -72,7 +56,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 +77,4 @@ This code produces the following output.
 co-op
 con
 coop
-
 */
-// </snippet1>

snippets/csharp/System.Globalization/CompareOptions/Overview/compareoptions_values.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Globalization;
+
+public class CompareOptionsExample
+{
+    public static void Run()
+    {
+        // 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 is 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.
+*/

snippets/fsharp/System.Globalization/Project.fsproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Library</OutputType>
+    <TargetFramework>net9.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Include="compareoptions_stringsort.fs" />
+    <Compile Include="compareoptions_values.fs" />
+  </ItemGroup>
+
+</Project>