组件模式代码实践（C#版本）

此测试代码包含3个基本类：

class EntityBase：实体基类

class ComponentBase：组件基类

class Event：消息类

组合模式的关键在于：（1）实体通过组件实现功能，组件依赖于实体而存在；（2）通过事件驱动组件的各种行为。

EntityBase代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
class EntityBase
{
// 组件列表，未实现RTTI，故用string做索引
// 如果有RTTI，可以直接存储List<ComponentBase>，并且大多是这么做的
Dictionary<string, ComponentBase> ComponentArray = new Dictionary<string, ComponentBase>();

// 通过此函数将消息分发给各个Component，各个Component各自处理此消息
// 通过DisptachEvetn，每个Compoent都会收到此消息，但是否处理此消息，由各组件自己决定
public virtual bool DispatchEvent(Event evt)
{
bool bHandled = false;
foreach (ComponentBase comp in ComponentArray.Values)
{
bool ret = comp.OnEvent(evt);
bHandled = (bHandled || ret);
}
if (bHandled == false)
Console.WriteLine("Receive an unhandled event: id = " + evt.EventID.ToString());

return bHandled;
}

public bool AddComponent(string compName, ComponentBase compObject)
{
if (compObject == null)
{
Console.Write("AddComponent Failed, Component.Name=" + compName);
return false;
}

ComponentArray.Add(compName, compObject);
compObject.OnAttachToEntity(this);
OnComponentAttached(compObject);

return true;
}

public bool RemoveComponent(string compName)
{
if (!ComponentArray.ContainsKey(compName))
{
Console.Write("RemoveComponent Failed, Component.Name=" + compName);
return false;
}

ComponentArray[compName].OnDetachFromEntity(this);
OnComponentDetached(ComponentArray[compName]);
ComponentArray.Remove(compName);
return true;
}

public virtual void OnComponentAttached(ComponentBase compObject)
{
}

public virtual void OnComponentDetached(ComponentBase compObject)
{
}

}
}

ComponentBase代码：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
class ComponentBase
{
protected delegate void EventHandleFunction(Event evt);

private EntityBase Owner = null;
// 事件映射表
private Dictionary<int, EventHandleFunction> EventHandlerMap = new Dictionary<int, EventHandleFunction>();

public virtual bool OnEvent(Event evt)
{
EventHandleFunction function = null;
if(EventHandlerMap.TryGetValue(evt.EventID, out function) == false)
{
return false;
}

if (function == null)
return false;

function(evt);
return true;
}

public virtual void OnAttachToEntity(EntityBase ety)
{
Owner = ety;
}

public virtual void OnDetachFromEntity(EntityBase ety)
{
Owner = null;
}

// 注册事件处理函数，同一事件注册两次，则后面的覆盖前面的
protected void RegisterEvent(int eventID, EventHandleFunction handlerFunc)
{
if (EventHandlerMap.ContainsKey(eventID))
EventHandlerMap.Remove(eventID);
EventHandlerMap.Add(eventID, handlerFunc);
}

protected void UnregiterEvent(int eventID)
{
if (EventHandlerMap.ContainsKey(eventID))
EventHandlerMap.Remove(eventID);
}
}
}

Event代码：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
class Event
{
public int EventID = -1;
public ArrayList EventArgs = new ArrayList();

public void PushUserData<T>(T data)
{
EventArgs.Add(data);
}

public T GetUserData<T>(int index)
{
if (index >= EventArgs.Count)
{
Console.Write("GetUserData Error!");
return default(T);
}
return (T)EventArgs[index];
}
}
}

测试代码包括Main.cs、一个继承自ComponentBase的组件TestComponent和一个事件定义的类EventDefines。

EventDefines代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
public enum EventDefines
{
Event_01 = 0,
Event_02,
Event_03,
}
}

TestComponent代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
class TestComponent : ComponentBase
{
public override void OnAttachToEntity(EntityBase ety)
{
base.OnAttachToEntity(ety);

// 注册事件响应函数
RegisterEvent((int)EventDefines.Event_01, DealEvent01);
RegisterEvent((int)EventDefines.Event_03, DealEvent03);
}

public override void OnDetachFromEntity(EntityBase ety)
{
base.OnDetachFromEntity(ety);
}

private void DealEvent01(Event evt)
{
string evtData = evt.GetUserData<string>(0);
Console.WriteLine("TestComponent Handle Event: ID = " + evt.EventID.ToString());
Console.WriteLine("TestComponent Handle Event: Data = " + evtData);
}

private void DealEvent03(Event evt)
{
float evtData = evt.GetUserData<float>(0);
Console.WriteLine("TestComponent Handle Event: ID = " + evt.EventID.ToString());
Console.WriteLine("TestComponent Handle Event: Data = " + evtData);
}
}
}

Main.cs代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TestComponentModel
{
class Program
{
static void Main(string[] args)
{
// 构造一个EntityBase对象
EntityBase ety = new EntityBase();
// 添加TestComponent组件，可以移到EntityBase的继承类的构造函数中
TestComponent testComp = new TestComponent();
ety.AddComponent("TestComponent", testComp);

// 发送消息Event_01
Event evt1 = new Event();
evt1.EventID = (int)EventDefines.Event_01;
evt1.PushUserData<string>("SomeData For Event01");
ety.DispatchEvent(evt1);

// 发送消息Event_02
Event evt2 = new Event();
evt2.EventID = (int)EventDefines.Event_02;
evt2.PushUserData<string>("SomeData For Event02");
ety.DispatchEvent(evt2);

// 发送消息Event_03
Event evt3 = new Event();
evt3.EventID = (int)EventDefines.Event_03;
evt3.PushUserData<float>(0.123f);
ety.DispatchEvent(evt3);

Console.Read();
}
}
}

运行结果截图：



组合模式是实用性很强的一种设计模式，目前在各种游戏代码中广泛存在，熟练运用此模式可以使代码简洁高效、可读易修改并且查错方便。

本例子所提供的代码只是测试代码，若想应用于项目，需根据实际情况进行一些修改。不过，改来改去，思想始终不变。

PS:所谓模式，即代码的组织方式，模式源于实践和总结。同时，模式也是一种思想，是人们对于程序对象的一种认识和剖析...