์ด๋ฒคํธ์ ๋ธ๋ฆฌ๊ฒ์ดํธ๋ ์ด๋ฒคํธ ๊ธฐ๋ฐ ํ๋ก๊ทธ๋๋ฐ๊ณผ ์ฝ๋ฐฑ ๋ฉ์ปค๋์ฆ์ ๊ตฌํํ๋ ํต์ฌ ๊ฐ๋ ์ผ๋ก ๊ฐ๋ฐ์๊ฐ ์ด๋ฒคํธ๋ฅผ ์์ฑํ๊ณ ์ฒ๋ฆฌํ ์ ์๋๋ก ๋๋๋ค.
โ ๋ธ๋ฆฌ๊ฒ์ดํธ (Delegate)
๋ธ๋ฆฌ๊ฒ์ดํธ๋ ํน์ ์๊ทธ๋์ฒ(๋ฐํํ, ๋งค๊ฐ๋ณ์)์ ์ผ์นํ๋ ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ ์ ์๋ ํ์ ์ด๋ค.
// ๋ธ๋ฆฌ๊ฒ์ดํธ ์ ์ธ
public delegate int Operation(int x, int y);
// ๋ธ๋ฆฌ๊ฒ์ดํธ์ ๋ฉ์๋ ํ ๋น
Operation op = (a, b) => a + b;
// ๋ธ๋ฆฌ๊ฒ์ดํธ๋ฅผ ํตํด ๋ฉ์๋ ํธ์ถ
int result = op(10, 5);
→ ๋ธ๋ฆฌ๊ฒ์ดํธ๋ ๋ฉ์๋(๋๋ค์) ์ฐธ์กฐ๋ฅผ ์ ์ฅํ๊ณ , ๋์ค์ ํธ์ถํ ์ ์๋ค.
โ ๋ฉํฐ ์บ์คํธ ๋ธ๋ฆฌ๊ฒ์ดํธ (Multicast Delegates)
์ฌ๋ฌ ๋ฉ์๋๋ฅผ ํ๋์ ๋ธ๋ฆฌ๊ฒ์ดํธ ์ธ์คํด์ค์ ์ฐ๊ฒฐํ ์ ์๋ค. ์ฐ๊ฒฐ๋ ๋ฉ์๋๋ ์์๋๋ก ํธ์ถ๋๋ค.
// ๋ฐํ ๊ฐ์ด ์๋ ๋ธ๋ฆฌ๊ฒ์ดํธ ์ ์ธ
public delegate void Notify();
// ๋ธ๋ฆฌ๊ฒ์ดํธ์ ์ฌ๋ฌ ๋ฉ์๋ ์ฐ๊ฒฐ
Notify notify => Method_A;
notify += Method_B;
// ์ฐ๊ฒฐ๋ ๋ฉ์๋ ์์ฐจ์ ์ผ๋ก ํธ์ถ
notify();
โ ์ฝ๋ฐฑ ๋ฉ์๋
์ฝ๋ฐฑ์ ํน์ ์์ ์ด ์๋ฃ๋ ํ ํธ์ถ๋๋ ๋ฉ์๋์ด๋ค. C#์์ ๋ธ๋ฆฌ๊ฒ์ดํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ฝ๋ฐฑ ๋ฉ์๋๋ฅผ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌํ๊ณ , ์์ ์ด ์๋ฃ๋ ํ ํด๋น ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋ค.
public class Processor
{
public void Process(Action callback)
{
Console.WriteLine("Processing...");
callback(); // ์์
์๋ฃ ํ ์ฝ๋ฐฑ ํธ์ถ
}
}
class Program
{
static void Main()
{
Processor processor = new Processor();
processor.Process(() => Console.WriteLine("Process completed!")); // ๋๋ค์์ผ๋ก ํด๋น ์์
์ด ์๋ฃ๋ ํ ํธ์ถ๋ ์ฝ๋ฐฑ ๋ฉ์๋๋ฅผ ์ ๋ฌ
}
}
โ Func
Func๋ ๋ฐํ๊ฐ์ ๊ฐ์ง๋ ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ๋ ๋ธ๋ฆฌ๊ฒ์ดํธ์ด๋ค. ์ธ์ ๊ฐ์์ ๋ฐ๋ผ ๋ค์ํ ์ค๋ฒ๋ก๋๊ฐ ์์ผ๋ฉฐ ๋ง์ง๋ง ์ธ์๋ ํญ์ ๋ฐํ ํ์ ์ด๋ค.
// int ํ์
๋งค๊ฐ๋ณ์ 2๊ฐ๋ฅผ ๋ฐ๊ณ int ํ์
์ ๋ฐํ๊ฐ์ ๊ฐ์ง๋ ๋ธ๋ฆฌ๊ฒ์ดํธ
Func<int, int, int> add = (x, y) => x + y;
int result = add(2, 3); // result๋ 5
์ธ์ ์์ด ๋ฐํ ํ์ ๋ง ์กด์ฌํ ์ ์๋ค. (์: Func<int>)
โ Action
Action์ ๋ฐํ๊ฐ์ด ์๋ (๋ฐํ๊ฐ์ด void์ธ) ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ๋ ๋ธ๋ฆฌ๊ฒ์ดํธ์ด๋ค. ์ธ์ ๊ฐ์์ ๋ฐ๋ผ ๋ค์ํ ์ค๋ฒ๋ก๋๊ฐ ์๋ค.
// string ํ์
๋งค๊ฐ๋ณ์ 1๊ฐ๋ฅผ ๋ฐ๊ณ ๋ฐํ๊ฐ์ด ์๋ ๋ธ๋ฆฌ๊ฒ์ดํธ
Action<string> printMessage = message => Console.WriteLine(message);
printMessage("Hello, World!"); // ์ฝ์์ "Hello, World!" ์ถ๋ ฅ
๋ฐํํ์
์ด ์์ผ๋ฉฐ ์ธ์๋ ์์ ์ ์๋ค. (์: Action)
โ UnityAction
UnityAction์ Unity ์์ง์์ ์ ๊ณตํ๋ ๋ธ๋ฆฌ๊ฒ์ดํธ๋ก Action๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐํ๊ฐ์ด ์๋ ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ๋ ๋ธ๋ฆฌ๊ฒ์ดํธ์ด๋ค.
using UnityEngine.Events;
UnityAction myAction = () => Debug.Log("UnityAction invoked!");
myAction.Invoke(); // Unity์ ์ฝ์์ "UnityAction invoked!" ์ถ๋ ฅ
UnityAction์ ์ฌ์ฉํ๋ ๊ฐ์ฅ ํฐ ์ด์ ๋ UnityAction์ Action๊ณผ ๋ฌ๋ฆฌ ์ง๋ ฌํ๋ฅผ ์ง์ํ์ฌ ์ธ์คํํฐ์์ ์ฝ๊ฒ ์ค์ ํ๊ณ ๊ด๋ฆฌํ ์ ์๋ค.
โ ์ด๋ฒคํธ (Event)
์ด๋ฒคํธ๋ ๊ฐ์ฒด๊ฐ ์ํ ๋ณํ๋ฅผ ์ธ๋ถ์ ์๋ฆฌ๋ ๋ฉ์ปค๋์ฆ์ผ๋ก, ์ฃผ๋ก UI์ ๊ฐ์ ๋น๋๊ธฐ ์์คํ ์์ ์ฌ์ฉ๋๋ค. ์ด๋ฒคํธ๋ ๋ธ๋ฆฌ๊ฒ์ดํธ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋๋ฉฐ, ๋ธ๋ฆฌ๊ฒ์ดํธ๋ ์ด๋ฒคํธ ๋ฐ์ ์ ํธ์ถ๋ ๋ฉ์๋ ๋ชฉ๋ก์ ๊ด๋ฆฌํ๋ค.
// ๋ธ๋ฆฌ๊ฒ์ดํธ ์ ์ธ
public delegate void Notify();
// ์ด๋ฒคํธ ์ ์ธ
public event Notify OnChange;
public void TriggerEvent()
{
// ์ด๋ฒคํธ ๋ฐ์
OnChange();
}
...
// ์ด๋ฒคํธ์ ๋ฉ์๋ ๊ตฌ๋
OnChange += Callback_Method;
// ์ด๋ฒคํธ ๋ฐ์
OnChange();
→ ์ด๋ฒคํธ ๋ฐ์ ์ ํธ์ถ๋ ์ฝ๋ฐฑ ๋ฉ์๋๋ฅผ OnChange ์ด๋ฒคํธ์ ๊ตฌ๋ ์์ผ ์ด๋ฒคํธ ๋ฐ์ ์ ํด๋น ๋ฉ์๋๊ฐ ํธ์ถ๋๊ฒ ํ๋ค.
โ ์ด๋ฒคํธ ์ ๊ทผ ์ ํ์
์ด๋ฒคํธ๋ ์ ์๋ ํด๋์ค ๋๋ ์ ์ธ๋ ๊ตฌ์กฐ์ฒด ๋ด์์๋ง ํธ์ถํ ์ ์๋ค. ์ด๋ ์ด๋ฒคํธ์ ๋ฌด๊ฒฐ์ฑ์ ์ ์งํ๊ณ , ์๋์น ์์ ์ด๋ฒคํธ ๋ฐ์์ ๋ฐฉ์งํ๋ ์ญํ ์ ํ๋ค.
โ ์ด๋ฒคํธ ํธ๋ค๋ฌ
EventHandler ๋ธ๋ฆฌ๊ฒ์ดํธ๋ ์ด๋ฒคํธ์ ๊ด๋ จ๋ ๋ฐ์ดํฐ๋ฅผ ํฌํจํ๋ EventArgs ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ ์ ์๋ค. ์ด๋ฒคํธ ํธ๋ค๋ฌ๋ ์ผ๋ฐ์ ์ผ๋ก EventHandler ๋ธ๋ฆฌ๊ฒ์ดํธ ๋๋ ์ ๋ค๋ฆญ ๋ฒ์ ์ธ EventHandler<TEventArgs>๋ฅผ ์ฌ์ฉํ์ฌ ์ผ๋ฐํ๋ ํํ๋ก ๊ตฌํ๋๋ค.
public class Publisher
{
public event EventHandler<EventArgs> OnChange;
public void TriggerEvent()
{
if (OnChange != null)
OnChange(this, EventArgs.Empty); // ์ด๋ฒคํธ ๋ฐ์ ์ ์ด๋ฒคํธ์ ๊ด๋ จ๋ ๋ฐ์ดํฐ EventArgs ์ ๋ฌ
}
}
public class Subscriber
{
public void OnEventTriggered(object sender, EventArgs e)
=> Console.WriteLine("Event received with EventArgs!");
}
โ ์ ๋ํฐ ์ด๋ฒคํธ (UnityEvent)
UnityEvent๋ ์ ๋ํฐ์์ ์ ๊ณตํ๋ ์ด๋ฒคํธ ์์คํ ์ด๋ค. ์ ๋ํฐ ์๋ํฐ์ ํตํฉ๋๊ณ ์ง๋ ฌํ๊ฐ ๊ฐ๋ฅํ์ฌ ์ธ์คํํฐ์์ ์ด๋ฒคํธ ๋ฆฌ์ค๋๋ฅผ ์ฝ๊ฒ ์ถ๊ฐํ๊ฑฐ๋ ์ ๊ฑฐํ ์ ์๋ค.
using UnityEngine;
using UnityEngine.Events;
public class ButtonHandler : MonoBehaviour
{
// UnityEvent ์ ์ธ
public UnityEvent onClick;
void Start()
{
if (onClick == null)
onClick = new UnityEvent();
// ์ฝ๋์์ ๋ฆฌ์ค๋ ์ถ๊ฐ
onClick.AddListener(TaskOnClick);
}
void TaskOnClick()
{
Debug.Log("Button was clicked!");
}
// ์ด๋ฒคํธ ํธ๋ฆฌ๊ฑฐ
public void TriggerClick()
{
onClick.Invoke();
}
}'๐ C#' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| ํด๋ก์ (Closure) (0) | 2024.08.29 |
|---|---|
| ์ต๋ช ๋ฉ์๋, ๋๋ค ํํ์ (0) | 2024.08.29 |
| ๊ฐ์ฒด ์งํฅ ์ค๊ณ 5๊ฐ์ง ์์น (SOLID) (0) | 2024.08.23 |
| ์์กด์ฑ ์ฃผ์ (Dependency Injection, DI) (0) | 2024.08.20 |
| ๋คํ์ฑ(Polymorphism), ๋ฐํ์ ๋คํ์ฑ, ์ปดํ์ผ ํ์ ๋คํ์ฑ (0) | 2024.08.20 |