์ด ํฌ์คํธ๋ ์ฐธ๊ณ ๋ฌธ์๋ฅผ ํ์๊ฐ ์ดํดํ๊ธฐ ์ฝ๊ฒ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค.
DI๋ IoC๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๋๋ค
DI(Dependency Injection)
๋ค์ PizzaStore ํด๋์ค๋ ์ ํด์ง ๊ฐ์์ Pizza์ธ์คํด์ค๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ๋ง์ฝ Pizza๊ฐ ๋ ํ์ํ๋ฉด PizzaStore๋ฅผ ์ง์ ์์ ํด์ผํ๋ค. ์ด๋ OCP๋ฅผ ์๋ฐํ๋ฉฐ DI๋ก ํด๊ฒฐํด์ค ์ ์๋ค
public class PizzaStore
{
private readonly Pizza[] pizzas =
new Pizza[]
{
new Pizza(),
new Pizza(),
new Pizza()
};
public void Sell(int count)
{๋ค์๊ณผ ๊ฐ์ด ์ธ์๋ฅผ ์ทจํ๋ ํํ์ DI๋ก ํด๊ฒฐ ๊ฐ๋ฅํ๋ค
public class PizzaStore
{
private readonly Pizza[] pizzas;
public PizzaStore(Pizza[] pizzas)
{
this.pizzas = pizzas;
}
public void Sell(int count)
{์ด์ฒ๋ผ DI๋ ์ถ์ํ๋ฅผ ํด์น์ง ์๊ณ ์์กด์ฑ์ ์ธ์๋ก ๋๊ฒจ์ฃผ๋ ๋ฐฉ๋ฒ์ ๋ปํ๋ค.
Rรบnar Bjarnason : Dependency Injection is really just a pretentious way to say โtaking an argumentโ.
DIP(Dependency Inversion Principle)
๊ณ ์ฐจ์ ๋ชจ๋์ ์ ์ฐจ์ ๋ชจ๋์ ์์กดํด์๋ ์๋๋ค. ์ด ๋์ ์ถ์ํ๋ ๊ฒ์ ์์กดํด์ผํ๋ค.
์ถ์ํ๋ ๊ฒ์ ๊ตฌ์ฒด์ ์ธ ๊ฒ์ ์์กดํ๋ฉด ์๋๋ค.
์ PizzaStore ํด๋์ค๋ ํ์ฌ Pizza ๊ตฌํ์ฒด์ ์์กดํ๊ณ ์๋ค. ์ด ํํ๋ DIP๋ฅผ ์๋ฐํ๊ณ ์๋ ๊ฒ์ผ๋ก, ๋ค์๊ณผ ๊ฐ์ด ๋ณ๊ฒฝ๋์ด์ผํ๋ค.


DI๋ DIP๋ฅผ ์ฌ์ฉํ๋ค๊ณ ์๊ฐํ์ง๋ง ์ด ๋์ ๋ณ๊ฐ๋ค. DI๋ฅผ ์ฌ์ฉํ๋ฉด์ DIP๊ฐ ํ์์๋ ๊ฒฝ์ฐ๋ ๋ง๋ค. ์๋ CachedUserStore ํด๋์ค์์๋ ์ผ์ ๊ธฐ๊ฐ(duration) ๋์ ์บ์ฌํ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค. ์ด๋ duration์ DI๋ฅผ ํตํด ์ฃผ์
๋์ง๋ง DIP๊ฐ ํ์ํ ๊ฒ์ ์๋๋ค.
public interface IUserStore
{
User Find(string userId);
}
public class CachedUserStore : IUserStore
{
...
public CachedUserStore(IUserStore innerStore, int duration)
{
...
}
public User Find(string userId)
{Inversion of Control
IoC๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํ๋ ์์ํฌ์ ์ฐจ์ด์์ ์์๋ณผ ์ ์๋ค.
๋ผ์ด๋ธ๋ฌ๋ฆฌ : ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋์ ๊ฐ์ ธ์์ ์ฌ์ฉํ ์ ์์. ๊ฐ๋ฐ์์๊ฒ ์ ์ด๊ถ์ด ์๋ค
ํ๋ ์์ํฌ : ๊ฐ๋ฐ์๊ฐ ํ๋ ์์ํฌ์ ๋ง์ถ์ด ๊ตฌ์ฑ์์๋ฅผ ๋ฑ๋กํ๋ฉด ํ๋ ์์ํฌ๊ฐ ํ๋ก๊ทธ๋จ์ ๋์์ํด. ์ ์ด๊ถ์ด ํ๋ ์์ํฌ์ ์๋ค.
๋ค์๊ณผ ๊ฐ์ด IoC ์ปจํ ์ด๋๊ฐ ์์กด์ฑ์ ์ฃผ์ ํด์ค๋ค๋ฉด ์ด๋ ์ ์ด๊ถ์ด IoC ์ปจํ ์ด๋์ ์๋ ๊ฒ์ผ๋ก IoC๊ฐ ๋ฐ์ํ ์ฌ๋ ์ด๋ค
public static void Main()
{
Type[] pizzaTypes = Assembly.GetEntryAssembly()
.GetExportedTypes()
.Where(typeof(IPizza).IsAssignableFrom);
var builder = new IoCContainerBuilder();
buildr.RegisterTypes(pizzaTypes);
IoCContainer container = builder.Build();
IPizza[] allKindsOfPizzas = container.Resolve<IPizza[]>();
var pizzaStore = new PizzaStore(allKindsOfPizzas);
...
}Pure DI
Mark Seemann์ IoC ์ปจํ ์ด๋๋ฅผ ์ฌ์ฉํ์ง ์๋ DI์ ๋ํด Pure DI๋ผ๊ณ ํ๋ค
DI๋ฅผ ์ฌ์ฉํ๋ค๊ณ ๋ฌด์กฐ๊ฑด IoC ์ปจํ
์ด๋๊ฐ ํ์ํ ๊ฒ์ ์๋๋ค. ๋ณดํต์ ์์กด์ฑ ๋ฑ๋ก๋น์ฉ(๊ฐ๋ฐ์๊ฐ ์ง์ ์์กด์ฑ์ ์ฃผ์
ํ๋ ๊ฒ) ๋๋ฌธ์ IoC ์ปจํ
์ด๋๋ก ์์กด์ฑ ์ฃผ์
ํ์ง๋ง, IoC ์ปจํ
์ด๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์๋ Weakly typed ๋ฌธ์ ๊ฐ ์๋ค.
Weakly typed ๋, IoC ์ปจํ ์ด๋์ ์์กด์ฑ์ ์๋ชป ๊ตฌ์ฑ๋์์ ๊ฒฝ์ฐ ์ปดํ์ผ ์๋ฌ๋์ ๋ฐํ์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ ๊ฒ์ด๋ค.
๋ฐ๋ผ์ Weakly typed ๋น์ฉ๊ณผ ์์กด์ฑ ๋ฑ๋ก ๋น์ฉ ์ค ์ด๋ค ๊ฒ์ด ๋ ํฐ์ง ์๊ฐํ์ฌ IoC ์ปจํ ์ด๋๋ก DI๋ฅผ ๊ตฌํํ ์ง Pure DI๋ฅผ ์ฌ์ฉํ ์ง ๊ฒฐ์ ํด์ผํ๋ค. (์ฐธ๊ณ ๋ฌธ์์ ํ์๋ weakly typed ๋น์ฉ์ด ๋ ํฌ๋ค๊ณ ํจ)
์ค์ํ ๊ฒ์ ๋ญ ์ฌ์ฉํด์ผํ ์ง๋ณด๋ค IoC ์ปจํ ์ด๋ ์์ด Pure DI๋ฅผ ์ฌ์ฉํ ์ ์๊ณ , Pure DI์๋ ์ฅ์ ์ด ์๋ค๋ ๊ฒ์ด๋ค.
์์ฝ
DI๋ ์ด๋ ํ ๊ณ ์ฐจ์ ๋ชจ๋์ด ์ ์ฐจ์ ๋ชจ๋์ ์์กดํด์๋ ์๋๋ค๋ DIP์ ๋ณ๊ฒฝ์๋ ๋ซํ์๊ณ ํ์ฅ์๋ ์ด๋ ค์์ด์ผํ๋ OCP๋ฅผ ์งํค๊ธฐ ์ํด, ์ธ๋ถ์์ ์์กดํ๋ ๋ชจ๋์ ์ฃผ์
ํด์ฃผ๋ ๊ฒ์ด๋ค.
๋ณดํต DI๋ IoC ์ปจํ
์ด๋๋ก ์ฃผ์
ํด์ฃผ์ง๋ง, weakly typed ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค.
๋ฐ๋ผ์ ์ง์ ์์กด์ฑ ๋ฑ๋กํ ๋ ๋ฐ์ํ๋ ๋น์ฉ๊ณผ weakly typed ๋น์ฉ์ ์ ๋น๊ตํ์ฌ ์ฌ์ฉํ๋ฉด ์ข๋ค.