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 LR
subgraph "队列 (Queue)"
direction LR
A[元素1] --> B[元素2] --> C[元素3]
end
New[新元素] -- 入队 (Enqueue) --> C
A -- 出队 (Dequeue) --> Output[处理/移除]
style A fill:#f9f,stroke:#333,stroke-width:2px
style 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 TD
subgraph "栈 (Stack)"
direction TB
C[元素3 (栈顶)] --> B[元素2] --> A[元素1 (栈底)]
end
New[新元素] -- 入栈 (Push) --> C
C -- 出栈 (Pop) --> Output[处理/移除]
style C fill:#f9f,stroke:#333,stroke-width:2px
style 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）。它们的核心特性和应用场景可以总结如下：
-
队列 (Queue):
- 原理: 先进先出 (FIFO)。
- C# 实现:
System.Collections.Generic.Queue<T>。 - 核心操作:
Enqueue(入队),Dequeue(出队),Peek(查看队头),Count。 - 应用: 任务调度、广度优先搜索、消息缓冲、游戏中的指令/事件/AI行为序列。
-
栈 (Stack):
- 原理: 后进先出 (LIFO)。
- C# 实现:
System.Collections.Generic.Stack<T>。 - 核心操作:
Push(入栈),Pop(出栈),Peek(查看栈顶),Count。 - 应用: 函数调用栈、表达式求值、括号匹配、深度优先搜索、撤销/重做功能、游戏状态管理。
-
游戏开发实践: 我们通过一个任务队列管理器的实例，展示了如何利用队列（
Queue<IGameTask>）来管理和执行游戏中的有序任务，使代码结构更清晰、更易于维护。 -
注意事项: 操作空集合可能导致异常（需检查
Count），标准集合非线程安全（多线程用ConcurrentQueue/ConcurrentStack），核心操作性能高效（通常为 O(1)）。
掌握队列和栈不仅能帮助你写出更优雅、高效的代码，更能让你在解决特定问题时拥有更合适的工具。希望通过今天的学习，你对这两种数据结构有了更深刻的理解！明天，我们将学习 C# 中的枚举（Enum），看看如何用它来定义游戏中的有限状态。
如果你在学习过程中遇到任何问题，或者有更有趣的应用场景分享，欢迎在评论区留言讨论！