49、C编程中的异常处理、枚举器与泛型-优快云博客

本文链接：https://blog.youkuaiyun.com/css33/article/details/149378345

C#编程中的异常处理、枚举器与泛型

1. 异常处理

1.1 输入异常处理

当输入不是数值时，程序会抛出异常而非崩溃。我们可以要求玩家提供数值输入。相较于使用 Debug.Log ，可以打开信息弹窗要求玩家重新输入。

1.2 自定义异常

在处理多种不同条件时，调试会变得复杂。使用自定义异常代码能更好地处理特定错误条件。例如， int 和 float 类有 Parse() 函数，它尝试将字符串解析为数值，若失败则抛出新异常。

下面是一个使用 ValidateRange() 函数检查数组中整数是否在 0 到 100 范围内的示例：

// 假设的 ValidateRange 函数示例
public void ValidateRange(int value)
{
    if (value > 100 || value < 0)
    {
        throw new MyException();
    }
}

在这个示例中，如果传入的值大于 100 或小于 0，会创建一个 MyException 并抛出。

1.3 异常捕获与处理

在 C# 中，使用 try-catch 语句来捕获和处理异常。当值抛出异常时， try 块会退出，程序跳转到 catch 块。若 ValidateRange 未抛出异常， try 块中的 Debug.Log() 会提示输入值通过验证。

我们可以为一个异常添加多个可能的 catch 块，并且可以抛出不同类型的异常，如在验证场景对象时，若提供的对象不是游戏对象，可以抛出 NullReferenceException 。

1.4 `finally` 语句

为了完善 try-catch 语句，可以添加 finally 语句。 finally 块在 try 和 catch 块完成任务后执行，常用于需要清理操作的函数，如解析玩家输入后清理输入字段或切换 UI 面板。

1.5 `try-catch-finally` 的实际应用

在使用 System.IO 和 StreamWriter 函数时，常遇到 UnauthorizedAccessExceptions ，通常是因为路径错误。以下是一个示例：

try
{
    // 在项目目录创建新文件
    StreamWriter file = new StreamWriter("FinalFile.txt");
    // 写入字符
    file.WriteByte(65); 
    file.Close();
}
catch (UnauthorizedAccessException e)
{
    // 捕获并处理异常
    Debug.LogError("写入文件时出现问题: " + e.Message);
}
finally
{
    // 确保文件关闭
    if (file != null)
    {
        file.Close();
    }
}

这个示例展示了如何使用 try-catch-finally 创建文件、检查问题并完成文件写入过程。

1.6 异常处理总结

try-catch-finally 这种结构为创建文件、检查问题和完成文件写入过程提供了清晰整洁的方式。在网络连接中，了解 try-catch-finally 过程也很重要，例如在通过 HTTP 获取图像或模型时，要确保连接不会中途断开。

2. `IEnumerator` 接口

2.1 `IEnumerator` 简介

C# 有多个内置接口， IEnumerator 是其中之一。它用于遍历数组，是一个具有一个属性和两个方法的接口，属性为 Current ，方法为 Reset 和 MoveNext 。

2.2 基本示例

以下是一个简单的 IEnumerator 使用示例：

// 获取整数数组
int[] intArray = { 1, 2, 3 };
// 获取枚举器
IEnumerator intEnumerator = intArray.GetEnumerator();
// 遍历数组
while (intEnumerator.MoveNext())
{
    int currentValue = (int)intEnumerator.Current;
    Debug.Log(currentValue);
}

在这个示例中，我们首先获取一个整数数组，然后使用 GetEnumerator() 方法获取枚举器，通过 MoveNext() 方法移动到下一个元素，并使用 Current 属性获取当前元素的值。

2.3 枚举器使用注意事项

IEnumerator 是一个对象，使用时可能需要进行类型转换。
在使用 foreach 语句时， IEnumerator 类型不会直接提供对其内容的访问，需要使用 MoveNext() 方法使 Current 属性有值。

2.4 实现 `IEnumerator`

要为一个类实现枚举器，需要添加两个新类：一个继承自 IEnumerator 的枚举器类和一个继承自 IEnumerable 的接口类。

以下是一个以 AZombie 类为例的实现：

// AZombie 类
public class AZombie
{
    public string Name { get; set; }
    public AZombie(string name)
    {
        Name = name;
    }
}

// ZombieEnumerator 类
public class ZombieEnumerator : IEnumerator
{
    private AZombie[] zombies;
    private int position = -1;

    public ZombieEnumerator(AZombie[] zombies)
    {
        this.zombies = zombies;
    }

    public object Current
    {
        get
        {
            if (position < 0 || position >= zombies.Length)
            {
                throw new InvalidOperationException();
            }
            return zombies[position];
        }
    }

    public bool MoveNext()
    {
        position++;
        return position < zombies.Length;
    }

    public void Reset()
    {
        position = -1;
    }
}

// Zombies 类
public class Zombies : IEnumerable
{
    private AZombie[] zombies;

    public Zombies(AZombie[] zombies)
    {
        this.zombies = zombies;
    }

    public IEnumerator GetEnumerator()
    {
        return new ZombieEnumerator(zombies);
    }
}

使用示例：

AZombie[] zombieArray = { new AZombie("Zombie1"), new AZombie("Zombie2") };
Zombies zombies = new Zombies(zombieArray);
IEnumerator zombieEnumerator = zombies.GetEnumerator();
while (zombieEnumerator.MoveNext())
{
    AZombie currentZombie = (AZombie)zombieEnumerator.Current;
    Debug.Log(currentZombie.Name);
}

2.5 枚举器总结

实现 IEnumerator 和 IEnumerable 接口可以为类添加遍历功能。在决定是否实现这些功能时，需要考虑项目的复杂性和需求。

3. 泛型

3.1 泛型的引入

在创建新的数据结构时，为适应多个任务对结构进行小修改会带来问题。随着项目复杂度增加，数据也会变得更复杂。C# 2.0 引入泛型使数据流动更轻松。

3.2 泛型函数

泛型允许函数遵循 C# 的类型安全特性，同时在一定程度上忽略类型差异。例如，在游戏开发中处理各种怪物和物品时，使用泛型可以更方便地组织数据。

3.3 基本示例

以下是一个简单的泛型函数示例：

public void log<T>(T thing)
{
    Debug.Log(thing.ToString());
}

在这个示例中， <T> 表示泛型类型， T 是类型占位符。这个函数可以接受任何具有 ToString() 方法的对象，如 int 、 GameObject 或 Vector3 。

3.4 泛型总结

泛型为数据处理提供了更大的灵活性，避免了创建过多新数据类型导致的数据不匹配问题。通过使用泛型，可以使代码更具通用性和可维护性。

总结

本文介绍了 C# 编程中的异常处理、 IEnumerator 接口和泛型的相关知识。异常处理通过 try-catch-finally 结构确保程序在出现错误时能优雅处理； IEnumerator 接口用于遍历数组，为类添加遍历功能；泛型则提高了数据处理的灵活性和代码的可维护性。在实际编程中，合理运用这些特性可以提高程序的健壮性和开发效率。

下面是一个简单的流程图，展示 try-catch-finally 的执行流程：

graph TD;
    A[开始] --> B[try 块];
    B --> C{是否抛出异常};
    C -- 是 --> D[catch 块];
    C -- 否 --> E[继续执行 try 块后续代码];
    D --> F[finally 块];
    E --> F;
    F --> G[结束];

同时，为了更清晰地对比不同部分的特点，我们可以列出以下表格：
| 特性 | 作用 | 示例 |
| ---- | ---- | ---- |
| 异常处理 | 处理程序运行中的错误 | try-catch-finally 结构 |
| IEnumerator 接口 | 遍历数组 | GetEnumerator() 、 MoveNext() 、 Current |
| 泛型 | 提高数据处理灵活性 | log<T>(T thing) |

4. 综合应用与深入探讨

4.1 异常处理与泛型的结合

在实际编程中，异常处理和泛型可以结合使用，以提高代码的健壮性和灵活性。例如，在一个泛型函数中处理可能出现的异常：

public void ProcessData<T>(T data)
{
    try
    {
        // 处理数据的逻辑
        // 这里可以根据 T 的类型进行不同的操作
        if (data is int)
        {
            int intData = (int)data;
            // 处理整数数据
        }
        else if (data is string)
        {
            string stringData = (string)data;
            // 处理字符串数据
        }
    }
    catch (Exception e)
    {
        Debug.LogError("处理数据时出现异常: " + e.Message);
    }
}

在这个示例中， ProcessData<T> 是一个泛型函数，它可以接受不同类型的数据。在 try 块中，根据数据的类型进行不同的处理，若出现异常则在 catch 块中进行捕获和处理。

4.2 `IEnumerator` 与泛型的结合

IEnumerator 也可以与泛型结合，实现更灵活的遍历功能。例如，创建一个泛型枚举器类：

// 泛型枚举器类
public class GenericEnumerator<T> : IEnumerator<T>
{
    private T[] array;
    private int position = -1;

    public GenericEnumerator(T[] array)
    {
        this.array = array;
    }

    public T Current
    {
        get
        {
            if (position < 0 || position >= array.Length)
            {
                throw new InvalidOperationException();
            }
            return array[position];
        }
    }

    object IEnumerator.Current
    {
        get { return Current; }
    }

    public bool MoveNext()
    {
        position++;
        return position < array.Length;
    }

    public void Reset()
    {
        position = -1;
    }

    public void Dispose()
    {
        // 释放资源的逻辑
    }
}

// 泛型可枚举类
public class GenericEnumerable<T> : IEnumerable<T>
{
    private T[] array;

    public GenericEnumerable(T[] array)
    {
        this.array = array;
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new GenericEnumerator<T>(array);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

使用示例：

int[] intArray = { 1, 2, 3 };
GenericEnumerable<int> genericEnumerable = new GenericEnumerable<int>(intArray);
IEnumerator<int> genericEnumerator = genericEnumerable.GetEnumerator();
while (genericEnumerator.MoveNext())
{
    int currentValue = genericEnumerator.Current;
    Debug.Log(currentValue);
}

在这个示例中， GenericEnumerator<T> 是一个泛型枚举器类， GenericEnumerable<T> 是一个泛型可枚举类。通过这种方式，可以对不同类型的数组进行遍历。

4.3 实际项目中的应用场景

4.3.1 游戏开发

在游戏开发中，异常处理可以用于处理玩家输入错误、资源加载失败等问题。例如，当加载游戏资源时，如果文件路径错误，会抛出 UnauthorizedAccessException 或 FileNotFoundException ，可以使用 try-catch 结构进行捕获和处理。

IEnumerator 可以用于实现游戏中的动画效果、状态机等。例如，在一个角色动画系统中，可以使用 IEnumerator 来控制角色动画的播放顺序和时间。

泛型则可以用于实现通用的游戏组件和数据结构。例如，创建一个泛型的游戏对象池，用于管理不同类型的游戏对象。

4.3.2 网络编程

在网络编程中，异常处理可以用于处理网络连接失败、数据传输错误等问题。例如，在通过 HTTP 协议获取数据时，如果网络中断或服务器返回错误，会抛出相应的异常，可以使用 try-catch 结构进行捕获和处理。

IEnumerator 可以用于异步网络操作，例如在下载大文件时，使用 IEnumerator 可以实现分块下载，提高下载效率。

泛型可以用于实现通用的网络数据处理类，例如创建一个泛型的网络数据包解析器，用于解析不同类型的网络数据包。

5. 总结与展望

5.1 总结

本文全面介绍了 C# 编程中的异常处理、 IEnumerator 接口和泛型的相关知识。异常处理通过 try-catch-finally 结构确保程序在出现错误时能优雅处理，提高了程序的健壮性； IEnumerator 接口用于遍历数组，为类添加了遍历功能，增强了代码的灵活性；泛型则提高了数据处理的灵活性和代码的可维护性，避免了创建过多新数据类型导致的数据不匹配问题。

以下是一个简单的列表，总结各部分的关键要点：
1. 异常处理 ：
- 使用 try-catch-finally 结构处理异常。
- 可以自定义异常类型。
- 用于处理程序运行中的各种错误。
2. IEnumerator 接口 ：
- 具有 Current 、 Reset 和 MoveNext 方法。
- 可以为类实现枚举器，实现遍历功能。
3. 泛型：
- 使用 <T> 表示泛型类型。
- 提高数据处理的灵活性和代码的可维护性。

5.2 展望

在未来的编程中，随着项目的复杂度不断增加，异常处理、 IEnumerator 接口和泛型的应用将更加广泛。例如，在人工智能、大数据等领域，需要处理大量的数据和复杂的算法，这些特性可以帮助开发者更高效地编写代码。

同时，随着 C# 语言的不断发展，可能会出现更多与异常处理、 IEnumerator 接口和泛型相关的新特性和优化。开发者需要不断学习和掌握这些新特性，以提高自己的编程水平和开发效率。

为了更直观地展示异常处理、 IEnumerator 接口和泛型之间的关系，我们可以绘制以下 mermaid 流程图：

graph LR;
    A[异常处理] --> B[程序健壮性];
    C[IEnumerator 接口] --> D[遍历数组];
    E[泛型] --> F[数据处理灵活性];
    B --> G[高效开发];
    D --> G;
    F --> G;

此外，为了更清晰地对比不同特性的优势，我们可以列出以下表格：
| 特性 | 优势 |
| ---- | ---- |
| 异常处理 | 确保程序在出现错误时能优雅处理，提高程序的健壮性 |
| IEnumerator 接口 | 实现数组的遍历，为类添加遍历功能，增强代码的灵活性 |
| 泛型 | 提高数据处理的灵活性，避免数据不匹配问题，提高代码的可维护性 |

通过合理运用异常处理、 IEnumerator 接口和泛型这些特性，开发者可以编写出更健壮、更灵活、更高效的 C# 程序。在实际编程中，需要根据具体的需求和场景，选择合适的特性进行应用。