只讀成員

        private struct Point
        {
            public Point(double x, double y)
            {
                X = x;
                Y = y;
            }

            private double X { get; set; }
            private double Y { get; set; }
            private readonly double Distance => Math.Sqrt(X * X + Y * Y);

            public override readonly string ToString() =>
                $"({X}, {Y}) is {Distance} from the origin";
        }

使用readonly修飾tostring方法，表示它不可修改

默認介面方法

        /// <summary>
        /// 默認介面方法
        /// </summary>
        private interface IWork
        {
            public void Work()
            {
                Console.WriteLine("Work");
            }
        }

現在可以在介面中定義默認的方法，而不是只能申明void Work();

更多的模式匹配

使用switch運算式的模式匹配

            public enum Rainbow
            {
                Red,
                Orange,
                Yellow,
                Green,
                Blue,
                Indigo,
                Violet
            }

            //switch運算式
            public static Color FromRainbow(Rainbow colorBand) =>
                colorBand switch
                {
                    Rainbow.Red => Color.Red,
                    Rainbow.Orange => Color.Orange,
                    Rainbow.Yellow => Color.Yellow,
                    Rainbow.Green => Color.Green,
                    Rainbow.Blue => Color.Blue,
                    Rainbow.Indigo => Color.Indigo,
                    Rainbow.Violet => Color.Violet,
                    _ => throw new ArgumentException(message: "invalid enum value", paramName: nameof(colorBand)),
                };

在變數后面使用switch關鍵字，同時將case:替換為=>，使用_替代default

屬性模式

            public static decimal ComputeSalesTax(Address location, decimal salePrice) =>
                location switch
                {
                    { State: "WA" } => salePrice * 0.06M,
                    { State: "MN" } => salePrice * 0.075M,
                    { State: "MI" } => salePrice * 0.05M,
                    // other cases removed for brevity...
                    _ => 0M
                };

            public struct Address
            {
                public string State { get; set; }
            }

對location變數的State屬性進行模式匹配

元組模式

            public static string RockPaperScissors(string first, string second)
                => (first, second) switch
                {
                    ("rock", "paper") => "rock is covered by paper. Paper wins.",
                    ("rock", "scissors") => "rock breaks scissors. Rock wins.",
                    ("paper", "rock") => "paper covers rock. Paper wins.",
                    ("paper", "scissors") => "paper is cut by scissors. Scissors wins.",
                    ("scissors", "rock") => "scissors is broken by rock. Rock wins.",
                    ("scissors", "paper") => "scissors cuts paper. Scissors wins.",
                    (_, _) => "tie"
                };

位置模式

            //位置模式，使用解構將屬性解構的離散變數，如果可以訪問 Deconstruct 方法，就可以使用位置模式 檢查物件的屬性并將這些屬性用于模式
            public class XPoint
            {
                public int X { get; set; }
                public int Y { get; set; }

                public void Deconstruct(out int x, out int y)
                {
                    x = X;
                    y = Y;
                }
            }

            public int GetNumber(XPoint point) => point switch
            {
                (0, 0) => 0,
                var (x, y) when x > 0 && y > 0 => 1,
                var (x, y) when x < 0 && y > 0 => 2,
                var (x, y) when x < 0 && y < 0 => 3,
                var (x, y) when x > 0 && y < 0 => 4,
                var (_, _) => -1,
                _ => -2
            };

 using申明

        /// <summary>
        /// using 宣告，using 運算式的運算元可以實作 IDisposable 或 IAsyncDisposable
        /// </summary>
        public void UsingStatement()
        {
            using var file = new System.IO.StreamWriter("WriteLines2.txt");
        }

可以對異步可釋放型別使用using關鍵字進行釋放

靜態本地函式

        /// <summary>
        /// 靜態本地函式，在本地函式中使用static關鍵字
        /// </summary>
        private class StaticLocalFunction
        {
            int N()
            {
                int y;
                LocalFunction();
                return y;

                void LocalFunction() => y = 0;
            }

            int M()
            {
                int y = 5;
                int x = 7;
                return Add(x, y);

                static int Add(int left, int right) => left + right;
            }
        }

可以在本地函式申明中使用static關鍵字

索引和范圍

        private class IndexRange
        {
            string[] words = new string[]
            {
                // index from start    index from end
                "The",      // 0                   ^9
                "quick",    // 1                   ^8
                "brown",    // 2                   ^7
                "fox",      // 3                   ^6
                "jumped",   // 4                   ^5
                "over",     // 5                   ^4
                "the",      // 6                   ^3
                "lazy",     // 7                   ^2
                "dog"       // 8                   ^1
            };              // 9 (or words.Length) ^0

            void Test()
            {
                //>=index_1 && < index_4
                var quickBrownFox = words[1..4];
                var lazyDog = words[^2..^0];
            }
        }

null合并賦值

        /// <summary>
        /// null合并賦值
        /// </summary>
        private void NullMergeAssignment()
        {
            List<int> list = new List<int>();
            List<int> numbers = list.Where(x => x > 20).ToList();
            
            numbers ??= new List<int>();
        }

當左運算元計算為 null 時，將??= 右運算元的值分配給左運算元

異步流

public static class AsyncStream
        {
            public static async System.Collections.Generic.IAsyncEnumerable<int> GenerateSequence()
            {
                for (int i = 0; i < 20; i++)
                {
                    await Task.Delay(100);
                    yield return i;
                }
            }


            public static async void GetNumbers()
            {
                var c = CSharp8.AsyncStream.GenerateSequence();
                await foreach (var number in c)
                {
                    Console.WriteLine(number);
                }
            }
        }

GetNumbers使用await等待回傳結果，每隔100ms會輸出i++的值

標籤：C#

上一篇：C#一個IM系統簡單總結

下一篇：C#使用FFmpeg的總結