C#基础编程实战：四则运算程序设计
简介：本项目使用Visual Studio 2010开发环境，采用C#语言实现了一个简单的四则运算程序，涵盖加减乘除基本运算。程序通过控制台实现用户交互，包括输入处理、类型转换、运算逻辑和结果输出。项目还包括异常处理（如除零异常）和输入验证机制，适合编程初学者学习C#基础语法、控制流程和错误处理机制，是掌握面向对象编程思维的良好入门实践。
1. C#语言基础与Visual Studio 2010开发环境概述
本章将介绍C#语言的基本语法结构以及Visual Studio 2010开发环境的基本使用方式。内容包括C#语言的核心特点、开发环境界面布局、项目创建流程、代码编写与调试初步操作，为后续章节的深入学习奠定坚实基础。
1.1 C#语言的核心特点
C#（C Sharp）是由微软公司推出的一种现代、面向对象的编程语言，专为.NET框架设计。它融合了C++的强大功能与Java的简洁性，具备以下核心特点：
- 类型安全 ：防止非法内存访问，提升程序稳定性。
- 自动垃圾回收 （GC）：自动管理内存，减少内存泄漏风险。
- 跨平台能力 （通过.NET Core/.NET 5+）：支持Windows、Linux、macOS等多平台部署。
- 面向对象 ：支持封装、继承、多态等OOP特性。
- 丰富的类库支持 ：.NET Framework提供大量类库，提升开发效率。
1.2 Visual Studio 2010开发环境简介
Visual Studio 2010 是微软推出的一款集成开发环境（IDE），专为Windows平台下的应用程序开发而设计。其主要功能包括：
- 代码编辑器 ：支持智能提示、语法高亮、代码折叠等功能。
- 项目管理器 （Solution Explorer）：用于管理项目文件、资源和引用。
- 调试器 ：提供断点设置、变量查看、单步执行等调试功能。
- 设计器工具 ：可视化设计Windows窗体、WPF界面等。
1.3 创建第一个C#控制台项目
步骤如下：
- 打开 Visual Studio 2010。
- 点击“文件” -> “新建” -> “项目”。
- 在模板中选择“Visual C#” -> “控制台应用程序”。
- 输入项目名称，如
HelloWorld，点击“确定”。
此时，Visual Studio 会自动生成一个基础的控制台程序结构，包含以下默认代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello, World!");
Console.ReadLine();
}
}
}
代码解释：
using System;：引入System命名空间，包含基本类库如Console。namespace HelloWorld：定义命名空间，组织代码结构。class Program：定义一个类，C#中一切皆类。static void Main(string[] args)：程序入口点，程序从这里开始执行。Console.WriteLine("Hello, World!");：向控制台输出文本。Console.ReadLine();：等待用户输入，防止控制台窗口瞬间关闭。
点击工具栏上的“启动”按钮或按 F5 ，即可运行程序。控制台窗口将显示 Hello, World! 并等待用户输入后关闭。
下一章将深入讲解控制台程序的结构与输入输出操作，帮助你构建更复杂的交互式命令行应用。
2. 控制台程序与输入输出操作
控制台程序是C#语言入门学习的重要起点，也是理解程序运行机制的基础。通过控制台应用程序，我们可以直接与程序进行交互，输入数据并观察程序的输出结果。本章将从控制台程序的基本结构入手，逐步深入讲解输入输出操作的实现方式，并探讨如何对程序运行流程进行简单的控制。通过对这些内容的掌握，读者将具备构建基本交互式控制台程序的能力，为后续章节中更复杂的逻辑控制与程序设计打下坚实基础。
2.1 控制台应用程序的基本结构
控制台应用程序是C#语言中最基础的应用程序类型之一，它以命令行界面作为交互方式，不依赖图形界面库，非常适合初学者学习和理解程序的基本运行机制。
2.1.1 程序入口Main方法的作用
在C#中，程序的执行总是从一个名为 Main 的方法开始。 Main 方法是程序的入口点（entry point），其定义方式如下：
class Program
{
static void Main(string[] args)
{
// 程序执行的起点
Console.WriteLine("程序开始执行");
}
}
代码解析：
static void Main(string[] args)：这是Main方法的标准定义。static表示该方法是静态的，无需创建类的实例即可调用。void表示该方法没有返回值。string[] args是命令行参数数组，允许程序在启动时接收外部输入。
逻辑分析：
该方法是程序启动时自动调用的入口。在 Visual Studio 中运行程序时，系统会自动查找并执行 Main 方法中的代码。如果没有定义 Main 方法，编译器将报错，提示找不到程序入口。
2.1.2 命名空间与类的基本定义
C# 是一门面向对象的语言，所有的代码都必须封装在类中。为了组织代码结构，C# 引入了命名空间（namespace）的概念。
using System;
namespace MyFirstConsoleApp
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("欢迎使用命名空间");
}
}
}
代码解析：
using System;：引入System命名空间，使我们可以使用Console类。namespace MyFirstConsoleApp：定义一个自定义命名空间，用于组织程序结构。class Program：定义一个类，所有方法（包括Main）都必须在类中定义。
逻辑分析：
命名空间可以避免类名冲突，尤其在大型项目中尤为重要。通过合理划分命名空间，可以提高代码的可维护性与可读性。例如，在公司项目中，可以按照模块划分命名空间，如 Company.Project.ModuleA 。
示例：结构化控制台程序的基本模板
| 组件 | 说明 |
|---|---|
| 命名空间 | 组织类，防止类名冲突 |
| 类 | 封装方法和数据 |
| Main方法 | 程序执行的起点 |
| 控制台输出 | 使用 Console.WriteLine() 输出信息 |
2.2 控制台输入输出的实现方式
控制台程序的交互性主要体现在输入和输出操作上。通过 Console 类提供的方法，我们可以实现基本的数据输入与结果显示。
2.2.1 使用Console.WriteLine进行输出
Console.WriteLine() 是最常用的输出方法之一，它用于将指定内容输出到控制台，并在末尾自动换行。
Console.WriteLine("Hello, World!");
参数说明：
Console.WriteLine(string format, params object[] args)：可以使用格式字符串和参数进行输出。- 示例：
Console.WriteLine("当前数值为：{0}", 42);
逻辑分析：
该方法内部调用了控制台的输出流（ Console.Out ），将字符串写入控制台窗口。它是线程安全的，适合多线程程序中使用。
2.2.2 使用Console.ReadLine进行输入
与输出相对应的是输入操作， Console.ReadLine() 方法用于从控制台读取用户输入的一行文本。
string input = Console.ReadLine();
Console.WriteLine("你输入的是：" + input);
参数说明：
Console.ReadLine()：返回一个字符串，表示用户输入的整行内容。- 输入结束标志是用户按下回车键。
逻辑分析：
该方法会阻塞程序执行，直到用户输入内容并按下回车。这对于需要等待用户输入的程序非常关键。例如，在计算器程序中，可以通过该方法获取用户输入的数值。
2.2.3 输入输出格式化技巧
格式化是控制台输入输出操作中非常重要的一个环节，它决定了输出内容的可读性和输入处理的准确性。
int age = 25;
string name = "张三";
Console.WriteLine("姓名：{0}，年龄：{1}", name, age);
参数说明：
{0}、{1}是占位符，表示第0个、第1个参数。- 可以使用格式字符串进行数字、日期等的格式化：
- 数字格式化：
{0:F2}表示保留两位小数。 - 日期格式化：
{0:yyyy-MM-dd}表示年月日格式。
逻辑分析：
格式化字符串不仅提高了输出的美观性，还能在多语言环境中保持一致性。例如，在输出金额时，统一保留两位小数可以避免歧义。
示例：格式化输出表格数据
graph TD
A[开始] --> B[定义数据]
B --> C[使用格式化字符串输出]
C --> D[展示表格]
Console.WriteLine("{0,-10} | {1,10}", "姓名", "年龄");
Console.WriteLine("------------------------");
Console.WriteLine("{0,-10} | {1,10}", "李四", 28);
Console.WriteLine("{0,-10} | {1,10}", "王五", 32);
输出结果：
姓名 | 年龄
李四 | 28
王五 | 32
代码分析：
{0,-10}：左对齐，占用10个字符宽度。{1,10}：右对齐，占用10个字符宽度。- 通过这种方式，可以实现整齐的表格输出，适用于日志记录、数据展示等场景。
2.3 程序运行流程的简单控制
控制台程序的执行流程通常是顺序执行的，但有时我们需要对流程进行简单控制，例如暂停程序、退出程序、添加注释等。
2.3.1 程序暂停与退出方法
在调试控制台程序时，我们经常需要让程序暂停，以便查看输出结果。常用的方法是使用 Console.ReadKey() 或 Console.ReadLine() 。
Console.WriteLine("按任意键继续...");
Console.ReadKey();
参数说明：
Console.ReadKey()：读取一个按键输入，但不显示输入内容。Console.ReadLine()：读取一行输入，通常用于等待用户输入回车。
逻辑分析：
在 Visual Studio 中运行控制台程序时，程序执行完毕后控制台窗口会立即关闭。使用上述方法可以实现窗口停留，方便查看输出结果。
2.3.2 多语句顺序执行与注释使用
C#程序是由多个语句构成的，它们通常按照顺序执行。同时，注释是程序中不可或缺的一部分，有助于提高代码的可读性。
// 这是一个单行注释
Console.WriteLine("第一步");
Console.WriteLine("第二步");
/*
* 这是一个多行注释
* 可以跨越多行
*/
Console.WriteLine("第三步");
参数说明：
//：单行注释，从该符号开始到行末的内容不会被编译。/* ... */：多行注释，适用于注释大段代码或说明。
逻辑分析：
良好的注释习惯有助于他人理解你的代码，也有助于自己后期维护。尤其是在团队协作中，清晰的注释可以显著提高开发效率。
示例：控制台程序执行流程图
graph TD
A[开始] --> B[输出欢迎信息]
B --> C[等待用户输入]
C --> D[输出用户输入]
D --> E[程序结束]
流程说明：
- 程序启动，输出欢迎信息；
- 程序等待用户输入；
- 用户输入内容后，程序输出该内容；
- 程序结束运行。
通过上述流程图，可以清晰地看到程序的执行顺序。这种流程控制方式是构建更复杂程序逻辑的基础。
本章通过控制台程序的基本结构、输入输出操作的实现方式以及程序运行流程的简单控制，帮助读者构建起对C#控制台程序的整体认知。掌握这些内容后，读者将能够编写基本的交互式控制台程序，并为后续学习条件判断、循环结构、异常处理等内容打下坚实基础。
3. 数据处理与基本运算逻辑实现
在编写任何实际功能的程序时，数据处理是不可或缺的核心环节。C#语言提供了丰富的数据类型和运算符支持，开发者可以利用这些工具实现各种复杂的计算和逻辑判断。本章将从数据类型的基础概念出发，深入探讨变量的使用方式，数据类型转换的技术细节，以及如何通过算术运算符构建表达式。最后，我们将结合条件判断语句，展示如何实现基本的运算逻辑控制。通过本章的学习，读者将具备独立完成基础数据处理和逻辑运算程序的能力。
3.1 数据类型与变量的使用
C#是一种强类型语言，意味着每个变量在声明时都必须指定其数据类型。数据类型决定了变量在内存中所占的空间大小以及它能存储的值的范围。理解并正确使用数据类型是编写高效、安全代码的基础。
3.1.1 常用基本数据类型介绍
C#提供了丰富的内置数据类型，主要包括以下几类：
| 类型类别 | 常见数据类型 | 占用字节数 | 范围/说明 |
|---|---|---|---|
| 整数类型 | byte , sbyte , short , ushort , int , uint , long , ulong |
1~8 | 有符号和无符号整数 |
| 浮点类型 | float , double , decimal |
4, 8, 16 | 浮点精度与精度不同， decimal 适用于金融计算 |
| 字符类型 | char |
2 | Unicode字符 |
| 布尔类型 | bool |
1 | 只能取 true 或 false |
| 字符串类型 | string |
动态 | 字符序列，不可变类型 |
例如， int 类型可以存储从 -2,147,483,648 到 2,147,483,647 的整数值，占用4个字节；而 decimal 类型则适合用于财务计算，具有更高的精度（28-29位有效数字）。
3.1.2 变量声明与赋值方式
变量是程序中用于存储数据的容器。在C#中，变量必须先声明后使用。声明语法如下：
[数据类型] [变量名] = [初始值];
示例代码如下：
int age = 25;
double price = 99.99;
char grade = 'A';
bool isStudent = true;
string name = "Alice";
上述代码中，每个变量都明确指定了数据类型，并赋予了初始值。这种显式声明方式有助于提高程序的可读性和安全性。
此外，C# 3.0 引入了 var 关键字，允许编译器根据赋值自动推断变量类型：
var count = 100; // 编译器自动推断为int
var rate = 3.14; // 编译器自动推断为double
虽然 var 提供了简洁的写法，但在实际开发中应谨慎使用，尤其是在需要明确数据类型的场合，建议使用显式声明以提高代码可维护性。
逻辑分析：
-int age = 25;：声明一个整型变量age并赋值为 25。
-double price = 99.99;：声明一个双精度浮点数price，适用于需要小数精度的场景。
-char grade = 'A';：字符类型用于表示单个字符，注意使用单引号。
-bool isStudent = true;：布尔类型用于逻辑判断。
-string name = "Alice";：字符串类型是C#中最常用的引用类型之一。
3.2 数据类型转换技术详解
在实际开发中，常常需要在不同数据类型之间进行转换。例如，用户输入通常是字符串形式，但我们需要将其转换为整数或浮点数进行计算。C#支持多种类型转换方式，包括隐式转换、显式转换以及字符串解析。
3.2.1 字符串到数值类型的转换（int.Parse、double.Parse）
将字符串转换为数值类型是常见的操作。C# 提供了 Parse 方法和 Convert 类来实现这一功能。
string input = "123";
int number = int.Parse(input);
double decimalValue = double.Parse(input);
int.Parse() 方法尝试将字符串解析为整数。如果字符串无法转换为整数（如包含字母或格式错误），将抛出 FormatException 异常。
逻辑分析：
-int.Parse(input)：将字符串"123"转换为整数123。
-double.Parse(input)：将字符串"123"转换为双精度浮点数123.0。
除了 Parse 方法，还可以使用 Convert.ToInt32() 或 Convert.ToDouble() ：
int num = Convert.ToInt32("456");
double dbl = Convert.ToDouble("78.9");
3.2.2 转换过程中的异常风险及应对策略
在类型转换过程中，若输入不符合目标类型的要求，程序将抛出异常。例如：
string invalidInput = "abc";
int result = int.Parse(invalidInput); // 将抛出FormatException
为避免程序因异常而中断，应使用异常处理机制或使用 TryParse 方法进行安全转换。
string input = "123a";
int value;
bool success = int.TryParse(input, out value);
if (success)
{
Console.WriteLine($"转换成功：{value}");
}
else
{
Console.WriteLine("转换失败：输入无效");
}
逻辑分析：
-int.TryParse()：尝试将字符串转换为整数，如果失败不会抛出异常，而是返回false。
-out value：输出参数，用于接收转换后的结果。
- 该方法适用于需要处理用户输入或不确定数据来源的场景。
流程图示意：
graph TD
A[开始] --> B[获取输入字符串]
B --> C{是否可转换为int?}
C -->|是| D[转换成功，输出结果]
C -->|否| E[提示转换失败]
D --> F[结束]
E --> F
3.3 算术运算符与表达式构建
C#支持多种算术运算符，可以用于执行加减乘除等基本数学运算。理解运算符的优先级和括号的使用技巧对于构建正确的表达式至关重要。
3.3.1 加减乘除与取模运算的使用
以下是C#中常用的算术运算符及其示例：
int a = 10, b = 3;
int sum = a + b; // 加法：13
int difference = a - b; // 减法：7
int product = a * b; // 乘法：30
int quotient = a / b; // 除法：3（整数除法）
int remainder = a % b; // 取模：1
逻辑分析：
-+：加法运算符，用于数值相加。
--：减法运算符。
-*：乘法运算符。
-/：除法运算符。注意在整数除法中，结果会被截断（不四舍五入）。
-%：取模运算符，返回除法的余数。
3.3.2 运算优先级与括号的使用技巧
在复杂的表达式中，运算符的优先级决定了运算的执行顺序。例如：
int result = 5 + 3 * 2; // 结果为11，因为乘法优先于加法
为了提高可读性或改变运算顺序，可以使用括号：
int result = (5 + 3) * 2; // 结果为16
常见运算符优先级表（从高到低）：
| 优先级 | 运算符 | 描述 |
|---|---|---|
| 1 | () |
括号 |
| 2 | * , / , % |
乘法、除法、取模 |
| 3 | + , - |
加法、减法 |
建议： 在编写复杂表达式时，尽量使用括号来明确运算顺序，这不仅有助于避免错误，也能提升代码的可读性。
3.4 运算逻辑的条件控制
在程序中，常常需要根据不同的条件执行不同的操作。C#提供了 if 、 else if 、 else 等条件语句，使开发者能够灵活控制程序流程。
3.4.1 if语句的结构与多条件判断
基本的 if 语句结构如下：
int score = 85;
if (score >= 90)
{
Console.WriteLine("成绩为A");
}
else if (score >= 80)
{
Console.WriteLine("成绩为B");
}
else
{
Console.WriteLine("成绩为C或以下");
}
逻辑分析：
- 首先判断score >= 90，若为真，执行对应代码块。
- 若第一个条件不满足，则继续判断score >= 80。
- 如果所有条件都不满足，则执行else分支。
你也可以使用逻辑运算符组合多个条件：
int age = 20;
bool isStudent = true;
if (age >= 18 && isStudent)
{
Console.WriteLine("你是成年学生");
}
逻辑分析：
-&&表示“与”逻辑，只有两个条件都为真时才执行代码块。
-||表示“或”逻辑，任一条件为真即可执行。
-!表示“非”逻辑，用于取反布尔值。
3.4.2 运算结果的分支处理逻辑设计
在实际项目中，常常需要根据运算结果进行不同的处理。例如，在一个简单的计算器程序中：
int num1 = 10, num2 = 5;
string operation = "+";
int result;
if (operation == "+")
{
result = num1 + num2;
Console.WriteLine($"加法结果：{result}");
}
else if (operation == "-")
{
result = num1 - num2;
Console.WriteLine($"减法结果：{result}");
}
else
{
Console.WriteLine("不支持的操作符");
}
逻辑分析：
- 根据operation的值选择不同的运算方式。
- 如果操作符不是+或-，则提示不支持的操作符。
流程图示意：
graph TD
A[开始] --> B[输入操作符]
B --> C{操作符是 "+" ?}
C -->|是| D[执行加法]
C -->|否| E{操作符是 "-" ?}
E -->|是| F[执行减法]
E -->|否| G[提示不支持]
D --> H[输出结果]
F --> H
G --> H
H --> I[结束]
本章详细讲解了C#中的数据类型、变量使用、类型转换、算术运算以及条件判断等基础但关键的内容。通过这些知识，开发者可以实现基本的数据处理和逻辑运算功能，为后续更复杂的程序开发打下坚实基础。
4. 程序健壮性与用户交互设计
在软件开发过程中，程序的健壮性（Robustness）和用户交互体验（User Interaction）是衡量系统质量的重要标准之一。尤其是在控制台程序中，用户输入的不可控性、运行环境的复杂性以及逻辑流程的多样性，使得开发者必须掌握异常处理机制、输入验证策略和面向对象的设计思想。本章将从异常处理机制入手，逐步深入用户输入验证、交互式控制台程序构建，以及面向对象思想的初步应用，最终帮助开发者构建一个具备良好健壮性和用户体验的控制台应用程序。
4.1 异常处理机制的引入
异常（Exception）是程序运行过程中发生的错误或非预期行为。C# 提供了结构化的异常处理机制，通过 try-catch 块可以捕获并处理运行时错误，从而防止程序崩溃并提升程序的稳定性。
4.1.1 try-catch块的基本结构
C# 中的异常处理机制主要通过 try 、 catch 和 finally 三个代码块来实现。其中：
try：包含可能引发异常的代码。catch：用于捕获特定类型的异常并处理。finally（可选）：无论是否发生异常，都会执行，常用于释放资源。
示例代码：
try
{
Console.Write("请输入一个整数：");
int number = int.Parse(Console.ReadLine());
Console.WriteLine("您输入的数字是：" + number);
}
catch (FormatException)
{
Console.WriteLine("输入格式不正确，请输入一个整数！");
}
catch (OverflowException)
{
Console.WriteLine("输入的数值超出范围，请输入一个有效的整数！");
}
finally
{
Console.WriteLine("程序执行完毕。");
}
逐行逻辑分析：
- 第1行：
try块开始，包裹可能抛出异常的代码。 - 第2-4行：提示用户输入，并尝试将输入转换为整数。
- 第5行：输出用户输入的数值。
- 第6-7行：捕获
FormatException异常，处理输入非数字的情况。 - 第8-9行：捕获
OverflowException异常，处理数值超出int范围的情况。 - 第10-12行：
finally块始终执行，用于资源清理或提示信息输出。
参数说明：
| 异常类型 | 描述 |
|---|---|
| FormatException | 输入字符串格式不符合转换要求 |
| OverflowException | 输入数值超出目标类型的最大或最小值 |
mermaid 流程图：
graph TD
A[开始执行try块] --> B{是否发生异常?}
B -->|是| C[进入catch块]
B -->|否| D[继续执行后续代码]
C --> E[处理异常]
D --> F[正常输出结果]
C --> G[输出错误提示]
E --> H[finally块执行]
F --> H
G --> H
H --> I[程序结束]
4.1.2 捕获用户输入错误并给出提示
在实际开发中，用户输入错误是常见问题，例如输入非数字、空值或超出范围的数值。通过捕获异常并给出明确的提示，可以显著提升程序的容错能力。
示例代码：通用异常捕获
try
{
Console.Write("请输入一个数字：");
string input = Console.ReadLine();
double value = double.Parse(input);
Console.WriteLine($"您输入的值为：{value}");
}
catch (Exception ex)
{
Console.WriteLine($"发生错误：{ex.Message}");
}
逻辑分析：
- 使用
double.Parse尝试将用户输入转换为浮点数。 - 若输入非法（如空字符串、字母等），会抛出异常。
catch (Exception ex)捕获所有类型的异常，并输出错误信息。ex.Message包含详细的错误描述，有助于调试和用户提示。
表格：常见输入异常类型
| 异常类型 | 触发条件 | 示例输入 |
|---|---|---|
| FormatException | 输入格式错误 | “abc” |
| ArgumentNullException | 输入为 null | 按 Enter 未输入 |
| OverflowException | 数值超出目标类型范围 | “99999999999999999999” |
4.2 用户输入验证实践
除了使用异常机制外，进行输入验证是提升程序健壮性的另一种有效方式。验证逻辑可以提前阻止非法输入，减少异常发生频率，提升程序效率。
4.2.1 输入合法性的判断逻辑
使用 TryParse 方法可以安全地尝试将字符串转换为目标类型，并返回布尔值表示是否转换成功。
示例代码：
Console.Write("请输入一个整数：");
string input = Console.ReadLine();
int number;
if (int.TryParse(input, out number))
{
Console.WriteLine("您输入的是合法整数：" + number);
}
else
{
Console.WriteLine("输入不合法，请输入一个整数！");
}
逻辑分析：
- 使用
int.TryParse方法替代int.Parse，避免抛出异常。 - 若输入合法，返回
true并将结果赋值给number。 - 否则返回
false，提示用户重新输入。
表格：TryParse 与 Parse 的对比
| 方法名 | 是否抛出异常 | 是否需要异常处理 | 返回值类型 | 适用场景 |
|---|---|---|---|---|
| Parse | 是 | 是 | 目标类型 | 输入已知合法时使用 |
| TryParse | 否 | 否 | bool | 用户输入验证首选 |
4.2.2 输入重复提示与循环结构设计
在实际交互中，若用户输入非法，应允许其重新输入。此时可以使用 while 循环实现输入验证与重复提示。
示例代码：
int number;
bool isValid = false;
while (!isValid)
{
Console.Write("请输入一个整数：");
string input = Console.ReadLine();
if (int.TryParse(input, out number))
{
isValid = true;
}
else
{
Console.WriteLine("输入不合法，请重新输入！");
}
}
Console.WriteLine("您输入的整数是：" + number);
逻辑分析：
- 定义
isValid控制循环是否继续。 - 每次输入后使用
TryParse判断是否合法。 - 合法则退出循环，否则继续提示用户输入。
mermaid 流程图：
graph TD
A[开始输入验证循环] --> B{输入是否合法?}
B -->|是| C[设置isValid为true]
B -->|否| D[提示用户重新输入]
C --> E[退出循环]
D --> A
E --> F[输出最终输入结果]
4.3 构建交互式控制台程序
在控制台程序中，良好的交互流程设计能够提升用户体验，使得程序更加直观、易用。
4.3.1 程序交互流程的设计原则
构建交互式程序时应遵循以下设计原则：
- 用户友好性 ：提示信息清晰明了，避免技术术语。
- 流程可控性 ：提供菜单或选项，让用户决定下一步操作。
- 容错性 ：处理非法输入，防止程序崩溃。
- 可扩展性 ：程序结构清晰，便于后期功能扩展。
4.3.2 实现多次运算与用户选择功能
我们可以构建一个简单的四则运算器，让用户选择运算类型，并多次进行运算。
示例代码：
bool exit = false;
while (!exit)
{
Console.WriteLine("请选择操作：");
Console.WriteLine("1. 加法");
Console.WriteLine("2. 减法");
Console.WriteLine("3. 乘法");
Console.WriteLine("4. 除法");
Console.WriteLine("5. 退出");
Console.Write("请输入选项：");
string choice = Console.ReadLine();
switch (choice)
{
case "1":
PerformOperation((a, b) => a + b);
break;
case "2":
PerformOperation((a, b) => a - b);
break;
case "3":
PerformOperation((a, b) => a * b);
break;
case "4":
PerformOperation((a, b) =>
{
if (b == 0)
{
Console.WriteLine("除数不能为零！");
return 0;
}
return a / b;
});
break;
case "5":
exit = true;
Console.WriteLine("程序退出。");
break;
default:
Console.WriteLine("无效选项，请重新选择！");
break;
}
}
void PerformOperation(Func<double, double, double> operation)
{
double a = GetValidNumber("请输入第一个数字：");
double b = GetValidNumber("请输入第二个数字：");
double result = operation(a, b);
Console.WriteLine($"运算结果为：{result}");
}
double GetValidNumber(string prompt)
{
double number;
bool isValid = false;
while (!isValid)
{
Console.Write(prompt);
string input = Console.ReadLine();
if (double.TryParse(input, out number))
{
isValid = true;
}
else
{
Console.WriteLine("输入不合法，请重新输入！");
}
}
return number;
}
逻辑分析：
- 主循环提供菜单选项，支持多次操作。
- 使用
switch判断用户选择，调用对应的运算方法。 PerformOperation接收一个函数作为参数，实现运算逻辑。GetValidNumber方法封装输入验证逻辑，确保输入合法。- 除法运算中增加对除数为零的判断，避免异常。
参数说明：
| 方法名 | 功能描述 |
|---|---|
| PerformOperation | 执行指定的运算逻辑 |
| GetValidNumber | 获取合法的数值输入 |
4.4 面向对象思想的初步应用
面向对象编程（OOP）是现代软件开发的核心思想之一。通过类与对象的组织方式，可以更好地封装数据与行为，提高代码的可维护性和复用性。
4.4.1 定义简单的类与对象
我们可以将四则运算逻辑封装为一个类 Calculator ，并通过对象调用其方法。
示例代码：
class Calculator
{
public double Add(double a, double b)
{
return a + b;
}
public double Subtract(double a, double b)
{
return a - b;
}
public double Multiply(double a, double b)
{
return a * b;
}
public double Divide(double a, double b)
{
if (b == 0)
{
throw new DivideByZeroException("除数不能为零！");
}
return a / b;
}
}
使用示例：
Calculator calc = new Calculator();
double result = calc.Add(5, 3);
Console.WriteLine("加法结果：" + result);
4.4.2 将运算逻辑封装为方法
将运算逻辑封装到类中，可以实现代码复用，并提升程序结构的清晰度。
示例代码（整合类与交互流程）：
class Program
{
static void Main()
{
Calculator calc = new Calculator();
bool exit = false;
while (!exit)
{
Console.WriteLine("请选择操作：");
Console.WriteLine("1. 加法");
Console.WriteLine("2. 减法");
Console.WriteLine("3. 乘法");
Console.WriteLine("4. 除法");
Console.WriteLine("5. 退出");
Console.Write("请输入选项：");
string choice = Console.ReadLine();
switch (choice)
{
case "1":
PerformOperation(calc.Add);
break;
case "2":
PerformOperation(calc.Subtract);
break;
case "3":
PerformOperation(calc.Multiply);
break;
case "4":
try
{
PerformOperation(calc.Divide);
}
catch (DivideByZeroException ex)
{
Console.WriteLine(ex.Message);
}
break;
case "5":
exit = true;
Console.WriteLine("程序退出。");
break;
default:
Console.WriteLine("无效选项，请重新选择！");
break;
}
}
}
static void PerformOperation(Func<double, double, double> operation)
{
double a = GetValidNumber("请输入第一个数字：");
double b = GetValidNumber("请输入第二个数字：");
try
{
double result = operation(a, b);
Console.WriteLine($"运算结果为：{result}");
}
catch (Exception ex)
{
Console.WriteLine("运算过程中发生错误：" + ex.Message);
}
}
static double GetValidNumber(string prompt)
{
double number;
bool isValid = false;
while (!isValid)
{
Console.Write(prompt);
string input = Console.ReadLine();
if (double.TryParse(input, out number))
{
isValid = true;
}
else
{
Console.WriteLine("输入不合法，请重新输入！");
}
}
return number;
}
}
逻辑分析：
Calculator类封装了四种基本运算。Main方法中通过类实例调用运算方法。- 使用
Func<double, double, double>实现通用的运算逻辑调用。 - 异常处理贯穿整个流程，增强程序健壮性。
表格：面向对象与过程式编程对比
| 对比维度 | 面向对象编程 | 过程式编程 |
|---|---|---|
| 数据组织 | 类与对象 | 全局变量与函数 |
| 代码复用性 | 高 | 低 |
| 可维护性 | 易扩展、易维护 | 随着规模增大难以维护 |
| 错误隔离 | 异常处理集中 | 错误分散，不易控制 |
通过本章内容的学习，开发者已经掌握了构建健壮控制台程序所需的核心技能：包括异常处理机制、输入验证策略、交互流程设计以及面向对象的基本应用。这些内容不仅适用于当前的控制台程序开发，也为后续章节中构建完整的四则运算程序打下了坚实的基础。
5. 综合实战——构建完整的四则运算程序
本章将基于前四章所学内容，综合运用C#语言的基本语法、控制台输入输出、数据类型处理、异常控制及面向对象编程思想，构建一个完整的四则运算控制台程序。该程序将支持用户输入两个操作数和一个运算符，输出运算结果，并具备良好的异常处理机制和交互设计。
5.1 程序功能需求分析
5.1.1 基础功能与扩展功能规划
程序的基础功能包括：
- 用户输入两个数字（整数或小数）
- 用户选择运算符（+、-、*、/）
- 程序输出运算结果
- 支持循环操作，用户可选择是否继续运算
扩展功能包括：
- 输入格式校验（防止非法输入）
- 除法时判断除数是否为0
- 提供友好的用户提示和错误反馈
- 支持多次运算直到用户选择退出
5.1.2 用户操作流程图设计
下面使用Mermaid语法绘制用户操作流程图：
graph TD
A[开始程序] --> B[提示用户输入第一个数字]
B --> C{输入是否合法?}
C -->|是| D[提示输入第二个数字]
C -->|否| E[提示错误并重新输入]
D --> F{输入是否合法?}
F -->|是| G[提示输入运算符]
F -->|否| H[提示错误并重新输入]
G --> I{运算符是否合法?}
I -->|是| J[执行运算并输出结果]
I -->|否| K[提示错误并重新输入]
J --> L{是否继续运算?}
L -->|是| B
L -->|否| M[结束程序]
该流程图清晰地展示了用户操作路径，有助于我们在编码过程中设计逻辑结构。
5.2 核心模块的代码实现
5.2.1 输入处理与数据转换模块
以下代码实现了对用户输入的处理和数据类型转换功能：
using System;
class CalculatorApp
{
static void Main()
{
bool continueCalc = true;
while (continueCalc)
{
double num1 = GetValidNumber("请输入第一个数字：");
double num2 = GetValidNumber("请输入第二个数字：");
char op = GetValidOperator();
// 调用运算方法
try
{
double result = Calculate(num1, num2, op);
Console.WriteLine($"运算结果：{result}");
}
catch (Exception ex)
{
Console.WriteLine($"发生错误：{ex.Message}");
}
// 是否继续
Console.Write("是否继续运算？(y/n): ");
string choice = Console.ReadLine();
continueCalc = choice.ToLower() == "y";
}
}
// 获取合法数字输入
static double GetValidNumber(string prompt)
{
double number;
do
{
Console.Write(prompt);
string input = Console.ReadLine();
if (double.TryParse(input, out number))
{
return number;
}
else
{
Console.WriteLine("输入无效，请输入一个有效的数字！");
}
} while (true);
}
// 获取合法运算符
static char GetValidOperator()
{
char op;
do
{
Console.Write("请输入运算符 (+, -, *, /): ");
string input = Console.ReadLine();
if (input.Length == 1 && "+-*/".Contains(input))
{
return input[0];
}
else
{
Console.WriteLine("运算符不合法，请重新输入！");
}
} while (true);
}
}
代码说明：
GetValidNumber方法负责获取合法的数字输入，并进行格式验证。GetValidOperator方法确保用户输入的是合法的四则运算符。- 使用
do-while循环实现输入重试机制，确保输入有效。 try-catch结构用于捕获异常，例如除以零的情况。
5.2.2 运算逻辑与异常处理模块
接下来我们实现 Calculate 方法，包含完整的四则运算逻辑及异常处理：
// 四则运算逻辑
static double Calculate(double num1, double num2, char op)
{
switch (op)
{
case '+':
return num1 + num2;
case '-':
return num1 - num2;
case '*':
return num1 * num2;
case '/':
if (num2 == 0)
throw new DivideByZeroException("除数不能为零！");
return num1 / num2;
default:
throw new ArgumentException("无效的运算符！");
}
}
参数说明：
num1：第一个操作数num2：第二个操作数op：运算符字符（+、-、*、/）
异常处理说明：
- 当除数为0时抛出
DivideByZeroException，在Main方法中被捕获。 - 使用
ArgumentException处理非法运算符输入。
5.3 程序测试与优化
5.3.1 常见错误场景测试
| 测试用例编号 | 输入1 | 输入2 | 运算符 | 预期结果 | 实际结果 |
|---|---|---|---|---|---|
| TC01 | 10 | 5 | + | 15 | 通过 |
| TC02 | 8 | 3 | / | 2.666… | 通过 |
| TC03 | abc | - | - | 错误提示 | 通过 |
| TC04 | 5 | 0 | / | 报错提示 | 通过 |
| TC05 | 5 | 2 | % | 报错提示 | 通过 |
5.3.2 用户体验优化建议
- 增加欢迎语和退出提示，提升交互友好性
- 增加清屏功能，避免界面混乱
- 支持输入“exit”或“quit”退出程序
- 添加版本信息和作者说明
- 使用颜色高亮关键提示信息（如错误信息使用红色）
优化示例代码片段（添加欢迎信息和颜色提示）：
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("欢迎使用简易四则运算程序！");
Console.ResetColor();
5.4 项目部署与运行
5.4.1 编译生成可执行文件
在 Visual Studio 2010 中编译项目：
- 打开项目 → 右键项目 → 选择“生成”或“重新生成”
- 在输出窗口查看编译结果
- 编译成功后，在项目目录下的
bin\Debug或bin\Release文件夹中找到.exe文件
5.4.2 在不同系统环境中运行程序
- Windows 系统 ：直接运行
.exe文件即可 - Linux / macOS ：需要使用 .NET Core 或 Mono 运行环境
- 安装 Mono：
sudo apt install mono-complete（Ubuntu） - 运行命令：
mono CalculatorApp.exe
注意：如果目标系统未安装 .NET Framework，可能需要发布为独立程序集，或使用 ClickOnce 部署方案。
（本章内容到此结束）
简介：本项目使用Visual Studio 2010开发环境，采用C#语言实现了一个简单的四则运算程序，涵盖加减乘除基本运算。程序通过控制台实现用户交互，包括输入处理、类型转换、运算逻辑和结果输出。项目还包括异常处理（如除零异常）和输入验证机制，适合编程初学者学习C#基础语法、控制流程和错误处理机制，是掌握面向对象编程思维的良好入门实践。
更多推荐
5
0- 0
已为社区贡献21条内容
所有评论(0)