Effective C# on Wenrong Nexus

Effective C# 做法 22-23

Sun, 13 Oct 2024 03:11:00 +0800

做法 22

支援泛型的共變數與反變數

1. 這個 out 也是共變數?

public static bool TryParse (string? s, IFormatProvider? provider, out int result);

方法參數中的 out 關鍵字：在 TryParse 方法中的 out int result 是一個輸出參數。這個 out 關鍵字的作用是：

表示這個參數是一個輸出參數。
方法必須在返回前為這個參數賦值。
呼叫方法時，不需要初始化這個參數，但必須在呼叫後使用它。

在泛型接口或委託定義中使用的 out 關鍵字表示協變。例如：

interface IEnumerable<out T> { ... }

這裡的 out 表示：

T 只能用作輸出（返回值），不能用作輸入（參數）。
允許將更具體（派生）類型的集合賦值給更一般（基類）類型的集合變量。

區別總結：

用途不同：
- 方法參數的 out：用於指定輸出參數。
- 泛型的 out：用於指定類型參數的協變性。
位置不同：
- 方法參數的 out：用在方法參數列表中。
- 泛型的 out：用在泛型類型參數定義中。
功能不同：
- 方法參數的 out：確保方法將值賦給參數。
- 泛型的 out：允許更靈活的類型轉換和賦值。
編譯時行為： - 方法參數的 out：編譯器確保方法內部對參數賦值。 - 泛型的 out：編譯器允許特定的類型轉換。所以， TryParse 方法中的 out 不是用於協變的，而是一個輸出參數標記。這兩種 out 雖然使用相同的關鍵字，但在 C# 中代表完全不同的概念。

簡單解釋共變數與反變數

共變數（Covariance）

定義：允許使用比原本指定的類別更具體（更繼承）的類型。關鍵字：out 應用：通常用於返回類別或只讀泛型介面。

IEnumerable<string> strings = new List<string>();
IEnumerable<object> objects = strings; // 合法，因為 IEnumerable<T> 是共變數

反變數（Contravariance）

定義：允許使用比原本指定的類別更一般（更基礎）的類別。關鍵字：in 應用：通常用於參數類別或只寫泛型介面。

Action<object> objectAction = (object obj) => Console.WriteLine(obj);
Action<string> stringAction = objectAction; // 合法，因為 Action<T> 是反變數

詳細解釋和更多例子

共變數例子：

public class Animal { }
public class Dog : Animal { }

IEnumerable<Dog> dogs = new List<Dog>();
IEnumerable<Animal> animals = dogs; // 共變數允許這種賦值

// 使用場景
void ProcessAnimals(IEnumerable<Animal> animals) { ... }
ProcessAnimals(dogs); // 可以傳入 Dog 的集合

反變數例子：

public interface IComparer<in T>
{
    int Compare(T x, T y);
}

IComparer<Animal> animalComparer = new AnimalComparer();
IComparer<Dog> dogComparer = animalComparer; // 反變數允許這種賦值

// 使用場景
class AnimalComparer : IComparer<Animal>
{
    public int Compare(Animal x, Animal y) { ... }
}

List<Dog> dogs = new List<Dog>();
dogs.Sort(dogComparer); // 可以使用 Animal 的比較器來比較 Dog

共變數和反變數的組合

public interface IConverter<in TInput, out TOutput>
{
    TOutput Convert(TInput input);
}

IConverter<Animal, Dog> animalToDog = new AnimalToDogConverter();
IConverter<Dog, Animal> dogToAnimal = animalToDog; // 合法

限制和注意事項

共變數和反變數只適用於引用類型，不適用於值類型。
只能用於介面和委託的定義，不能用於類別。
一個類別參數不能同時標記為共變數和反變數。
共變數類別參數不能用作方法參數，反變數類別參數不能用作方法返回類型。

實際應用

LINQ: LINQ 大量使用共變數和反變數來提高其靈活性。
事件處理：允許更靈活地處理不同類別的事件。
依賴注入：在依賴注入框架中常用，提高容器的靈活性。

性能考慮共變數和反變數主要是編譯時特性，不會對運行時性能產生顯著影響。總結：共變數和反變數強大的特性，能夠提高程式碼的靈活性和可重用性。共變數（out）允許使用更具體的類型，而反變數（in）允許使用更一般的類型。正確理解和使用這些概念可以幫助設計更靈活、更強大的 API 和框架。

static void Main(string[] args)
{
    Dog dog = new Dog("doggy");
    IOutDog<Dog> dogProvider = new DogProvider(dog);
    IOutDog<Animal> animalProvider = dogProvider;
    Console.WriteLine($"{animalProvider.Value.GetName()}, {dogProvider.Value.GetName()}");

    // 使用基本的 AnimalSetter
    IInDog<Animal> animalSetter = new AnimalSetter();
    animalSetter.SetValue(new Animal());
    animalSetter.SetValue(new Dog()); // 這也是有效的，因為 Dog 是 Animal 的子類

    // 使用 DogSetter，展示反變數
    // IInDog<Animal> dogSetterAsAnimal = (IInDog<Animal>)new DogSetter();
    // dogSetterAsAnimal.SetValue(new Animal()); // 注意：這在運行時可能會拋出異常，因為實際的實現期望一個 Dog

    // 使用泛型實現
    IInDog<Dog> dogSetter = new GenericAnimalSetter<Dog>();
    dogSetter.SetValue(new Dog());

    IConverter<Animal, Dog> animalToDog = new AnimalToDogConverter();
    IConverter<Dog, Animal> dogToAnimal = animalToDog; // 合法
}

public class Animal
{
    private readonly string name;
    public Animal(string name = "") => this.name = name;
    public virtual string GetName() => name;
}

public class Dog : Animal
{
    public Dog(string name = "") : base(name) { }
    public override string GetName() => $"Dog {base.GetName()}";
}

public interface IOutDog<out T> where T : Animal
{
    T Value { get; }
}

public class DogProvider : IOutDog<Dog>
{
    public Dog Value { get; set; }
    public DogProvider(Dog value) => Value = value;
}

public interface IInDog<in T> where T : Animal
{
    void SetValue(T value);
}

public class AnimalSetter : IInDog<Animal>
{
    private Animal value;
    public void SetValue(Animal value) => this.value = value;
}

public class DogSetter : IInDog<Dog>
{
    private Dog value;
    public void SetValue(Dog value) => this.value = value;
}

public class GenericAnimalSetter<T> : IInDog<T> where T : Animal
{
    private T value;
    public void SetValue(T value) => this.value = value;
}

public interface IConverter<in TInput, out TOutput>
{
    TOutput Convert(TInput input);
}

public class AnimalToDogConverter : IConverter<Animal, Dog>
{
    public Dog Convert(Animal input) => new Dog(input.GetName());
}

心得

如果編譯器告訴你錯了就要小心是不是有什麼地方搞錯了做 cast 時要了解自己在做什麼不然能編譯成功也會在 runtime 時炸掉

做法 23

使用 delegate 定義型別參數的方法約束

// double[] xValues = { 0,1,2,3,4,5,6,7,8,9,
//                 0,1,2,3,4,5,6,7,8,9,};
// double[] yValues = { 0,1,2,3,4,5,6,7,8,9,
//                 0,1,2,3,4,5,6,7,8,9,};
// List<Point> values = new List<Point>(Zip(xValues, yValues, (x, y) => new Point(x, y)));
private static IEnumerable<TOutput> Zip<T1, T2, TOutput>(IEnumerable<T1> left, IEnumerable<T2> right, Func<T1, T2, TOutput> generator)
{
    IEnumerator<T1> leftEnumerator = left.GetEnumerator();
    IEnumerator<T2> rightEnumerator = right.GetEnumerator();
    while (leftEnumerator.MoveNext() && rightEnumerator.MoveNext())
    {
        yield return generator(leftEnumerator.Current, rightEnumerator.Current);
    }

    leftEnumerator.Dispose();
    rightEnumerator.Dispose();
}

private class Point
{
    public double X { get; set; }
    public double Y { get; set; }

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

    public Point(TextReader textReader) { }
}

/// InputCollection<Point> points = new InputCollection<Point>((InputStream) => new Point(InputStream));
public delegate T CreateFromStream<T>(System.IO.TextReader textReader);
public class InputCollection<T>
{
    private List<T> thingsRead = new List<T>();

    private readonly CreateFromStream<T> readFunc;
    public InputCollection(CreateFromStream<T> readFunc)
    {
        this.readFunc = readFunc;
    }

    public void ReadFromStream(System.IO.TextReader textReader)
    {
        thingsRead.Add(readFunc(textReader));
    }
    public IEnumerable<T> Values => thingsRead;
}

做法 23 心得

可以利用這種方式，讓不同類別擁有相同介面，使用相同的方法，讓程式彈性變高

// ForeachIn(items,(item, i) =>
// {
//      item.SetIcon(icon[i]);
// });
// ForeachIn(items,(item, i) =>
// {
//      item.SetPosition(positions[i]);
// });
public void ForeachIn<T>(T[] arr, Action<T, int> action)
{
    for (int i = 0; i < arr.Length; i++)
    {
        action(arr[i], i);
    }
}

Effective C# 做法 20-21

Mon, 07 Oct 2024 00:57:47 +0800

做法 20

以 IComparable<T> 與 IComparer<T> 實作排序關係

實作

public struct Customer : IComparable<Customer>, IComparable
{
    private readonly string name;
    private double revenue;

    public Customer(string name)
    {
        this.name = name;
    }

    public int CompareTo(Customer other)
    {
        return name.CompareTo(other.name);
    }

    int IComparable.CompareTo(object? obj)
    {
        if (obj is Customer other)
        {
            return this.CompareTo(other);
        }
        throw new ArgumentException("Argument must be a Customer", nameof(obj));
    }

    public static bool operator <(Customer left, Customer right) => left.CompareTo(right) < 0;
    public static bool operator <=(Customer left, Customer right) => left.CompareTo(right) <= 0;
    public static bool operator >(Customer left, Customer right) => left.CompareTo(right) > 0;
    public static bool operator >=(Customer left, Customer right) => left.CompareTo(right) >= 0;

    private static Lazy<RevenueComparer> revComp = new Lazy<RevenueComparer>(() => new());

    public static IComparer<Customer> RevenueCompare => revComp.Value;
    public static Comparison<Customer> CompareByRevenue => (left, right) => left.revenue.CompareTo(right.revenue);

    private class RevenueComparer : IComparer<Customer>
    {
        public int Compare(Customer left, Customer right)
        {
            return left.revenue.CompareTo(right.revenue);
        }
    }
}

使用方式

static void Main(string[] args)
{
    // 創建一些 Customer 實例
    var customers = new List<Customer>
    {
    new Customer("Alice",1000) ,
    new Customer("Bob",1500) ,
    new Customer("Charlie",1200),
    new Customer("David",800)
    };

    // 1. 使用默認比較（按名稱）
    customers.Sort();
    Console.WriteLine("Sorted by name:");
    // Alice: 1000
    // Bob: 1500
    // Charlie: 1200
    // David: 800
    PrintCustomers(customers);

    // 2. 使用運算符比較
    var alice = new Customer("Alice");
    var bob = new Customer("Bob");
    // Alice < Bob: True
    // Alice <= Bob: True
    // Alice > Bob: False
    // Alice >= Bob: False
    Console.WriteLine($"Alice < Bob: {alice < bob}");
    Console.WriteLine($"Alice <= Bob: {alice <= bob}");
    Console.WriteLine($"Alice > Bob: {alice > bob}");
    Console.WriteLine($"Alice >= Bob: {alice >= bob}");

    // 3. 使用 RevenueCompare
    customers.Sort(Customer.RevenueCompare);
    Console.WriteLine("\nSorted by revenue (using RevenueCompare):");
    // David: 800
    // Alice: 1000
    // Charlie: 1200
    // Bob: 1500
    PrintCustomers(customers);

    // 4. 使用 CompareByRevenue
    customers.Sort(Customer.CompareByRevenue);
    Console.WriteLine("\nSorted by revenue (using CompareByRevenue):");
    // David: 800
    // Alice: 1000
    // Charlie: 1200
    // Bob: 1500
    PrintCustomers(customers);

    // 5. 使用 LINQ 排序
    var sortedByName = customers.OrderBy(c => c);
    Console.WriteLine("\nSorted by name (using LINQ):");
    // lice: 1000
    // Bob: 1500
    // Charlie: 1200
    // David: 800

    PrintCustomers(sortedByName);

    var sortedByRevenue = customers.OrderBy(c => c, Customer.RevenueCompare);
    Console.WriteLine("\nSorted by revenue (using LINQ and RevenueCompare):");
    // David: 800
    // Alice: 1000
    // Charlie: 1200
    // Bob: 1500
    PrintCustomers(sortedByRevenue);
}

static void PrintCustomers(IEnumerable<Customer> customers)
{
    foreach (var customer in customers)
    {
        Console.WriteLine($"{customer.ToString()}");
    }
}

做法 21

建構支援 Disposable 型別參數的泛型類別

如果你建構的泛型類別的型別參數描述的任何型別實例，你必須考慮到這些型別可能有實作 IDisposable。你必須防衛性的撰寫程式並確保這些物件離開範圍後不會洩漏資源。

public interface IEngine
{
    void DoWork();
}

private class Engine : IEngine
{
    public void DoWork()
    {
        Console.WriteLine("Hello World!");
    }
}

public class EngineDriver1<T> where T : IEngine, new()
{
    public void GetThingsDone()
    {
        T engine = new T();
        using (engine as IDisposable)
        {
            engine.DoWork();
        }
    }
}

// using (var x = new EngineDriver2<Engine>())
// {
//     x.GetThingsDone();
// }
public class EngineDriver2<T> : IDisposable where T : IEngine, new()
{
    private Lazy<T> engine = new Lazy<T>(() => new T());

    public void GetThingsDone()
    {
        using (engine.Value as IDisposable)
        {
            engine.Value.DoWork();
        }
    }

    public void Dispose()
    {
        if (engine.IsValueCreated)
        {
            var resource = engine.Value as IDisposable;
            resource?.Dispose();
        }
    }
}

public class EngineDriver3<T> where T : IEngine
{
    private T engine;

    public EngineDriver3(T engine)
    {
        this.engine = engine;
    }

    public void GetThingsDone()
    {
        engine.DoWork();
    }
}

若 T 沒有實作 IDisposable ，則此區域變數的值為 null

如果 T（在這個例子中是 Engine）沒有實作 IDisposable 接口，那麼 engine as IDisposable 的結果就會是 null。這個 null 值並不會導致異常或錯誤。 using 語句被設計為可以安全地處理 null 值。當 disposable 為 null 時， using 語句簡單地不執行任何釋放資源的操作。這就是為什麼即使 Engine 類沒有實作 IDisposable，代碼仍然可以正常運行。 using 語句在這種情況下實際上不會做任何特殊的事情，代碼會繼續執行 engine.DoWork()。

Effective C# 做法 18-19

Sat, 28 Sep 2024 01:48:09 +0800

做法 18

使用泛型 & 定義最少與足夠的約束

使用泛型

為什麼這三組執行期都共用相同的程式

List<string> strings = new List<string>();
List<Stream> streams=newList<Stream>();
List<MyClassType> myClassTypes=newList<MyClassType>();

JIT 編譯器識別出這些類型都是引用類型，因此可以使用相同的機器代碼。

為什麼這三組有不同的機械碼?

List<double> doubles = new List<double>();
List<int> ints = new List<int>();
List<MyStruct> myStructs = new List<MyStruct>();

CLR 為每種值類型參數生成特定的代碼，以優化性能和類型安全性。

1. 泛型類別使用 default()

在講到泛型類別使用 default() 的方法寫時，需要把 T 改成 T?，因為 Value Type 的 Default = 0，而 Reference Type 是沒有 Default，回傳的結果會是 null。需要告訴使用者可能會回傳 null 建議還是要回傳 T?，也提高程式碼閱讀性。

public static T? FirstOrDefault<T>(this IEnumerable<T> source, Predicate<T> predicate)
{
    foreach (var item in source)
    {
        if (predicate(item))
            return item;
    }
    return default;
}

2. 少了 null 確認

原本課本的判斷，少了 null 確認

public static bool AreEqual(T left, T right) =>    left.Equals(right);

可以改這種寫法，多了做法 03 的寫法，用來判斷 null。

public static bool AreEqual<T>(T left, T right)
{
    if (left is T qu)
    {
        return qu.Equals(right);
    }
    return right == null;
}

3. 使用 T?

使用 T? 明確表示 factory 方法可能返回 null。這增加了代碼的可讀性和意圖的清晰度。

MyClass obj1 = Factory(() => new MyClass { Name = "Object 1" });
Console.WriteLine(obj1.Name); // 輸出: Object 1

// 使用返回 null 的工廠方法
MyClass obj2 = Factory<MyClass>(() => null);
Console.WriteLine(obj2.Name); // 輸出: Default Name

public delegate T FactoryFunc<T>();

public static T Factory<T>(FactoryFunc<T?> factory) where T : new()
{
    T? resultVal = factory();
    if (resultVal == null)
    {
        resultVal = new T();
    }
    return resultVal;
}

4. 為什麼要盡量避免約束 new()、struct、class

new() 約束

優點：

保證類型有無參數構造函數。缺點：
限制了類型的靈活性，排除了沒有公共無參數構造函數的類型。
可能導致不必要的對象創建，影響性能。
難以進行單元測試，因為無法輕易模擬或替換對象。

struct 約束

優點：

確保類型是值類型。

缺點：

過度限制了類型，排除了可能同樣適用的引用類型。
可能導致不必要的裝箱和拆箱操作。
限制了代碼的重用性和靈活性。

class 約束

優點：

確保類型是引用類型。

缺點：

排除了可能同樣適用的值類型。
限制了代碼的通用性。
可能導致不必要的堆分配。

一般建議：

優先使用接口約束：接口約束更靈活，能同時適用於值類型和引用類型。例如：
```
public class GenericClass<T> where T : IComparable<T>
```
基於行為而非類型種類進行約束：關注類型能做什麼，而不是類型是什麼。
考慮使用泛型約束的組合：在必要時，可以組合多個接口約束來精確定義所需的功能。
使用 default 關鍵字：代替 new()，使用 default(T) 來獲取類型的默認值。
設計靈活的 API：避免過度約束，以增加代碼的重用性和適應性。
考慮性能影響：某些約束（如 struct）可能導致意外的性能問題。

總結

避免使用 new()、 struct 和 class 約束主要是為了提高代碼的靈活性、可重用性和可測試性。通過使用更通用的約束（如接口），我們可以編寫出更加靈活和強大的泛型代碼，適用於更廣泛的類型。

做法 19

使用執行期型別檢查特化泛型演算法實作

public sealed class ReverseEnumerable<T> : IEnumerable<T>
{
    private class ReverseEnumerator : IEnumerator<T>
    {
        private int currentIndex = 0;
        private IList<T> collection;

        public T Current => collection[currentIndex];

        object IEnumerator.Current => Current;
        public ReverseEnumerator(List<T> collection) : this(collection.ToArray())
        {
        }
        public ReverseEnumerator(IList<T> collection)
        {
            currentIndex = collection.Count;
            this.collection = collection;
        }

        public void Dispose()
        {

        }

        public bool MoveNext()
        {
            return --currentIndex >= 0;
        }

        public void Reset()
        {
            currentIndex = collection.Count;
        }
    }

    private sealed class ReverseStringEnumerator : IEnumerator<char>
    {
        private string sourceSequence;
        private int currentIndex;

        public ReverseStringEnumerator(string source)
        {
            sourceSequence = source;
            currentIndex = source.Length;
        }

        public char Current => sourceSequence[currentIndex];

        object IEnumerator.Current => sourceSequence[currentIndex];

        public void Dispose() { }

        public bool MoveNext()
        {
            return --currentIndex >= 0;
        }

        public void Reset()
        {
            currentIndex = sourceSequence.Length;
        }
    }

    private IEnumerable<T>? sourceSequence;
    private IList<T>? originalSequence;

    public ReverseEnumerable(IEnumerable<T> source)
    {
        if (source is ReverseEnumerable<T> reverseEnumerable)
            sourceSequence = reverseEnumerable;

        if (source is string str)
        {
            originalSequence = str.ToArray() as IList<T>;
        }
        else
        {
            originalSequence = source as IList<T>;
        }
    }

    public ReverseEnumerable(IList<T> source) : this((IEnumerable<T>)source)
    { }

    public IEnumerator<T> GetEnumerator()
    {
        if (sourceSequence is string str)
        {
            return new ReverseStringEnumerator(str) as IEnumerator<T>;
        }

        if (originalSequence == null)
        {
            if (sourceSequence is ICollection<T> source)
            {
                originalSequence = new List<T>(source.Count);
            }
            else
            {
                originalSequence = new List<T>(sourceSequence);
            }
        }

        return new ReverseEnumerator(originalSequence);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

使用方式

private static void StringEnumerable()
{
    string str = "Hello, World!";

    var reverseEnumerable = new ReverseEnumerable<char>(str);
    foreach (char c in reverseEnumerable)
    {
        Console.Write(c);
    }
    /// !dlroW ,olleH
    Console.WriteLine();
}

private static void ListEnumerable()
{
    List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7 };
    var reverseEnumerable = new ReverseEnumerable<int>(list);
    foreach (int i in reverseEnumerable)
    {
        Console.Write(i);
    }
    /// 76543210
    Console.WriteLine();
}

Effective C# 做法 16-17

Sun, 22 Sep 2024 22:17:41 +0800

做法 16

絕不在建構元中呼叫虛擬函式

本章節有提到 Static Code Analyzer 工具，可以利用這些工具避免建構子中呼叫虛擬函式。工具分別有

Visual Studio
JetBrains Rider
Visual Studio + ReSharper 針對 Unity 的 Static Code Analyzer 只能用這些工具
JetBrains Rider
Visual Studio + ReSharper
Unity + Roslyn

做法 17

`實作標準 Dispose 模式

Unmanaged 型別

sbyte、byte、short、ushort、int、uint、long、ulong、nint、nuint、char、float、double、decimal 或 bool
任何 enum 型別
任何指標型別
Tuple 其成員皆為非受控型別
任何只包含非受控型別欄位的使用者定義結構型別。

Unmanaged 資源

是否繼承 IDisposable
檢查類別文件
分析類別用途和功能
看原始碼
利用反射，查看有沒有 Finalizer，如 sadehandle

需要實現 IDisposable 的類別

有 Unmanaged 資源
包含 IDisposable 成員
大型物件或耗資源的類別，如大型資料庫、影片、音效等
長生命週期物件，如連線功能、控制器等
自訂義資源管理類別

不需要實現 IDisposable 的類別

純數據類資料
無狀態工具類
短生命週期的簡單物件
不管理任何資源的類別不是每的類別都蓄要繼承 IDisposable 。僅當你的類別管理 Unmanaged 資源或者包含實現 IDisposable 介面的成員，才考慮繼承 IDisposable。

1.除非你的類別直接持有 Unmanaged 資源，否則你不應該實作 finalizer

實作 Dispose 方法

Effective C# 做法 14-15

Sat, 14 Sep 2024 23:57:56 +0800

做法 14

減少重複的初始化邏輯

1. 建構子初始化程序讓一個建構子呼叫其他的建構子

public class MyClass
{
    private List<string> coll;
    private string name;

    public MyClass() : this(0, string.Empty) { }

    public MyClass(int count, string name)
    {
        coll = new List<string>(count);
        this.name = name;
    }
}

2. 選擇預設參數與

選擇預設參數與使用多個建構子多載之間需要權衡考量，建議是不超過 3 個，超過時可以考慮使用一個類別當初始化類別使用。一般來說應該偏好預設值而非多載建構子。

3. 繼承類別不能修改父類別中宣告為 readonly 的欄位

readonly 欄位只能在宣告時或在定義該欄位的類別建構子中賦值。

做法 15

避免建構不必要的物件

protected override void OnPaint(PaintEventArgs e)
{
    /// 劣
    using(Font myFont = new Font("Arial", 12.0f)){
        e.Graphics.DrawString("Hello, World!", myFont, Brushes.Black, 10, 10);
    }
}

推薦方式

private readonly Font myFont = new Font("Arial", 12.0f);

protected override void OnPaint(PaintEventArgs e)
{
    e.Graphics.DrawString("Hello, World!", myFont, Brushes.Black, 10, 10);
}

1. 區域變數的選擇

在區域變數是參考型別（實值類型就沒關係），且會在經常被呼叫的程序中使用時將它提升至成員變數。

2. string 不可變的原因

安全性：敏感資訊不會因此被修改。
執行緒安全：不可變性是天然的執行緒安全。
hash 一致：字典的 key 相同內容、相同的位址。
字串池：.NET 優化
性能優化：編譯器和運行可優化字串。
API 設計簡化

3.建構不可變的可變 builder 類別

可以參考設計模式中的建造者模式。

Effective C# 做法 11-13

Sat, 07 Sep 2024 13:54:06 +0800

做法 11

認識 .NET 資源管理

1. 簡易圖示記憶體區塊的關聯圖

2. 記憶體排列物件的放置位址

呼叫 GC 後，記憶體位置改變了，這就是記憶體回收的概念

3. 記憶體層代

層代 0

最新的層代而且包含存留較短的物件。大部分物件都會在層代 0 的記憶體回收，而且不會存留至下一個層代。記憶體回收從第 0 個層代開始。
層代 1

這個層代包含存留較短的物件，且當做較短與較長物件的緩衝區。層代 0 回收後，將壓縮可取得的物件，升階至層代 1。

層代 0 已滿時，記憶體會執行回收。如果層代 0 回收沒有足夠的記憶體，才會執行層代 1 回收，再執行層代 2 回收，層代 1 回收之後有存留的物件，會提升至層代 2。
層代 2

存留較長的物件。層代 2 回收存留的物件還是回留在層代 2。

最後結論就是，假如不在一開始就把物件釋放掉，最後存留至層代 1、2 時，要回收物件的時間就會越來越久，造成的記憶體效率不佳，所以要手動釋放掉物件。

記憶體回收的基本概念

4. 使用 Dispose 釋放資源，而不是 Finalizer

做法 12

偏好成員初始化程序而非指派陳述

為什麼 initobj 會導致 box、unbox？

initobj 指令用於將值類型的變量初始化為其默認值，因此 initobj 不會導致 boxing 或 unboxing。使用 initobj 時，是直接記憶體操作，不涉及對象的創建或類型的轉換。

推薦用法

public class MyClass
{
    private List<string> labels = new List<string>();
}

做法 13

對靜態類別成員進行適當的初始化

Singleton 初始化具有複雜的邏輯，可以在 static 建構子中寫。

public class MySingleton
{
    private static readonly MySingleton instance = new MySingleton();

    public static MySingleton Instance => instance;

    private MySingleton() { }
}

public class MySingleton2
{
    private static readonly MySingleton2 instance;

    static MySingleton2()
    {
        instance = new MySingleton2();
    }

    public static MySingleton2 Instance => instance;

    private MySingleton2() { }
}

Effective C# 做法 07-10

Wed, 28 Aug 2024 00:19:53 +0800

做法 07

以 delegate 表示 callback

可以利用 delegate 回傳 bool 當判斷或者是回傳類別等功能降低城市耦合。

List<int> numbers = Enumerable.Range(1, 10).ToList();
var oddNumbers = numbers.Find(x => x % 2 == 1);
var test = numbers.TrueForAll(x => x < 50);
numbers.RemoveAll(x => x % 2 == 0);
numbers.ForEach(x => Console.WriteLine(x));

public void LengthyOperation2(Func<bool> pred)
{
    bool bContinue = true;
    foreach (var cl in container)
    {
        cl.DoLengthyOperation();
        foreach (Func<bool> pr in pred.GetInvocationList())
                bContinue &= pr();

        if (!bContinue) return;
    }
}

做法 08

對事件叫用使用空條件運算子

推薦這樣寫

public void RaiseUpdate()
{
    counter++;
    Updated?.Invoke(this, counter);
}

做法 09

減少 boxing 與 unboxing

int i = 25;
object o = i; /// box
Console.WriteLine(o.ToString()); /// 25

object fp = 5;
object fo = fp;
int ip = (int)fo; /// unbox
Console.WriteLine(ip.ToString()); /// 5

實值類型可變轉換成 System.Object 或任何界面參考。這些轉換隱含的發生，使得尋找它們變得更為複雜。 boxing 與 unboxing 操作會在你預料之外的複製拷貝，這導致 bug。以多型方式處理實值類型也有效能成本。

參考類型轉換為 System.Object 或介面時的行為確實不同：

參考類型轉換:
- 參考類型本來就是從 System.Object 繼承的，所以轉換為 System.Object 或實現的介面時不需要 boxing。
- 這種轉換只是改變了引用的類型，不會創建新的對象或複製數據。
效能影響:
- 參考類型轉換為 System.Object 或介面基本上沒有額外的效能成本。
- 不會發生像實值類型那樣的額外記憶體分配或數據複製。
多態性:
- 參考類型本來就支持多態，不需要額外的轉換步驟。
潛在問題:
- 雖然參考類型不會遇到 boxing/unboxing 的問題，但可能會遇到其他問題，如意外的類型轉換或空引用。

做法 10

只對基底類別更新使用 new 修飾詞

public class MyClass
{
    public new void MagicMethod() { }
}

new 修飾詞必須小心使用。如果你不假思索的套用它，你會在你的物件中產生模糊的方法呼叫。這是發生在升級你的基底類別導致與你的類別衝突的特殊情況。就算在這種情況下，使用前還是要仔細思考。更重要的是，其他情況不要使用它。

Effective C# 做法 04-06

Thu, 22 Aug 2024 21:28:59 +0800

做法 04

以內插字串取代 string.Format()

推薦這樣寫

string name = "test";
float height = 180;
int age = 20;
string str = $"userName: {name}, age: {age}, height: {height}";

1. 為什麼 Math.PI 不寫 ToString 會造成 box 呢?

當需要調用 ToString() 方法時，如果我們沒有顯式調用，編譯器會嘗試使用 Object.ToString()。但是，為了使用 Object 上的方法，值類型必須先轉換為 Object，這就導致了裝箱。

做法 05

對文化特定字串偏好 FormattableString

推薦使用 FormattableString，不會因為當地時間顯示或者數字的顯示有所差異。double 的小數點會是＂.＂；如果再歐洲會是顯示＂,＂。

做法 06

避免字串型別 API

使用 nameof 運算子時，任何對於屬性名稱的改變都會正確的反應在用於事件參數的字串中。

public string Name
{
    get { return name; }
    set
    {
        if (value != name)
        {
            name = value;
            PropertyChanged?.Invoke(this,
            new PropertyChangedEventArgs(nameof(Name)));
        }
    }
}

Effective C# 做法 01-03

Sat, 17 Aug 2024 23:09:29 +0800

做法 01

偏好隱含型別的區域變數

參考書籍提到的最後一段

簡單說，除非開者（包括以後的你）必須看到型別宣告才能理解程式，否則就使用 var 宣告區域變數。這個做法的標題是＂偏好＂而不是＂總是＂。我建議明確的宣告所有數值型別（int、float、double 與其他）而不要使用 var 宣告。其他東西就是用 var。多打幾個字 - 明確的宣告型別 - 不會提升行別安全或改善可讀性。如果挑錯宣告型別，你可能會造成編譯器本來能夠避免的低效率。

做法 02

偏好 readonly 而非 const

必須在編譯期確定的值必須使用 const：屬性參數、switch case 標籤與 enum 定義，以及少數部會在版本間變化的數值。其餘狀況則傾向以 readonly 常數提升彈性。

1. const 使用建議

對於在編譯時就能確定且永不改變的值
適用於基本數據類型（int、float、bool 等）和字符串
效能略優於 readonly，因為它是編譯時常量

2. readonly 使用建議

對於運行時才能確定值的情況
可用於任何數據類型，包括引用類型和複雜類型
允許在構造函數中賦值

選擇指南

如果值在編譯時就能確定，且是基本類型或字符串，優先使用 const。
如果是引用類型或需要在運行時計算的值，使用 readonly。
如果需要在不同的構造函數中賦予不同的值，使用 readonly。
對於靜態成員，如果符合 const 的條件，優先使用 const；否則使用 static readonly。

做法 03

偏好 is 或 as 運算子而非型別轉換

推薦這樣寫

object o = new MyType();

/// 不推薦
var t = (MyType)o;

/// 推薦
if (o is MyType myType)
{
    myType.Do();
    /// do samething ...
}

Effective C# on Wenrong Nexus

Effective C# 做法 22-23

做法 22

1. 這個 out 也是 共變數?

簡單解釋共變數與反變數

共變數（Covariance）

反變數（Contravariance）

詳細解釋和更多例子

限制和注意事項

心得

做法 23

做法 23 心得

Effective C# 做法 20-21

做法 20

實作

使用方式

做法 21

若 T 沒有實作 IDisposable ，則此區域變數的值為 null

Effective C# 做法 18-19

做法 18

使用泛型

1. 泛型類別使用 default()

2. 少了 null 確認

3. 使用 T?

4. 為什麼要盡量避免約束 new()、struct、class

new() 約束

struct 約束

class 約束

總結

做法 19

Effective C# 做法 16-17

做法 16

做法 17

Unmanaged 型別

Unmanaged 資源

需要實現 IDisposable 的類別

不需要實現 IDisposable 的類別

1.除非你的類別直接持有 Unmanaged 資源，否則你不應該實作 finalizer

Effective C# 做法 14-15

做法 14

1. 建構子初始化程序讓一個建構子呼叫其他的建構子

2. 選擇預設參數與

3. 繼承類別不能修改父類別中宣告為 readonly 的欄位

做法 15

1. 區域變數的選擇

2. string 不可變的原因

3.建構不可變的可變 builder 類別

Effective C# 做法 11-13

做法 11

1. 簡易圖示記憶體區塊的關聯圖

2. 記憶體排列物件的放置位址

3. 記憶體層代

4. 使用 Dispose 釋放資源，而不是 Finalizer

做法 12

為什麼 initobj 會導致 box、unbox？

做法 13

Effective C# 做法 07-10

做法 07

做法 08

做法 09

做法 10

Effective C# 做法 04-06

做法 04

1. 為什麼 Math.PI 不寫 ToString 會造成 box 呢?

做法 05

做法 06

Effective C# 做法 01-03

做法 01

做法 02

1. const 使用建議

2. readonly 使用建議

選擇指南

做法 03

1. 這個 out 也是共變數?