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 ...
}

C# 淺複製與深複製

Sat, 22 Jun 2024 19:02:04 +0800

前言

之前有講到 C# Value Type、Reference Type 的差異，現在來講一下淺複製（Shallow Copy）與深複製（Deep Copy）。

淺複製

將原有物件的欄位依照其型別來複製，Value Type 欄位複製其數值到另一個空間，Reference Type 欄位則是複製其參考到另一個空間，因此此兩物件的 Reference Type 都是參考到同一 instance。

淺複製方式

public class Address
{
    public string Street = string.Empty;
    public string City = string.Empty;
}

public class Person
{
    public string Name = string.Empty;
    public int Age = 0;
    public Address Address = new Address();

    public Person ShallowCopy()
    {
        return (Person)this.MemberwiseClone();
    }
}

Person origin = new Person()
{
    Name = "Sam",
    Age = 20,
    Address = new Address()
    {
        Street = "123 Main St",
        City = "Anytown"
    }
};
Person copy = origin.ShallowCopy();

copy.Name = "John";
copy.Age = 30;
copy.Address.Street = "456 Main St";
copy.Address.City = "Taiwan";

Console.WriteLine("Shallow Copy");
// Origin: Sam, 20, 456 Main St, Taiwan
Console.WriteLine($"Origin: {origin.Name}, {origin.Age}, {origin.Address.Street}, {origin.Address.City}");
// Copy: John, 30, 456 Main St, Taiwan
Console.WriteLine($"Copy: {copy.Name}, {copy.Age}, {copy.Address.Street}, {copy.Address.City}");

輸出結果

Origin: Sam, 20, 456 Main St, Taiwan

Copy: John, 30, 456 Main St, Taiwan

Name 是 String，可是沒有跟著改變，可以先看C# Reference Type String這篇。

Age 是 int，也是 Value Type，所以會改變。

Address 是 class 是 Reference Type，因為淺複製的關係導致他們（Origin、Copy）有一起改變

深複製

ValueType 與淺複製相同，主要差異是深複製的 Reference Type 欄位會產生新的 instance，所以其倆欄位是參考到不同 instance 的。

深複製方式

public class Address
{
    public string Street = string.Empty;
    public string City = string.Empty;
}

public class Person
{
    public string Name = string.Empty;
    public int Age = 0;
    public Address Address = new Address();

    public Person DeepCopy()
    {
        Person clone = (Person)this.MemberwiseClone();
        clone.Address = new Address
        {
            Street = this.Address.Street,
            City = this.Address.City
        };
        return clone;
    }
}

Person origin = new Person()
{
    Name = "Sam",
    Age = 20,
    Address = new Address()
    {
        Street = "123 Main St",
        City = "Anytown"
    }
};
Person copy = origin.DeepCopy();

copy.Name = "John";
copy.Age = 30;
copy.Address.Street = "456 Main St";
copy.Address.City = "Taiwan";

Console.WriteLine("Shallow Copy");
// Origin: Sam, 20, 123 Main St, Anytown
Console.WriteLine($"Origin: {origin.Name}, {origin.Age}, {origin.Address.Street}, {origin.Address.City}");
// Copy: John, 30, 456 Main St, Taiwan
Console.WriteLine($"Copy: {copy.Name}, {copy.Age}, {copy.Address.Street}, {copy.Address.City}");

Origin: Sam, 20, 123 Main St, Anytown

Copy: John, 30, 456 Main St, Taiwan

與淺複製的差異，深複製的 Address 欄位也會產生新的 instance，在修改 copy.Address 時，不會影響到 origin.Address。

參考連結

C# 複製物件的方式比較

C# Reference Type String

Sat, 22 Jun 2024 17:40:52 +0800

前言

之前有提到 C# Value Type、Reference Type 的差異，提到 String 是 Reference Type，可是在使用時卻很像 Value Type。

比較值

Value Type 以 int 為舉例

int a = 1;
int b = a;
a = 2;
Console.WriteLine(a == b); // 輸出: false

b 並沒有隨著 a 改變，看得出 int 是 Value Type。

string str1 = "abc";
string str2 = str1;
str1 = "def";
Console.WriteLine(str1 == str2); // 輸出:  false

修改 str1 卻沒有影響到 str2，所以會覺得 string 也是 Value Type(?)。

比較地址

使用 object.ReferenceEquals 來比較，假如是 Value Type，則會輸出 false。

int a = 1;
int b = 1;
Console.WriteLine(object.ReferenceEquals(a, b)); // 輸出: false

int 確實是 Value Type，所以會輸出 false。

string str1 = "abc";
string str2 =  "abc";
Console.WriteLine(object.ReferenceEquals(str1, str2)); // 輸出: true

比較結果為 true，假如 String 是 Value Type，應該會與 int 的結果一樣會是 false。

也就是 String 其實是 Reference Type。

String 為什麼是 Reference Type

.NET 框架-string 是 value or reference type?

這裡面提到兩點

String 對象，若值相同，則其引用地址相同。
String 對象，若值不等，則其引用地址不等。

string str1 = "abc"; //str1指向記憶體位置 addressA 為 abc
string str2 = str1; //str2指向記憶體位置 addressA
str1 = "def"; //str1新指向記憶體位置 addressB 為 def
Console.WriteLine(str1 == str2); // 輸出:  false

String 特點

String 特點就是具有不可變性（immutable），一旦 new String 在記憶體(managed heap)上為它分配一塊連續記憶體空間，我們將不能以任何方式對這個 String 進行修改。所有對這個 String 進行各項操作而返回的 String，實際上是另一個重新 new 的 String，其本身並不會產生任何變化。

String 效能如何？

從上面就可以知道 String 有不可變性，一旦創建了就不能修改值，每次修改 String 都會產生一個新的 String，所以 String 效能比較低。

所以需要經常性操作 String 可以考慮使用 StringBuilder。

結論

來自 ChatGPT 的解釋

C# String 有以下特性：

String 有不可變性：一旦創建 string，它的內容就不能被改變。
賦值操作的實際行為：當執行 str = "abc" 時，實際上是創建了一個新的 string 對象，而不是修改原有的對象。然後，變量 str 被重新指向這個新對象。
為什麼 str2 不變：當執行 string str2 = str1 時，str1 和 str2 確實指向了同一個對象。但是當 str1 被賦予新值時，它指向了一個新對象，而 str2 仍然指向原來的對象。
值類型的行為：這種行為看起來很像值類型，但 string 仍然是引用類型。這是因為 string 的不可變性和特殊的內存管理方式。
性能和內存管理：這種設計有助於提高性能和簡化內存管理，特別是在字符串被廣泛使用的情況下。
字符串池（String Interning）：C#使用字符串池來優化內存使用。相同的字符串字面量會指向內存中的同一位置。

這種行為是 C# 語言設計的一個特點，旨在結合引用類型的靈活性和值類型的一些優勢。它可能看起來有點反直覺，但在實際使用中通常是有益的。

C# Class 和 Struct 選擇

Wed, 12 Jun 2024 22:47:08 +0800

前言

之前有講到 C# Value Type、Reference Type 的差異，現在來講一下 Class 和 Struct 選擇。

從上一篇的文章中可以知道 Class 是 Reference type，而 Struct 是 Value type。

如何選擇

根據在類別和結構之間選擇

作為經驗規則，架構中大部分的類型應該為類別。不過，在某些情況下，實值型別的特性會使它更適合使用結構。

可以知道其實大部分時都是使用 Class，但在某些情況下使用 Struct 會比較適合。

什麼時候使用 Struct

如果類型的執行個體很小，且通常短期或通常內嵌在其他物件中，請考慮定義結構，而不是類別。

除非類型具有下列所有特性，否則請「避免」定義結構：

其以邏輯方式表示單一值，類似於基本類型 (int、double 等)。
其執行個體大小低於 16 個位元組。
類型為不可變，
而且不需要經常進行 Box。

在所有其他情況下，您應該將類型定義為類別。

參考連結

一起學 Class and Struct (C#)

C# Value Type、Reference Type 的差異

Tue, 11 Jun 2024 22:38:53 +0800

前言

在公司讀書會與同事討論淺複製與深複製的差異和使用時機時，聊到 Reference Type、Value Type 的不同，但是要講淺複製與深複製之前要先講 Reference Type、Value Type 的差異。

Value Type 有哪些

整數的數字型別：sbyte、byte、short、ushort、int、uint、long、ulong、nint、nuint
浮點數值型別：float、double、decimal
內建數值轉換
bool
char
enum
struct
ref struct
tuples
可為 Null 的值類型 (C# 參考)

參考：實值類型 (C# 參考)

Reference Type 有哪些

宣告參考型別：class、interface、delegate、record
內建參考類型：dynamic、object、string
可為 Null 的參考型別
集合和陣列：集合（List、Dictionary）、陣列（int[]、string[]）

參考：參考型別 (C# 參考)

Value Type、Reference Type 的差異

根據在類別和結構之間選擇裡的一段話，可以分出 5 點差異。

1. 存放記憶體

參考型別會配置在回收的堆積和記憶體上，而實值型別則會配置在堆疊上，或內嵌在包含型別上，並在堆疊回溯時或其包含類型解除配置時解除配置。

因此，實值型別的配置和解除配置的成本通常比參考型別的配置和解除配置的成本更低。

可以得知主要是在存放的記憶體差異，因此 Value Type 配置和解除配置的成本比 Reference Type 成本更低。

實值型別的配置和解除配置的成本通常比參考型別的配置和解除配置的成本更低。

2. 陣列

參考型別的陣列會以換行方式配置，這表示陣列元素只是位於堆積上之參考型別執行個體的參考。實值型別陣列會內嵌配置，這表示陣列元素是實值型別實際的執行個體。

因此，實值型別陣列的配置和解除配置的成本會遠比參考型別陣列的配置和解除配置的成本來得低。此外，在大部分情況下，實值型別陣列會呈現較佳的參考位置。

Value Type 陣列的配置和解除配置成本較低，且通常在記憶體存取表現上優於 Reference Type 陣列。然而，Reference Type 陣列在處理複雜的物件或需要物件參考的情境中仍有其必要性。

3. 記憶體使用量

強制轉型為參考型別或其實作的其中一個介面時，實值型別會進行 Boxed。當強制轉型回實值型別時，它們會進行 Unboxed。

因為 Box 是配置在堆積上且被回收記憶體的物件，所以過多 Boxing 和 unboxing 可能會對堆積、記憶體回收行程，以及最終是應用程式的效能造成負面影響。

強制轉型為 Reference Type 時，Value Type 會進行 Boxed。當強制轉型回實值型別時會進行 Unboxed，過多的 Boxed 和 Unboxed 會增加垃圾回收（GC）的負擔，從而影響應用程式效能。

4. 複製參考

參考型別指派會複製參考，而實值型別指派則會複製整個值。因此，大型參考型別的指派成本比大型實值型別的指派成本更低。

5. 傳遞方式

參考型別會以傳址方式傳遞，而實值型別則是以傳值方式傳遞。對參考型別的執行個體所做的變更會影響所有指向執行個體的參考。實值型別執行個體會在以傳值方式傳遞時複製。變更實值型別的執行個體時，它必然不會影響其任何複本。

由於不會由使用者明確建立複本，而是會在傳回引數或傳回值時隱含建立，因此可以變更的實值型別可能會對許多使用者造成混淆。因此，實值型別應該為不可變。

由於 Value Type 在傳遞過程中會複製，變更複本時不會影響原始值，這有時會讓使用者感到困惑，因為預期的變更並未反映在原始變數上。

為了避免這種混淆，Value Type 通常應設計為不可變（immutable）。不可變的 Value Type 一旦創建，其狀態就無法改變，這樣可以確保每個複本都是一致且獨立的。

Reference Type

傳遞物件的記憶體地址。因此，對該物件所做的變更會影響所有持有該物件地址的參考。

當 Reference Type 的物件進行變更時，因為所有指向該物件的參考都是同一個實例，所有持有該參考的變數都會受到變更影響。

Value Type

會複製該值並將複本傳遞給目標位置。因此，對複本的變更不會影響原始值。

當傳遞 Value Type 並對其進行變更時，因為是對複本進行操作，原始實例不會受到任何影響。這意味著每個複本都是獨立的。

參考連結

一起學 Class and Struct

Whitelist for Windows UAC

Mon, 04 Nov 2019 00:00:00 +0000

前言

因為某些程式開啟時，會跳出需要系統管理員（Administrator）權限執行程式，也導致了只要是ㄧ般使用者每次開啟時都需要輸入系統管理員密碼來執行。為了ㄧ般使用者的權限問題也不能關閉 Windows UAC。也不可能修改一般使用者的權限，所以需要讓 Windows UAC 加入此程式為白名單，這樣就不會每次都會跳出權限要求。

已知限制條件

程式必須以 Administrator 執行
一般使用者可以執行
不可完全關閉 Windows UAC

解決方式

根據不變更 UAC 安全性，但執行程式時又不擾民的設定方式，可以在 Windows Regedit 新增白名單。

Win+R 輸入 regedit 執行
根據此路徑尋找 HKEY_CURRENT_USERS\Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers
右鍵新增字串值，名稱為程式（exe）路徑、資料為~ RunAsInvoker

C# 解決方式

public class RegEditWhiteList
{
    public string keyName { get; set; }
    private readonly string root = @"Software\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Layers";
    private readonly string keyValue = "~ RunAsInvoker";

    public RegEditWhiteList(string keyName)
    {
        this.keyName = keyName;
    }

    public void SendRegedit()
    {
        RegistryKey key = Registry.CurrentUser.OpenSubKey(root, true);
        key.SetValue(keyName, keyValue,RegistryValueKind.String);
        key.Close();
    }
}

GitHub

使用方式

因為修改註冊碼是修正當前使用者的註冊碼，因此只要換使用者就需要再新增一次白名單。

參考資料

不變更 UAC 安全性，但執行程式時又不擾民的設定方式

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

C# 淺複製與深複製

前言

淺複製

淺複製方式

深複製

深複製方式

參考連結

1. 這個 out 也是共變數?