《C# 编程入门全攻略：从基础到进阶的学习秘籍》

全栈ACE

于 2025-03-31 13:45:18 发布

阅读量928

点赞数 33

分类专栏： C#开发指南文章标签： c#

本文链接：https://blog.youkuaiyun.com/zhu1996zhu/article/details/146817200

版权

C#开发指南专栏收录该内容

6 篇文章

订阅专栏

一、开启学习之旅前的准备

在踏入 C# 学习的大门之前，先让自己对编程有一个整体的、初步的认知是很有必要的。你可以想象编程就像是给计算机下达一系列详细的指令，让它按照我们期望的方式去完成任务。了解一些基本的计算机基础知识，比如计算机是如何存储和处理数据的，操作系统的基本功能等，这些背景知识会帮助你更好地理解后续 C# 编程中的各种概念。

二、搭建学习环境

（一）安装集成开发环境（IDE）

对于 C# 编程来说，一个合适且功能强大的集成开发环境（IDE）至关重要，这里首推 Visual Studio。它是由微软官方打造的，专为开发 C# 等.NET 应用程序而设计，集代码编写、调试、编译等多种功能于一身。

你可以通过微软官方网站下载 Visual Studio 的安装包，在安装过程中，要注意选择合适的工作负载，对于初学者而言，选择 “.NET 桌面开发” 这个工作负载基本就能满足初期学习和实践的需求了。安装完成后，打开 Visual Studio，你会看到一个功能丰富、界面友好的开发平台，它将陪伴你完成每一个 C# 项目的创建与开发。

（二）了解 IDE 的基本布局和常用功能

初次接触 Visual Studio 可能会觉得有些复杂，但不用担心，我们先熟悉一些基本的部分就好。比如，有用于编写代码的代码编辑器窗口，在这里你将输入所有的 C# 代码语句；有解决方案资源管理器窗口，通过它可以清晰地看到整个项目的文件结构，方便对各个代码文件进行管理；还有调试工具栏，在后续查找代码中的错误、跟踪程序运行流程时会经常用到。花些时间在 IDE 里随意点击、查看，逐渐熟悉各个功能区域的作用，这会让你后续的编程过程更加顺畅。

三、基础语法学习阶段

（一）“Hello, World!” 程序 —— 编程世界的第一声问候

学习任何编程语言，编写一个经典的 “Hello, World!” 程序都是一个很好的起点。在 Visual Studio 中创建一个新的控制台应用程序项目，操作步骤大致如下：

打开 Visual Studio 后，点击 “创建新项目”，在弹出的对话框中选择 “控制台应用（.NET）” 模板，然后按照提示填写项目名称、选择保存位置等信息，点击 “创建” 按钮，一个空白的控制台应用项目就创建好了。

接着，在自动生成的代码文件（一般是Program.cs）中，你会看到如下类似的代码结构：

csharp

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

这就是一个简单的 C# 程序示例，using System;这一行是引入了必要的命名空间，让我们可以使用像Console这样的类。class Program定义了一个名为Program的类，而static void Main()方法则是整个程序的入口点，也就是程序开始运行的地方。在Main方法里，Console.WriteLine("Hello, World!");语句的作用是在控制台输出 “Hello, World!” 这句话。

你可以点击 Visual Studio 的 “运行” 按钮（通常是一个绿色的三角形图标），看看程序运行的结果，是不是很有成就感呢？通过这个简单的程序，你不仅熟悉了 IDE 的基本操作，也初步接触到了 C# 的语法结构。

（二）数据类型和变量 —— 给信息找个 “家”

C# 中有多种数据类型，每种类型都用于存储特定种类的数据，就像不同大小和功能的盒子用来装不同的物品一样。

整数类型：
- int：这是最常用的整数类型，用于存储整数，范围大致是从 -2,147,483,648 到 2,147,483,647。例如，你可以这样声明一个int类型的变量并赋值：int num = 10;，这就相当于创建了一个名为num的 “盒子”，并往里面放了数字10。
- long：如果需要存储更大范围的整数，可以使用long类型，它的范围比int更大。声明方式如：long bigNum = 1234567890123456789L;（注意这里末尾的L是用来区分它和int类型的，不能省略哦）。
浮点类型：
- float：用于存储带有小数部分的数字，也就是浮点数。声明时需要在数字后面加上f后缀，例如：float pi = 3.14f;。
- double：它比float能表示的精度更高、范围更广，通常在不特别指定的情况下，小数会被默认当作double类型处理。像double price = 9.99;这样就声明了一个double类型的变量来表示价格。
字符类型：
char类型用于存储单个字符，要用单引号括起来，比如：char grade = 'A';，这里就把字符A存储到了grade这个变量中。
布尔类型：
bool类型只有两个值，true（真）和false（假），常用于表示条件判断的结果，例如：bool isSunny = true;，可以用来表示天气是否晴朗这样的逻辑判断。

在使用变量时，要遵循先声明后使用的原则，并且变量的命名也要遵循一定的规范，比如要具有描述性，一般采用驼峰命名法（像studentName这样，首字母小写，后面每个单词首字母大写）等，方便自己和他人理解代码的含义。

（三）控制结构 —— 掌控程序的运行 “路线”

条件语句（if/else 和 switch）：
- if/else语句就像是生活中的决策过程，根据不同的条件来决定执行不同的操作。例如，判断一个学生的成绩是否及格：

csharp

int score = 80;
if (score >= 60)
{
    Console.WriteLine("及格了，继续加油哦！");
}
else
{
    Console.WriteLine("很遗憾，没及格，要努力学习呀。");
}

这里首先定义了一个变量score表示成绩，然后通过if语句判断成绩是否大于等于60分，如果满足条件，就输出及格的提示信息，不满足的话则执行else部分输出不及格的提示。

switch语句则适用于有多个固定分支情况的判断，比如根据星期几来输出不同的活动安排：

csharp

int day = 3;
switch (day)
{
    case 1:
        Console.WriteLine("星期一，要上班/上学啦，元气满满哦！");
        break;
    case 2:
        Console.WriteLine("星期二，继续努力呀！");
        break;
    case 3:
        Console.WriteLine("星期三，已经过半了，加油！");
        break;
    case 4:
        Console.WriteLine("星期四，快到周末啦，期待一下吧！");
        break;
    case 5:
        Console.WriteLine("星期五，开心，明天就可以休息咯！");
        break;
    case 6:
        Console.WriteLine("星期六，可以尽情放松啦！");
        break;
    case 7:
        Console.WriteLine("星期日，好好享受假期的最后时光哦。");
        break;
    default:
        Console.WriteLine("输入的数字不符合星期的范围呀，请重新输入。");
        break;
}

在这个例子中，根据变量day的值来匹配不同的case情况，然后执行相应的代码块，break语句很重要，它用于跳出switch语句，避免出现意外的执行结果。

循环语句（for、while 和 foreach）：
循环语句可以让程序重复执行某一段代码，大大提高了代码的复用性和效率。

for循环通常用于已知循环次数的情况，比如打印出1到10的数字：

csharp

for (int i = 1; i <= 10; i++)
{
    Console.Write(i + " ");
}

这里for循环的括号里有三个部分，第一部分int i = 1是初始化循环变量，第二部分i <= 10是循环条件，只要这个条件满足，循环就会继续执行，第三部分i++是每次循环结束后对循环变量进行的操作（在这里就是让i的值加1）。

while循环则是在满足某个条件时一直执行循环体里的代码，例如，用while循环实现计算1到100的累加和：

csharp

int sum = 0;
int j = 1;
while (j <= 100)
{
    sum += j;
    j++;
}
Console.WriteLine("1到100的累加和是：" + sum);

在这个例子中，只要j的值小于等于100，就会不断执行循环体里的累加操作，直到条件不满足为止。

foreach循环主要用于遍历数组、集合等类型的数据，比如遍历一个字符串数组：

csharp

string[] fruits = { "苹果", "香蕉", "橙子" };
foreach (string fruit in fruits)
{
    Console.WriteLine(fruit);
}

它会自动依次取出数组里的每个元素，赋值给变量fruit，然后执行循环体里的代码，这样就能方便地对数组中的每个元素进行操作了。

（四）函数和方法 —— 代码的 “小模块”

在 C# 中，我们可以把一段具有特定功能的代码封装到一个函数（或者叫方法）里，这样可以让代码更加模块化，便于管理和复用。

例如，我们可以定义一个简单的函数来计算两个整数的和：

csharp

static int Add(int num1, int num2)
{
    return num1 + num2;
}

在这个函数定义中，static表示这是一个静态方法（对于初学者来说，先按这个方式来定义就好，后续会深入了解静态和非静态的区别），int是函数的返回类型，表示这个函数执行完后会返回一个整数，Add是函数的名字，括号里的int num1和int num2是函数的参数，用于接收外部传入的值。

要调用这个函数并获取结果，可以这样写：

csharp

int result = Add(5, 3);
Console.WriteLine("5和3的和是：" + result);

通过这样的方式，我们可以把复杂的程序逻辑分解成一个个小的函数，每个函数负责一个小功能，让整个代码结构更加清晰明了。

（五）数组和集合 —— 数据的 “收纳箱”

数组：
数组是一种用于存储多个相同类型数据的容器，它的大小在创建时就固定了。例如，创建一个存储整数的数组：

csharp

int[] numbers = { 1, 2, 3, 4, 5 };

这就创建了一个名为numbers的数组，里面存放了5个整数元素。我们可以通过索引（下标）来访问数组中的元素，索引是从0开始的，比如要获取数组中的第三个元素，可以这样写：int thirdNumber = numbers[2];（注意这里索引是2，因为是从0开始计数的哦）。

也可以先声明数组，再给它赋值，比如：

csharp

int[] scores;
scores = new int[10]; // 创建一个可以存放10个整数的数组，初始值都是0
scores[0] = 85; // 给第一个元素赋值为85

列表（List）：
列表是一种更加灵活的集合类型，它可以动态地增加或减少元素个数。使用前需要先引入System.Collections.Generic命名空间，然后就可以这样创建和使用列表了：

csharp

using System.Collections.Generic;

List<string> names = new List<string>(); // 创建一个空的字符串列表
names.Add("张三"); // 添加元素
names.Add("李四");
Console.WriteLine("列表里的第一个名字是：" + names[0]); // 访问元素，同样是从0开始索引
names.Remove("李四"); // 删除元素

列表提供了很多方便的方法来操作其中的元素，比如Add用于添加元素，Remove用于删除元素，Count属性可以获取列表中元素的个数等等，让我们在处理一组数据时更加得心应手。

四、面向对象编程阶段

（一）类和对象 —— 构建编程世界的 “万物”

在面向对象编程中，类就像是一个 “蓝图” 或者 “模板”，它定义了一种对象应该具有的属性（也就是数据）和行为（也就是方法）。

例如，我们要创建一个描述 “汽车” 的类，可以这样写：

csharp

class Car
{
    // 属性，用来描述汽车的一些特征
    public string Brand { get; set; }
    public string Color { get; set; }
    public int Speed { get; set; }

    // 方法，用来定义汽车能做的事情
    public void Start()
    {
        Console.WriteLine($"{Brand} {Color}的汽车启动了，当前速度为 {Speed} km/h。");
    }
}

在这个Car类中，定义了三个属性Brand（品牌）、Color（颜色）和Speed（速度），它们都是公共的（用public修饰），意味着可以在类的外部访问和修改这些属性的值。同时还定义了一个Start方法，用来模拟汽车启动的行为。

有了类之后，就可以根据这个 “蓝图” 创建具体的对象了，就像按照汽车设计图纸制造出实实在在的汽车一样。创建对象的方式如下：

csharp

Car myCar = new Car();
myCar.Brand = "丰田";
myCar.Color = "白色";
myCar.Speed = 0;
myCar.Start();

这里首先通过Car myCar = new Car();创建了一个Car类的对象myCar，然后分别给对象的属性赋值，最后调用Start方法，就可以看到对应的输出信息了，这样就实现了基于类创建对象并让对象执行相应行为的过程。

（二）继承和多态 —— 代码复用与多样化的 “魔法”

继承：
继承是面向对象编程中的一个重要特性，它允许我们创建一个新的类（子类），这个子类可以继承另一个类（父类）的属性和方法，就像是孩子继承了父母的某些特征一样。

比如，我们已经有了一个Vehicle（交通工具）类，它具有一些通用的属性和方法，像轮子数量、行驶的方法等：

csharp

class Vehicle
{
    public int Wheels { get; set; }

    public void Move()
    {
        Console.WriteLine($"这个交通工具正在移动，它有 {Wheels} 个轮子。");
    }
}

现在我们想要创建一个专门描述 “自行车” 的类，自行车也是一种交通工具，所以它可以继承自Vehicle类，并且可以添加自己特有的属性和方法，比如有无脚撑这个属性：

csharp

class Bicycle : Vehicle
{
    public bool HasKickstand { get; set; }

    public void RingBell()
    {
        Console.WriteLine("自行车按铃啦，叮铃铃~");
    }
}

在这个例子中，Bicycle类通过:后面跟着Vehicle来表示它继承自Vehicle类，这样Bicycle类就自动拥有了Vehicle类中的Wheels属性和Move方法，同时还可以定义自己独有的属性和方法。我们可以创建Bicycle类的对象并使用这些属性和方法：

csharp

Bicycle myBike = new Bicycle();
myBike.Wheels = 2;
myBike.HasKickstand = true;
myBike.Move();
myBike.RingBell();

通过继承，大大提高了代码的复用性，避免了重复编写相同的代码。

多态：
多态则是让不同的类对象可以以各自的方式响应相同的方法调用，使得代码更加灵活和可扩展。

还是以上面的例子来说，我们可以定义一个方法，它接收一个Vehicle类型的参数，然后调用Move方法，不管传入的是Vehicle类的对象，还是它的子类（比如Bicycle类）的对象，都能正确地执行对应的Move方法：

csharp

static void MakeVehicleMove(Vehicle vehicle)
{
    vehicle.Move();
}

Vehicle car = new Car();
car.Wheels = 4;
MakeVehicleMove(car);

Bicycle bike = new Bicycle();
bike.Wheels = 2;
MakeVehicleMove(bike);

在这个例子中，MakeVehicleMove方法并不知道具体传入的是哪种交通工具对象，但它都能正确调用对应的Move方法，这就是多态的体现，让代码可以更方便地处理多种类型的对象，而不需要针对每种对象编写不同的处理代码。

（三）封装和抽象 —— 保护与规范代码的 “利器”

using Microsoft.AspNetCore.Mvc;

namespace WebApp.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }
    }
}

@{
    ViewData["Title"] = "主页";
}

<h1>欢迎来到我的网站！</h1>

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

namespace WebApi.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
        };

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            var rng = new System.Random();
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateTime.Now.AddDays(index),
                TemperatureC = rng.Next(-20, 55),
                Summary = Summaries[rng.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }

    public class WeatherForecast
    {
        public DateTime Date { get; set; }

        public int TemperatureC { get; set; }

        public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);

        public string Summary { get; set; }
    }
}

（四）游戏开发

使用 Unity 和 C# 可以开发各种类型的游戏，从简单的 2D 游戏到复杂的 3D 游戏。Unity 是一个流行的游戏开发引擎，它提供了丰富的工具和资源，结合 C# 可以实现游戏的逻辑和交互。

using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float speed = 5f;

    void Update()
    {
        float horizontalInput = Input.GetAxis("Horizontal");
        float verticalInput = Input.GetAxis("Vertical");

        Vector3 movement = new Vector3(horizontalInput, verticalInput, 0f) * speed * Time.deltaTime;
        transform.Translate(movement);
    }
}

六、进阶学习阶段

（一）LINQ（语言集成查询）

LINQ 是 C# 的一项强大功能，它允许你使用类似于 SQL 的语法来查询和操作各种数据源，如数组、列表、数据库等。LINQ 提供了一种统一的方式来处理不同类型的数据，提高了代码的可读性和可维护性。

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // 查询所有偶数
        var evenNumbers = from num in numbers
                          where num % 2 == 0
                          select num;

        foreach (var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }
}

（二）异步编程

在现代应用程序中，异步编程变得越来越重要。C# 提供了async和await关键字来支持异步编程，允许程序在等待 I/O 操作（如网络请求、文件读写等）完成时继续执行其他任务，提高了程序的性能和响应速度。

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("开始异步操作...");
        await DoAsyncWork();
        Console.WriteLine("异步操作完成。");
    }

    static async Task DoAsyncWork()
    {
        await Task.Delay(2000); // 模拟一个耗时2秒的操作
        Console.WriteLine("异步操作正在执行...");
    }
}

（三）设计模式和架构

了解常见的设计模式和软件架构可以帮助你编写更具可维护性、可扩展性和可测试性的代码。

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

七、持续学习与资源利用

（一）阅读优秀的书籍和文档

选择一些经典的 C# 编程书籍进行深入学习，如《C# 7.0 in a Nutshell》《Head First C#》等。这些书籍通常会详细介绍 C# 的语法、特性和最佳实践，帮助你建立扎实的知识基础。同时，微软官方文档也是非常重要的学习资源，它提供了最新、最准确的 C# 语言和.NET 框架的相关信息。

（二）参与开源项目

在 GitHub 等开源代码托管平台上找到一些适合初学者的 C# 开源项目，参与其中的开发和维护。通过阅读和修改他人的代码，你可以学习到不同的编程风格和最佳实践，同时也可以与其他开发者进行交流和合作，提升自己的编程能力。

（三）加入开发者社区

加入 C# 开发者社区，如 CNDS、Stack Overflow、C# 编程论坛等。在这些社区中，你可以提问、回答问题、分享自己的经验和见解，与其他开发者互动交流。同时，还可以关注一些知名的 C# 开发者和技术博客，及时了解行业的最新动态和技术趋势。

（四）持续实践和挑战自己

编程是一门实践性很强的技能，只有不断地实践才能真正掌握。可以尝试自己设计和开发一些小型项目，或者参加一些编程竞赛和挑战活动，锻炼自己的编程思维和解决问题的能力。

封装：
封装的目的是把类中的数据（属性）和操作这些数据的方法 “包裹” 起来，只对外暴露

必要的接口，从而隐藏内部实现细节，提高代码的安全性和可维护性。通过访问修饰符（如 public、private、protected 等）可以控制类成员（属性和方法）的访问权限。

在之前的 Car 类示例中，我们可以对属性进行封装，将属性设置为私有，然后通过公共的访问器方法来访问和修改这些属性。这样做可以在访问属性时添加额外的逻辑，比如进行数据验证。

csharp

class Car
{
    private string brand;
    private string color;
    private int speed;

    public string Brand
    {
        get { return brand; }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                brand = value;
            }
            else
            {
                Console.WriteLine("品牌名称不能为空。");
            }
        }
    }

    public string Color
    {
        get { return color; }
        set
        {
            if (!string.IsNullOrEmpty(value))
            {
                color = value;
            }
            else
            {
                Console.WriteLine("颜色名称不能为空。");
            }
        }
    }

    public int Speed
    {
        get { return speed; }
        set
        {
            if (value >= 0)
            {
                speed = value;
            }
            else
            {
                Console.WriteLine("速度不能为负数。");
            }
        }
    }

    public void Start()
    {
        Console.WriteLine($"{brand} {color} 的汽车启动了，当前速度为 {speed} km/h。");
    }
}

在上述代码中，brand、color 和 speed 属性被声明为私有（private），外界无法直接访问和修改它们。通过公共的属性访问器（get 和 set），可以对属性的访问和修改进行控制。例如，在设置 Brand 属性时，会检查传入的值是否为空，如果为空则输出错误信息。这样可以确保数据的有效性和一致性。

抽象：
抽象是指通过抽象类和接口来定义一组相关类的共同特征和行为，而不具体实现这些行为。抽象类是一种不能被实例化的类，它可以包含抽象方法（只有方法声明，没有方法体）和具体方法。接口则是一种完全抽象的类型，只包含方法、属性、事件和索引器的声明，不包含任何实现代码。
以下是一个抽象类的示例：

csharp
```
abstract class Animal
{
    public abstract void MakeSound();

    public void Eat()
    {
        Console.WriteLine("动物正在吃东西。");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("汪汪汪！");
    }
}

class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("喵喵喵！");
    }
}
```
在上述代码中，Animal 是一个抽象类，它包含一个抽象方法 MakeSound() 和一个具体方法 Eat()。Dog 和 Cat 类继承自 Animal 类，并实现了抽象方法 MakeSound()。由于 Animal 是抽象类，不能直接创建 Animal 类的对象，但可以创建 Dog 和 Cat 类的对象，并调用它们的方法。

csharp
```
Dog dog = new Dog();
dog.MakeSound();
dog.Eat();

Cat cat = new Cat();
cat.MakeSound();
cat.Eat();
```
接口的示例如下：

csharp
```
interface IAnimal
{
    void MakeSound();
}

class Bird : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("叽叽喳喳！");
    }
}
```
在这个例子中，IAnimal 是一个接口，它定义了一个方法 MakeSound()。Bird 类实现了 IAnimal 接口，并实现了 MakeSound() 方法。通过接口，可以实现多态性，不同的类可以以不同的方式实现同一个接口。

五、项目实战阶段

（一）控制台应用程序实践

在掌握了 C# 的基础知识和面向对象编程的概念后，通过实际项目来巩固所学知识是非常重要的。控制台应用程序是一个很好的起点，因为它们相对简单，专注于逻辑实现，不需要复杂的用户界面。
计算器程序：
编写一个简单的计算器程序，实现基本的四则运算（加、减、乘、除）。用户可以输入两个数字和一个运算符，程序根据用户输入进行相应的计算并输出结果。

csharp

using System;

class Calculator
{
    static void Main()
    {
        Console.Write("请输入第一个数字: ");
        double num1 = Convert.ToDouble(Console.ReadLine());

        Console.Write("请输入运算符 (+, -, *, /): ");
        char op = Convert.ToChar(Console.ReadLine());

        Console.Write("请输入第二个数字: ");
        double num2 = Convert.ToDouble(Console.ReadLine());

        double result = 0;

        switch (op)
        {
            case '+':
                result = num1 + num2;
                break;
            case '-':
                result = num1 - num2;
                break;
            case '*':
                result = num1 * num2;
                break;
            case '/':
                if (num2 != 0)
                {
                    result = num1 / num2;
                }
                else
                {
                    Console.WriteLine("除数不能为零。");
                    return;
                }
                break;
            default:
                Console.WriteLine("无效的运算符。");
                return;
        }

        Console.WriteLine($"计算结果: {result}");
    }
}

任务管理器：
创建一个任务管理器程序，允许用户添加、查看和删除任务。每个任务可以包含任务名称、截止日期等信息。

csharp

using System;
using System.Collections.Generic;

class TaskManager
{
    static List<string> tasks = new List<string>();

    static void Main()
    {
        while (true)
        {
            Console.WriteLine("请选择操作:");
            Console.WriteLine("1. 添加任务");
            Console.WriteLine("2. 查看任务列表");
            Console.WriteLine("3. 删除任务");
            Console.WriteLine("4. 退出");

            int choice = Convert.ToInt32(Console.ReadLine());

            switch (choice)
            {
                case 1:
                    Console.Write("请输入任务名称: ");
                    string task = Console.ReadLine();
                    tasks.Add(task);
                    Console.WriteLine("任务已添加。");
                    break;
                case 2:
                    if (tasks.Count == 0)
                    {
                        Console.WriteLine("任务列表为空。");
                    }
                    else
                    {
                        Console.WriteLine("任务列表:");
                        for (int i = 0; i < tasks.Count; i++)
                        {
                            Console.WriteLine($"{i + 1}. {tasks[i]}");
                        }
                    }
                    break;
                case 3:
                    Console.Write("请输入要删除的任务编号: ");
                    int index = Convert.ToInt32(Console.ReadLine()) - 1;
                    if (index >= 0 && index < tasks.Count)
                    {
                        tasks.RemoveAt(index);
                        Console.WriteLine("任务已删除。");
                    }
                    else
                    {
                        Console.WriteLine("无效的任务编号。");
                    }
                    break;
                case 4:
                    return;
                default:
                    Console.WriteLine("无效的选择，请重新输入。");
                    break;
            }
        }
    }
}

（二）Windows Forms 或 WPF 应用程序开发

当你对控制台应用程序有了一定的经验后，可以尝试开发具有图形用户界面（GUI）的应用程序。Windows Forms 和 WPF（Windows Presentation Foundation）是微软提供的用于创建 Windows 桌面应用程序的技术。

Windows Forms：
Windows Forms 是一个基于.NET Framework 的传统 GUI 开发技术，它提供了一组丰富的控件（如按钮、文本框、标签等），可以方便地创建用户界面。以下是一个简单的 Windows Forms 应用程序示例，实现一个简单的加法计算器。

首先，在 Visual Studio 中创建一个新的 Windows Forms 应用程序项目。在设计视图中，添加两个文本框（用于输入数字）、一个按钮（用于触发计算）和一个标签（用于显示计算结果）。然后，在按钮的点击事件处理程序中编写以下代码：

csharp

using System;
using System.Windows.Forms;

namespace WindowsFormsCalculator
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                double num1 = Convert.ToDouble(textBox1.Text);
                double num2 = Convert.ToDouble(textBox2.Text);
                double result = num1 + num2;
                label1.Text = $"计算结果: {result}";
            }
            catch (Exception ex)
            {
                MessageBox.Show("输入无效，请输入有效的数字。");
            }
        }
    }
}

WPF：
WPF 是一种更现代的 GUI 开发技术，它使用 XAML（可扩展应用程序标记语言）来定义用户界面，提供了更强大的布局和样式控制能力。以下是一个简单的 WPF 应用程序示例，实现一个简单的文本显示界面。

在 Visual Studio 中创建一个新的 WPF 应用程序项目。在MainWindow.xaml文件中，添加以下 XAML 代码：

xml

<Window x:Class="WpfApp1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="WPF示例" Height="350" Width="525">
    <Grid>
        <Button Content="点击我" HorizontalAlignment="Left" Margin="207,140,0,0" VerticalAlignment="Top" Width="75" Click="Button_Click"/>
        <TextBlock x:Name="textBlock" HorizontalAlignment="Left" Margin="183,192,0,0" TextWrapping="Wrap" Text="" VerticalAlignment="Top" Width="150"/>
    </Grid>
</Window>

在MainWindow.xaml.cs文件中，添加以下代码：

csharp

using System.Windows;

namespace WpfApp1
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            textBlock.Text = "你点击了按钮！";
        }
    }
}

（三）Web 应用程序开发

如果你对 Web 开发感兴趣，可以学习ASP.NET Core 来开发 Web 应用程序。ASP.NET Core 是一个跨平台的开源框架，用于构建现代的 Web 应用程序和服务。

MVC 模式：
MVC（Model-View-Controller）是一种常用的软件设计模式，用于将应用程序的逻辑、数据和用户界面分离。在ASP.NET Core 中，MVC 模式被广泛应用。
首先，在 Visual Studio 中创建一个新的ASP.NET Core Web 应用程序项目，选择 MVC 模板。项目创建完成后，你会看到以下几个主要的文件夹：
Controllers：包含控制器类，负责处理用户请求并返回响应。
Views：包含视图文件，用于呈现用户界面。
Models：包含数据模型类，用于表示应用程序的数据。
Web API 开发：
Web API 是一种用于构建 RESTful 服务的技术，允许不同的应用程序通过 HTTP 协议进行通信。在ASP.NET Core 中，可以轻松地创建 Web API。
创建一个简单的 2D 游戏：
在 Unity 中创建一个新的 2D 项目。首先，创建一个玩家角色（例如一个小方块），并添加一个 C# 脚本控制其移动。
设计模式：
设计模式是指在软件开发过程中，针对反复出现的问题所总结归纳出的通用解决方案。常见的设计模式包括单例模式、工厂模式、观察者模式等。
软件架构：
软件架构是指软件系统的整体结构和组织方式，常见的软件架构包括分层架构、微服务架构等。