C# 指派運算子與指派運算式：簡單/複合指派、右結合性、類型轉換規則全解析

指派運算子是程式狀態變更的核心機制。C# 提供簡單指派 (=) 與 10 種複合指派 (+=, -= 等)，並具備右結合性與嚴格的類型轉換規則。掌握其語意細節，能避免隱性 Bug 與效能陷阱。

指派運算子完整清單

核心規則：左運算元必須可寫入

左運算元必須為：

• 區域變數
• 欄位 (非 readonly，建構函式除外)
• 屬性 (需有 set 存取子)
• 索引子 (需有 set 存取子)

// 合法
int x = 0; x = 1;
obj.Field = 1;
obj.Property = 1;
arr[0] = 1;

// 非法
5 = 1;                    // 常數
readonlyField = 1;        // 唯讀欄位 (建構函式外)
obj.ReadOnlyProp = 1;     // 唯讀屬性

右結合性：連續指派語意

// 右結合：a = b = c  等價於  a = (b = c)
// 執行順序：先算 c，指派給 b，結果再指派給 a

int a, b, c;
a = b = c = 10; // 依序：c=10, b=10, a=10

// 實戰：鏈式初始化
var x = y = z = DefaultValue(); // 單次呼叫，三變數同值

簡單指派 (=) 深度解析

隱含轉換規則

// 右運算元型別必須隱含轉換為左運算元型別
int i = 10;
long l = i;        // ✅ int → long (隱含)
short s = i;       // ❌ int → short (需顯式轉型)
float f = l;       // ✅ long → float (隱含，可能精度遺失)

結果值與型別

• 運算式結果 = 指派給左運算元的值
• 結果型別 = 左運算元型別
• 永遠為值類型語意 (即使左運算元為參考類型，結果為參考值)

int x;
Console.WriteLine(x = 5);  // 輸出 5，x = 5

// 巢狀指派
int y = (x = 10) + 5; // x=10, 運算式值=10, y=15

複合指派 (op=) 語意與三大規則

x op= y 等價於 x = x op y，但 x 只評估一次 (對屬性/索引子至關重要)。

三大編譯規則 (優先順序)

關鍵特性：單次評估

// 屬性/索引子只存取一次
obj.Prop += 1; 
// 等價於 (非真實碼)
var temp = obj.Prop; 
obj.Prop = temp + 1; // 只呼叫 1 次 get, 1 次 set

// 陣列索引
arr[GetIndex()] += 1; // GetIndex() 只呼叫一次！

實戰範例與陷阱

位元旗標操作

[Flags] enum Perm { Read = 1, Write = 2, Exec = 4 }
Perm p = Perm.Read;
p |= Perm.Write;     // p = Read | Write
p &= ~Perm.Write;    // 移除 Write
p ^= Perm.Exec;      // 切換 Exec

事件訂閱/取消訂閱

event Action OnEvent;

OnEvent += Handler;  // 訂閱
OnEvent -= Handler;  // 取消訂閱

危險：複合指派與運算子優先級

x += y + z;  // x = x + (y + z) — + 優先級高於 +=
x *= y + z;  // x = x * (y + z)

// 建議：明確括號
x += (y + z);

值類型陷阱：結構複合指派

struct Point { public int X; }
var p = new Point();
p.X += 1; // ⚠️ 若 Point 為 class 則正常，struct 可能編譯錯誤 (取決於語境)

// 正確：整體替換
p = new Point { X = p.X + 1 };

類型轉換在指派中的角色

隱含數值轉換

byte b = 10;
int i = b;        // ✅ byte → int
long l = i;       // ✅ int → long
float f = l;      // ✅ long → float (精度可能遺失)

顯式轉換需求

int i = 300;
byte b = (byte)i; // 44 (截斷)
long l = 100;
int j = (int)l;   // ✅ 明確轉型

使用者定義轉換

struct Celsius { public double Value; 
    public static implicit operator double(Celsius c) => c.Value;
    public static explicit operator Celsius(double d) => new Celsius { Value = d }; }

Celsius c = 25.0;      // 隱含 double → Celsius
double d = c;          // 隱含 Celsius → double
Celsius c2 = (Celsius)100.0; // 顯式 double → Celsius

最佳實踐總結

1. 複合指派優於展開形式 — x += 1 優於 x = x + 1 (單次評估、意圖明確)
2. 連續指派僅用於簡單初始化 — 避免 a = b = c = Compute() (副作用順序難追蹤)
3. 位元/旗標操作必用複合指派 — flags |= Flag 標準慣用語
4. 事件訂閱用 +=/-= — 語言內建支援
5. 警惕屬性/索引子副作用 — 複合指派保證單次存取，但 get/set 邏輯可能複雜
6. 隱含轉換優先，顯式轉換最小化 — 讓編譯器檢查型別安全

精通指派運算子的右結合性、單次評估保證與三大複合指派規則，能編寫更安全、高效且符合 C# 慣用語的程式碼。