1. Delegate(๋๋ฆฌ์)
Delegate๋ ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ๋ ํ์ ์ด๋ค. ๋๋ฆฌ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฉ์๋๋ฅผ ๋ณ์์ฒ๋ผ ์ ๋ฌํ๊ณ ํธ์ถํ ์ ์๋ค.
- ์ด๋ฒคํธ์ ํจ๊ป ๋๋ฆฌ์๋ฅผ ์ฌ์ฉํ์ฌ ์ด๋ฒคํธ ํธ๋ค๋ฌ์ ๋ฑ๋กํ๊ณ ํธ์ถํ ์ ์๋ค. ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ๋ฑ๋ก๋ ๋ชจ๋ ์ด๋ฒคํธ ํธ๋ค๋ฌ๊ฐ ํธ์ถ๋์ด ์ฒ๋ฆฌ๋๋ค.
- BeginInvoke, EndInvoke ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋๋ฆฌ์๋ฅผ ๋น๋๊ธฐ์ ์ผ๋ก ํธ์ถํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์ฒ๋ฆฌํ ์ ์๋ค.
- ๋ค๋ฅธ ๋ฉ์๋์ ์ฝ๋ฐฑ ํจ์๋ฅผ ์ ๋ฌํ ์ ์๋ค. ๋ณดํต ๋น๋๊ธฐ ์์ ๊ณผ ํจ๊ป ์ฌ์ฉํ๋ค.
// delegate ๋ฐํํ delegate๋ช
(๋งค๊ฐ๋ณ์, ๋งค๊ฐ๋ณ์, ๋งค๊ฐ๋ณ์, ....);
delegate int DelegateName(int value1, string value2);
๋๋ฆฌ์๋ ๋ณดํต ์ฌ๋ฌ ๊ฐ์ ๋ฉ์๋๋ฅผ ๋์์ ํธ์ถํด์ผ ํ ๋ ์ฌ์ฉํ๊ธฐ ์ฉ์ดํ๋ค. ๋ฉ์๋๋ฅผ ๋๋ฆฌ์์ ๋ฑ๋กํ ํ ํธ์ถ์ด ํ์ํ ๋ ๋๋ฆฌ์๋ง ํธ์ถํ๋ฉด ๋ฑ๋ก๋ ๋ฉ์๋๋ค์ด ๋ชจ๋ ํธ์ถ๋๊ฒ ๋๋ค.
- interface ๋ด๋ถ์์ ์ ์ธํ ์ ์๋ค.
public delegate void DelegatePlus(int coin, int point, int exp);
public class Program
{
static int userCoin = 0;
static int userPoint = 0;
static int userExp = 0;
static void PlusCoin(int coin, int point, int exp)
{
userCoin = userCoin + coin;
}
static void PlusPoint(int coin, int point, int exp)
{
userPoint = userPoint + point;
}
static void PlusExp(int coin, int point, int exp)
{
userExp = userExp + exp;
}
static void Main(string[] args)
{
DelegatePlus killMonster = PlusCoin;
killMonster += PlusPoint;
killMonster += PlusExp;
killMonster(100, 30, 40);
}
}
2. Event
Event๋ ๋ฐ์ํ๋ ํน์ ๋์์ ๋ํ๋ด๋ ์ ํธ์ด๋ฉฐ ํด๋น ๋์์ ๋ํ ์๋ต์ ๋ฐ์ ์ ์๋๋ก ์๋ฆผ์ ์ ๊ณตํ๋ค. ๊ฐ์ฒด ๊ฐ์ ์ํธ ์์ฉ์์ ์ค์ํ ์ญํ ์ ์ํํ๋ฉฐ ์ผ์ข ์ ํต์ ๋ฉ์ปค๋์ฆ์ผ๋ก ๋ณผ ์ ์๋ค.
- ์ด๋ฒคํธ ํธ๋ค๋ง์ ํตํด ๋ค๋ฅธ ๊ฐ์ฒด๋ ์ฌ์ฉ์์ ๋์์ ๋ํ ์๋ฆผ์ ์ ๊ณตํ๊ณ ์ด์ ๋ํ ์๋ต์ผ๋ก ํน์ ๋์์ ์ํํ๋ค.
- ์ด๋ฒคํธ ๊ธฐ๋ฐ ์ํคํ ์ฒ์์ ํต์ฌ์ ์ธ ์ญํ ์ ์ํํ๋ค. ์ด๋ฒคํธ๋ฅผ ์ฌ์ฉํ์ฌ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ค์ํ ์ปดํฌ๋ํธ๋ ๋ชจ๋ ๊ฐ์ ํต์ ์ ๋จ์ํ๊ณ ์ ์ฐํ๊ฒ ๊ตฌ์ฑํ ์ ์๋ค. ์ปดํฌ๋ํธ ๊ฐ์ ๊ฒฐํฉ๋๋ฅผ ๋ฎ์ถ๊ณ ์ฌ์ฌ์ฉ์ฑ์ ๋์ผ ์ ์๋ค.
- ์ด๋ฒคํธ ๋๋ฆฌ๋ธ ํ๋ก๊ทธ๋๋ฐ ํจํด์์ ๋น๋๊ธฐ์ ์ธ ์ํฉ์์ ์ด๋ฒคํธ์ ์ํด ํธ๋ฆฌ๊ฑฐ ๋๋ ๋์์ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ค.
// ํ์ ์ event delegate๋ช
event๋ช
;
public event TenEventHandler TenEvent;
๋ฐ์ํ ์ฌ๊ฑด์ ์ฒ๋ฆฌํ๊ธฐ ์ํด ์ด๋ฒคํธ ํธ๋ค๋ฌ๋ผ๊ณ ํ๋ ๋ฉ์๋๋ฅผ ๋ฑ๋กํ๊ณ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ๋ฑ๋ก๋ ๋ชจ๋ ์ด๋ฒคํธ ํธ๋ค๋ฌ๊ฐ ์์ฐจ์ ์ผ๋ก ํธ์ถ๋์ด ํด๋น ๋์์ ๋ํ ์๋ต์ ์ฒ๋ฆฌํ๋ค.
- .NET์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ์ด๋ฒคํธ ์ฒ๋ฆฌ๋ฅผ ์ํ EventHandler๊ฐ ์กด์ฌํ๋ค.
- ํด๋์ค ์ธ๋ถ์์ ์ง์ ํธ์ถํ ์ ์์ผ๋ฉฐ ํด๋น ํด๋์ค์ ๋ฉ์๋ ๋ด์์๋ง ํธ์ถ ๊ฐ๋ฅํ๋ค.
- interface ๋ด๋ถ์์ ์ ์ธํ ์ ์๋ค.
using System;
class Program
{
delegate void EventHandler(string message);
class Notifier
{
public event EventHandler Execute;
public void Notifiy()
{
Execute("Event");
}
}
static void Print(string str)
{
Console.WriteLine(str);
}
static void Main(string[] args)
{
Notifier notifier = new Notifier();
notifier.Execute += Print;
// notifier.Execute(""); ๋ถ๊ฐ๋ฅ!
notifier.Notifiy();
}
}
์ด๋ฒคํธ์ ์ด๋ฆ์ ๋ช ํํ๊ณ ์ผ๊ด์ฑ ์๊ฒ ์ง์ด์ผ ํ๋ค. ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ ๋์์ด๋ ์ํ๋ฅผ ์ ํํํ๊ณ ๋ค๋ฅธ ๊ฐ๋ฐ์๋ค์ด ์ดํดํ๊ธฐ ์ฝ๋๋ก ๋ค์ด๋ฐํด์ผ ํ๋ค.
3. ๋ฌด๋ช ํจ์
์ผ๋ฐ์ ์ธ delegate๋ ์ด๋ฏธ ์ ์๋ ๋ฉ์๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ค. ์ด๋ ๊ฒ ๋ฏธ๋ฆฌ ์ ์๋ ๋ฉ์๋๋ค๊ณผ๋ ๋ฌ๋ฆฌ, C# 2.0์์๋ถํฐ๋ ๋ฉ์๋๋ฅผ ๋ฏธ๋ฆฌ ์ ์ํ์ง ์์๋ ๋๋ ๋ฉ์๋ ๋ช ์ด ์๋ ๋ฌด๋ช ํจ์๋ฅผ ์ง์ํ๋ค. ๋ง์ฝ ์ด๋ค ๋ฉ์๋๊ฐ ์ผํ์ฉ์ผ๋ก ๋จ์ํ ๋ฌธ์ฅ๋ค๋ก ๊ตฌ์ฑ๋์ด ์๋ค๋ฉด, ๊ตณ์ด ๋ณ๋์ ๋ฉ์๋๋ฅผ ์ ์ํ์ง ์์๋ ๋๋ ๊ฒ์ด๋ค.
// delegate(ํ๋ผ๋ฏธํฐ) { ์คํ ๋ฌธ์ฅ };
delegate(int param1) { };
- ํ๋ผ๋ฏธํฐ๋ ํด๋น ๋ฉ์๋ ์ํ(Prototype)์ ๋ง๋ ๋์ผํ ํ์ ์ด์ด์ผ ํ๋ค.
- ์ธ๊ด์ ์ธ๋ผ์ธ ๋ฉ์๋(inline method) ํ์์ ๊ฐ์ง๋ค.
// delegate
delegate void MyDelegate(int a);
MyDelegate d = delegate(int p) { Console.Write(p); };
d(100);
// EventHandler
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
// ์ด๋ฒคํธ ํธ๋ค๋ฌ์ ๋ฉ์๋๋ช
์ง์
this.button1.Click += new System.EventHandler(this.button1_Click);
// ์ด๋ฒคํธ ํธ๋ค๋ฌ์ ๋ฌด๋ช
๋ฉ์๋ ์ง์
this.button2.Click += delegate(object s, EventArgs e)
{
MessageBox.Show("๋ฒํผ2 ํด๋ฆญ");
};
}
private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("๋ฒํผ1 ํด๋ฆญ");
}
}
- delegate์ ํ ๋นํด์ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
- EventHandler์ ์ถ๊ฐํด์ ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
- ๋ฉ์๋ ํ๋ผ๋ฏธํฐ์ ์ธ๋ผ์ธ ํ์์ผ๋ก ์ฌ์ฉ ๊ฐ๋ฅํ๋ค.
4. Func, Action
๋ฌด๋ช ํจ์๋ ์ผํ์ฑ์ผ๋ก ์ฌ์ฉ๋ ํจ์์ ์ฉ์ดํ์ฌ ์ฝ๋๋ฅผ ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค์ด์ฃผ์ง๋ง, ๋๋ฆฌ์๋ฅผ ์ ์ธํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์๋ค. ๊ทธ๋ฌ๋ .NET์๋ ๋ฏธ๋ฆฌ ์ ์ธ๋ ๋๋ฆฌ์๊ฐ ์กด์ฌํ์ฌ ๋๋ฆฌ์๋ฅผ ๋ฐ๋ก ์ ์ธํ์ง ์๊ณ ์ฌ์ฉํ ์ ์๋ค.
1) Func
๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๋ฉ์๋๋ฅผ ์ฐธ์กฐํ๊ธฐ ์ํด ๋ง๋ค์ด์ก์ผ๋ฉฐ ๋งค๊ฐ๋ณ์ ์ค ๊ฐ์ฅ ๋ง์ง๋ง์ ์๋ ๊ฒ์ด ๋ฐํ ํ์์ด๋ค.
public delegate TResult Func<out TResult>()
public delegate TResult Func<in T, out TResult>(T arg)
public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2)
public delegate TResult Func<in T1, in T2, in T3, out TResult>(T1 arg1, T2 arg2, T3 arg3)
...
public delegate TResult Func<in T1, in T2, ..., in T16, out TResult>(T1 arg1, ..., T16 arg16)
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ
Func<int> func1 = () => 10;
Console.WriteLine(func1());
// 10
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ 1๊ฐ ์๋ ๊ฒฝ์ฐ
Func<int, int> func2 = (x) => x*2; // ์
๋ ฅ ๋งค๊ฐ๋ณ์๋ int ํ์ ํ๋, ๋ฐํ ํ์๋ int
Console.WriteLine(func2(3));
// 6
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ 2๊ฐ ์๋ ๊ฒฝ์ฐ
Func<int, int, int> func3 = (x, y) => x + y; // int ํ์ ์
๋ ฅ ๋งค๊ฐ๋ณ์ 2๊ฐ, ๋ฐํ ํ์๋ int
Console.WriteLine(func3(3, 4));
// 7
2) Action
Fun ๋๋ฆฌ์์ ๊ฑฐ์ ๋์ผํ์ง๋ง ๋ฐํ ํ์์ด ์๋ค.
public delegate void Action<>()
public delegate void Action<in T>(T arg)
public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2)
...
public delegate void Action<in T1, ..., in T16>(T1 arg1, ..., T16 arg16)
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ ์๋ ๊ฒฝ์ฐ
Action act1 = () => Console.WriteLine("Action()");
act1();
// Action()
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ 1๊ฐ ์๋ ๊ฒฝ์ฐ
int result = 0;
Action<int> act2 = (x) => result = x * x; // ๋๋ค์ ๋ฐ์์ ์ ์ธํ result์ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅ
act2(5);
Console.WriteLine("result : {0}", result);
// result : 25
- ์ ๋ ฅ ๋งค๊ฐ๋ณ์๊ฐ 2๊ฐ ์๋ ๊ฒฝ์ฐ
Action<double, double> act3 = (x, y) = >
{
double pi = x / y;
Console.WriteLine("Action<T1, T2>({0}, {1}) : {2}", x, y, pi);
};
act3(22.0, 7.0);
// Action<T1, T2>(22, 7) : 3.14285714285714
์ฐธ๊ณ
https://woojoolog.tistory.com/13