Unity C# 환경에서 효과적인 메시징 시스템을 설계하는 것은 게임 프레임워크 구축의 핵심 요소입니다. 메시지 구동 방식은 모듈 간의 결합도를 낮추고 유지보수성을 높이는 데 기여하지만, 구현 과정에서 여러 난관에 부딪힐 수 있습니다. 이 글에서는 메시지 파라미터 처리 방식과 메시지 키 선택에 대한 실질적인 개선 방안을 논의합니다.
1. 파라미터 전달 방식의 유연성 확보
메시지 시스템에서 이벤트를 등록(Register)하고 호출(Invoke)할 때, 다양한 수의 파라미터를 처리하는 방식은 중요한 고려 사항입니다. 많은 개발자가 초기에는 다음과 같이 제네릭 오버로딩을 통해 파라미터를 처리하는 방식을 생각할 수 있습니다.
void Register<T1, T2, T3, T4>(...);
void Register<T1, T2, T3>(...);
void Register<T1, T2>(...);
void Register<T1>(...);
void Register();
이러한 방식은 각 파라미터 수에 따라 메서드를 여러 개 작성해야 하므로 코드의 유지보수가 매우 어려워집니다. 반면, params object[]를 사용하는 방법은 파라미터의 유연성을 극대화합니다.
// params object[]를 활용한 등록 메서드 (가상)
void Register(string messageId, params object[] args);
// 사용 예시
void MyMethod()
{
Register("PlayerAttack", 10, "Sword", true);
}
이 방법은 코드 유지보수가 용이하지만, 값 타입(value type)을 object로 전달할 때 발생하는 박싱(boxing) 현상 때문에 성능 저하가 발생할 수 있습니다. 힙 메모리 할당과 가비지 컬렉션(GC) 부하로 이어질 수 있기 때문입니다.
C#의 ValueTuple 또는 Tuple을 활용하는 것은 박싱 문제를 피하면서 유연성을 확보하는 좋은 대안이 될 수 있습니다. ValueTuple은 값 타입으로 처리되어 힙 할당 없이 여러 값을 함께 전달할 수 있습니다. 이 방식은 메시지 핸들러(delegate)가 ValueTuple 타입의 단일 파라미터를 받도록 강제하지만, 성능과 코드 유지보수성 사이의 균형을 제공합니다.
// 메시지 브로커 (간단한 예시)
public class MessageBroker
{
private Dictionary<string, Delegate> _handlers = new Dictionary<string, Delegate>();
// ValueTuple을 사용하여 특정 타입의 페이로드를 받는 델리게이트 등록
public void Register<TMessagePayload>(string messageId, Action<TMessagePayload> handler)
{
_handlers[messageId] = handler;
}
// ValueTuple 타입의 페이로드로 메시지 발행
public void Publish<TMessagePayload>(string messageId, TMessagePayload payload)
{
if (_handlers.TryGetValue(messageId, out Delegate handler))
{
// 등록된 핸들러를 TMessagePayload 타입의 Action으로 캐스팅 후 호출
(handler as Action<TMessagePayload>?)?.Invoke(payload);
}
}
}
// 사용 예시
public class MyComponent
{
private MessageBroker _broker = new MessageBroker();
public MyComponent()
{
// (int, string) 형태의 ValueTuple을 받는 델리게이트 등록
_broker.Register<(int playerId, string status)>("PlayerStatusUpdate", (status) =>
{
Console.WriteLine($"플레이어 ID: {status.playerId}, 상태: {status.status}");
});
}
public void UpdatePlayer(int id, string status)
{
// (int, string) ValueTuple로 메시지 발행
_broker.Publish("PlayerStatusUpdate", (id, status));
}
}
어떤 방법을 선택할지는 프로젝트의 특정 요구사항에 따라 달라집니다. 최고는 없으며, 가장 적합한 디자인이 있을 뿐입니다.
2. 메시지 키(Key) 선택의 유연성 확장
메시지 시스템에서 이벤트를 식별하는 키(Key)를 선택하는 것도 중요한 설계 결정입니다. 전통적으로 string, enum, int/long과 같은 타입이 사용되어 왔으며, 각각의 장단점이 있습니다.
string: 설명력이 매우 뛰어나지만, 문자열 복사로 인한 GC 부하를 유발할 수 있습니다.enum: 설명력과 성능을 모두 잡을 수 있지만, 새로운 이벤트마다 수동으로 열거형을 추가해야 하는 불편함이 있습니다.int/long: 성능은 우수하지만, 어떤 정수 값이 어떤 이벤트를 나타내는지 직관적으로 알기 어려워 코드 가독성이 떨어집니다.
하지만 메시지 시스템의 키는 위에서 언급된 특정 타입에 국한되지 않습니다. C#의 Dictionary<TKey, TValue>에서 TKey는 거의 모든 타입이 될 수 있으며, 이를 활용하여 더욱 유연한 메시징 시스템을 설계할 수 있습니다.
object: 가장 느슨한 형태의 키 타입입니다. C#의 확장 메서드와 함께 사용하면object.Send()와 같은 편리한 API를 구현할 수 있습니다. 하지만 불필요한 박싱/언박싱 문제를 야기할 수 있습니다.interface: 특정 인터페이스를 구현하는 클래스만을 키로 사용하도록 강제할 수 있습니다. 이는object의 유연성을 유지하면서도, 메시지 타입에 대한 구조적 제약을 부여하여 코드의 안정성을 높이는 방법입니다.
인터페이스를 메시지 키로 사용하는 개념은 메시지 자체를 식별자로 간주하는 디자인 패턴과 유사합니다. 예를 들어, IMessage 인터페이스를 정의하고, 모든 메시지 클래스가 이 인터페이스를 구현하도록 강제할 수 있습니다. 메시지 시스템은 이 IMessage 구현체의 Type을 키로 사용하여 핸들러를 관리할 수 있습니다.
// 예시 메시지 인터페이스
public interface IEventMessage { }
// 특정 이벤트 메시지 구현
public class PlayerDiedEvent : IEventMessage
{
public int PlayerId { get; set; }
public string CauseOfDeath { get; set; } = string.Empty;
}
// 메시지 브로커 (인터페이스를 키로 사용하는 예시)
public class EventBroker
{
// Dictionary의 키로 Type을 사용하여 IEventMessage 구현체를 구분
private Dictionary<Type, List<Delegate>> _handlers = new Dictionary<Type, List<Delegate>>();
// 특정 IEventMessage 타입의 메시지를 구독
public void Subscribe<TMessage>(Action<TMessage> handler) where TMessage : IEventMessage
{
Type messageType = typeof(TMessage);
if (!_handlers.ContainsKey(messageType))
{
_handlers[messageType] = new List<Delegate>();
}
_handlers[messageType].Add(handler);
}
// IEventMessage 타입의 메시지를 발행
public void Publish<TMessage>(TMessage message) where TMessage : IEventMessage
{
Type messageType = typeof(TMessage);
if (_handlers.TryGetValue(messageType, out List<Delegate>? handlers))
{
foreach (var handler in handlers)
{
(handler as Action<TMessage>?)?.Invoke(message);
}
}
}
}
// 메시지를 사용하는 클래스 예시
public class GameController
{
private EventBroker _eventBroker;
public GameController(EventBroker broker)
{
_eventBroker = broker;
// PlayerDiedEvent 메시지에 대한 핸들러 구독
_eventBroker.Subscribe<PlayerDiedEvent>(OnPlayerDied);
}
private void OnPlayerDied(PlayerDiedEvent e)
{
Console.WriteLine($"플레이어 {e.PlayerId} 사망! 원인: {e.CauseOfDeath}");
// 게임 오버 처리 또는 관련 로직 실행
}
public void HandlePlayerFatalDamage(int playerId)
{
// ... 플레이어가 치명적인 피해를 입어 사망했다고 가정
_eventBroker.Publish(new PlayerDiedEvent { PlayerId = playerId, CauseOfDeath = "Critical Hit" });
}
}
이 방식은 강력한 타입 안전성을 제공하며, 메시지 자체가 식별자 역할을 하므로 코드의 가독성을 높입니다. MediatR과 같은 잘 알려진 라이브러리들도 유사한 패턴을 사용하여 메시지 기반 통신을 구현하고 있습니다. 이러한 설계는 시스템의 확장성을 높이고, 각 컴포넌트가 직접적인 의존성 없이 메시지를 통해 상호작용할 수 있도록 돕습니다.