(6)從護士到C#開發者--基礎進階：程式控制與資料結構

前言

在我從護士轉職成為 C# 開發者的學習旅程中，這是我的第六篇學習筆記。今天我學習了更多關於程式控制與資料結構的內容，這些知識幫助我更好地組織和管理程式中的資料與流程。

Continue 陳述式

Continue 陳述式用於立即結束本次迴圈，判斷迴圈條件，如果成立則進入下一次迴圈，否則退出迴圈。這讓我想起在護理工作中，當某個步驟不適用於特定病人時，我們會跳過該步驟，繼續執行護理計畫的其他部分。

讓我透過一個例子來說明 Continue 的使用：

// 模擬病房巡視，跳過空床位
for (int bedNumber = 1; bedNumber <= 10; bedNumber++)
{
    // 假設4號床和7號床是空床位
    if (bedNumber == 4 || bedNumber == 7)
    {
        Console.WriteLine($"{bedNumber}號床是空床位，跳過檢查");
        continue; // 跳過本次迴圈，直接進入下一次
    }

    // 執行病人檢查流程
    Console.WriteLine($"正在檢查{bedNumber}號床的病人");
    // 其他檢查程式碼...
}

在這個例子中，迴圈遍歷了 1 到 10 號床位，當遇到空床位（4 號和 7 號）時，使用 continue 陳述式跳過當前迴圈，不執行後面的病人檢查流程，直接進入下一個床位的檢查。

另一個例子是處理患者資料：

// 處理患者體溫資料，跳過無效資料
double[] temperatures = { 36.5, 37.2, 0, 36.8, 39.1, 0, 36.9 };
double sum = 0;
int validCount = 0;

for (int i = 0; i < temperatures.Length; i++)
{
    // 跳過記錄為0的無效資料
    if (temperatures[i] == 0)
    {
        Console.WriteLine($"第{i+1}個體溫資料無效，跳過");
        continue;
    }

    // 處理有效資料
    sum += temperatures[i];
    validCount++;
    Console.WriteLine($"記錄有效體溫: {temperatures[i]}°C");
}

// 計算平均體溫
double average = sum / validCount;
Console.WriteLine($"患者平均體溫: {average:F1}°C");

在護理工作中，continue 陳述式就像是我們在執行一系列標準護理操作時，根據患者具體情況決定跳過某些不適用的步驟，直接進入下一個環節的過程。這種靈活性使我們能夠更有效率地處理各種情況。

三元運算式

三元運算式的語法為：運算式1 ? 運算式2 : 運算式3

• 運算式 1 一般為關係運算式
• 如果運算式 1 的值為 true，那麼運算式 2 的值就是整個三元運算式的值
• 如果運算式 1 的值為 false，那麼運算式 3 的值就是整個三元運算式的值

需要注意的是，運算式 2 的結果型別必須跟運算式 3 的結果型別一致，並且也要跟整個三元運算式的結果型別一致。

讓我透過幾個例子來說明三元運算式的使用：

// 例1：根據體溫判斷是否發燒
double temperature = 37.8;
string result = temperature >= 37.5 ? "患者發燒" : "體溫正常";
Console.WriteLine(result); // 輸出：患者發燒

上面的例子等同於以下 if-else 陳述式：

double temperature = 37.8;
string result;
if (temperature >= 37.5)
{
    result = "患者發燒";
}
else
{
    result = "體溫正常";
}
Console.WriteLine(result);

可以看到，三元運算式讓程式碼更簡潔。

再看一個稍複雜的例子：

// 例2：根據血壓值回傳不同的護理建議
int systolicBP = 145; // 收縮壓
string advice = systolicBP >= 140 ?
                (systolicBP >= 180 ? "緊急處理，立即降壓" : "需觀察，按醫囑用藥") :
                "血壓正常，繼續監測";
Console.WriteLine(advice); // 輸出：需觀察，按醫囑用藥

這個例子中，我們使用巢狀的三元運算式來處理多個條件。當收縮壓超過 140 時，再進一步判斷是否達到 180 以上的緊急狀態。

三元運算式在計算值時也很有用：

// 例3：計算藥物劑量（根據體重）
double weight = 65.5; // 患者體重（kg）
double baseDose = 5.0; // 基礎劑量（mg）
double doseMultiplier = weight < 50 ? 0.8 : (weight > 80 ? 1.2 : 1.0);
double finalDose = baseDose * doseMultiplier;

Console.WriteLine($"患者體重: {weight}kg");
Console.WriteLine($"劑量調整係數: {doseMultiplier}");
Console.WriteLine($"最終藥物劑量: {finalDose}mg");

在我的護理工作中，類似的快速判斷場景很常見。比如根據病人的各項指標分配不同的護理等級，或者根據評估結果決定採取何種措施。三元運算式可以幫助我在程式碼中簡潔地表達這些決策邏輯。

凡是 if-else 可以做的事都可以用三元運算式完成，不過當邏輯過於複雜時，為了程式碼可讀性，使用傳統的 if-else 可能更為清晰。

常數

常數的宣告語法：

const 變數型別 變數名稱 = 值

常數一旦宣告就不能被重新賦值。在護理中，這類似於一些固定的醫療參數，如正常體溫範圍、血壓標準值等。

讓我透過幾個例子來說明常數的使用：

// 定義醫療相關常數
const double NORMAL_BODY_TEMP = 36.5;      // 正常體溫參考值
const int NORMAL_SYSTOLIC_BP = 120;        // 正常收縮壓參考值
const int NORMAL_DIASTOLIC_BP = 80;        // 正常舒張壓參考值
const int MIN_ADULT_HEART_RATE = 60;       // 成人最低心率
const int MAX_ADULT_HEART_RATE = 100;      // 成人最高心率
const string HOSPITAL_NAME = "仁愛醫院";    // 醫院名稱

// 使用常數
double patientTemp = 38.2;
if (patientTemp > NORMAL_BODY_TEMP + 1.0)
{
    Console.WriteLine("患者體溫明顯升高，需要醫生評估");
}

int patientSystolicBP = 135;
if (patientSystolicBP > NORMAL_SYSTOLIC_BP)
{
    Console.WriteLine("患者血壓偏高");
}

Console.WriteLine($"歡迎來到{HOSPITAL_NAME}!");

常數的命名通常採用全大寫字母，多個單字之間用底線分隔，這是一種常見的命名約定。

常數的好處：

1. 提高程式碼可讀性 - 使用有意義的名稱代替魔術數字（如 36.5 代替體溫）
2. 易於維護 - 如果需要修改某個值，只需修改一處常數定義
3. 避免錯誤 - 防止在程式碼中意外修改這些值

嘗試給常數重新賦值會導致編譯錯誤：

const int ADMISSION_AGE = 18;
ADMISSION_AGE = 16; // 編譯錯誤：無法給常數賦值

在我的護理工作中，有許多固定的標準和閾值，如生命徵象的正常範圍、藥物劑量的上限、治療的標準流程等。在程式設計中使用常數讓我想起這些醫療標準，幫助我更好地理解和記憶這個概念。

列舉

列舉可以規範我們的開發，語法如下：

[public] enum 列舉名稱
{
    值1,
    值2,
    值3,
    ...
}

public 是存取修飾詞，表示公開的、公共的，可以在任何地方存取。列舉名稱要符合 Pascal 命名規範。將列舉宣告到命名空間的下面、類別的外面，表示這個命名空間下所有類別都可以使用這個列舉。

列舉本質上是一個變數型別，類似於 int、double、string、decimal 等，只是列舉宣告、賦值、使用的方式與普通變數型別不同。我們可以將列舉型別的變數與 int 型別和 string 型別互相轉換。

讓我透過一個醫療場景的例子來說明列舉的使用：

// 定義護理評估中的疼痛等級列舉
public enum PainLevel
{
    None,           // 0 - 無疼痛
    Mild,           // 1 - 輕度疼痛
    Moderate,       // 2 - 中度疼痛
    Severe,         // 3 - 嚴重疼痛
    Unbearable      // 4 - 難以忍受的疼痛
}

// 定義護理任務優先級列舉
public enum NursingPriority
{
    Routine = 1,    // 常規護理
    Urgent = 2,     // 緊急護理
    Emergency = 3   // 危急情況
}

// 定義患者風險評估結果列舉
public enum RiskAssessment
{
    Low = 10,       // 低風險
    Medium = 20,    // 中等風險
    High = 30       // 高風險
}

// 在程式中使用列舉
class Program
{
    static void Main(string[] args)
    {
        // 1. 基本列舉使用
        PainLevel patientPain = PainLevel.Moderate;
        Console.WriteLine($"患者疼痛等級: {patientPain}"); // 輸出: 患者疼痛等級: Moderate

        // 2. 根據疼痛等級確定護理優先級
        NursingPriority priority;
        if (patientPain >= PainLevel.Severe)
        {
            priority = NursingPriority.Urgent;
        }
        else if (patientPain == PainLevel.None)
        {
            priority = NursingPriority.Routine;
        }
        else
        {
            priority = NursingPriority.Routine;
        }

        Console.WriteLine($"護理優先級: {priority}"); // 輸出: 護理優先級: Routine

        // 3. 使用列舉進行決策
        switch (patientPain)
        {
            case PainLevel.None:
                Console.WriteLine("無需止痛藥物");
                break;
            case PainLevel.Mild:
                Console.WriteLine("考慮使用非處方止痛藥");
                break;
            case PainLevel.Moderate:
                Console.WriteLine("按醫囑給予口服止痛藥");
                break;
            case PainLevel.Severe:
            case PainLevel.Unbearable:
                Console.WriteLine("立即連絡醫生，考慮注射止痛藥");
                break;
            default:
                Console.WriteLine("無效的疼痛評估");
                break;
        }

        // 4. 列舉與整數互相轉換
        int painValue = (int)patientPain;
        Console.WriteLine($"疼痛數值: {painValue}"); // 輸出: 疼痛數值: 2

        // 整數轉換為列舉
        PainLevel convertedPain = (PainLevel)3;
        Console.WriteLine($"轉換後的疼痛等級: {convertedPain}"); // 輸出: 轉換後的疼痛等級: Severe

        // 5. 列舉轉換為字串
        string painString = patientPain.ToString();
        Console.WriteLine($"疼痛描述: {painString}"); // 輸出: 疼痛描述: Moderate

        // 6. 字串轉換為列舉
        PainLevel parsedPain = (PainLevel)Enum.Parse(typeof(PainLevel), "Mild");
        Console.WriteLine($"解析後的疼痛等級: {parsedPain}"); // 輸出: 解析後的疼痛等級: Mild

        // 7. 嘗試轉換數字字串
        PainLevel numericPain = (PainLevel)Enum.Parse(typeof(PainLevel), "1");
        Console.WriteLine($"數字解析的疼痛等級: {numericPain}"); // 輸出: 數字解析的疼痛等級: Mild

        // 8. 處理可能發生的例外
        try
        {
            PainLevel invalidPain = (PainLevel)Enum.Parse(typeof(PainLevel), "Critical");
            Console.WriteLine($"解析結果: {invalidPain}");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("無法將'Critical'轉換為有效的疼痛等級，因為列舉中沒有此值");
        }

        // 9. 取得列舉的所有可能值
        Console.WriteLine("所有可能的疼痛等級:");
        foreach (PainLevel level in Enum.GetValues(typeof(PainLevel)))
        {
            Console.WriteLine($"- {level} ({(int)level})");
        }
    }
}

在這個範例中，我們可以看到：

1. 列舉定義：我們定義了三個與護理相關的列舉類型（疼痛等級、護理優先級和風險評估）
2. 預設值：如果不指定值，列舉的第一個成員值為 0，後續成員值依序遞增 1
3. 自訂值：我們可以為列舉成員指定自訂的整數值，如NursingPriority和RiskAssessment
4. 列舉比較：可以用大於、等於等運算子比較同一列舉類型的不同值
5. 型別轉換：列舉可以與 int 和 string 互相轉換
6. 錯誤處理：當嘗試將不存在的字串轉換為列舉值時會擲出例外

在我的護理工作中，類似的分級系統隨處可見。例如：

• 疼痛評估量表（0-10 分）
• 壓瘡風險評分（Braden 量表）
• 跌倒風險等級
• 靜脈炎分級
• 藥物分類系統

使用列舉可以讓程式碼更加規範和易於理解，避免使用「魔術數字」（如直接使用 1、2、3 而不說明其含義）。同時，編譯器還會檢查型別安全，防止我們誤用列舉值。

結構

結構可以幫助我們一次宣告多個不同型別的變數，通常寫在命名空間下面。語法如下：

[public] struct 結構名稱（符合Pascal）
{
    成員; //欄位
}

與變數在程式執行期間只能存一個值不同，結構可以儲存多個值。讓我透過一個護理場景的例子來說明結構的使用：

// 定義患者生命徵象結構
public struct VitalSigns
{
    public double Temperature;      // 體溫
    public int HeartRate;          // 心率
    public int SystolicBP;         // 收縮壓
    public int DiastolicBP;        // 舒張壓
    public int RespiratoryRate;    // 呼吸頻率
    public int OxygenSaturation;   // 血氧飽和度
}

// 定義患者基本資訊結構
public struct PatientInfo
{
    public string Name;            // 姓名
    public int Age;                // 年齡
    public char Gender;            // 性別（'M' 或 'F'）
    public string ID;              // 病歷號
    public string Ward;            // 病區
    public int BedNumber;          // 床號
    public VitalSigns Vitals;      // 生命徵象
}

// 使用結構的範例
class Program
{
    static void Main(string[] args)
    {
        // 建立並初始化一個患者資訊
        PatientInfo patient;
        patient.Name = "張三";
        patient.Age = 45;
        patient.Gender = 'M';
        patient.ID = "P20250305001";
        patient.Ward = "內科";
        patient.BedNumber = 12;

        // 設定患者生命徵象
        patient.Vitals.Temperature = 37.2;
        patient.Vitals.HeartRate = 78;
        patient.Vitals.SystolicBP = 130;
        patient.Vitals.DiastolicBP = 85;
        patient.Vitals.RespiratoryRate = 16;
        patient.Vitals.OxygenSaturation = 98;

        // 顯示患者資訊
        DisplayPatientInfo(patient);

        // 評估生命徵象
        AssessVitalSigns(patient.Vitals);
    }

    // 顯示患者資訊的方法
    static void DisplayPatientInfo(PatientInfo patient)
    {
        Console.WriteLine("患者基本資訊：");
        Console.WriteLine($"姓名: {patient.Name}");
        Console.WriteLine($"年齡: {patient.Age}歲");
        Console.WriteLine($"性別: {(patient.Gender == 'M' ? "男" : "女")}");
        Console.WriteLine($"病歷號: {patient.ID}");
        Console.WriteLine($"病區: {patient.Ward}");
        Console.WriteLine($"床號: {patient.BedNumber}號");
        Console.WriteLine("\n生命徵象：");
        Console.WriteLine($"體溫: {patient.Vitals.Temperature}°C");
        Console.WriteLine($"心率: {patient.Vitals.HeartRate}次/分");
        Console.WriteLine($"血壓: {patient.Vitals.SystolicBP}/{patient.Vitals.DiastolicBP} mmHg");
        Console.WriteLine($"呼吸: {patient.Vitals.RespiratoryRate}次/分");
        Console.WriteLine($"血氧: {patient.Vitals.OxygenSaturation}%");
    }

    // 評估生命徵象的方法
    static void AssessVitalSigns(VitalSigns vitals)
    {
        Console.WriteLine("\n生命徵象評估：");

        // 評估體溫
        if (vitals.Temperature > 37.5)
            Console.WriteLine("- 體溫偏高，需要監測");

        // 評估心率
        if (vitals.HeartRate < 60 || vitals.HeartRate > 100)
            Console.WriteLine("- 心率異常，需要關注");

        // 評估血壓
        if (vitals.SystolicBP >= 140 || vitals.DiastolicBP >= 90)
            Console.WriteLine("- 血壓偏高，建議複查");

        // 評估呼吸
        if (vitals.RespiratoryRate < 12 || vitals.RespiratoryRate > 20)
            Console.WriteLine("- 呼吸頻率異常，需要觀察");

        // 評估血氧
        if (vitals.OxygenSaturation < 95)
            Console.WriteLine("- 血氧偏低，考慮給氧");
    }
}

在這個例子中，我們可以看到：

1. 結構的定義：我們定義了兩個結構（VitalSigns和PatientInfo），用於儲存患者的相關資訊
2. 結構的巢狀：PatientInfo結構中包含了VitalSigns結構，展示了結構的巢狀使用
3. 結構的初始化：展示了如何建立結構變數並設定其欄位值
4. 結構作為參數：展示了如何將結構作為方法參數傳遞
5. 結構的實際應用：透過評估生命徵象的方法展示了結構在實際場景中的應用

這種組織資料的方式讓我想起護理工作中的病歷記錄系統。在病歷中，我們也會將患者的各種資訊（基本資訊、生命徵象、檢查結果等）按照特定的格式組織在一起。使用結構可以幫助我們更好地管理這些相關的資料，使程式碼更有條理和可維護性。

陣列

陣列允許我們一次性儲存多個相同型別的變數。語法：

陣列型別[] 陣列名稱 = new 陣列型別[陣列長度]

例如：int[] nums = new int[10];

當我寫了上面這行程式碼後，就在記憶體中開闢了連續的 10 塊空間。我們將每一塊空間稱為陣列的元素。如果想要存取陣列中的某個元素，需要透過元素的下標或索引去存取。陣列中最後一個元素的索引是長度減一。

讓我透過幾個護理工作中的例子來說明陣列的使用：

// 例1：記錄一週的病房人數
int[] wardPatients = new int[7];  // 建立長度為7的陣列

// 設定每天的病人數量
wardPatients[0] = 45;  // 星期一
wardPatients[1] = 42;  // 星期二
wardPatients[2] = 48;  // 星期三
wardPatients[3] = 50;  // 星期四
wardPatients[4] = 47;  // 星期五
wardPatients[5] = 40;  // 星期六
wardPatients[6] = 38;  // 星期日

// 計算平均住院人數
int totalPatients = 0;
for (int i = 0; i < wardPatients.Length; i++)
{
    totalPatients += wardPatients[i];
}
double averagePatients = (double)totalPatients / wardPatients.Length;
Console.WriteLine($"本週平均住院人數: {averagePatients:F1}人");

// 例2：陣列的初始化方式
// 方式1：直接初始化
double[] temperatures = { 36.5, 36.8, 37.2, 36.9, 37.0 };

// 方式2：new關鍵字初始化
string[] medications = new string[] { "青黴素", "頭孢", "阿莫西林", "布洛芬" };

// 方式3：先宣告後賦值
int[] bedNumbers;
bedNumbers = new int[] { 101, 102, 103, 104, 105 };

// 例3：二維陣列 - 記錄多個病人一天的體溫記錄
double[,] patientTemps = new double[3, 4];  // 3個病人，每天4次體溫記錄

// 設定體溫資料
patientTemps[0, 0] = 36.5;  // 1號病人早上
patientTemps[0, 1] = 36.8;  // 1號病人中午
patientTemps[0, 2] = 37.1;  // 1號病人下午
patientTemps[0, 3] = 36.9;  // 1號病人晚上

// 走訪二維陣列
string[] timeSlots = { "早上", "中午", "下午", "晚上" };
for (int patient = 0; patient < 3; patient++)
{
    Console.WriteLine($"\n{patient + 1}號病人的體溫記錄：");
    for (int time = 0; time < 4; time++)
    {
        Console.WriteLine($"{timeSlots[time]}: {patientTemps[patient, time]}°C");
    }
}

// 例4：陣列作為方法參數
static double CalculateAverageTemp(double[] temps)
{
    double sum = 0;
    foreach (double temp in temps)
    {
        sum += temp;
    }
    return sum / temps.Length;
}

// 呼叫方法
double[] patient1Temps = { 36.5, 36.8, 37.2, 36.9 };
double avgTemp = CalculateAverageTemp(patient1Temps);
Console.WriteLine($"患者平均體溫: {avgTemp:F1}°C");

// 例5：陣列的常見操作
string[] nurses = { "張護士", "李護士", "王護士", "趙護士" };

// 取得陣列長度
Console.WriteLine($"護士數量: {nurses.Length}");

// 查詢元素
string searchNurse = "李護士";
bool found = Array.IndexOf(nurses, searchNurse) != -1;
Console.WriteLine($"是否找到{searchNurse}: {found}");

// 陣列排序
Array.Sort(nurses);
Console.WriteLine("排序後的護士名單：");
foreach (string nurse in nurses)
{
    Console.WriteLine(nurse);
}

// 陣列複製
string[] backupNurses = new string[nurses.Length];
Array.Copy(nurses, backupNurses, nurses.Length);

在這些例子中，我們可以看到：

1. 陣列的建立：可以使用多種方式建立和初始化陣列
2. 陣列的存取：透過索引存取陣列元素
3. 陣列的走訪：使用 for 迴圈或 foreach 迴圈走訪陣列
4. 二維陣列：用於儲存更複雜的資料結構
5. 陣列作為參數：陣列可以作為方法的參數傳遞
6. 陣列的常用操作：如取得長度、查詢元素、排序和複製等

陣列的長度一旦固定就不能被改變。這讓我想起醫院中的藥品分發系統，每個藥品有固定的儲存位置和數量。在護理工作中，我們經常需要處理一組相關的資料，比如：

• 病房的床位號
• 患者的體溫記錄
• 藥品清單
• 護理班次安排
• 生命徵象監測資料

使用陣列可以有效地組織和管理這些資料，使我們的程式更加結構化和易於維護。

氣泡排序

氣泡排序用於將陣列中的元素按照從大到小或從小到大的順序排列。例如，對於陣列：

int[] nums = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};

下面是一個完整的氣泡排序範例，將患者按照優先級排序：

// 患者優先級陣列（數字越大優先級越高）
int[] priorities = { 2, 5, 1, 7, 3, 8, 4, 6 };
string[] patientNames = { "張三", "李四", "王五", "趙六", "錢七", "孫八", "周九", "吳十" };

Console.WriteLine("排序前的患者優先級:");
for (int i = 0; i < priorities.Length; i++)
{
    Console.WriteLine($"{patientNames[i]}: 優先級 {priorities[i]}");
}

// 氣泡排序（從高到低）
for (int i = 0; i < priorities.Length - 1; i++)
{
    for (int j = 0; j < priorities.Length - 1 - i; j++)
    {
        // 如果當前元素小於下一個元素，交換位置（降序排列）
        if (priorities[j] < priorities[j + 1])
        {
            // 交換優先級
            int tempPriority = priorities[j];
            priorities[j] = priorities[j + 1];
            priorities[j + 1] = tempPriority;

            // 同時交換對應的患者姓名
            string tempName = patientNames[j];
            patientNames[j] = patientNames[j + 1];
            patientNames[j + 1] = tempName;
        }
    }
}

Console.WriteLine("\n排序後的患者優先級（從高到低）:");
for (int i = 0; i < priorities.Length; i++)
{
    Console.WriteLine($"{i+1}. {patientNames[i]}: 優先級 {priorities[i]}");
}

這類似於在護理工作中按照優先級對患者進行檢傷分類與治療。氣泡排序的思想讓我想起護理站中根據患者病情輕重決定先處理哪些患者的場景。

方法

方法是將一堆程式碼進行重複使用的機制。語法如下：

[public] static 傳回值型別 方法名稱([參數清單])
{
    方法主體;
}

讓我透過幾個護理相關的例子來說明方法的使用：

class NursingProgram
{
    // 1. 無參數無傳回值的方法
    public static void DisplayNursingProtocol()
    {
        Console.WriteLine("標準護理流程：");
        Console.WriteLine("1. 測量生命徵象");
        Console.WriteLine("2. 檢查輸液情況");
        Console.WriteLine("3. 觀察病情變化");
        Console.WriteLine("4. 記錄護理記錄");
    }

    // 2. 有參數有傳回值的方法
    public static double CalculateIdealWeight(double height, char gender)
    {
        // 根據身高和性別計算理想體重
        if (gender == 'M' || gender == 'm')
        {
            return (height - 100) * 0.9;
        }
        else
        {
            return (height - 100) * 0.85;
        }
    }

    // 3. 多參數的方法
    public static double CalculateBMI(double weight, double height)
    {
        double heightInMeters = height / 100;
        return weight / (heightInMeters * heightInMeters);
    }

    // 4. 方法多載 - 評估體溫
    public static string EvaluateTemperature(double temperature)
    {
        if (temperature < 35.5) return "低體溫";
        if (temperature <= 37.2) return "正常";
        if (temperature <= 38.0) return "低燒";
        if (temperature <= 39.0) return "中度發燒";
        return "高燒";
    }

    // 同名方法，但參數不同
    public static string EvaluateTemperature(double temperature, bool isInfant)
    {
        if (isInfant)
        {
            // 嬰兒體溫標準略有不同
            if (temperature < 36.0) return "嬰兒低體溫";
            if (temperature <= 37.5) return "嬰兒正常體溫";
            if (temperature <= 38.5) return "嬰兒低燒";
            return "嬰兒高燒";
        }
        else
        {
            return EvaluateTemperature(temperature); // 呼叫另一個多載方法
        }
    }

    // 5. 參數預設值
    public static string AssessBloodPressure(int systolic, int diastolic, bool detailed = false)
    {
        string result = "";
        if (systolic >= 140 || diastolic >= 90)
        {
            result = "血壓偏高";
            if (detailed)
            {
                result += $" (收縮壓:{systolic}, 舒張壓:{diastolic})";
            }
        }
        else if (systolic < 90 || diastolic < 60)
        {
            result = "血壓偏低";
            if (detailed)
            {
                result += $" (收縮壓:{systolic}, 舒張壓:{diastolic})";
            }
        }
        else
        {
            result = "血壓正常";
        }
        return result;
    }

    // 6. 使用ref參數的方法
    public static void UpdateVitalSigns(ref double temperature, ref int pulse)
    {
        // 模擬新的測量值
        temperature = 37.2;
        pulse = 75;
    }

    // 主方法中使用這些方法
    static void Main(string[] args)
    {
        // 呼叫無參數方法
        DisplayNursingProtocol();

        // 計算理想體重
        double height = 170;
        char gender = 'F';
        double idealWeight = CalculateIdealWeight(height, gender);
        Console.WriteLine($"\n身高{height}cm的{(gender == 'F' ? "女" : "男")}性理想體重: {idealWeight:F1}kg");

        // 計算BMI
        double weight = 65;
        double bmi = CalculateBMI(weight, height);
        Console.WriteLine($"BMI指數: {bmi:F1}");

        // 使用方法多載評估體溫
        double adultTemp = 38.5;
        double infantTemp = 37.8;
        Console.WriteLine($"\n成人体溫{adultTemp}°C評估: {EvaluateTemperature(adultTemp)}");
        Console.WriteLine($"嬰兒體溫{infantTemp}°C評估: {EvaluateTemperature(infantTemp, true)}");

        // 使用預設參數
        int systolic = 145;
        int diastolic = 88;
        Console.WriteLine($"\n血壓評估: {AssessBloodPressure(systolic, diastolic)}");
        Console.WriteLine($"血壓評估(詳細): {AssessBloodPressure(systolic, diastolic, true)}");

        // 使用ref參數
        double temp = 36.8;
        int pulse = 80;
        Console.WriteLine($"\n更新前 - 體溫: {temp}°C, 脈搏: {pulse}次/分");
        UpdateVitalSigns(ref temp, ref pulse);
        Console.WriteLine($"更新後 - 體溫: {temp}°C, 脈搏: {pulse}次/分");
    }
}

在這些例子中，我們可以看到：

1. 無參數方法：DisplayNursingProtocol()展示了如何定義和使用無參數方法
2. 有參數和傳回值的方法：CalculateIdealWeight()和CalculateBMI()展示了如何處理輸入參數並回傳計算結果
3. 方法多載：EvaluateTemperature()展示了如何為同一個方法名稱提供不同的參數版本
4. 預設參數：AssessBloodPressure()展示了如何使用選擇性參數
5. 參考參數：UpdateVitalSigns()展示了如何使用 ref 參數在方法中修改變數的值

這些方法讓我想起護理工作中的標準作業流程（SOP）：

• 每個護理程序都有明確的輸入（如患者狀況）和輸出（如護理措施）
• 相同的護理程序可能根據患者類型（如成人和兒童）有不同的變體
• 某些護理操作會直接改變患者的狀態（如給藥）
• 護理評估可以有簡單版本和詳細版本

透過將方法與護理實務連結起來，我更容易理解和記憶這些程式設計概念。方法使我們的程式碼更有組織性，就像標準化的護理流程一樣，提高了工作效率和準確性。

return 陳述式

return 陳述式有兩個作用：

1. 在方法中回傳要回傳的值
2. 立即結束本次方法的執行

下面是一個使用 return 陳述式的例子：

// 評估患者體溫狀態並給出護理建議
static string EvaluateTemperature(double temperature)
{
    // 低體溫
    if (temperature < 35.5)
    {
        return "體溫過低，需保暖並監測";
    }

    // 正常體溫
    if (temperature >= 35.5 && temperature <= 37.2)
    {
        return "體溫正常，定時監測";
    }

    // 輕度發燒
    if (temperature > 37.2 && temperature <= 38.0)
    {
        return "輕度發燒，密切觀察";
    }

    // 中度發燒
    if (temperature > 38.0 && temperature <= 39.0)
    {
        return "中度發燒，物理降溫並考慮用藥";
    }

    // 高燒
    return "高燒，緊急處理，立即通知醫生";
}

// 在Main方法中呼叫
static void Main(string[] args)
{
    double[] patientTemps = { 36.5, 37.8, 39.2, 35.0, 38.5 };

    foreach (double temp in patientTemps)
    {
        string advice = EvaluateTemperature(temp);
        Console.WriteLine($"體溫 {temp}°C: {advice}");
    }
}

在這個例子中，一旦滿足某個條件，return 陳述式就會回傳對應的建議並立即結束方法的執行，不會繼續檢查後面的條件。這類似於在護理決策中，一旦確定了患者的情況，就立即採取對應的措施，而不需要考慮其他可能性。

總結

作為一名護士轉職的開發者，我發現程式設計和護理工作有許多相似之處。透過將這些程式設計概念與護理經驗連結起來，我能夠更好地理解和應用這些知識，逐步成長為一名優秀的 C# 開發者。