C#程序结构：顺序结构 - 《C#编程指南》 - 严富坤的知识库专栏(yanfukun.com)

引言
基本语法和结构
- C# 程序的基本结构
变量和常量
- 变量
- 常量
数据类型
- 值类型
- 引用类型
运算符
- 算术运算符
- 关系运算符
- 逻辑运算符
- 赋值运算符
输入和输出
- 输出
- 输入
控制结构
- 条件语句
  - if 语句
  - switch 语句
- 循环语句
方法
- 方法声明
- 方法调用
- 方法重载
- 可选参数
类和对象
- 类的定义
- 创建对象
- 继承
- 多态
异常处理
- try-catch 语句
- finally 语句
- 抛出异常
文件操作
- 读取文件
- 写入文件
- 文件存在性检查
异步编程
- async 和 await 关键字
- Task 类
事件
- 定义事件
- 订阅和触发事件
委托
- 定义委托
- 使用委托
- 多播委托
Lambda 表达式
- 定义 Lambda 表达式
- Lambda 表达式与 LINQ
LINQ
- LINQ 查询语法
- LINQ 方法语法
属性
- 自动属性
- 手动属性
索引器
- 定义索引器
- 使用索引器
接口
- 定义接口
- 实现接口
- 接口多重继承
抽象类
- 定义抽象类
- 继承抽象类
枚举
- 定义枚举
- 使用枚举
嵌套类
- 定义嵌套类
- 使用嵌套类
泛型
- 泛型类
- 泛型方法
扩展方法
- 定义扩展方法
空值处理
- 可空类型
- 空合并运算符
- 空条件运算符
类型比较
- 使用 is 运算符
- 使用 as 运算符
类型转换和模式匹配
- 模式匹配
异常处理
- 自定义异常
- 异常过滤器
类型推断和异步编程
- 异步编程
反射
- 使用反射获取类型信息
- 动态调用方法
总结

C# 是一种现代、通用的编程语言，由微软在2000年发布。作为一种面向对象的语言，C# 提供了丰富的语法和功能，能够满足各种应用程序开发的需求。程序结构是编程语言的基础，决定了代码的组织和执行顺序。在所有的程序结构中，顺序结构是最基本的，它决定了程序的执行顺序从上到下，逐行执行代码。本篇文章将深入探讨C#中顺序结构的细节和应用，帮助读者更好地理解和掌握这一基础概念。

引言

顺序结构是所有程序中最基本的控制结构。它表示程序中的指令按它们在源代码中出现的顺序一条接一条地执行，直到程序结束。理解顺序结构是掌握编程的第一步，对于编写清晰、易懂、逻辑性强的代码至关重要。

基本语法和结构

C# 程序的基本结构

一个典型的C#程序包括以下几个部分：

命名空间声明：命名空间用于组织代码，避免名称冲突。
类定义：类是C#的基本构建块，包含数据和方法。
方法：方法是执行代码的地方，Main方法是程序的入口点。
语句：每个语句表示一个独立的操作，按照顺序执行。

以下是一个简单的C#程序的示例：

using System;
namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }
    }
}

在这个示例中，Main方法中的语句按顺序执行，首先是输出 “Hello, World!” 到控制台。

变量和常量

变量

变量是存储数据的命名空间。在C#中，变量必须先声明后使用，声明时需要指定变量的类型。变量的声明和赋值是顺序结构中的基本操作。

int number; // 声明一个整数变量
number = 10; // 给变量赋值

可以在声明时直接赋值：

int number = 10; // 声明并赋值

常量

常量是指在程序执行过程中其值不会改变的变量。使用 const 关键字声明常量：

const int MaxValue = 100;

常量在声明时必须初始化，并且之后不能改变它的值。

数据类型

C# 提供了丰富的数据类型，以满足不同的数据存储需求。数据类型分为值类型和引用类型。

值类型

值类型直接存储数据，常见的值类型包括：

整型：int、short、long 等
浮点型：float、double
字符型：char
布尔型：bool

示例：

int age = 30;
float temperature = 36.6f;
char grade = 'A';
bool isStudent = true;

引用类型

引用类型存储的是数据的引用，包括：

字符串：string
数组：array
类：class
接口：interface
委托：delegate

示例：

string name = "Alice";
int[] scores = { 90, 85, 100 };

运算符

运算符用于执行各种操作。C# 提供了多种运算符，包括算术运算符、关系运算符、逻辑运算符和赋值运算符。

算术运算符

用于执行基本的数学运算：

+：加法
-：减法
*：乘法
/：除法
%：取余

示例：

int sum = 10 + 5; // 15
int difference = 10 - 5; // 5
int product = 10 * 5; // 50
int quotient = 10 / 5; // 2
int remainder = 10 % 3; // 1

关系运算符

用于比较两个值：

==：等于
!=：不等于
>：大于
<：小于
>=：大于或等于
<=：小于或等于

示例：

bool isEqual = (10 == 10); // true
bool isNotEqual = (10 != 5); // true
bool isGreater = (10 > 5); // true
bool isLess = (5 < 10); // true

逻辑运算符

用于执行逻辑操作：

&&：逻辑与
||：逻辑或
!：逻辑非

示例：

bool result1 = (10 > 5) && (5 < 10); // true
bool result2 = (10 > 5) || (5 > 10); // true
bool result3 = !(10 > 5); // false

赋值运算符

用于给变量赋值：

=：赋值
+=：加法赋值
-=：减法赋值
*=：乘法赋值
/=：除法赋值
%=：取余赋值

示例：

int a = 10;
a += 5; // a = 15
a -= 3; // a = 12
a *= 2; // a = 24
a /= 4; // a = 6
a %= 5; // a = 1

输入和输出

输入和输出是程序与用户交互的重要部分。C# 提供了 Console 类来处理控制台的输入和输出。

输出

使用 Console.WriteLine 方法将文本输出到控制台：

Console.WriteLine("Hello, World!");

输入

使用 Console.ReadLine 方法从控制台读取用户输入：

Console.WriteLine("Enter your name:");
string name = Console.ReadLine();
Console.WriteLine($"Hello, {name}!");

控制结构

控制结构用于改变程序的执行顺序，主要包括条件语句和循环语句。虽然这些并不属于顺序结构的范畴，但理解它们对于全面掌握C#编程是必要的。

条件语句

条件语句根据表达式的真假来决定执行的代码块。

if 语句

int number = 10;
if (number > 0)
{
    Console.WriteLine("Positive number");
}
else if (number < 0)
{
    Console.WriteLine("Negative number");
}
else
{
    Console.WriteLine("Zero");
}

switch 语句

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("Monday");
        break;
    case 2:
        Console.WriteLine("Tuesday");
        break;
    case 3:
        Console.WriteLine("Wednesday");
        break;
    default:
        Console.WriteLine("Invalid day");
        break;
}

循环语句

循环语句用于重复执行一段代码。

for 循环

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

while 循环

int i = 0;
while (i < 10)
{
    Console.WriteLine(i);
    i++;
}

do-while 循环

int i = 0;
do
{
    Console.WriteLine(i);
    i++;
} while (i < 10);

foreach 循环

int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

方法

方法是执行特定任务的代码块。方法可以接受参数，并返回值。

方法声明

public int Add(int a, int b)
{
    return a + b;
}

方法调用

int result = Add(5, 10);
Console.WriteLine(result); // 输出 15

方法重载

方法重载是指在同一个类中可以定义多个具有相同名称但参数不同的方法。

public int Add(int a, int b)
{
    return a + b;
}
public double Add(double a, double b)
{
    return a + b;
}

可选参数

C# 支持为方法定义可选参数，如果调用方法时没有提供这些参数，则使用默认值。

public void PrintMessage(string message = "Hello, World!")
{
    Console.WriteLine(message);
}
PrintMessage(); // 输出 "Hello, World!"
PrintMessage("Hi there!"); // 输出 "Hi there!"

类和对象

C# 是一种面向对象的编程语言，类和对象是其核心概念。

类的定义

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {Name} and I'm {Age} years old.");
    }
}

创建对象

Person person = new Person { Name = "Alice", Age = 25 };
person.Introduce(); // 输出 "Hi, I'm Alice and I'm 25 years old."

继承

public class Employee : Person
{
    public string Company { get; set; }
    public void Work()
    {
        Console.WriteLine($"{Name} is working at {Company}.");
    }
}
Employee employee = new Employee { Name = "Bob", Age = 30, Company = "ACME Corp" };
employee.Introduce(); // 输出 "Hi, I'm Bob and I'm 30 years old."
employee.Work(); // 输出 "Bob is working at ACME Corp."

多态

多态允许使用基类的引用来调用子类的方法。

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks.");
    }
}
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks.");
    }
}
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Cat meows.");
    }
}
Animal myDog = new Dog();
Animal myCat = new Cat();
myDog.Speak(); // 输出 "Dog barks."
myCat.Speak(); // 输出 "Cat meows."

异常处理

异常处理是指在程序运行过程中捕获和处理异常，以防止程序崩溃并提供有意义的错误信息。

try-catch 语句

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}
catch (Exception ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

finally 语句

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}
finally
{
    Console.WriteLine("Execution completed.");
}

抛出异常

public void Divide(int a, int b)
{
    if (b == 0)
    {
        throw new DivideByZeroException("Divisor cannot be zero.");
    }
    Console.WriteLine(a / b);
}
try
{
    Divide(10, 0);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine(ex.Message);
}

文件操作

C# 提供了丰富的文件操作类，用于读取和写入文件。

读取文件

using System.IO;
string path = "example.txt";
using (StreamReader reader = new StreamReader(path))
{
    string content = reader.ReadToEnd();
    Console.WriteLine(content);
}

写入文件

using System.IO;
string path = "example.txt";
string content = "Hello, world!";
using (StreamWriter writer = new StreamWriter(path))
{
    writer.WriteLine(content);
}

文件存在性检查

string path = "example.txt";
if (File.Exists(path))
{
    Console.WriteLine("File exists.");
}
else
{
    Console.WriteLine("File does not exist.");
}

异步编程

异步编程是一种编程模式，允许程序在等待某些操作完成时不阻塞主线程。

async 和 await 关键字

using System.Net.Http;
using System.Threading.Tasks;
public async Task<string> FetchDataAsync(string url)
{
    using (HttpClient client = new HttpClient())
    {
        string result = await client.GetStringAsync(url);
        return result;
    }
}
async Task Main()
{
    string data = await FetchDataAsync("http://example.com");
    Console.WriteLine(data);
}

Task 类

public async Task<int> ComputeAsync(int a, int b)
{
    return await Task.Run(() =>
    {
        // 模拟长时间计算
        System.Threading.Thread.Sleep(2000);
        return a + b;
    });
}
async Task Main()
{
    int result = await ComputeAsync(5, 10);
    Console.WriteLine(result); // 输出 15
}

事件

事件是一种用于在对象之间传递消息的机制，常用于实现事件驱动编程。

定义事件

public class Alarm
{
    public event EventHandler Ring;
    public void Trigger()
    {
        if (Ring != null)
        {
            Ring(this, EventArgs.Empty);
        }
    }
}

订阅和触发事件

public class Program
{
    static void Main()
    {
        Alarm alarm = new Alarm();
        alarm.Ring += Alarm_Ring;
        alarm.Trigger();
    }
    private static void Alarm_Ring(object sender, EventArgs e)
    {
        Console.WriteLine("Alarm triggered!");
    }
}

委托

委托是C#中的一种类型安全的函数指针，允许你将方法作为参数传递。

定义委托

public delegate void Notify(string message);

使用委托

public class Program
{
    public static void Main()
    {
        Notify notify = new Notify(ShowMessage);
        notify("Hello, delegates!");
    }
    public static void ShowMessage(string message)
    {
        Console.WriteLine(message);
    }
}

多播委托

多播委托可以指向多个方法，并依次调用这些方法。

public delegate void Notify(string message);
public class Program
{
    public static void Main()
    {
        Notify notify = ShowMessage;
        notify += ShowAnotherMessage;
        notify("Hello, delegates!");
    }
    public static void ShowMessage(string message)
    {
        Console.WriteLine("Message: " + message);
    }
    public static void ShowAnotherMessage(string message)
    {
        Console.WriteLine("Another message: " + message);
    }
}

Lambda 表达式

Lambda 表达式是一种简洁的匿名函数语法，常用于简化委托和 LINQ 表达式。

定义 Lambda 表达式

Func<int, int, int> add = (a, b) => a + b;
int result = add(5, 10); // 输出 15

Lambda 表达式与 LINQ

结合 Lambda 表达式和 LINQ 查询数据：

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);
foreach (int number in evenNumbers)
{
    Console.WriteLine(number); // 输出 2 4
}

LINQ

语言集成查询（LINQ）是一种查询数据的功能，允许你使用类似SQL的语法来查询集合。

LINQ 查询语法

使用 LINQ 查询语法查询数据：

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = from number in numbers
                  where number % 2 == 0
                  select number;
foreach (int number in evenNumbers)
{
    Console.WriteLine(number); // 输出 2 4
}

LINQ 方法语法

使用 LINQ 方法语法查询数据：

int[] numbers = { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0).Select(n => n);
foreach (int number in evenNumbers)
{
    Console.WriteLine(number); // 输出 2 4
}

属性

属性是类中的变量，通过访问器（getter 和 setter）来控制对这些变量的访问。

自动属性

使用自动属性简化属性定义：

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

手动属性

使用手动属性定义带有访问器的属性：

public class Person
{
    private int age;
    public int Age
    {
        get { return age; }
        set
        {
            if (value >= 0)
            {
                age = value;
            }
        }
    }
}

索引器

索引器允许类像数组一样通过索引访问其内部数据。

定义索引器

使用 this 关键字定义索引器：

public class DataCollection
{
    private int[] data = new int[10];
    public int this[int index]
    {
        get { return data[index]; }
        set
 { data[index] = value; }
    }
}

使用索引器

创建对象并通过索引器访问数据：

DataCollection collection = new DataCollection();
collection[0] = 42;
int value = collection[0]; // 42

接口

接口定义了一组方法和属性的规范，而不提供实现。

定义接口

使用 interface 关键字定义接口：

public interface IMovable
{
    void Move();
}

实现接口

使用 : 符号实现接口：

public class Car : IMovable
{
    public void Move()
    {
        Console.WriteLine("Car is moving.");
    }
}

接口多重继承

一个类可以实现多个接口：

public interface IFlyable
{
    void Fly();
}
public class FlyingCar : IMovable, IFlyable
{
    public void Move()
    {
        Console.WriteLine("FlyingCar is moving.");
    }
    public void Fly()
    {
        Console.WriteLine("FlyingCar is flying.");
    }
}

抽象类

抽象类是不能被实例化的类，通常用于作为其他类的基类。

定义抽象类

使用 abstract 关键字定义抽象类和抽象方法：

public abstract class Animal
{
    public abstract void Speak();
}

继承抽象类

使用 override 关键字重写抽象方法：

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks.");
    }
}
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Cat meows.");
    }
}

枚举

枚举是定义一组命名常量的类型，通常用于表示一组相关的值。

定义枚举

使用 enum 关键字定义枚举：

public enum DaysOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

使用枚举

创建枚举变量并赋值：

DaysOfWeek today = DaysOfWeek.Monday;
if (today == DaysOfWeek.Monday)
{
    Console.WriteLine("Today is Monday.");
}

嵌套类

嵌套类是定义在另一个类内部的类，用于组织相关的类。

定义嵌套类

在外部类内部定义嵌套类：

public class OuterClass
{
    public class NestedClass
    {
        public void Display()
        {
            Console.WriteLine("This is a nested class.");
        }
    }
}

使用嵌套类

创建嵌套类的实例并调用其方法：

OuterClass.NestedClass nested = new OuterClass.NestedClass();
nested.Display(); // 输出 "This is a nested class."

泛型

泛型允许定义类、接口和方法时使用类型参数，从而使代码更加通用和类型安全。

泛型类

定义泛型类：

public class GenericList<T>
{
    private T[] items = new T[100];
    private int count = 0;
    public void Add(T item)
    {
        items[count++] = item;
    }
    public T Get(int index)
    {
        return items[index];
    }
}
GenericList<int> intList = new GenericList<int>();
intList.Add(1);
intList.Add(2);
Console.WriteLine(intList.Get(1)); // 输出 2

泛型方法

定义泛型方法：

public class Utilities
{
    public T Max<T>(T a, T b) where T : IComparable<T>
    {
        return a.CompareTo(b) > 0 ? a : b;
    }
}
Utilities utilities = new Utilities();
int maxInt = utilities.Max(10, 20); // 20
string maxString = utilities.Max("apple", "banana"); // "banana"

扩展方法

扩展方法允许向现有类型添加新方法，而无需修改类型本身。扩展方法必须在静态类中定义，并且第一个参数使用 this 关键字指定要扩展的类型。

定义扩展方法

示例代码：

public static class StringExtensions
{
    public static int WordCount(this string str)
    {
        return str.Split(new char[] { ' ', '.', '?' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}
string text = "Hello, world!";
int count = text.WordCount();
Console.WriteLine($"Word count: {count}"); // 输出 "Word count: 2"

空值处理

C# 提供了一些工具来处理可能为空的引用类型和值类型。

可空类型

可空类型允许值类型可以为 null，使用 ? 语法表示。

示例代码：

int? nullableInt = null;
if (nullableInt.HasValue)
{
    Console.WriteLine($"Value: {nullableInt.Value}");
}
else
{
    Console.WriteLine("Value is null");
}

空合并运算符

空合并运算符 ?? 用于简化空值检查和默认值赋值。

示例代码：

string message = null;
string displayMessage = message ?? "Default message";
Console.WriteLine(displayMessage); // 输出 "Default message"

空条件运算符

空条件运算符 ?. 用于安全地调用可能为空的对象成员。

示例代码：

Person person = null;
int? age = person?.Age;
Console.WriteLine($"Age: {age}"); // 输出 "Age: "

类型比较

类型比较是指在运行时检查对象的类型，以便根据类型执行不同的操作。

使用 `is` 运算符

is 运算符用于检查对象是否为指定类型。

示例代码：

object obj = "Hello, world!";
if (obj is string)
{
    Console.WriteLine("obj is a string");
}

使用 `as` 运算符

as 运算符用于尝试将对象转换为指定类型，如果转换失败，则返回 null。

示例代码：

object obj = "Hello, world!";
string str = obj as string;
if (str != null)
{
    Console.WriteLine("Conversion succeeded");
}
else
{
    Console.WriteLine("Conversion failed");
}

类型转换和模式匹配

C# 提供了多种类型转换和模式匹配的方法，使得代码更简洁、更安全。

模式匹配

C# 7.0 引入了模式匹配语法，允许在 switch 语句和 is 表达式中使用模式匹配。

示例代码：

object obj = "Hello, world!";
if (obj is string str)
{
    Console.WriteLine($"String length: {str.Length}");
}
switch (obj)
{
    case int i:
        Console.WriteLine($"Integer: {i}");
        break;
    case string s:
        Console.WriteLine($"String: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}

异常处理

异常处理是捕获和处理运行时错误的重要机制。C# 提供了丰富的异常处理工具，包括自定义异常、异常过滤器等。

自定义异常

自定义异常类继承自 Exception 类。

示例代码：

public class CustomException : Exception
{
    public CustomException(string message) : base(message) { }
}
public class Program
{
    public static void Main()
    {
        try
        {
            throw new CustomException("This is a custom exception.");
        }
        catch (CustomException ex)
        {
            Console.WriteLine(ex.Message);
        }
    }
}

异常过滤器

异常过滤器允许根据条件捕获异常。

示例代码：

try
{
    throw new InvalidOperationException("Invalid operation");
}
catch (Exception ex) when (ex.Message.Contains("Invalid"))
{
    Console.WriteLine("Caught invalid operation exception");
}

类型推断和异步编程

C# 支持类型推断和异步编程，使代码更加简洁和高效。

异步编程

异步编程允许在不阻塞主线程的情况下执行长时间运行的操作。

示例代码：

using System.Net.Http;
using System.Threading.Tasks;
public class Program
{
    public static async Task Main()
    {
        string url = "http://example.com";
        string content = await FetchContentAsync(url);
        Console.WriteLine(content);
    }
    public static async Task<string> FetchContentAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            return await client.GetStringAsync(url);
        }
    }
}

反射

反射是一种在运行时检查和操作类型信息的机制。它允许动态创建对象、调用方法和访问字段和属性。

使用反射获取类型信息

示例代码：


using System;
using System.Reflection;
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public void Introduce()
    {
        Console.WriteLine($"Hi, I'm {Name} and I'm {Age} years old.");
    }
}
Type type = typeof(Person);
Console.WriteLine($"Type: {type.Name}");
PropertyInfo[] properties = type.GetProperties();
foreach (PropertyInfo property in properties)
{
    Console.WriteLine($"Property: {property.Name}");
}
MethodInfo method = type.GetMethod("Introduce");
Console.WriteLine($"Method: {method.Name}");

动态调用方法

示例代码：

Person person = new Person { Name = "Alice", Age = 25 };
MethodInfo method = typeof(Person).GetMethod("Introduce");
method.Invoke(person, null); // 输出 "Hi, I'm Alice and I'm 25 years old."

总结

C# 的顺序结构是编程的基础，通过学习顺序结构，开发者可以掌握如何按顺序执行代码，声明和使用变量，处理输入输出，使用基本运算符和控制结构。顺序结构在所有编程语言中都是最基本的部分，理解它是掌握编程的第一步。希望本文能够帮助读者全面了解C#的顺序结构，并在实际编程中灵活运用。