Merge branch 'master' into publish-3781

Author: cxwtool

snippets/System.Text/Rune/csharp/CountLettersInSpan.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class CountLettersInSpan
+    {
+        public static void Run()
+        {
+            Console.WriteLine($"Incorrect code: { CountLettersBadExample(new Span<char>("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟".ToCharArray()))} letters in 𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+            Console.WriteLine($"  Correct code: { CountLetters(new Span<char>("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟".ToCharArray()))} letters in 𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+
+            // <SnippetBadExample>
+            // THE FOLLOWING METHOD SHOWS INCORRECT CODE.
+            // DO NOT DO THIS IN A PRODUCTION APPLICATION.
+            static int CountLettersBadExample(ReadOnlySpan<char> span)
+            {
+                int letterCount = 0;
+
+                foreach (char ch in span)
+                {
+                    if (char.IsLetter(ch))
+                    { letterCount++; }
+                }
+
+                return letterCount;
+            }
+            // </SnippetBadExample>
+
+            // <SnippetGoodExample>
+            static int CountLetters(ReadOnlySpan<char> span)
+            {
+                int letterCount = 0;
+
+                foreach (Rune rune in span.EnumerateRunes())
+                {
+                    if (Rune.IsLetter(rune))
+                    { letterCount++; }
+                }
+
+                return letterCount;
+            }
+            // </SnippetGoodExample>
+        }
+    }
+}

snippets/System.Text/Rune/csharp/CountLettersInString.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class CountLettersInString
+    {
+        public static void Run()
+        {
+            Console.WriteLine($"Incorrect code: { CountLettersBadExample("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟")} letters in 𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+            Console.WriteLine($"  Correct code: { CountLetters("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟")} letters in 𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+            //Console.WriteLine($"String '𐓏𐓘𐓻𐓘𐓻𐓟𐒻𐓟' consists entirely of letters: { StringConsistsEntirelyOfLetters("𐓏𐓘𐓻𐓘𐓻𐓟𐒻𐓟")}");
+
+            // <SnippetBadExample>
+            // THE FOLLOWING METHOD SHOWS INCORRECT CODE.
+            // DO NOT DO THIS IN A PRODUCTION APPLICATION.
+            int CountLettersBadExample(string s)
+            {
+                int letterCount = 0;
+
+                foreach (char ch in s)
+                {
+                    if (char.IsLetter(ch))
+                    { letterCount++; }
+                }
+
+                return letterCount;
+            }
+            // </SnippetBadExample>
+
+            // <SnippetGoodExample>
+            int CountLetters(string s)
+            {
+                int letterCount = 0;
+
+                foreach (Rune rune in s.EnumerateRunes())
+                {
+                    if (Rune.IsLetter(rune))
+                    { letterCount++; }
+                }
+
+                return letterCount;
+            }
+            // </SnippetGoodExample>
+        }
+    }
+}

snippets/System.Text/Rune/csharp/EncodeRune.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class EncodeRune
+    {
+        public static void Run()
+        {
+            Console.WriteLine("Converting ox emoji to UTF-16 and UTF-8");
+            Rune rune = Rune.GetRuneAt("🐂", 0);
+            Console.WriteLine($"Rune value: {rune.Value}");
+
+            // <SnippetUtf16CharArray>
+            char[] chars = new char[rune.Utf16SequenceLength];
+            int numCharsWritten = rune.EncodeToUtf16(chars);
+            // </SnippetUtf16CharArray>
+
+            Console.WriteLine($"Number of chars: {numCharsWritten}");
+
+            // <SnippetUtf16String>
+            string theString = rune.ToString();
+            // </SnippetUtf16String>
+
+            // <SnippetUtf8ByteArray>
+            byte[] bytes = new byte[rune.Utf8SequenceLength];
+            int numBytesWritten = rune.EncodeToUtf8(bytes);
+            // </SnippetUtf8ByteArray>
+
+            Console.WriteLine($"Number of UTF-8 bytes: {numBytesWritten}");
+        }
+    }
+}

snippets/System.Text/Rune/csharp/FindFirstLetter.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class FindFirstLetter
+    {
+        public static void Run()
+        {
+            Console.WriteLine($"Index of first capital letter of Latin alphabet in \"𐓏𐓘𐓻𐓘𐓻𐓟F𐒻𐓟\": { GetIndexOfFirstAToZ("𐓏𐓘𐓻𐓘𐓻𐓟F𐒻𐓟")}");
+
+            // <SnippetExample>
+            int GetIndexOfFirstAToZ(string s)
+            {
+                for (int i = 0; i < s.Length; i++)
+                {
+                    char thisChar = s[i];
+                    if ('A' <= thisChar && thisChar <= 'Z')
+                    {
+                        return i; // found a match
+                    }
+                }
+
+                return -1; // didn't find 'A' - 'Z' in the input string
+            }
+            // </SnippetExample>
+        }
+    }
+}

snippets/System.Text/Rune/csharp/InstantiateRunes.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public class InstantiateRunes
+    {
+        public static void Run()
+        {
+            // <SnippetCodePoint>
+            Rune a = new Rune(0x0061); // LATIN SMALL LETTER A
+            Rune b = new Rune(0x10421); // DESERET CAPITAL LETTER ER 
+            // </SnippetCodePoint>
+
+            // <SnippetChar>
+            Rune c = new Rune('a');
+            // </SnippetChar>
+
+            // <SnippetSurrogate>
+            Rune d = new Rune('\ud83d', '\udd2e'); // U+1F52E CRYSTAL BALL
+            // </SnippetSurrogate>
+
+            Console.WriteLine($"Rune a: {a}");
+            Console.WriteLine($"Rune b: {b}");
+            Console.WriteLine($"Rune c: {c}");
+            Console.WriteLine($"Rune d: {d}");
+            Console.WriteLine($"Rune d code point: {d.Value}");
+
+            // <SnippetValue>
+            Rune rune = new Rune('\ud83d', '\udd2e'); // U+1F52E CRYSTAL BALL
+            int codePoint = rune.Value; // = 128302 decimal (= 0x1F52E)
+            // </SnippetValue>
+
+        }
+    }
+}

snippets/System.Text/Rune/csharp/Program.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Buffers;
+using System.Text;
+using System.Linq;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+
+namespace RuneSamples
+{
+    partial class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("\n----- Count letters in string");
+            CountLettersInString.Run();
+
+            Console.WriteLine("\n----- Count letters in span");
+            CountLettersInSpan.Run();
+
+            Console.WriteLine("\n----- Handle surrogates");
+            WorkWithSurrogates.Run();
+
+            Console.WriteLine("\n----- Find first letter");
+            FindFirstLetter.Run();
+
+            Console.WriteLine("\n----- Split string  on char");
+            SplitStringOnChar.Run();
+
+            Console.WriteLine("\n----- Instantiate Runes");
+            InstantiateRunes.Run();
+
+            Console.WriteLine("\n----- Trim letters and nondigits");
+            TrimNonLettersAndNonDigits.Run();
+
+            Console.WriteLine("\n----- Encode a Rune");
+            EncodeRune.Run();
+        }
+    }
+}

snippets/System.Text/Rune/csharp/RuneSamples.csproj

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

snippets/System.Text/Rune/csharp/SplitStringOnChar.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class SplitStringOnChar
+    {
+        public static void Run()
+        {
+            // <SnippetExample>
+            string inputString = "🐂, 🐄, 🐆";
+            string[] splitOnSpace = inputString.Split(' ');
+            string[] splitOnComma = inputString.Split(',');
+            // </SnippetExample>
+
+            Console.WriteLine($"Splitting string {inputString} on space");
+            Array.ForEach(splitOnSpace, s => Console.WriteLine(s));
+
+            Console.WriteLine($"Splitting string {inputString} on comma");
+            Array.ForEach(splitOnComma, s => Console.WriteLine(s));
+        }
+    }
+}

snippets/System.Text/Rune/csharp/TrimNonLettersAndNonDigits.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    class TrimNonLettersAndNonDigits
+    {
+        public static void Run()
+        {
+            char[] s = "!Hello!".ToCharArray();
+            ReadOnlySpan<char> span = new ReadOnlySpan<char>(s);
+            Console.WriteLine(span.ToString());
+            ReadOnlySpan<char> newSpan = TrimNonLettersAndNonDigits(span);
+            Console.WriteLine(newSpan.ToString());
+
+            // <SnippetExample>
+            static ReadOnlySpan<char> TrimNonLettersAndNonDigits(ReadOnlySpan<char> span)
+            {
+                // First, trim from the front.
+                // If any Rune can't be decoded
+                // (return value is anything other than "Done"),
+                // or if the Rune is a letter or digit, 
+                // stop trimming from the front and
+                // instead work from the end.
+                while (Rune.DecodeFromUtf16(span, out Rune rune, out int charsConsumed) == OperationStatus.Done)
+                {
+                    if (Rune.IsLetterOrDigit(rune))
+                    { break; }
+                    span = span[charsConsumed..];
+                }
+
+                // Next, trim from the end. 
+                // If any Rune can't be decoded, 
+                // or if the Rune is a letter or digit,
+                // break from the loop, and we're finished.
+                while (Rune.DecodeLastFromUtf16(span, out Rune rune, out int charsConsumed) == OperationStatus.Done)
+                {
+                    if (Rune.IsLetterOrDigit(rune))
+                    { break; }
+                    span = span[..^charsConsumed];
+                }
+
+                return span;
+            }
+            // <SnippetExample>
+        }
+    }
+}

snippets/System.Text/Rune/csharp/WorkWithSurrogates.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace RuneSamples
+{
+    public static class WorkWithSurrogates
+    {
+        public static void Run()
+        {
+            ProcessStringUseChar("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+            ProcessStringUseRune("𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟");
+
+            // <SnippetUseChar>
+            static void ProcessStringUseChar(string s)
+            {
+                Console.WriteLine("Using char");
+
+                for (int i = 0; i < s.Length; i++)
+                {
+                    if (!char.IsSurrogate(s[i]))
+                    {
+                        Console.WriteLine($"Code point: {(int)(s[i])}");
+                    }
+                    else if (i + 1 < s.Length && char.IsSurrogatePair(s[i], s[i + 1]))
+                    {
+                        int codePoint = char.ConvertToUtf32(s[i], s[i + 1]);
+                        Console.WriteLine($"Code point: {codePoint}");
+                        i++; // so that when the loop iterates it's actually +2
+                    }
+                    else
+                    {
+                        throw new Exception("String was not well-formed UTF-16.");
+                    }
+                }
+            }
+            // </SnippetUseChar>
+
+            // <SnippetUseRune>
+            static void ProcessStringUseRune(string s)
+            {
+                Console.WriteLine("Using Rune");
+
+                for (int i = 0; i < s.Length;)
+                {
+                    if (!Rune.TryGetRuneAt(s, i, out Rune rune))
+                    {
+                        throw new Exception("String was not well-formed UTF-16.");
+                    }
+
+                    Console.WriteLine($"Code point: {rune.Value}");
+                    i += rune.Utf16SequenceLength; // increment the iterator by the number of chars in this Rune
+                }
+            }
+            // </SnippetUseRune>
+
+        }
+    }
+}