(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#開發者。