C#游戏开发【第18天】 | 深入理解队列(Queue)与栈(Stack)：从基础到任务队列实战

Langchain系列文章目录

01-玩转LangChain：从模型调用到Prompt模板与输出解析的完整指南
02-玩转 LangChain Memory 模块：四种记忆类型详解及应用场景全覆盖
03-全面掌握 LangChain：从核心链条构建到动态任务分配的实战指南
04-玩转 LangChain：从文档加载到高效问答系统构建的全程实战
05-玩转 LangChain：深度评估问答系统的三种高效方法（示例生成、手动评估与LLM辅助评估）
06-从 0 到 1 掌握 LangChain Agents：自定义工具 + LLM 打造智能工作流！
07-【深度解析】从GPT-1到GPT-4：ChatGPT背后的核心原理全揭秘

PyTorch系列文章目录

Python系列文章目录

C#系列文章目录

01-C#与游戏开发的初次见面：从零开始的Unity之旅
02-C#入门：从变量与数据类型开始你的游戏开发之旅
03-C#运算符与表达式：从入门到游戏伤害计算实践
04-从零开始学C#：用if-else和switch打造智能游戏逻辑
05-掌握C#循环：for、while、break与continue详解及游戏案例
06-玩转C#函数：参数、返回值与游戏中的攻击逻辑封装
07-Unity游戏开发入门：用C#控制游戏对象移动
08-C#面向对象编程基础：类的定义、属性与字段详解
09-C#封装与访问修饰符：保护数据安全的利器
10-如何用C#继承提升游戏开发效率？Enemy与Boss案例解析
11-C#多态性入门：从零到游戏开发实战
12-C#接口王者之路：从入门到Unity游戏开发实战 (IAttackable案例详解)
13-C#静态成员揭秘：共享数据与方法的利器
14-Unity 面向对象实战：掌握组件化设计与脚本通信，构建玩家敌人交互
15-C#入门 Day15：彻底搞懂数组！从基础到游戏子弹管理实战
16-C# List 从入门到实战：掌握动态数组，轻松管理游戏敌人列表 (含代码示例)
17-C# 字典 (Dictionary) 完全指南：从入门到游戏属性表实战 (Day 17)
18-C#游戏开发【第18天】 | 深入理解队列(Queue)与栈(Stack)：从基础到任务队列实战

---

---

前言

欢迎来到《C#游戏开发从入门到精通：50天全面掌握》专栏的第18天！在前几天的学习中，我们已经接触了数组(Array)、动态列表(List<T>)以及键值对集合(Dictionary<TKey, TValue>)等常用的数据结构。今天，我们将深入探讨两种非常重要且具有鲜明特色的数据结构——队列(Queue) 和 栈(Stack)。它们虽然不像List那样“万能”，但在特定场景下却能发挥出巨大的作用，尤其是在游戏开发中，例如管理任务序列、实现撤销/重做功能、处理状态变化等。本篇文章将带你从基本概念出发，彻底理解队列和栈的工作原理、C#中的实现方式、核心操作，并通过一个游戏任务队列的实例，让你掌握它们在实际项目中的应用。

一、队列（Queue）：先进先出的数据排队策略

1.1 什么是队列？

1.1.1 定义与特性

队列（Queue）是一种遵循 先进先出（First-In, First-Out, FIFO） 原则的线性数据结构。你可以把它想象成现实生活中的排队：第一个来排队的人，第一个接受服务。在队列中，新元素总是被添加到队列的尾部（Rear/Tail），而元素的移除（或访问）则总是从队列的**头部（Front/Head）**进行。

核心特性总结:

• 先进先出 (FIFO): 最早进入队列的元素将最先被移出。
• 线性结构: 数据元素之间存在一对一的逻辑关系。
• 操作受限: 只能在队列的两端进行操作（尾部添加，头部移除）。

1.1.2 生活中的类比

• 排队买票: 先到售票窗口排队的人先买到票。
• 打印任务: 先提交的打印请求先被打印机处理。
• 客服电话: 先打入电话的客户先被接听。

1.1.3 FIFO 原理图示

我们可以用一个简单的图来表示队列的工作方式：

graph LRsubgraph "队列 (Queue)"direction LRA[元素1] --> B[元素2] --> C[元素3]endNew[新元素] -- 入队 (Enqueue) --> CA -- 出队 (Dequeue) --> Output[处理/移除]style A fill:#f9f,stroke:#333,stroke-width:2pxstyle New fill:#ccf,stroke:#333,stroke-width:2px

• 入队 (Enqueue): 新元素总是从队尾加入。
• 出队 (Dequeue): 元素总是从队头移除。最先进入的元素1最先被移除。

1.2 C# 中的 Queue<T>

在 C# 中，.NET 库提供了泛型类 System.Collections.Generic.Queue<T> 来实现队列。泛型 <T> 意味着你可以创建一个存储任何特定类型元素的队列，例如 Queue<int>、Queue<string> 或 Queue<PlayerTask>。

1.2.1 如何创建队列

创建队列非常简单，使用 new 关键字即可：

using System.Collections.Generic; // 引入命名空间// 创建一个存储整数的队列
Queue<int> numberQueue = new Queue<int>();// 创建一个存储字符串的队列
Queue<string> messageQueue = new Queue<string>();// 创建一个存储自定义任务对象的队列（假设已定义 PlayerTask 类）
// Queue<PlayerTask> taskQueue = new Queue<PlayerTask>();

1.2.2 核心操作

Queue<T> 提供了几个关键方法来操作队列：

（1） 入队：Enqueue(T item)

将一个元素添加到队列的尾部。

Queue<string> taskQueue = new Queue<string>();// 向队列中添加任务
taskQueue.Enqueue("加载地图"); // "加载地图" 在队头
taskQueue.Enqueue("生成玩家"); // "生成玩家" 在队尾
taskQueue.Enqueue("播放背景音乐"); // "播放背景音乐" 在新的队尾// 此刻队列内容 (从头到尾): ["加载地图", "生成玩家", "播放背景音乐"]
Console.WriteLine($"当前队列任务数: {taskQueue.Count}"); // 输出：当前队列任务数: 3

（2） 出队：Dequeue()

移除并返回队列头部的元素。如果队列为空，调用 Dequeue() 会抛出 InvalidOperationException 异常。

// 假设 taskQueue 内容为: ["加载地图", "生成玩家", "播放背景音乐"]if (taskQueue.Count > 0) // 检查队列是否为空是好习惯
{string nextTask = taskQueue.Dequeue(); // 移除并获取 "加载地图"Console.WriteLine($"处理任务: {nextTask}"); // 输出：处理任务: 加载地图Console.WriteLine($"剩余任务数: {taskQueue.Count}"); // 输出：剩余任务数: 2// 此刻队列内容: ["生成玩家", "播放背景音乐"]
}
else
{Console.WriteLine("任务队列为空！");
}

（3） 查看队头元素：Peek()

返回队列头部的元素，但不移除它。如果队列为空，调用 Peek() 也会抛出 InvalidOperationException 异常。

// 假设 taskQueue 内容为: ["生成玩家", "播放背景音乐"]if (taskQueue.Count > 0)
{string upcomingTask = taskQueue.Peek(); // 查看队头 "生成玩家"Console.WriteLine($"下一个任务是: {upcomingTask}"); // 输出：下一个任务是: 生成玩家Console.WriteLine($"队列任务数仍为: {taskQueue.Count}"); // 输出：队列任务数仍为: 2 (元素未被移除)
}

（4） 获取元素数量：Count

这是一个属性，返回队列中当前包含的元素数量。

// 假设 taskQueue 内容为: ["生成玩家", "播放背景音乐"]
int taskCount = taskQueue.Count;
Console.WriteLine($"队列中有 {taskCount} 个任务。"); // 输出：队列中有 2 个任务。

1.2.3 其他常用方法/属性

• Clear(): 移除队列中的所有元素。
• Contains(T item): 判断队列中是否包含指定的元素。
• ToArray(): 将队列中的元素复制到一个新数组中（保持队列顺序）。

1.3 队列的应用场景

队列的 FIFO 特性使其在以下场景中非常有用：

• 任务调度: 按顺序处理一系列任务，如游戏中的指令队列、打印任务队列。
• 广度优先搜索 (BFS): 在图或树的遍历中，用于存储待访问的节点。
• 消息队列 (MQ): 在分布式系统中解耦服务，缓冲消息。
• 缓冲区: 例如网络数据包的接收与处理，先进来的数据包先被处理。
• 游戏开发:
  • 玩家指令处理: 按玩家输入顺序执行动作。
  • AI 决策序列: AI 按照计划顺序执行一系列行为。
  • 事件处理: 按事件发生顺序处理游戏事件。
  • 资源加载: 按需顺序加载资源。

二、栈（Stack）：后进先出的数据叠放策略

2.1 什么是栈？

2.1.1 定义与特性

栈（Stack）是另一种重要的线性数据结构，它遵循 后进先出（Last-In, First-Out, LIFO） 原则。你可以把它想象成一摞盘子：最后放上去的盘子，最先被取走。在栈中，元素的添加（称为 压栈 或 入栈 Push）和移除（称为 弹栈 或 出栈 Pop）都只能在栈的同一端进行，这一端被称为 栈顶（Top）。

核心特性总结:

• 后进先出 (LIFO): 最后进入栈的元素将最先被移出。
• 线性结构: 数据元素之间存在一对一的逻辑关系。
• 操作受限: 只能在栈顶进行添加和移除操作。

2.1.2 生活中的类比

• 一摞盘子: 你总是从最上面取盘子，也把新洗好的盘子放在最上面。
• 浏览器历史记录: “后退”按钮总是带你回到上一个访问的页面（最后访问的页面先被“移除”）。
• 函数调用栈: 程序在调用函数时，会将当前函数的状态（返回地址、局部变量等）压入调用栈，函数返回时再从栈顶弹出。

2.1.3 LIFO 原理图示

graph TDsubgraph "栈 (Stack)"direction TBC[元素3 (栈顶)] --> B[元素2] --> A[元素1 (栈底)]endNew[新元素] -- 入栈 (Push) --> CC -- 出栈 (Pop) --> Output[处理/移除]style C fill:#f9f,stroke:#333,stroke-width:2pxstyle New fill:#ccf,stroke:#333,stroke-width:2px

• 入栈 (Push): 新元素总是被添加到栈顶。
• 出栈 (Pop): 元素总是从栈顶移除。最后入栈的 元素3 最先被移除。

2.2 C# 中的 Stack<T>

与队列类似，C# 提供了泛型类 System.Collections.Generic.Stack<T> 来实现栈。

2.2.1 如何创建栈

创建栈同样使用 new 关键字：

using System.Collections.Generic; // 引入命名空间// 创建一个存储整数的栈
Stack<int> numberStack = new Stack<int>();// 创建一个存储字符串的栈
Stack<string> historyStack = new Stack<string>();// 创建一个存储游戏状态对象的栈（假设已定义 GameState 类）
// Stack<GameState> stateStack = new Stack<GameState>();

2.2.2 核心操作

Stack<T> 提供的主要操作方法如下：

（1） 入栈：Push(T item)

将一个元素添加到栈的顶部。

Stack<string> browserHistory = new Stack<string>();// 模拟浏览页面
browserHistory.Push("首页"); // "首页" 在栈底
browserHistory.Push("产品页");
browserHistory.Push("详情页"); // "详情页" 在栈顶// 此刻栈内容 (从顶到底): ["详情页", "产品页", "首页"]
Console.WriteLine($"当前历史记录数: {browserHistory.Count}"); // 输出：当前历史记录数: 3

（2） 出栈：Pop()

移除并返回栈顶部的元素。如果栈为空，调用 Pop() 会抛出 InvalidOperationException 异常。

// 假设 browserHistory 内容为: ["详情页", "产品页", "首页"]if (browserHistory.Count > 0) // 检查栈是否为空
{string lastVisited = browserHistory.Pop(); // 移除并获取 "详情页"Console.WriteLine($"按后退键，回到: {lastVisited}"); // 输出：按后退键，回到: 详情页 (实际应回到"产品页"，Pop返回的是刚离开的页面)Console.WriteLine($"剩余历史记录数: {browserHistory.Count}"); // 输出：剩余历史记录数: 2// 此刻栈内容: ["产品页", "首页"]
}
else
{Console.WriteLine("没有更多历史记录了！");
}

注意： 在浏览器后退的场景中，Pop() 返回的是你 刚刚离开 的页面。栈顶现在是你 将要回到 的页面。

（3） 查看栈顶元素：Peek()

返回栈顶部的元素，但不移除它。如果栈为空，调用 Peek() 也会抛出 InvalidOperationException 异常。

// 假设 browserHistory 内容为: ["产品页", "首页"]if (browserHistory.Count > 0)
{string currentPage = browserHistory.Peek(); // 查看栈顶 "产品页"Console.WriteLine($"当前页面是: {currentPage}"); // 输出：当前页面是: 产品页Console.WriteLine($"栈中记录数仍为: {browserHistory.Count}"); // 输出：栈中记录数仍为: 2 (元素未被移除)
}

（4） 获取元素数量：Count

同样是一个属性，返回栈中当前包含的元素数量。

// 假设 browserHistory 内容为: ["产品页", "首页"]
int historyCount = browserHistory.Count;
Console.WriteLine($"栈中有 {historyCount} 条记录。"); // 输出：栈中有 2 条记录。

2.2.3 其他常用方法/属性

• Clear(): 移除栈中的所有元素。
• Contains(T item): 判断栈中是否包含指定的元素。
• ToArray(): 将栈中的元素复制到一个新数组中（注意：数组中的顺序通常是 LIFO，即栈顶元素在数组前面）。

2.3 栈的应用场景

栈的 LIFO 特性使其在以下场景中非常有用：

• 函数调用: 管理函数调用的上下文（调用栈）。
• 表达式求值: 如中缀表达式转后缀表达式（逆波兰表示法）并进行计算。
• 括号匹配: 检查代码或文本中的括号是否正确配对。
• 深度优先搜索 (DFS): 在图或树的遍历中，用于存储待访问的节点。
• 撤销/重做 (Undo/Redo):
  • 撤销: 将操作存入一个“撤销栈”，撤销时从栈顶取出操作并执行其逆操作，同时可能将该操作存入“重做栈”。
  • 重做: 从“重做栈”取出操作执行，并可能放回“撤销栈”。
• 游戏开发:
  • 撤销玩家操作: 如棋类游戏、编辑器中的操作。
  • 状态管理: 管理游戏状态的切换（例如暂停菜单覆盖游戏界面，返回时恢复）。
  • 路径查找回溯: 在某些寻路算法中记录路径。

三、游戏开发中的应用：任务队列

现在，让我们结合游戏开发的场景，看看如何使用队列来实现一个简单的任务队列系统。这在需要按顺序执行一系列复杂操作（如过场动画、新手引导步骤、AI 行为序列）时非常有用。

3.1 为什么需要任务队列？

在游戏中，经常有需要按特定顺序执行的动作或事件链。例如：

• 新手引导: 显示提示 -> 等待玩家点击 -> 移动镜头 -> 显示下一个提示…
• 剧情事件: 角色A说话 -> 角色B回应 -> 播放动画 -> 触发音效…
• AI 行为: 移动到位置X -> 扫描敌人 -> 如果发现敌人则攻击 -> 否则继续巡逻…

如果直接用一长串的 if-else 或者嵌套调用来写，代码会变得非常复杂且难以维护。任务队列提供了一种更清晰、更模块化的方式来管理这些序列。

3.2 使用队列实现任务队列

3.2.1 定义任务接口/基类

首先，我们需要定义一个通用的“任务”表示。使用接口或抽象类是个好方法。

// 定义一个任务接口
public interface IGameTask
{// 执行任务的方法// 返回 true 表示任务完成，可以执行下一个任务// 返回 false 表示任务正在进行中，下一帧需要继续执行bool Execute();// (可选) 任务开始时调用的方法void Start();// (可选) 任务结束时调用的方法void End();
}// 示例：一个简单的移动任务
public class MoveToTask : IGameTask
{private UnityEngine.Transform _target; // 移动的目标对象private UnityEngine.Vector3 _destination;private float _speed;private bool _isStarted = false;public MoveToTask(UnityEngine.Transform target, UnityEngine.Vector3 destination, float speed){_target = target;_destination = destination;_speed = speed;}public void Start(){Console.WriteLine($"开始移动任务: 将 {_target.name} 移动到 {_destination}");_isStarted = true;}public bool Execute(){if (!_isStarted) Start(); // 确保Start被调用// 简单的移动逻辑 (实际项目中会更复杂)float step = _speed * UnityEngine.Time.deltaTime;_target.position = UnityEngine.Vector3.MoveTowards(_target.position, _destination, step);// 判断是否到达目的地 (允许一点误差)if (UnityEngine.Vector3.Distance(_target.position, _destination) < 0.1f){End(); // 调用结束方法return true; // 任务完成}return false; // 任务未完成}public void End(){Console.WriteLine($"移动任务完成: {_target.name} 已到达 {_destination}");}
}// 示例：一个简单的等待任务
public class WaitTask : IGameTask
{private float _duration;private float _startTime;private bool _isStarted = false;public WaitTask(float duration){_duration = duration;}public void Start(){Console.WriteLine($"开始等待任务: 等待 {_duration} 秒");_startTime = UnityEngine.Time.time;_isStarted = true;}public bool Execute(){if (!_isStarted) Start();if (UnityEngine.Time.time >= _startTime + _duration){End();return true; // 等待时间到，任务完成}return false; // 还在等待}public void End(){Console.WriteLine($"等待任务完成");}
}

注意: 上述代码使用了 UnityEngine 命名空间下的类，如 Transform, Vector3, Time。你需要在一个 Unity 项目环境中才能完整运行。核心思想是定义具有 Execute 方法的任务。

3.2.2 任务队列管理器

接下来，创建一个管理任务队列的类。

using System.Collections.Generic;
using UnityEngine; // 假设在 Unity 环境中public class TaskQueueManager : MonoBehaviour
{private Queue<IGameTask> _taskQueue = new Queue<IGameTask>();private IGameTask _currentTask = null; // 当前正在执行的任务// Update 方法会在每一帧被 Unity 调用void Update(){ProcessNextTask();}// 添加新任务到队列尾部public void AddTask(IGameTask newTask){_taskQueue.Enqueue(newTask);Debug.Log($"新任务已添加，当前队列长度: {_taskQueue.Count}");}// 处理队列中的任务private void ProcessNextTask(){// 如果当前没有任务在执行，并且队列中有任务if (_currentTask == null && _taskQueue.Count > 0){// 从队列头部取出一个任务_currentTask = _taskQueue.Dequeue();// _currentTask.Start(); // Start 调用移到 Execute 内部确保执行Debug.Log($"开始处理下一个任务，剩余队列长度: {_taskQueue.Count}");}// 如果当前有任务在执行if (_currentTask != null){// 执行任务，如果返回 true，表示任务完成if (_currentTask.Execute()){// _currentTask.End(); // End 调用移到 Execute 内部确保执行_currentTask = null; // 标记当前任务为空，以便处理下一个Debug.Log("当前任务完成！");}// 如果返回 false，表示任务还在进行中，下一帧继续 Execute}}// (可选) 提供清空队列的方法public void ClearTasks(){_currentTask = null;_taskQueue.Clear();Debug.Log("任务队列已清空");}
}

3.2.3 示例：玩家指令队列

假设我们有一个 TaskQueueManager 组件挂载在场景中的某个 GameObject 上。我们可以这样添加和执行任务：

// 在另一个脚本中，获取 TaskQueueManager 实例
TaskQueueManager taskManager = FindObjectOfType<TaskQueueManager>(); // 或者通过其他方式获取引用// 获取需要移动的玩家对象
Transform playerTransform = GameObject.Find("Player").transform; // 假设玩家对象名为 "Player"// 创建一系列任务
IGameTask task1 = new MoveToTask(playerTransform, new Vector3(5, 0, 0), 2.0f);
IGameTask task2 = new WaitTask(1.5f); // 等待1.5秒
IGameTask task3 = new MoveToTask(playerTransform, Vector3.zero, 3.0f); // 移回原点// 将任务按顺序添加到队列
taskManager.AddTask(task1);
taskManager.AddTask(task2);
taskManager.AddTask(task3);// 之后，TaskQueueManager 的 Update 方法会自动按顺序执行这些任务

这样，玩家对象就会先移动到 (5, 0, 0)，然后原地等待1.5秒，最后再移动回原点 (0, 0, 0)。代码逻辑清晰，易于扩展和修改。

3.3 栈在游戏中的应用场景（补充）

虽然本节重点是任务队列，但栈在游戏中也有其独特用途：

• 游戏状态管理: 进入暂停菜单时，将当前游戏状态（如PlayingState）压栈，显示暂停菜单（PausedState）。退出暂停菜单时，弹栈恢复到之前的状态。
• 编辑器撤销/重做: 对场景进行的每次修改（移动物体、改变颜色等）可以封装成一个操作对象，放入撤销栈。执行撤销时，Pop 出操作，执行其逆操作，并放入重做栈。
• 复杂的 AI 状态切换: 在某些 AI 设计模式（如分层状态机）中，栈可以用来管理状态的进入和退出顺序。

四、常见问题与注意事项

4.1 队列/栈为空时操作

对空的 Queue<T> 调用 Dequeue() 或 Peek()，或者对空的 Stack<T> 调用 Pop() 或 Peek()，都会抛出 System.InvalidOperationException。因此，在执行这些操作前，务必检查 Count 属性是否大于 0。

// 安全地出队
if (myQueue.Count > 0)
{var item = myQueue.Dequeue();// ... process item
}// 安全地出栈
if (myStack.Count > 0)
{var item = myStack.Pop();// ... process item
}

4.2 线程安全

标准的 Queue<T> 和 Stack<T> 不是线程安全的。如果在多线程环境中使用它们（例如，一个线程添加任务，另一个线程处理任务），可能会导致数据竞争和不可预料的结果。对于多线程场景，应使用 .NET 提供的线程安全集合：

• System.Collections.Concurrent.ConcurrentQueue<T>
• System.Collections.Concurrent.ConcurrentStack<T>

这些并发集合提供了原子性的操作，可以在多线程环境下安全使用。

4.3 性能考量

对于 Queue<T> 和 Stack<T>：

• Enqueue, Dequeue, Peek (对于 Queue)
• Push, Pop, Peek (对于 Stack)
• Count

这些基本操作通常具有 O(1) 的平均时间复杂度，意味着它们的执行时间不随集合中元素的数量增加而显著增加，效率非常高。

Contains 操作的时间复杂度是 O(n)，因为它可能需要遍历整个集合来查找元素。如果需要频繁检查元素是否存在，可能需要考虑其他数据结构（如 HashSet<T> 或 Dictionary<TKey, TValue>）。

五、总结

今天我们深入学习了 C# 中的两种特殊数据结构：队列（Queue）和栈（Stack）。它们的核心特性和应用场景可以总结如下：

1. 队列 (Queue):

   • 原理: 先进先出 (FIFO)。
   • C# 实现: System.Collections.Generic.Queue<T>。
   • 核心操作: Enqueue (入队), Dequeue (出队), Peek (查看队头), Count。
   • 应用: 任务调度、广度优先搜索、消息缓冲、游戏中的指令/事件/AI行为序列。

2. 栈 (Stack):

   • 原理: 后进先出 (LIFO)。
   • C# 实现: System.Collections.Generic.Stack<T>。
   • 核心操作: Push (入栈), Pop (出栈), Peek (查看栈顶), Count。
   • 应用: 函数调用栈、表达式求值、括号匹配、深度优先搜索、撤销/重做功能、游戏状态管理。

3. 游戏开发实践: 我们通过一个任务队列管理器的实例，展示了如何利用队列（Queue<IGameTask>）来管理和执行游戏中的有序任务，使代码结构更清晰、更易于维护。

4. 注意事项: 操作空集合可能导致异常（需检查 Count），标准集合非线程安全（多线程用 ConcurrentQueue/ConcurrentStack），核心操作性能高效（通常为 O(1)）。

掌握队列和栈不仅能帮助你写出更优雅、高效的代码，更能让你在解决特定问题时拥有更合适的工具。希望通过今天的学习，你对这两种数据结构有了更深刻的理解！明天，我们将学习 C# 中的枚举（Enum），看看如何用它来定义游戏中的有限状态。

如果你在学习过程中遇到任何问题，或者有更有趣的应用场景分享，欢迎在评论区留言讨论！

---