👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

《黑神话 悟空》游戏开发教程，共40节，完全免费，点击学习

《AI副业教程》，完全原创教程，点击学习

发表更新编程 / C#进阶6 分钟读完 (大约852个字)

13 反射的基本概念

在上一篇我们讨论了委托和事件，探讨了如何使用命名和泛型委托来有效地管理事件和回调函数。本篇将深入到反射（Reflection）的基本概念，特别是如何在运行时获取关于类型的信息。反射是 C# 中一个强大的功能，允许你在运行时探索和操作类型。

什么是反射？

反射是一种强大的机制，允许程序在运行时动态地访问和修改对象的类型信息。例如，你可以利用反射获取类的构造函数、属性、方法等信息。这在许多场景中都能派上用场，例如：

  • 插件系统
  • 动态加载类型
  • 序列化与反序列化
  • 测试和mock

在 C# 中，System.Reflection 命名空间提供了所有反射相关的类和方法。

反射的基本组成

反射的核心组件包括：

  1. 类型（Type）：表示类型信息的对象。
  2. 成员（MemberInfo）：可以是类的字段、方法、属性等。
  3. 方法（MethodInfo）：描述方法的具体信息。
  4. 属性（PropertyInfo）：提供有关属性的信息。
  5. 构造函数（ConstructorInfo）：提供有关类型构造函数的信息。

示例：使用反射获取类型信息

下面我们通过一个案例来演示如何使用反射获取类型的基本信息。

假设我们有一个简单的类 Person，包含一些属性和方法。

1
2
3
4
5
6
7
8
9
10
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void Greet()
    {
        Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
    }
}

我们可以使用反射来获取 Person 类型的信息。

获取类型信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Reflection;

class Program
{
    static void Main()
    {
        Type personType = typeof(Person);

        // 获取类型的名称
        Console.WriteLine("Type Name: " + personType.Name);

        // 获取所有公有属性
        PropertyInfo[] properties = personType.GetProperties();
        foreach (var property in properties)
        {
            Console.WriteLine("Property Name: " + property.Name + ", Property Type: " + property.PropertyType);
        }

        // 获取所有公有方法
        MethodInfo[] methods = personType.GetMethods();
        foreach (var method in methods)
        {
            Console.WriteLine("Method Name: " + method.Name);
        }
    }
}

运行上述代码，输出将会是：

1
2
3
4
5
6
7
8
Type Name: Person
Property Name: Age, Property Type: System.Int32
Property Name: Name, Property Type: System.String
Method Name: Greet
Method Name: ToString
Method Name: Equals
Method Name: GetHashCode
Method Name: GetType

创建实例

通过反射，我们不仅可以访问类型信息，还可以创建实例。以下示例展示如何使用 Activator.CreateInstance 方法动态创建 Person 对象：

1
2
3
4
5
6
7
8
9
10
var personInstance = Activator.CreateInstance(personType);
PropertyInfo nameProperty = personType.GetProperty("Name");
PropertyInfo ageProperty = personType.GetProperty("Age");

nameProperty.SetValue(personInstance, "Alice");
ageProperty.SetValue(personInstance, 30);

// 调用方法
MethodInfo greetMethod = personType.GetMethod("Greet");
greetMethod.Invoke(personInstance, null);

运行上述代码将输出：

1
Hello, my name is Alice and I am 30 years old.

小结

本篇介绍了反射的基本概念，包括它的组成部分和用法。我们通过 Reflect API 提取类的元数据，以及如何动态地实例化类和调用其方法。反射在许多高级编程场景中是不可替代的工具，使得我们可以在运行时灵活地处理类型和对象。

在下一篇中，我们将探索如何使用反射获取类型信息，深入巩固我们对反射的理解，让我们继续保持对 C# 的热情与好奇！

分享转发

发表更新编程 / C#进阶6 分钟读完 (大约957个字)

14 反射和自定义特性之使用反射获取类型信息

在上一篇中，我们讨论了反射的基本概念，包括其定义、常见用途以及如何在C#中利用反射来获取类型信息。今天，我们将深入探讨如何使用反射获取类型信息，通过一些实际的案例和代码示例来说明这一过程。

1. 使用反射获取类型信息

在C#中，Type类是反射的核心，提供了一套用于获取类型信息的方法。通过Type类，我们可以获取一个类型的名称、属性、方法、字段以及其他相关信息。

1.1 获取类型的基本信息

我们可以使用Type.GetType()方法来获取一个已有类型的Type实例。以下是一个基本示例，演示如何获取一个类型的名称和全名。

1
2
3
4
5
6
7
8
9
10
11
using System;

class Program
{
    static void Main()
    {
        Type type = typeof(string);
        Console.WriteLine($"类型名称: {type.Name}"); // 输出: 类型名称: String
        Console.WriteLine($"类型全名: {type.FullName}"); // 输出: 类型全名: System.String
    }
}

1.2 获取字段信息

通过反射，我们还可以获取一个类的字段信息。例如，假设我们有一个Person类。

1
2
3
4
5
public class Person
{
    public string Name;
    public int Age;
}

我们可以使用反射获取Person类的字段信息，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Reflection;

class Program
{
    static void Main()
    {
        Type type = typeof(Person);
        FieldInfo[] fields = type.GetFields();

        foreach (FieldInfo field in fields)
        {
            Console.WriteLine($"字段名称: {field.Name}, 字段类型: {field.FieldType}");
        }
        // 输出:
        // 字段名称: Name, 字段类型: System.String
        // 字段名称: Age, 字段类型: System.Int32
    }
}

1.3 获取方法信息

同样地，我们也可以获取类的方法信息。以下是获取Person类的方法的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Person
{
    public void Introduce()
    {
        Console.WriteLine("Hello, my name is " + Name);
    }
}

class Program
{
    static void Main()
    {
        Type type = typeof(Person);
        MethodInfo[] methods = type.GetMethods();

        foreach (MethodInfo method in methods)
        {
            Console.WriteLine($"方法名称: {method.Name}, 返回类型: {method.ReturnType}");
        }
        // 输出可能会包括一些系统方法，可以根据需要添加过滤条件
    }
}

1.4 获取属性信息

可以使用类似的方法获取类的属性信息。假设我们为Person类添加了属性：

1
2
3
4
5
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

然后使用反射获取属性信息的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Program
{
    static void Main()
    {
        Type type = typeof(Person);
        PropertyInfo[] properties = type.GetProperties();

        foreach (PropertyInfo property in properties)
        {
            Console.WriteLine($"属性名称: {property.Name}, 属性类型: {property.PropertyType}");
        }
        // 输出:
        // 属性名称: Name, 属性类型: System.String
        // 属性名称: Age, 属性类型: System.Int32
    }
}

2. 反射的高级用法

反射不仅能获取类型信息，您还可以通过反射来创建对象、调用方法以及设置字段和属性的值。

2.1 动态创建对象

我们可以使用Activator.CreateInstance()方法动态创建对象。例如：

1
2
Type type = typeof(Person);
object personInstance = Activator.CreateInstance(type);

2.2 动态调用方法

您可以使用MethodInfo.Invoke方法来动态调用对象的方法。以下是一个示例：

1
2
MethodInfo methodInfo = type.GetMethod("Introduce");
methodInfo.Invoke(personInstance, null);

2.3 设置字段或属性值

最后，使用反射来设置对象的字段或属性值如下：

1
2
3
4
5
FieldInfo nameField = type.GetField("Name");
nameField.SetValue(personInstance, "John");

PropertyInfo ageProperty = type.GetProperty("Age");
ageProperty.SetValue(personInstance, 30);

3. 总结

通过本文，我们已详细介绍了如何使用反射获取类型信息，包括字段、方法和属性，使得我们能够在运行时动态地访问和操作类型。此外，反射还允许我们动态创建对象并调用其方法，为程序赋予了灵活性。在下一篇中，我们将讨论如何创建和使用自定义特性，这将为您开启更高级的反射应用大门。敬请期待！

分享转发

发表更新编程 / C#进阶5 分钟读完 (大约773个字)

15 反射和自定义特性之自定义特性的创建与使用

在上一篇中，我们探讨了如何使用反射获取类型信息。反射是一种非常强大的功能，允许我们在运行时检查类型、方法、属性等。而在反射的强大之上，自定义特性（Attributes）则为我们提供了一种能够为类型、方法、属性等提供元数据的方式。这一篇将着重于如何创建和使用自定义特性，帮助我们更好地利用反射进行编程。

自定义特性的创建

自定义特性的定义

在 C# 中，我们创建自定义特性非常简单，只需定义一个类，并从 System.Attribute 基类继承。在类定义中，我们可以使用构造函数以及属性以便传递额外的信息。

下面是一个简单的自定义特性的示例，它用于描述一个方法的开发者和创建日期：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;

[AttributeUsage(AttributeTargets.Method)]
public class DeveloperInfoAttribute : Attribute
{
    public string Developer { get; }
    public string Date { get; }

    public DeveloperInfoAttribute(string developer, string date)
    {
        Developer = developer;
        Date = date;
    }
}

在上面的代码中，我们使用了 AttributeUsage 特性来指定这个自定义特性只能应用于方法上。DeveloperInfoAttribute 特性有两个只读属性：Developer 和 Date。

应用自定义特性

自定义特性的定义完成后，我们就可以在方法上使用这个特性。下面是一个示例：

1
2
3
4
5
6
7
8
public class SampleClass
{
    [DeveloperInfo("Alice", "2023-01-01")]
    public void SampleMethod()
    {
        Console.WriteLine("Sample Method Executed.");
    }
}

在这个示例中，SampleMethod 上应用了我们刚刚创建的 DeveloperInfoAttribute 特性。在特性中，我们指定了开发者的名字和日期。

通过反射获取自定义特性信息

现在我们来看看如何使用反射来获取这些自定义特性的信息。我们可以通过获取类型的MethodInfo和使用 GetCustomAttributes 方法来实现这一点。

以下是示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Reflection;

class Program
{
    static void Main(string[] args)
    {
        // 获取SampleClass类型
        Type sampleType = typeof(SampleClass);
        // 获取SampleMethod方法的信息
        MethodInfo methodInfo = sampleType.GetMethod("SampleMethod");

        // 获取自定义特性
        DeveloperInfoAttribute attribute = (DeveloperInfoAttribute)Attribute.GetCustomAttribute(methodInfo, typeof(DeveloperInfoAttribute));
        if (attribute != null)
        {
            Console.WriteLine($"Developer: {attribute.Developer}, Date: {attribute.Date}");
        }
    }
}

运行以上代码，你将看到输出：

1
Developer: Alice, Date: 2023-01-01

在这个示例中，我们使用 GetMethod 方法获取了 SampleMethod 的 MethodInfo，再用 Attribute.GetCustomAttribute() 来获取特性信息，并最终输出相关信息。

小结

通过这篇文章，我们学习了如何创建和使用自定义特性，并结合反射来获取这些特性的元数据。自定义特性为我们的代码提供了丰富的元数据，从而在后续程序执行中可以利用反射进行动态操作，从而提高了程序的灵活性。在后面的篇幅中，我们将探讨内存管理和垃圾回收的基础知识，为理解 C# 的运行时环境奠定基础。

分享转发

发表更新编程 / C#进阶9 分钟读完 (大约1294个字)

16 内存管理与垃圾回收基础

在 C# 的程序设计中，内存管理是一个非常重要的方面。随着应用程序的复杂度不断增加，合理的内存使用和管理变得尤为关键。在上一节中，我们探讨了反射和自定义特性的创建与使用，而现在，我们将深入了解 C# 中的内存管理基础，以及为什么它对我们编写高效和稳定的代码至关重要。

什么是内存管理？

内存管理指的是程序分配、使用和释放内存资源的过程。在 C# 这种高级语言中，内存管理主要是通过垃圾回收 (Garbage Collection, GC) 机制自动处理的，但理解其基础原理仍然是很重要的。

在 C# 中，内存主要分为两种：堆（Heap）和栈（Stack）。

  • 栈：用于存储局部变量和方法调用信息。当方法调用结束，栈上的内存被自动释放。
  • 堆：用于存储动态分配的对象。堆上的内存需要通过垃圾回收机制来管理。

栈与堆的区别

栈 堆
存储局部变量和方法调用信息 存储动态分配的对象
速度较快 速度较慢
自动管理 自动和手动结合管理
先进后出 (LIFO) 无结构

内存中的对象

在 C# 中，所有对象都是从堆中分配内存的。例如，考虑以下简单的类实现：

1
2
3
4
5
6
7
8
9
public class Person
{
    public string Name { get; set; }

    public Person(string name)
    {
        Name = name;
    }
}

当你创建一个 Person 对象时，内存是从堆中动态分配的：

1
Person person = new Person("Alice");

在上述代码中，person 变量在栈上存储了对堆中 Person 对象的引用。

引用类型与值类型

C# 有两种主要的数据类型：值类型和引用类型。

  • 值类型：如 int、double、struct，它们的值直接存储在栈上。
  • 引用类型：如 class、string、array，它们存储引用，实际数据存储在堆上。

值类型与引用类型的区别

值类型 引用类型
存储实际数据 存储数据的引用
存储在栈上 存储在堆上
当复制时，复制的是值 当复制时，复制的是引用

以下示例展示了值类型和引用类型的复制行为：

1
2
3
4
5
6
7
int a = 10; // 值类型
int b = a;  // b 复制 a 的值
b = 20;     // a 不受影响，a 仍为 10

Person person1 = new Person("Alice");
Person person2 = person1; // 引用类型
person2.Name = "Bob";     // person1 的 Name 也变为 "Bob"

垃圾回收的基础概念

C# 使用垃圾回收器来自动管理内存。垃圾回收器会定期检查不再被任何引用使用的对象，并将其内存回收。垃圾回收的过程主要包括以下几个步骤：

  1. 标记：识别那些不再被引用的对象。
  2. 清理：释放这些对象所占用的内存。
  3. 压缩：将存活的对象移动，以便释放出一块连续的内存空间。

垃圾回收的触发

垃圾回收并不是在某个具体的时间点触发的，而是根据内存使用情况自动执行。常见的触发条件包括：

  • 申请内存时未能获取到足够的空间。
  • 系统空闲时，垃圾回收器可能会主动运行。
  • 调用 GC.Collect() 显式请求垃圾回收。

小心内存泄漏

尽管 C# 提供了垃圾回收机制，但我们仍然需要小心内存泄漏。内存泄漏通常发生在我们有长生命周期的对象持有对短生命周期对象的引用时。例如，事件订阅未被正确注销，导致某些对象无法被垃圾回收供释放。

以下是一个简单的例子，展示了如何导致内存泄漏：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Publisher
{
    public event EventHandler OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}

public class Subscriber
{
    public void Subscribe(Publisher publisher)
    {
        publisher.OnChange += Publisher_OnChange;
    }

    private void Publisher_OnChange(object sender, EventArgs e)
    {
        // 处理事件
    }
}

在这个例子中，如果 Subscriber 没有取消订阅 Publisher 的事件，即使 Subscriber 对象不再被使用，也无法被垃圾回收，从而造成内存泄漏。

结论

内存管理是开发高性能 C# 应用程序的一个至关重要的部分。了解堆与栈、值类型与引用类型的区别，以及垃圾回收的基础知识，能够帮助我们编写更有效的代码。遵循良好的内存管理实践，例如及时注销事件订阅和避免不必要的引用，可以有效降低内存泄漏的风险。

在下一节中，我们将深入探讨垃圾回收机制，了解它是如何工作的，以及我们在使用时可以采取的优化策略。

分享转发

发表更新编程 / C#进阶7 分钟读完 (大约1122个字)

17 理解垃圾回收机制

在讨论 C# 的内存管理时，我们已经了解了内存的分配与释放机制。现在，我们将深入探讨 C# 中的垃圾回收（Garbage Collection，GC）机制，它是 C# 自动管理内存的重要组成部分。垃圾回收机制不仅可以帮助开发者减少与内存管理相关的错误，还可以优化程序的性能。

垃圾回收的基本概念

在 C# 中，对象的创建通常通过 new 关键字来进行。这些对象会分配在托管堆上。随着程序的运行，某些对象可能会不再被使用，然而这些对象所占用的内存并不会立即释放，这就是垃圾回收的工作内容。垃圾回收是指系统自动回收不再被引用的对象所占用的内存，从而避免内存泄漏。

垃圾回收的工作原理

C# 垃圾回收的工作往往涉及以下几个步骤：

  1. 标记阶段：标记所有可到达的对象。从根对象（如全局变量和线程栈）出发，找到所有可以访问的对象，并将它们标记为活动对象。

  2. 清理阶段：遍历堆，找出未被标记的对象，也就是不再被程序引用的对象。将这部分对象视为“垃圾”并进行回收。

  3. 压缩阶段：这一步并不是每次垃圾回收都一定会进行。它将存活的对象向堆的一侧移动，以便将内存碎片整理，以提高后续内存分配的效率。

例子

考虑以下代码，它展示了一个简单的对象创建和垃圾回收过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class SampleObject
{
    public int Value { get; set; }
}

public class Program
{
    public static void Main()
    {
        SampleObject obj1 = new SampleObject { Value = 10 };
        SampleObject obj2 = new SampleObject { Value = 20 };

        //  obj1 和 obj2 在这里都是活动对象
        Console.WriteLine(obj1.Value);
        Console.WriteLine(obj2.Value);

        // 设置 obj1 为 null，使其不再可访问
        obj1 = null;

        // 在这个点，obj1 是垃圾，obj2 仍然可以访问
        Console.WriteLine(obj2.Value);

        // 强制进行垃圾回收
        GC.Collect();
    }
}

在上面的例子中，obj1 被设为 null，因此它会被标记为垃圾对象，并在后续的垃圾回收中被清除。虽然我们可以通过调用 GC.Collect() 来强制垃圾回收，但是不推荐在生产代码中频繁调用。

垃圾回收的特点

  • 自动化：C# 的垃圾回收是自动进行的，开发者无需手动释放内存。
  • 非确定性：垃圾回收的时机是非确定的，这意味着你不能确切地知道何时会发生回收。
  • 性能优化：尽管垃圾回收会耗费性能，但它通过整理内存来提高后续分配的效率。

GC 调优和相关设置

C# 提供了一些方式使得开发者可以控制垃圾回收机制的行为，但一般情况下，默认设置已经能够满足大多数需求。值得注意的是，GC.Collect() 可以手动触发垃圾回收，但通常应该避免使用，因为它可能导致性能下降。在高性能的应用中，我们更应该关注对象的创建和生命周期管理。

优化垃圾回收的示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class OptimizationExample
{
    public void DoWork()
    {
        for (int i = 0; i < 1000; i++)
        {
            var tempObject = new SampleObject { Value = i };
            // 处理对象
            ProcessObject(tempObject);
        }
    }

    private void ProcessObject(SampleObject obj)
    {
        // 执行一些与对象相关的操作
        Console.WriteLine(obj.Value);
    }
}

在这个示例中，tempObject 在每次循环结束后不再被引用，因此这些对象在下一次垃圾回收时会被回收。相较于在循环中创建大量对象，适时使用对象池可以减少内存分配频率。

总结

了解 C# 的垃圾回收机制对于开发高效能的应用至关重要。通过掌握 GC 的基本原理，开发者能够更好地控制内存使用，并在需要时进行适当的调优。而在下一篇中，我们将讨论如何处理内存泄漏的问题，这是确保应用程序性能和稳定性的另一项重要技能。

分享转发

发表更新编程 / C#进阶6 分钟读完 (大约950个字)

18 C# 内存管理与垃圾回收之处理内存泄漏

在上一篇文章中，我们深入探讨了 C# 的垃圾回收机制以及其工作原理。这次，我们将聚焦于如何有效地处理内存泄漏问题，确保我们的应用程序能够保持良好的性能和稳定性。

什么是内存泄漏？

内存泄漏是指程序在运行过程中动态分配的内存不再被使用，但依然被保留在内存中，从而导致可用内存减少，最终可能导致应用程序崩溃或系统性能下降。

在 C# 中，虽然有垃圾回收机制来自动释放不再使用的对象，但仍然存在可能导致内存泄漏的情况。

常见的内存泄漏原因

  1. 事件处理器未释放
    当对象注册了事件处理器而没有在对象销毁时解除注册，这将导致对象无法被回收，从而造成内存泄漏。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    public class EventSource
    {
        public event EventHandler SomeEvent;

        public void RaiseEvent()
        {
            SomeEvent?.Invoke(this, EventArgs.Empty);
        }
    }

    public class Consumer
    {
        public Consumer(EventSource source)
        {
            source.SomeEvent += HandleEvent; // 添加事件处理器
        }

        private void HandleEvent(object sender, EventArgs e)
        {
            // 事件处理逻辑
        }
    }

    在这个例子中，如果 Consumer 对象不再需要，但 EventSource 仍然持有对它的引用，Consumer 的内存将无法释放。

  2. 静态引用
    如果一个对象通过静态变量引用，尽管它的生命周期很长，但它可能会阻止其他对象的垃圾回收。

    1
    2
    3
    4
    public class StaticHolder
    {
        public static Consumer ConsumerInstance { get; set; }
    }

    在此例中，一旦 StaticHolder.ConsumerInstance 被赋值，Consumer 的实例将不易被垃圾回收。

  3. 集合未清理
    当将对象存储在集合（如 List、Dictionary 等）中，若未在使用后进行清理，将导致内存泄漏。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class CollectionHolder
    {
        private List<Consumer> _consumers = new List<Consumer>();

        public void AddConsumer(Consumer consumer)
        {
            _consumers.Add(consumer);
        }

        public void Clear()
        {
            _consumers.Clear(); // 清理集合以避免内存泄漏
        }
    }

如何防止内存泄漏？

1. 正确管理事件

确保在对象不再需要的时候解除事件订阅。如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Consumer
{
    private EventSource _eventSource;

    public Consumer(EventSource source)
    {
        _eventSource = source;
        source.SomeEvent += HandleEvent;
    }

    public void DetachEvent()
    {
        _eventSource.SomeEvent -= HandleEvent; // 解除事件处理器
    }
}

2. 规范使用静态变量

限制静态变量的使用，尽量避免不必要的长生命周期引用。如果非用不可，确保在适当的时机清空静态引用。

3. 释放集合中的对象

定期遍历和清理集合内的对象，特别是在对象不再需要时。

1
2
3
4
public void RemoveConsumer(Consumer consumer)
{
    _consumers.Remove(consumer); // 确保从集合中移除对象
}

使用 IDisposable 接口

对于涉及到非托管资源的类，确保实现 IDisposable 接口，并在 Dispose 方法中释放所有资源：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class ResourceHolder : IDisposable
{
    private bool _disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // 释放托管资源
            }
            // 释放非托管资源
            _disposed = true;
        }
    }

    ~ResourceHolder()
    {
        Dispose(false);
    }
}

结论

内存泄漏在 C# 中虽然不如在其他语言（如 C 或 C++）中常见，但仍然是一个需要注意的问题。通过有效的事件管理、控制静态引用和清理集合，我们可以显著减少内存泄漏的风险。为确保资源的正确管理，使用 IDisposable 接口以及及时调用 Dispose 方法是一个良好的实践。

在下一篇文章中，我们将学习扩展方法和动态类型，探讨如何定义与使用扩展方法，这将使我们更灵活地操作现有类型。我们期待与您继续探讨 C# 的更多进阶内容。

分享转发

发表更新编程 / C#进阶7 分钟读完 (大约1020个字)

19 C# 中的扩展方法与动态类型的定义与使用

在前一篇文章中，我们探讨了 C# 中的内存管理及垃圾回收，对如何处理内存泄漏进行了详细讨论。今天，我们将继续深入 C# 的一个重要特性——扩展方法，特别是《扩展方法和动态类型之扩展方法的定义与使用》。在接下来的篇幅中，我们将详细介绍什么是扩展方法，如何定义它们，以及它们在实际开发中的应用。

什么是扩展方法？

扩展方法是 C# 3.0 引入的一种特殊的静态方法，允许你为现有类型添加新方法，而无需修改其源代码或重新编译它们。它们在需要增强某个类型的功能时非常有用，尤其是当你只能使用原始类型，而无法对其进行修改时。

扩展方法的定义

扩展方法必须定义在一个 static 类中，并且方法本身也必须是 static 的。扩展方法的第一个参数指定了要扩展的类型，并使用 this 关键字进行修饰。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static class StringExtensions
{
    public static int WordCount(this string str)
    {
        // 如果字符串为空，返回0
        if (string.IsNullOrEmpty(str))
        {
            return 0;
        }
        
        // 按空格拆分字符串并返回单词数
        return str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Length;
    }
}

在上面的例子中，我们创建了一个名为 StringExtensions 的静态类，并在其中定义了一个扩展方法 WordCount，用于统计字符串中的单词数量。

使用扩展方法

一旦定义了扩展方法，就可以像调用实例方法一样使用它。以下是如何使用上述 WordCount 扩展方法的示例：

1
2
3
4
5
6
7
8
9
class Program
{
    static void Main()
    {
        string text = "Hello world! Welcome to C#!";
        int count = text.WordCount();
        Console.WriteLine($"单词数量: {count}");  // 输出: 单词数量: 5
    }
}

在这个示例中，我们可以看到，扩展方法的使用和普通实例方法没有区别，这大大提高了代码的可读性和可维护性。

扩展方法的实际应用场景

扩展方法在日常开发中具有广泛的应用场景，例如：

  1. 增强现有库的功能：当使用第三方库时，可以通过扩展方法添加特定的功能，而无需修改库的源代码。
  2. 工具或帮助类：为常用的操作创建扩展方法，让代码更整洁。
  3. LINQ 方法的实现：LINQ 本身就是通过扩展方法的方式实现的，使得集合操作更加简洁。

我们可以看一个更复杂的例子，在一个应用程序中，假设我们需要为 IEnumerable<T> 添加一个扩展方法，以便更方便地计算平均值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static class EnumerableExtensions
{
    public static double Average<T>(this IEnumerable<T> source) where T : IConvertible
    {
        if (source == null || !source.Any()) throw new ArgumentException("Source is empty");
        
        double sum = 0;
        int count = 0;

        foreach (var item in source)
        {
            sum += Convert.ToDouble(item);
            count++;
        }
        return sum / count;
    }
}

使用新的扩展方法

1
2
3
4
5
6
7
8
9
class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        double average = numbers.Average();
        Console.WriteLine($"平均值: {average}");  // 输出: 平均值: 3
    }
}

在上面的代码中，我们为 IEnumerable<T> 定义了一个 Average 扩展方法，用于计算集合的平均值。这个方法可以处理任何实现了 IEnumerable<T> 接口的集合，例如 List<int>、Array 等。

总结

通过对扩展方法的定义与使用的讲解，我们了解到扩展方法不仅能够增强现有类型的功能，还能使得我们的代码更简洁、更具可读性。在完美结合了内存管理的高效性与代码的优雅性后，我们的 C# 开发将会更加得心应手。

在下篇文章中，我们将探讨动态类型的使用场景，揭示其在灵活性与性能之间的平衡如何影响现代 C# 程序的设计。

分享转发

发表更新编程 / C#进阶6 分钟读完 (大约965个字)

20 扩展方法和动态类型之动态类型的使用场景

在上篇文章中，我们了解到什么是扩展方法以及如何定义和使用它们。现在，我们将重点探讨动态类型，并讨论一些使用场景，以帮助我们理解动态类型在C#中的应用。

什么是动态类型？

在C#中，dynamic类型是一种特殊类型，它可以在运行时确定数据类型。这意味着我们不需要在编译时定义变量的确切类型，这为开发者提供了更大的灵活性。例如：

1
2
dynamic variable = "Hello, World!";
Console.WriteLine(variable); // 输出: Hello, World!

在这段代码中，variable的类型在运行时被确定为string。接下来，如果我们将它赋值为一个整数：

1
2
variable = 42;
Console.WriteLine(variable); // 输出: 42

这样，variable的类型变成了int，并且我们可以在运行时随意改变它。

动态类型的使用场景

1. 与动态语言交互

当我们需要与其他动态语言（如Python或JavaScript）交互时，动态类型非常有用。通过使用动态类型，我们可以方便地处理这些语言返回的数据，因为我们不需要事先知道返回的具体类型。例如：

1
2
dynamic jsonResponse = GetJsonResponseFromDynamicLanguage();
Console.WriteLine(jsonResponse.SomeProperty);

在这个例子中，GetJsonResponseFromDynamicLanguage是一个与动态语言交互的方法，它返回一个动态类型的对象。我们可以直接访问其属性，而无需了解具体的类型。

2. 处理反射

在某些情况下，我们需要处理复杂的对象，并且在编译时无法确定对象的类型。动态类型在这种情况下极为有用。例如，使用反射从某个对象中提取数据：

1
2
3
4
var obj = Activator.CreateInstance(typeof(SomeClass));
dynamic dynamicObj = obj;

Console.WriteLine(dynamicObj.SomeMethod());

在这里，SomeClass可能是我们在编译时无法直接访问的类。通过dynamic修饰符，我们可以调用它的方法而不需要事先检查类型。

3. 未知数据结构的处理

有时，我们可能会处理不规则的数据结构，例如从数据库或外部API获取的数据。通过动态类型，可以轻松处理这些未知的数据结构，例如JSON对象：

1
2
3
4
5
string jsonString = "{\"name\":\"John\", \"age\":30}";
dynamic jsonObject = JsonConvert.DeserializeObject(jsonString);

Console.WriteLine(jsonObject.name); // 输出: John
Console.WriteLine(jsonObject.age);  // 输出: 30

在以上代码中，我们使用JsonConvert.DeserializeObject方法将JSON字符串转换为动态对象，从而能够直接访问其属性。

4. LINQ查询中的动态类型

在使用LINQ时，有时我们需要构造动态查询。利用dynamic类型，可以构建更灵活的查询。例如：

1
2
3
4
5
6
7
8
var data = new List<dynamic>
{
    new { Id = 1, Name = "Alice" },
    new { Id = 2, Name = "Bob" }
};

var result = data.Where(d => d.Id == 1).FirstOrDefault();
Console.WriteLine(result.Name);  // 输出: Alice

在这个例子中，data中的元素具有匿名类型，通过dynamic关键字，我们可以灵活处理这些数据。

小结

动态类型在C#中的使用场景广泛，特别是在与动态语言交互、处理未知数据结构和反射时表现出色。然而，使用动态类型时需要小心，因为它会牺牲编译时类型检查的安全性，可能导致运行时错误。在使用动态类型时，开发者应确保合理的错误处理和相关的单元测试。

我们在下篇文章中将深入探讨动态语言运行时(DLR)，了解如何利用这一强大的功能提升C#编程的灵活性和可扩展性。敬请期待！

分享转发

发表更新编程 / C#进阶6 分钟读完 (大约870个字)

21 动态语言运行时的应用

在上一篇中，我们探讨了动态类型的使用场景，了解了如何在C#中有效地使用dynamic关键字。此次，我们将深入研究扩展方法与动态类型结合使用的场景，尤其是如何利用动态语言运行时（DLR）来扩展现有类型的功能。这将使我们能够创建更灵活和可扩展的代码。

什么是扩展方法

在C#中，扩展方法允许你为现有类型添加新方法，而无需修改其定义。扩展方法的语法比较特殊，它需要定义在一个静态类中，方法本身也是静态的，第一参数使用this关键字修饰，以指示要扩展的类型。

例子：简单的扩展方法

1
2
3
4
5
6
7
public static class StringExtensions
{
    public static int WordCount(this string str)
    {
        return string.IsNullOrWhiteSpace(str) ? 0 : str.Split(' ').Length;
    }
}

在以上代码中，我们定义了一个扩展方法WordCount，它可以返回字符串中的单词数量。使用时，我们可以直接调用：

1
2
string text = "Hello, how are you?";
int count = text.WordCount(); // count = 5

动态类型与扩展方法结合

当我们在动态类型中使用扩展方法时，考虑到dynamic的灵活性，使用扩展方法能够进一步增强代码的可读性和可维护性。因为扩展方法是在编译时解析的，而dynamic类型则是在运行时解析，这种结合使用可以提供更好的动态特性。

动态类型的例子

1
2
dynamic sample = "Hello, how are you?";
int wordCount = sample.WordCount(); // 运行时解析出扩展方法

然而，这里必须确保在使用动态类型时，实际上扩展方法的存在与类型支持，不然在运行时将会抛出RuntimeBinderException。

使用动态语言运行时扩展类型

为了有效地利用动态语言运行时（DLR），我们可以将扩展方法与ExpandoObject结合。这使得我们可以在运行时动态地添加属性和方法。

例子：动态对象扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Dynamic;

public static class DynamicExtensions
{
    public static void AddProperty(this ExpandoObject expando, string propertyName, object value)
    {
        var dict = expando as IDictionary<string, object>;
        dict[propertyName] = value;
    }
}

class Program
{
    static void Main()
    {
        dynamic person = new ExpandoObject();
        person.AddProperty("Name", "Alice");
        person.AddProperty("Age", 30);

        Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
    }
}

在上述代码中，我们创建了一个ExpandoObject的动态实例，并通过扩展方法AddProperty动态添加属性Name和Age。通过这种方式，我们可以在运行时根据需求动态扩展对象的机制。

总结

在本篇中，我们深入探讨了C#中的扩展方法与动态类型结合使用的优势。通过利用动态语言运行时（DLR），我们能够在项目中为现有类型提供更灵活和可扩展的功能，尤其是在处理动态类型时。扩展方法的强大特性加上动态对象的灵活性，能够帮助我们应对复杂的编码需求，从而提升代码的可维护性。

在下一篇文章中，我们将转向设计模式，探讨在C#中如何实现单例模式，帮助你掌握类别设计中的最佳实践，敬请期待！

分享转发

发表更新编程 / C#进阶6 分钟读完 (大约943个字)

22 设计模式在C#中的应用之单例模式

在软件开发中，设计模式是一种被广泛采用的解决方案，具有可重用性和可维护性。继上一篇关于扩展方法和动态类型之动态语言运行时的讨论后，本节将深入探讨单例模式（Singleton Pattern）在C#中的应用。单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。

什么是单例模式？

单例模式的主要目的是控制实例的创建。通过确保只有一个实例，单例模式可以有效地管理资源，如数据库连接或配置设置。这种模式尤其适用于需要全局访问的共享资源。

单例模式的结构

在C#中，单例模式通常包含以下组件：

  1. 私有构造函数：阻止外部直接实例化该类。
  2. 静态变量：持有该类的唯一实例。
  3. 公共静态方法：提供对实例的访问。

单例模式实现示例

以下是一个简单的单例模式在C#中的实现示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Singleton
{
    // 持有唯一实例的静态变量
    private static Singleton _instance;

    // 锁对象，用于线程安全
    private static readonly object _lock = new object();

    // 私有构造函数
    private Singleton()
    {
        // 初始化代码
    }

    // 公共静态方法，提供对实例的访问
    public static Singleton Instance
    {
        get
        {
            // 双重检查锁定，确保线程安全
            if (_instance == null)
            {
                lock (_lock)
                {
                    if (_instance == null)
                    {
                        _instance = new Singleton();
                    }
                }
            }
            return _instance;
        }
    }

    // 示例方法
    public void DoSomething()
    {
        Console.WriteLine("Doing something...");
    }
}

代码解析

  1. 私有构造函数：通过将构造函数设为private，防止外部实例化该类。

  2. 静态变量和锁：_instance是私有的静态变量，用于存储单例实例。_lock用于确保在多线程环境中安全地创建实例。

  3. Instance 属性：通过双重检查锁定方法，确保即使在多线程环境下也能安全地创建单例实例。

  4. DoSomething 方法：这是一个普通方法，展示了如何使用单例实例。

使用单例模式

使用单例模式，我们可以确保在任何时间只有一个实例。以下是一个案例，展示如何在一个控制台应用程序中使用单例模式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Program
{
    static void Main(string[] args)
    {
        // 通过单例模式获取实例
        var singleton1 = Singleton.Instance;
        var singleton2 = Singleton.Instance;

        // 验证两个实例是否相同
        Console.WriteLine(object.ReferenceEquals(singleton1, singleton2)); // 输出 True

        // 调用示例方法
        singleton1.DoSomething();
    }
}

案例解析

在这个示例中：

  • singleton1和singleton2均通过Singleton.Instance访问同一单例实例。
  • 使用object.ReferenceEquals验证两个引用是否指向同一对象，返回True确认了单例模式的实施。

单例模式的优缺点

优点：

  • 确保全局只有一个实例，节省内存。
  • 提供对该实例的全局访问。

缺点：

  • 难以测试，由于存在全局状态。
  • 可能导致与并发相关的问题（需要适当的锁定机制）。

小结

单例模式在C#中的应用非常广泛，特别是在需要集中管理资源的场景中。通过使用单例模式，开发者可以有效地控制资源，避免多次不必要的资源创建。接下来，在下一节中，我们将探讨另一种常用的设计模式——工厂模式（Factory Pattern），继续深入理解设计模式在实际开发中的重要性和实现方式。

分享转发

发表更新编程 / C#进阶7 分钟读完 (大约1112个字)

23 设计模式在C#中的应用之工厂模式

在前一篇文章中，我们深入探讨了单例模式的应用，了解了如何确保一个类只有一个实例并提供全局访问。在本篇中，我们将聚焦于另一种重要的设计模式——工厂模式。这种模式在创建对象方面提供了一种灵活的解决方案，使得代码更加模块化，易于维护和扩展。

什么是工厂模式？

工厂模式是一种创建型设计模式，主要负责实例化对象。它通过定义一个接口或抽象类来创建对象，从而允许子类决定实例化哪个类。工厂模式将对象的创建与使用分离，使得代码结构更加清晰。

工厂模式通常分为三种类型：

  • 简单工厂模式（虽然严格来说不是一个设计模式）
  • 工厂方法模式
  • 抽象工厂模式

在本篇中，我们将重点讨论简单工厂模式和工厂方法模式。

简单工厂模式

简单工厂模式的核心是一个工厂类，可以根据提供的信息创建不同的对象。下面是一个示例。

示例：简单工厂模式

假设我们要创建一个简单的图形应用程序，可以绘制多种形状，比如Circle和Square。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 产品接口
public interface IShape
{
    void Draw();
}

// 具体产品 - 圆形
public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Circle");
    }
}

// 具体产品 - 正方形
public class Square : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Square");
    }
}

// 工厂类
public class ShapeFactory
{
    public static IShape GetShape(string shapeType)
    {
        switch (shapeType.ToLower())
        {
            case "circle":
                return new Circle();
            case "square":
                return new Square();
            default:
                throw new ArgumentException("Shape type not recognized");
        }
    }
}

// 使用工厂
class Program
{
    static void Main(string[] args)
    {
        IShape shape1 = ShapeFactory.GetShape("circle");
        shape1.Draw();  // 输出: Drawing a Circle

        IShape shape2 = ShapeFactory.GetShape("square");
        shape2.Draw();  // 输出: Drawing a Square
    }
}

在上述示例中，ShapeFactory负责创建具体的形状对象。通过传递形状的类型，调用者可以获取所需的对象，而无需了解具体实现。

工厂方法模式

与简单工厂模式不同，工厂方法模式为每个产品定义一个创建的接口，允许子类决定实例化哪个类。通过这种方式，工厂方法模式提供了更高的灵活性和可扩展性。

示例：工厂方法模式

让我们修改之前的例子，使用工厂方法模式创建不同形状的工厂。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
// 产品接口
public interface IShape
{
    void Draw();
}

// 具体产品 - 圆形
public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Circle");
    }
}

// 具体产品 - 正方形
public class Square : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a Square");
    }
}

// 工厂接口
public interface IShapeFactory
{
    IShape CreateShape();
}

// 具体工厂 - 圆形工厂
public class CircleFactory : IShapeFactory
{
    public IShape CreateShape()
    {
        return new Circle();
    }
}

// 具体工厂 - 正方形工厂
public class SquareFactory : IShapeFactory
{
    public IShape CreateShape()
    {
        return new Square();
    }
}

// 使用工厂方法
class Program
{
    static void Main(string[] args)
    {
        IShapeFactory circleFactory = new CircleFactory();
        IShape circle = circleFactory.CreateShape();
        circle.Draw();  // 输出: Drawing a Circle

        IShapeFactory squareFactory = new SquareFactory();
        IShape square = squareFactory.CreateShape();
        square.Draw();  // 输出: Drawing a Square
    }
}

在这个示例中，每种形状都有一个专属的工厂。通过工厂接口IShapeFactory，我们实现了对具体工厂的抽象。这使得我们能够轻松扩展，例如添加新的形状产品和对应的工厂，而不需要修改现有代码。

总结

在本篇中，我们详细探讨了工厂模式及其在C#中的实现。我们了解了简单工厂模式和工厂方法模式，并通过示例代码展示了如何使用这些模式创造灵活和可扩展的代码结构。工厂模式尤其适用于需要创建多个相关或相似对象的场景，从而达到降低耦合度、提高代码可维护性的目的。

在下一篇文章中，我们将继续探讨观察者模式，了解如何在对象之间建立一种一对多的依赖关系，以便在一个对象的状态改变时自动通知所有依赖于它的对象。在这个模式中，您将看到如何处理多方交互，同时保持组件之间的低耦合性。敬请期待！

分享转发

发表更新编程 / C#进阶7 分钟读完 (大约1081个字)

24 在C#中应用观察者模式

在软件设计中，观察者模式是一种常见的设计模式，它属于行为型模式，主要用于建立一种一对多的关系，使得一个对象（被观察者）状态的变化能够自动通知所有依赖于它的对象（观察者）。在本篇教程中，我们将探讨如何在C#中实现观察者模式，并通过具体的示例代码进行说明。

观察者模式的基本概念

在观察者模式中，核心组件包含以下几个角色：

  1. Subject（被观察者）：在状态变化时通知观察者的对象。
  2. Observer（观察者）：需要被通知并进行相应更新的对象。
  3. ConcreteSubject（具体被观察者）：实现了Subject接口的具体类。
  4. ConcreteObserver（具体观察者）：实现了Observer接口的具体类。

这种模式的优点在于它实现了对象间的解耦，允许动态添加和删除观察者。

使用C#实现观察者模式

示例场景

假设我们在开发一个股票行情监控系统，Stock类作为被观察者，而多个Investor类作为观察者，他们能够实时接收股票价格的变动。

步骤一：定义观察者接口

首先，我们定义一个 IObserver 接口，它包含一个更新方法，用于当被观察者状态变化时通知观察者。

1
2
3
4
public interface IObserver
{
    void Update(string stockSymbol, decimal price);
}

步骤二：定义被观察者接口

接着，我们定义一个 ISubject 接口，用于管理观察者的添加和移除，以及通知观察者。

1
2
3
4
5
6
public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

步骤三：实现具体被观察者类

现在我们实现一个具体的被观察者类 Stock，它包含股票符号和价格，并能够在价格变化时通知所有观察者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
using System;
using System.Collections.Generic;

public class Stock : ISubject
{
    private string _symbol;
    private decimal _price;
    private readonly List<IObserver> _observers = new List<IObserver>();

    public Stock(string symbol, decimal price)
    {
        _symbol = symbol;
        _price = price;
    }

    public string Symbol => _symbol;

    public decimal Price
    {
        get => _price;
        set
        {
            _price = value;
            Notify(); // 价格变化后通知观察者
        }
    }

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in _observers)
        {
            observer.Update(_symbol, _price);
        }
    }
}

步骤四：实现具体观察者类

接下来，我们实现一个具体的观察者类 Investor，它实现了 IObserver 接口，并在 Update 方法中接收被观察者的通知。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Investor : IObserver
{
    private string _name;

    public Investor(string name)
    {
        _name = name;
    }

    public void Update(string stockSymbol, decimal price)
    {
        Console.WriteLine($"投资者 {_name} 收到通知: 股票 {stockSymbol} 的新价格为 {price}");
    }
}

步骤五：演示观察者模式的应用

最后，在主程序中创建被观察者和观察者，并展示它们是如何协同工作的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Program
{
    static void Main()
    {
        Stock stock = new Stock("AAPL", 150.00m);

        Investor investor1 = new Investor("张三");
        Investor investor2 = new Investor("李四");

        stock.Attach(investor1);
        stock.Attach(investor2);

        // 模拟股票价格变化
        stock.Price = 155.00m;  // 通知观察者
        stock.Price = 160.00m;  // 通知观察者

        // 移除一个观察者
        stock.Detach(investor1);
        stock.Price = 162.00m;  // 仅通知剩下的观察者
    }
}

输出结果

运行上述程序将输出：

1
2
3
4
5
投资者 张三 收到通知: 股票 AAPL 的新价格为 155.00
投资者 李四 收到通知: 股票 AAPL 的新价格为 155.00
投资者 张三 收到通知: 股票 AAPL 的新价格为 160.00
投资者 李四 收到通知: 股票 AAPL 的新价格为 160.00
投资者 李四 收到通知: 股票 AAPL 的新价格为 162.00

小结

本篇文章详细讲解了 观察者模式 在 C# 中的应用。通过股票行情监控的案例，我们实现了被观察者和观察者的类，并演示了它们之间如何进行通信。观察者模式为我们提供了一个灵活的解决方案，使得对象之间的耦合度降低，从而可更好地管理代码的复杂性。

在下一篇教程中，我们将讨论 装饰者模式，继续扩展我们的设计模式系列。请继续关注！

分享转发

×