游戏客户端架构 / 系统课时
引擎差异应该隔离在哪里
引擎差异应该隔离在哪里
对象池真正难迁移的部分通常不是队列或栈,而是创建对象、激活节点、恢复变换、解绑组件和销毁资源这些引擎操作。把这些差异集中在适配层,池核心与玩法代码才能保持稳定,只替换少量引擎相关实现。
学习目标
- 划分对象池核心、引擎适配层与业务层的职责
- 通过适配接口阻止具体引擎 API 渗透到池核心
- 判断哪些代码应该随引擎迁移,哪些代码应该原样保留
把变化最大的代码压到最外层
一个可迁移的对象池至少可以分成三层:业务层决定什么时候获取或归还对象;池核心管理空闲集合、容量和生命周期顺序;引擎适配层负责真正创建、启用、停用和销毁引擎对象。

这种结构的判断原则很直接:只要某段代码必须引用具体引擎命名空间、对象基类、场景 API 或资源销毁 API,就优先放到适配层。 栈、队列、容量计数、重复归还检查等纯逻辑则留在池核心。
用适配接口包住引擎生命周期
下面的完整 C# 示例把创建和生命周期操作全部放进 IEngineObjectAdapter<T>。示例中的 DemoAdapter 用普通对象模拟引擎适配器,因此可以直接运行;迁移到真实引擎时,只需替换适配器实现。
using System;
using System.Collections.Generic;
public interface IEngineObjectAdapter<T> where T : class
{
T Create();
void PrepareForUse(T instance);
void PrepareForPool(T instance);
void Destroy(T instance);
}
public sealed class ObjectPool<T> where T : class
{
private readonly Stack<T> inactive = new();
private readonly IEngineObjectAdapter<T> adapter;
public ObjectPool(IEngineObjectAdapter<T> adapter)
{
this.adapter = adapter;
}
public T Acquire()
{
T instance = inactive.Count > 0 ? inactive.Pop() : adapter.Create();
adapter.PrepareForUse(instance);
return instance;
}
public void Release(T instance)
{
adapter.PrepareForPool(instance);
inactive.Push(instance);
}
public void Clear()
{
while (inactive.Count > 0)
adapter.Destroy(inactive.Pop());
}
}
public sealed class DemoObject
{
public int Id { get; init; }
public bool Active { get; set; }
}
public sealed class DemoAdapter : IEngineObjectAdapter<DemoObject>
{
private int nextId;
public DemoObject Create()
{
var instance = new DemoObject { Id = ++nextId };
Console.WriteLine($"create #{instance.Id}");
return instance;
}
public void PrepareForUse(DemoObject instance)
{
instance.Active = true;
Console.WriteLine($"activate #{instance.Id}");
}
public void PrepareForPool(DemoObject instance)
{
instance.Active = false;
Console.WriteLine($"deactivate #{instance.Id}");
}
public void Destroy(DemoObject instance)
{
Console.WriteLine($"destroy #{instance.Id}");
}
}
public static class Program
{
public static void Main()
{
var pool = new ObjectPool<DemoObject>(new DemoAdapter());
DemoObject first = pool.Acquire();
pool.Release(first);
DemoObject second = pool.Acquire();
Console.WriteLine($"reused={ReferenceEquals(first, second)}");
pool.Release(second);
pool.Clear();
}
}预期输出:
create #1
activate #1
deactivate #1
activate #1
reused=True
deactivate #1
destroy #1池核心没有出现任何具体引擎类。换到真实项目后,适配器内部可以将 Create 映射为引擎实例化操作,将 PrepareForUse 映射为激活和必要的场景挂接,将 PrepareForPool 映射为停用及引用清理,将 Destroy 映射为引擎规定的销毁流程。
不要让适配层变成第二个业务层
隔离引擎差异并不意味着把所有重置逻辑都塞进适配器。适配器只应该处理与引擎运行时相关的动作,例如激活状态、父节点关系、组件启停、引擎级销毁和资源句柄操作。
角色生命值、子弹伤害、技能冷却、敌人目标引用等属于游戏对象自己的业务状态,应该由对象的重置接口或专门的重置器负责。否则适配器会逐渐知道所有玩法规则,迁移引擎时反而需要重写大量业务逻辑。
用依赖方向检查迁移成本
迁移前可以顺着依赖关系做一次检查:玩法代码只能认识池接口,池核心只能认识抽象适配器,只有适配器能够认识具体引擎。这样从引擎 A 切换到引擎 B 时,需要替换的通常只是创建、激活、停用、销毁等边界代码。
反过来,如果业务层到处直接调用引擎对象的激活和销毁方法,即使已经存在一个名为“对象池”的类,也仍然只是把实例缓存了起来,并没有真正形成可迁移的池化架构。
合理的边界不是追求完全消除引擎代码,而是让它们集中在数量少、职责清晰、可以整体替换的适配器中。池的容量策略、空闲集合、获取归还顺序以及玩法调用方式因此可以跨引擎继续复用。