devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C#编程技术指南：从入门到精通的全面教程_c#教程

作者：Li_阴宅 | 2024-08-05 17:31:51

赞

踩

c#教程

        无论你是编程新手，还是想要深化.NET技能的开发者，本文都将为你提供一条清晰的学习路径，从C#基础到高级特性，每一站都配有详尽解析和实用示例，旨在帮助你建立坚实的知识体系，并激发你对C#及.NET生态的热情。

目录

第一部分：C#基础——构建你的第一个程序

1. 环境搭建

2. 第一个C#程序

3. 变量、数据类型与控制流

1）变量

2）数据类型

3）控制流

4）条件判断（if语句）

5）循环（for语句）

6）循环（while语句）

7）选择（switch语句）

第二部分：面向对象编程（OOP）——构建模块化的代码世界

  

1、类 (Class)

2、对象 (Object)

对象的创建与使用

3、构造函数 (Constructor)

4、属性 (Property)

5、方法 (Method)

6、继承 (Inheritance)

7、封装 (Encapsulation)

第三部分：高级特性——解锁更高效、更优雅的编程技巧

1、 泛型与集合

1）泛型类

2）泛型方法

3）泛型约束

4）数组 (Array)

5）列表 (List)

6）队列 (Queue)

7）栈 (Stack)

8）字典 (Dictionary)

        9）泛型集合

2、 异常处理

3、Lambda表达式与LINQ

第四部分：并发编程——在多核时代乘风破浪

         1、 多线程与并发

     1）线程基础

     2）线程池

    3）任务并行库 (TPL)

   4）并行循环

   5） 异步编程 (async/await)

2、 并发集合

3、 原子操作

4、委托与事件

5、 线程同步

    1）lock 关键字

   2) Monitor 类

  3) Semaphore 类

第五部分：实战演练——理论到实践的跨越

结语

        C#（发音为“See Sharp”）由微软公司精心打造，是一种现代化的面向对象编程语言。它在.NET平台上运行，旨在提供高效、类型安全的开发体验，广泛应用于Windows桌面应用、Web服务、游戏开发（Unity尤为青睐）、以及跨平台解决方案。让我们一起揭开C#的面纱，逐步掌握其精髓。

第一部分：C#基础——构建你的第一个程序

1. 环境搭建

  • Visual Studio：微软官方提供的全能IDE，适用于从简单到复杂的所有项目。
  • .NET SDK：确保安装最新版，它是运行C#程序的基石。

2. 第一个C#程序

  1. using System;
  2.  
  3. namespace HelloWorld
  4. {
  5.     class Program
  6.     {
  7.         static void Main(string[] args)
  8.         {
  9.             Console.WriteLine("你好，C#的世界！");
  10.         }
  11.     }
  12. }

这行简单的输出，标志着你的C#旅程正式启航。

3. 变量、数据类型与控制流

  • 在C#编程语言中，变量、数据类型和控制流是构建程序的基础元素。下面我将详细讲解这些概念，并提供一些示例代码来帮助理解。

    1）变量

    变量是存储数据的基本单元。在C#中，变量必须先声明后使用，并且需要指定其数据类型。

    1. int age = 25; // 声明一个整数型变量age并赋值为25
    2. string name = "Alice"; // 声明一个字符串型变量name并赋值为"Alice"
    3. double height = 1.75; // 声明一个双精度浮点型变量height并赋值为1.75

    2）数据类型

    C#支持多种数据类型，包括基本数据类型和复合数据类型。基本数据类型包括整数类型（如int）、浮点类型（如double）、字符类型（如char）和布尔类型（如bool）。

    1. int number = 10; // 整数类型
    2. double pi = 3.14159; // 双精度浮点类型
    3. char letter = 'A'; // 字符类型
    4. bool isTrue = true; // 布尔类型

    3）控制流

    控制流语句用于控制程序的执行流程，包括条件判断和循环操作。常见的控制流语句有if、for、while和switch等。

  • 4）条件判断（if语句）

    if语句用于根据条件执行不同的代码块。

    1. int x = 10;
    2. if (x > 5)
    3. {
    4.     Console.WriteLine("x is greater than 5");
    5. }
    6. else
    7. {
    8.     Console.WriteLine("x is not greater than 5");
    9. }
    5）循环（for语句）

    for语句用于重复执行一段代码，直到满足特定条件为止。

    1. for (int i = 0; i < 5; i++)
    2. {
    3.     Console.WriteLine("Iteration " + i);
    4. }
    6）循环（while语句）

    while语句用于在条件为真时重复执行一段代码。

    1. int count = 0;
    2. while (count < 5)
    3. {
    4.     Console.WriteLine("Count is " + count);
    5.     count++;
    6. }
    7）选择（switch语句）

    switch语句用于根据变量的值执行不同的代码块。

    1. int day = 3;
    2. switch (day)
    3. {
    4.     case 1:
    5.         Console.WriteLine("Monday");
    6.         break;
    7.     case 2:
    8.         Console.WriteLine("Tuesday");
    9.         break;
    10.     case 3:
    11.         Console.WriteLine("Wednesday");
    12.         break;
    13.     default:
    14.         Console.WriteLine("Other day");
    15.         break;
    16. }

第二部分：面向对象编程（OOP）——构建模块化的代码世界

        C# 是一种面向对象的编程语言，类和对象是其核心概念。类是对象的蓝图或模板，而对象是类的实例。下面我将详细讲解 C# 中的类与对象。

1、类 (Class)

        类是用户定义的数据类型，它包含数据成员（字段）和函数成员（方法、属性、事件等）。类定义了对象的结构和行为。

示例：

  1. public class Person
  2. {
  3.     // 字段
  4.     private string name;
  5.     private int age;
  6.  
  7.     // 构造函数
  8.     public Person(string name, int age)
  9.     {
  10.         this.name = name;
  11.         this.age = age;
  12.     }
  13.  
  14.     // 属性
  15.     public string Name
  16.     {
  17.         get { return name; }
  18.         set { name = value; }
  19.     }
  20.  
  21.     public int Age
  22.     {
  23.         get { return age; }
  24.         set { age = value; }
  25.     }
  26.  
  27.     // 方法
  28.     public void SayHello()
  29.     {
  30.         Console.WriteLine($"Hello, my name is {name} and I am {age} years old.");
  31.     }
  32. }

2、对象 (Object)

对象是类的实例，通过类创建对象的过程称为实例化。对象可以访问类中定义的字段、属性和方法。

对象的创建与使用

示例：

  1. class Program
  2. {
  3.     static void Main()
  4.     {
  5.         // 创建对象
  6.         Person person = new Person("Alice", 30);
  7.  
  8.         // 访问属性
  9.         Console.WriteLine(person.Name); // 输出: Alice
  10.         Console.WriteLine(person.Age);  // 输出: 30
  11.  
  12.         // 调用方法
  13.         person.SayHello(); // 输出: Hello, my name is Alice and I am 30 years old.
  14.  
  15.         // 修改属性
  16.         person.Name = "Bob";
  17.         person.Age = 25;
  18.  
  19.         // 再次调用方法
  20.         person.SayHello(); // 输出: Hello, my name is Bob and I am 25 years old.
  21.     }
  22. }

3、构造函数 (Constructor)

构造函数是类的一种特殊方法，用于初始化对象。构造函数与类同名，没有返回类型。

示例：

  1. public class Person
  2. {
  3.     private string name;
  4.     private int age;
  5.  
  6.     // 构造函数
  7.     public Person(string name, int age)
  8.     {
  9.         this.name = name;
  10.         this.age = age;
  11.     }
  12.  
  13.     // 其他成员省略...
  14. }

4、属性 (Property)

属性提供了一种访问和修改字段的机制，它包含 get 和 set 访问器。

示例：

  1. public class Person
  2. {
  3.     private string name;
  4.     private int age;
  5.  
  6.     public string Name
  7.     {
  8.         get { return name; }
  9.         set { name = value; }
  10.     }
  11.  
  12.     public int Age
  13.     {
  14.         get { return age; }
  15.         set { age = value; }
  16.     }
  17.  
  18.     // 其他成员省略...
  19. }

 

5、方法 (Method)

方法是类中定义的函数，用于执行特定的操作。

示例：

  1. public class Person
  2. {
  3.     private string name;
  4.     private int age;
  5.  
  6.     public void SayHello()
  7.     {
  8.         Console.WriteLine($"Hello, my name is {name} and I am {age} years old.");
  9.     }
  10.  
  11.     // 其他成员省略...
  12. }

6、继承 (Inheritance)

继承是面向对象编程的一个重要特性，它允许一个类继承另一个类的字段和方法。

示例：

  1. public class Student : Person
  2. {
  3.     private string studentId;
  4.  
  5.     public Student(string name, int age, string studentId) : base(name, age)
  6.     {
  7.         this.studentId = studentId;
  8.     }
  9.  
  10.     public string StudentId
  11.     {
  12.         get { return studentId; }
  13.         set { studentId = value; }
  14.     }
  15.  
  16.     public void Study()
  17.     {
  18.         Console.WriteLine($"{Name} with student ID {studentId} is studying.");
  19.     }
  20. }
  21.  
  22. class Program
  23. {
  24.     static void Main()
  25.     {
  26.         Student student = new Student("Alice", 20, "12345");
  27.         student.SayHello(); // 输出: Hello, my name is Alice and I am 20 years old.
  28.         student.Study();    // 输出: Alice with student ID 12345 is studying.
  29.     }
  30. }

 

7、封装 (Encapsulation)

封装是将数据和操作数据的方法绑定在一起，并隐藏对象的内部实现细节。C# 通过访问修饰符（如 private、public、protected）来实现封装。

示例：

  1. public class Person
  2. {
  3.     private string name;
  4.     private int age;
  5.  
  6.     public string Name
  7.     {
  8.         get { return name; }
  9.         set { name = value; }
  10.     }
  11.  
  12.     public int Age
  13.     {
  14.         get { return age; }
  15.         set { age = value; }
  16.     }
  17.  
  18.     // 其他成员省略...
  19. }

        通过这些示例，你可以看到 C# 中类与对象的基本概念和用法。类是对象的蓝图，而对象是类的实例。类定义了对象的结构和行为，而对象是类的具体实现。继承、封装和多态是面向对象编程的三大特性，它们在 C# 中得到了很好的支持。 

第三部分：高级特性——解锁更高效、更优雅的编程技巧

1、 泛型与集合

C# 中的泛型和集合是两个非常重要的概念，它们极大地增强了代码的灵活性和可重用性。下面我将详细讲解这两个概念。

泛型 (Generics)

泛型允许你在定义类、接口、方法或委托时使用类型参数，从而使这些类型或方法可以在不指定具体类型的情况下工作。泛型提高了代码的重用性，增强了类型安全性，并减少了类型转换的需要。

1）泛型类

示例：

  1. public class GenericClass<T>
  2. {
  3.     private T _value;
  4.  
  5.     public GenericClass(T value)
  6.     {
  7.         _value = value;
  8.     }
  9.  
  10.     public T GetValue()
  11.     {
  12.         return _value;
  13.     }
  14. }
  15.  
  16. class Program
  17. {
  18.     static void Main()
  19.     {
  20.         GenericClass<int> intGeneric = new GenericClass<int>(10);
  21.         Console.WriteLine(intGeneric.GetValue()); // 输出: 10
  22.  
  23.         GenericClass<string> stringGeneric = new GenericClass<string>("Hello");
  24.         Console.WriteLine(stringGeneric.GetValue()); // 输出: Hello
  25.     }
  26. }
2）泛型方法

示例：

  1. public class GenericMethod
  2. {
  3.     public static void Print<T>(T value)
  4.     {
  5.         Console.WriteLine(value);
  6.     }
  7. }
  8.  
  9. class Program
  10. {
  11.     static void Main()
  12.     {
  13.         GenericMethod.Print(10); // 输出: 10
  14.         GenericMethod.Print("Hello"); // 输出: Hello
  15.     }
  16. }

 

3）泛型约束

你可以通过泛型约束来限制类型参数必须满足的条件。

示例：

  1. public class GenericClassWithConstraint<T> where T : IComparable<T>
  2. {
  3.     private T _value;
  4.  
  5.     public GenericClassWithConstraint(T value)
  6.     {
  7.         _value = value;
  8.     }
  9.  
  10.     public T GetValue()
  11.     {
  12.         return _value;
  13.     }
  14.  
  15.     public bool IsGreaterThan(T other)
  16.     {
  17.         return _value.CompareTo(other) > 0;
  18.     }
  19. }
  20.  
  21. class Program
  22. {
  23.     static void Main()
  24.     {
  25.         GenericClassWithConstraint<int> intGeneric = new GenericClassWithConstraint<int>(10);
  26.         Console.WriteLine(intGeneric.IsGreaterThan(5)); // 输出: True
  27.     }
  28. }

 

集合 (Collections)

C# 提供了多种集合类型，用于存储和操作一组对象。这些集合类型包括数组、列表、队列、栈、字典等。

4）数组 (Array)

数组是最基本的集合类型，它具有固定大小。

示例：

  1. int[] numbers = new int[5];
  2. numbers[0] = 1;
  3. numbers[1] = 2;
  4. numbers[2] = 3;
  5. numbers[3] = 4;
  6. numbers[4] = 5;
  7.  
  8. foreach (int number in numbers)
  9. {
  10.     Console.WriteLine(number);
  11. }

 

5）列表 (List)

列表是一种动态数组，它的大小可以动态调整。

示例：

  1. using System.Collections.Generic;
  2.  
  3. List<int> numbers = new List<int>();
  4. numbers.Add(1);
  5. numbers.Add(2);
  6. numbers.Add(3);
  7. numbers.Add(4);
  8. numbers.Add(5);
  9.  
  10. foreach (int number in numbers)
  11. {
  12.     Console.WriteLine(number);
  13. }

 

6）队列 (Queue)

队列是一种先进先出 (FIFO) 的数据结构。

示例：

  1. using System.Collections.Generic;
  2.  
  3. Queue<int> queue = new Queue<int>();
  4. queue.Enqueue(1);
  5. queue.Enqueue(2);
  6. queue.Enqueue(3);
  7.  
  8. while (queue.Count > 0)
  9. {
  10.     Console.WriteLine(queue.Dequeue());
  11. }
7）栈 (Stack)

栈是一种后进先出 (LIFO) 的数据结构。

示例：

  1. using System.Collections.Generic;
  2.  
  3. Stack<int> stack = new Stack<int>();
  4. stack.Push(1);
  5. stack.Push(2);
  6. stack.Push(3);
  7.  
  8. while (stack.Count > 0)
  9. {
  10.     Console.WriteLine(stack.Pop());
  11. }
8）字典 (Dictionary)

字典是一种键值对集合，可以通过键快速查找值。

示例：

  1. using System.Collections.Generic;
  2.  
  3. Dictionary<string, int> dictionary = new Dictionary<string, int>();
  4. dictionary.Add("one", 1);
  5. dictionary.Add("two", 2);
  6. dictionary.Add("three", 3);
  7.  
  8. foreach (var item in dictionary)
  9. {
  10.     Console.WriteLine($"{item.Key}: {item.Value}");
  11. }

9）泛型集合

泛型集合是 C# 中推荐的集合类型，因为它们提供了类型安全性和性能优势。

示例：

  1. using System.Collections.Generic;
  2.  
  3. List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
  4. Queue<string> queue = new Queue<string>();
  5. queue.Enqueue("first");
  6. queue.Enqueue("second");
  7. Stack<double> stack = new Stack<double>();
  8. stack.Push(1.1);
  9. stack.Push(2.2);
  10. Dictionary<int, string> dictionary = new Dictionary<int, string>
  11. {
  12.     { 1, "one" },
  13.     { 2, "two" },
  14.     { 3, "three" }
  15. };
  16.  
  17. foreach (int number in numbers)
  18. {
  19.     Console.WriteLine(number);
  20. }
  21.  
  22. while (queue.Count > 0)
  23. {
  24.     Console.WriteLine(queue.Dequeue());
  25. }
  26.  
  27. while (stack.Count > 0)
  28. {
  29.     Console.WriteLine(stack.Pop());
  30. }
  31.  
  32. foreach (var item in dictionary)
  33. {
  34.     Console.WriteLine($"{item.Key}: {item.Value}");
  35. }

通过这些示例，你可以看到泛型和集合在 C# 中的强大功能和灵活性。它们是现代 C# 编程中不可或缺的工具。

2、 异常处理

  1. try
  2. {
  3.     // 尝试访问数组越界
  4.     int[] arr = { 1, 2, 3 };
  5.     Console.WriteLine(arr[3]);
  6. }
  7. catch (IndexOutOfRangeException ex)
  8. {
  9.     Console.WriteLine("数组越界：" + ex.Message);
  10. }

使用try-catch捕获并处理异常，增强程序的健壮性。

3、Lambda表达式与LINQ

  1. List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
  2. var evenNumbers = numbers.Where(n => n % 2 == 0);
  3. foreach (var num in evenNumbers)
  4. {
  5.     Console.WriteLine(num);
  6. }

Lambda表达式让代码更简洁，LINQ则提供了查询数据的强大工具集。

第四部分：并发编程——在多核时代乘风破浪

1、 多线程与并发

        C# 多线程与并发编程技术是现代软件开发中的重要组成部分，它允许开发者创建高效、响应迅速的应用程序。以下是对C#中多线程与并发编程技术的详细介绍：

1）线程基础

在C#中，线程是执行代码的基本单元。可以使用 System.Threading.Thread 类来创建和管理线程。

示例：

  1. using System;
  2. using System.Threading;
  3.  
  4. class Program
  5. {
  6.     static void Main()
  7.     {
  8.         Thread thread = new Thread(new ThreadStart(DoWork));
  9.         thread.Start();
  10.         Console.WriteLine("Main thread continues.");
  11.     }
  12.  
  13.     static void DoWork()
  14.     {
  15.         Console.WriteLine("Worker thread is running.");
  16.     }
  17. }

2）线程池

线程池是一种管理线程的机制，它可以重用线程，减少线程创建和销毁的开销。可以使用 ThreadPool 类来使用线程池。

示例：

  1. using System;
  2. using System.Threading;
  3.  
  4. class Program
  5. {
  6.     static void Main()
  7.     {
  8.         ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork));
  9.         Console.WriteLine("Main thread continues.");
  10.         Thread.Sleep(1000); // 等待工作线程完成
  11.     }
  12.  
  13.     static void DoWork(object state)
  14.     {
  15.         Console.WriteLine("Worker thread from thread pool is running.");
  16.     }
  17. }

 

3）任务并行库 (TPL)

任务并行库 (Task Parallel Library, TPL) 是 .NET Framework 4.0 引入的一个库，它提供了更高级别的抽象来处理并发和并行编程。

示例：

  1. using System;
  2. using System.Threading.Tasks;
  3.  
  4. class Program
  5. {
  6.     static void Main()
  7.     {
  8.         Task task = Task.Run(() => DoWork());
  9.         Console.WriteLine("Main thread continues.");
  10.         task.Wait(); // 等待任务完成
  11.     }
  12.  
  13.     static void DoWork()
  14.     {
  15.         Console.WriteLine("Task is running.");
  16.     }
  17. }

4）并行循环

TPL 还提供了并行循环的机制，如 Parallel.For 和 Parallel.ForEach，它们可以自动并行化循环操作。

示例：

  1. using System;
  2. using System.Threading.Tasks;
  3.  
  4. class Program
  5. {
  6.     static void Main()
  7.     {
  8.         Parallel.For(0, 10, i =>
  9.         {
  10.             Console.WriteLine($"Task {i} is running.");
  11.         });
  12.     }
  13. }

5） 异步编程 (async/await)

异步编程模型 (async/await) 是 C# 5.0 引入的一种编程模式，它使得异步编程更加简单和直观。

示例：

  1. using System;
  2. using System.Threading.Tasks;
  3.  
  4. class Program
  5. {
  6.     static async Task Main()
  7.     {
  8.         await DoWorkAsync();
  9.         Console.WriteLine("Main thread continues.");
  10.     }
  11.  
  12.     static async Task DoWorkAsync()
  13.     {
  14.         await Task.Delay(1000); // 模拟异步操作
  15.         Console.WriteLine("Async task is completed.");
  16.     }
  17. }

2、 并发集合

.NET 提供了一些并发集合类，如 ConcurrentQueue、ConcurrentStack 和 ConcurrentDictionary，它们可以在多线程环境下安全地进行操作。

示例：

  1. using System;
  2. using System.Collections.Concurrent;
  3. using System.Threading.Tasks;
  4.  
  5. class Program
  6. {
  7.     static void Main()
  8.     {
  9.         ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
  10.  
  11.         Task producer = Task.Run(() =>
  12.         {
  13.             for (int i = 0; i < 10; i++)
  14.             {
  15.                 queue.Enqueue(i);
  16.                 Console.WriteLine($"Enqueued {i}");
  17.             }
  18.         });
  19.  
  20.         Task consumer = Task.Run(() =>
  21.         {
  22.             int result;
  23.             while (queue.TryDequeue(out result))
  24.             {
  25.                 Console.WriteLine($"Dequeued {result}");
  26.             }
  27.         });
  28.  
  29.         Task.WaitAll(producer, consumer);
  30.     }
  31. }

3、 原子操作

原子操作是不可分割的操作，可以确保在多线程环境下操作的原子性。Interlocked 类提供了一些原子操作方法。

示例：

  1. using System;
  2. using System.Threading;
  3.  
  4. class Program
  5. {
  6.     static int counter = 0;
  7.  
  8.     static void Main()
  9.     {
  10.         for (int i = 0; i < 10; i++)
  11.         {
  12.             new Thread(IncrementCounter).Start();
  13.         }
  14.     }
  15.  
  16.     static void IncrementCounter()
  17.     {
  18.         int newValue = Interlocked.Increment(ref counter);
  19.         Console.WriteLine($"Counter: {newValue}");
  20.     }
  21. }

通过这些技术和工具，C# 开发者可以有效地处理多线程和并发编程，创建高性能、高并发的应用程序。

4、委托与事件

  1. public delegate void MessageHandler(string msg);
  2. public class Publisher
  3. {
  4.     public event MessageHandler NewMessage;
  5.  
  6.     public void Publish(string message)
  7.     {
  8.         NewMessage?.Invoke(message);
  9.     }
  10. }

委托机制允许你将方法作为参数传递，事件则是基于委托的通信方式，增强了组件之间的解耦。

5、 线程同步

  • lock关键字：防止多个线程同时访问共享资源，避免数据竞争。
  • 其他同步工具：如Monitor、Semaphore等，提供了更细致的并发控制手段。

    1）lock 关键字

    lock 关键字用于确保在同一时刻只有一个线程可以进入代码的临界区。

    1. using System;
    2. using System.Threading;
    3.  
    4. class Counter
    5. {
    6.     private int count = 0;
    7.     private readonly object lockObject = new object();
    8.  
    9.     public void Increment()
    10.     {
    11.         lock (lockObject)
    12.         {
    13.             count++;
    14.             Console.WriteLine($"Count: {count}");
    15.         }
    16.     }
    17. }
    18.  
    19. class Program
    20. {
    21.     static void Main()
    22.     {
    23.         var counter = new Counter();
    24.         for (int i = 0; i < 10; i++)
    25.         {
    26.             new Thread(counter.Increment).Start();
    27.         }
    28.     }
    29. }

    在这个示例中，lock 关键字确保了 count 变量的自增操作是线程安全的。

    2) Monitor 类

    Monitor 类提供了与 lock 关键字类似的功能，但提供了更多的控制选项，如 Wait 和 Pulse 方法。

    1. using System;
    2. using System.Threading;
    3.  
    4. class CounterWithMonitor
    5. {
    6.     private int count = 0;
    7.     private readonly object lockObject = new object();
    8.  
    9.     public void Increment()
    10.     {
    11.         Monitor.Enter(lockObject);
    12.         try
    13.         {
    14.             count++;
    15.             Console.WriteLine($"Count: {count}");
    16.         }
    17.         finally
    18.         {
    19.             Monitor.Exit(lockObject);
    20.         }
    21.     }
    22. }
    23.  
    24. class Program
    25. {
    26.     static void Main()
    27.     {
    28.         var counter = new CounterWithMonitor();
    29.         for (int i = 0; i < 10; i++)
    30.         {
    31.             new Thread(counter.Increment).Start();
    32.         }
    33.     }
    34. }

    在这个示例中，Monitor.Enter 和 Monitor.Exit 方法用于确保 count 变量的自增操作是线程安全的。

    3) Semaphore 类

    Semaphore 类用于控制对一个或多个共享资源的并发访问。它可以限制同时访问资源的线程数量。

    1. using System;
    2. using System.Threading;
    3.  
    4. class SemaphoreExample
    5. {
    6.     private static Semaphore semaphore = new Semaphore(2, 2); // 允许2个线程同时访问
    7.  
    8.     public void AccessResource(int threadId)
    9.     {
    10.         semaphore.WaitOne();
    11.         try
    12.         {
    13.             Console.WriteLine($"Thread {threadId} is accessing the resource.");
    14.             Thread.Sleep(1000); // 模拟资源访问时间
    15.         }
    16.         finally
    17.         {
    18.             Console.WriteLine($"Thread {threadId} is releasing the resource.");
    19.             semaphore.Release();
    20.         }
    21.     }
    22. }
    23.  
    24. class Program
    25. {
    26.     static void Main()
    27.     {
    28.         var semaphoreExample = new SemaphoreExample();
    29.         for (int i = 0; i < 5; i++)
    30.         {
    31.             int threadId = i;
    32.             new Thread(() => semaphoreExample.AccessResource(threadId)).Start();
    33.         }
    34.     }
    35. }

    在这个示例中，Semaphore 类限制了同时访问资源的线程数量为2个。

    通过这些示例，你可以看到如何在C#中使用不同的同步工具来确保线程安全。选择合适的同步工具取决于具体的应用场景和需求。

第五部分：实战演练——理论到实践的跨越

        选择一个小型项目，如简单的图书管理系统、天气查询应用等，动手实践。从需求分析到编码实现，再到调试部署，每一步都是学习成长的机会。记得利用学到的所有知识：OOP设计、泛型集合、异常处理、多线程等，让理论在实践中开花结果。

结语

        C#及其.NET平台是一个广阔且不断演进的技术宇宙。本文仅是入门与进阶的起点，鼓励你持续探索，如C# 10的新特性、Blazor WebAssembly、.NET MAUI跨平台开发等。参加社区讨论，阅读官方文档，不断实践，你将会发现C#不仅仅是一种语言，它是一种强大的工具，助你创造无限可能。现在，带着这份指南，开启你的C#编程征途吧！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/933403
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号