- GUI 프로그램에서 상태에 따라 버튼의 Enable, Disable 등 여부를 바꾸고 싶을 때
- 상태 변수를 switch로 넣어서 case로 때려 넣은 코드가 있을 때 (리펙토링 대상!!)
Class 다이어그램
스테이트 패턴
코드
스테이트 패턴
public interface State {
void insertQuarter();
void ejectQuarter();
void turnCrank();
void dispense();
}
public class HasQuarterSate : State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine)
{
this.gumballMachine = gumballMachine;
}
public void insertQuarter()=> Console.WriteLine("손잡이를 돌렸습니다.");
public void ejectQuarter(){
Console.WriteLine("동전이 반환됩니다.");
gumballMachine.setState(gumballMachine.noQuarterState);
}
public void turnCrank() => Console.WriteLine("손잡이를 돌렸습니다.");
public void dispense()=> Console.WriteLine("알맹이가 나갈수 없습니다.");
}
public class SoldState : State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine)
{
this.gumballMachine = gumballMachine;
}
public void insertQuarter()=> Console.WriteLine("잠깐만 기다려 주세요. 알맹이가 나가고 있습니다.");
public void ejectQuarter()=> Console.WriteLine("이미 알맹이를 뽑으셨습니다.");
public void turnCrank(){}=> Console.WriteLine("손잡이는 한 번만 돌려주세요.");
public void dispense(){
gumballMachine.releaseBall();
if ( gumballMachine.count > 0){
gumballMachine.setState(gumballMachine.noQuarterState);
}
else{
Console.WriteLine("더이상 동전이 없습니다");
gumballMachine.setState(gumballMachine.soldOutState);
}
}
}
public class SoldOutState : State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine)
{
this.gumballMachine = gumballMachine;
}
//인터페이스 구현체..
}
public class NoQuarterState : State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine)
{
this.gumballMachine = gumballMachine;
}
//인터페이스 구현체..
}
인터페이스와 구현체
public class GumballMachine {
State soldOutState {get;set;}
State noQuarterState{get;set;}
State hasQuarterSate{get;set;}
State soldState{get;set;}
State state = soldOutState;
int count {get;set;};
public GumballMachine(int numberGumballs){
soldOutState = new SoldOutState(this);
noQuarterState = new NoQuarterState(this);
hasQuarterSate = new HasQuarterSate(this);
soldState = new SoldState(this);
this.count = numberGumballs;
if (numberGumballs > 0){
state = noQuarterState;
}
}
public void insertQuarter(){
state.insertQuarter();
}
public void ejectQuarter(){
state.ejectQuarter();
}
public void turnCrank(){
state.turnCrank();
state.dispense();
}
public void dispense(){
state.dispense();
}
public void setState(State state){
this.state = state;
}
public void releaseBall(){
Console.WriteLine("A gumball comes rolling out the solt.....");
if (count != 0){
count = count - 1;
}
}
}
상태패턴을 이용하는 Context Class
코드 설명
스테이트 패턴
1. 인터페이스와 구현체
public interface State {
void insertQuarter();
void ejectQuarter();
void turnCrank();
void dispense();
}
Context Class에서 제공하는 기능을 인터페이스 함수로 대체했다.
public class HasQuarterSate : State {
GumballMachine gumballMachine;
public SoldOutState(GumballMachine gumballMachine)
{
this.gumballMachine = gumballMachine;
}
public void insertQuarter()=> Console.WriteLine("손잡이를 돌렸습니다.");
public void ejectQuarter(){
Console.WriteLine("동전이 반환됩니다.");
gumballMachine.setState(gumballMachine.noQuarterState);
}
public void turnCrank() => Console.WriteLine("손잡이를 돌렸습니다.");
public void dispense()=> Console.WriteLine("알맹이가 나갈수 없습니다.");
}
인터페이스의 구현체는 Context Class 인스턴스를 가지고 있으며, 인터페이스 구현체를 직접 실행하면서 상태 변경이 필요한 경우 Context Class 인스턴스의 상태를 직접 변경한다. 이부분에서 Context Class와의 종속성이 생긴다. (결합성이 올라감..)
2. 스테이트패턴을 이용하는 Context Class
Context Class는 스테이트 구현체들을 모두 가지고 있으며, 기능 실행이 필요할 때 인터페이스 구현체들의 함수만 호출한다.
설명 보충을 위한 그림 자료
스테이트 패턴
현재 상태 : HasQuarter, 상태별로 구현한 인터페이스 구현체들(슬롯 머신 기능 + 상태 천이 기능)
현재 상태 : Sold, 상태별로 구현한 인터페이스 구현체들(슬롯 머신 기능 + 상태 천이 기능)
필요에 따라 추가 설명
x
정리 및 결론
스테이트 패턴은 현재 프로그램의 상태에 따라 기능을 달리해야 할 때 적용할만한 패턴이다. 주요 특징은 아래와 같다.
1. 상태 인터페이스를 두고 그에 맞는 구현체들을 모든 상태 별로 구현한다.
2. 상태 인터페이스 구현체들은 온전히 자신의 기능만을 수행하며 상태 천이가 필요한 경우 Context Class의 상태 천이를 수행한다.
3. 전략 패턴과 유사하다.
개인적으로 상태 패턴을 실제로 사용한 사례를 보고싶다. 전략 패턴, 옵저버 패턴, 팩토리 패턴, 데코 패턴은 많이 쓰인다고 들었는데 상태 패턴을 사용하는 사례를 보지 못했다.
- 새로운 인터페이스를 이미 개발되어 있는 인터페이스로 변환시키고 싶을 때 (Array -> List 적용 등..)
퍼사드 패턴
- 나열되어 있는 여러 인터페이스를 통합하여 동시 실행 등 다양한 기능을 제공하고 싶을 때 (매크로 기능..)
Class 다이어그램
어댑터 패턴
퍼사드 패턴
코드
어댑터 패턴
서로 다른 인터페이스 코드
public interface VoltOf110
{
void volt110On();
void volt110Off();
}
public interface VoltOf220
{
void volt220On();
void volt220Off();
}
기존의 VoltOf110 인터페이스로 구현된 코드
public class DVDPlayer : VoltOf110
{
public void volt110Off()
{
System.Console.WriteLine("DVD Player Off by 110Volt Adapter");
}
public void volt110On()
{
System.Console.WriteLine("DVD Player On by 110Volt Adapter");
}
}
110Volt To 220 Volt 클래스
public class Converter110To220 : VoltOf220
{
VoltOf110 iVoltOf110;
public Converter110To220(VoltOf110 iVoltOf110)
{
this.iVoltOf110 = iVoltOf110;
}
public void volt220Off()
{
iVoltOf110.volt110Off();
}
public void volt220On()
{
iVoltOf110.volt110On();
}
}
220 volt 사용 클래스 코드
public class Controller
{
VoltOf220 ivoltOf220;
public Controller(VoltOf220 ivoltOf220)
{
this.ivoltOf220 = ivoltOf220;
}
public void turnOn()
{
ivoltOf220.volt220On();
}
public void turnOff()
{
ivoltOf220.volt220Off();
}
}
메인 코드
DVDPlayer dvdPlayer = new DVDPlayer();
Converter110To220 converter110To220 = new Converter110To220(dvdPlayer);
Controller controller = new Controller(converter110To220);
controller.turnOn();
controller.turnOff();
퍼사드 패턴
다양한 인터페이스 코드
public interface Something1
{
void doSomeThing1();
}
public interface Something2
{
void doSomeThing2();
}
public interface Something3
{
void doSomeThing3();
}
public interface Something4
{
void doSomeThing4();
}
다양한 인터페이스 구현 코드
public class Something1_object : Something1
{
public Something1_object()
{
}
public void doSomeThing1()
{
System.Console.WriteLine("DoOne");
}
}
public class Something2_object : Something2
{
public Something2_object()
{
}
public void doSomeThing2()
{
System.Console.WriteLine("DoTwo");
}
}
public class Something3_object : Something3
{
public Something3_object()
{
}
public void doSomeThing3()
{
System.Console.WriteLine("DoThree");
}
}
public class Something4_object : Something4
{
public Something4_object()
{
}
public void doSomeThing4()
{
System.Console.WriteLine("DoFour");
}
}
Something1_object something1 = new Something1_object();
Something2_object something2 = new Something2_object();
Something3_object something3 = new Something3_object();
Something4_object something4 = new Something4_object();
AllInOne allInOne = new AllInOne(something1, something2, something3, something4);
allInOne.doAll();
코드 설명
어댑터 패턴
서로 다른 인터페이스 코드 : 기존 110 volt 인터페이스와 새롭게 교체할 220 volt의 인터페이스이다.
기존의 VoltOf110 인터페이스로 구현된 코드 : 기존 110 volt의 인터페이스를 상속받아 구현한 클래스이다.
110 Volt To 220 Volt 클래스 : 기존의 110 volt 구현체를 받아서 220 volt의 구현 함수로 매칭시켜준다.
메인 코드 : 어뎁터 패턴의 사용 방법을 보여준 코드이다.
퍼사드 패턴
다양한 인터페이스 코드 : 서로 다른 인터페이스를 보여준다.
다양한 인터페이스 구현 코드 : 서로 다른 인터페이스들의 구현체들을 보여준다.
모든 인터페이스를 통합 실행하는 클래스 코드 : 서로 다른 인터페이스를 모두 생성자에서 등록한 후 하나의 함수로 실행시켜 준다.
메인 코드 : 퍼사드 패턴의 사용 방법을 보여준 코드이다.
설명 보충을 위한 그림 자료
어댑터 패턴
110 volt 어뎁터, 110 volt To 220 volt 변환 어뎁터, 220 volt 콘센트이다.
어뎁터 패턴은 이처럼 기존에 맞기 않는 인터페이스 규격을 맞춰주는 패턴이다.
퍼사드 패턴
퍼사드 패턴은 복잡하게 산재되어 있는 인터페이스들을 취합하여 실행하고 관리를 도와주는 패턴이다.
어뎁터 패턴과 달리 하나의 인터페이스를 다룬다기보다는 여러 인터페이스를 받아서 좀 더 고도화시키는 패턴이다. 매크로 기능이랑 비슷하다.
필요에 따라 추가 설명
x
정리 및 결론
어댑터 패턴은 기존에 규격에 맞지 않는 경우 사용하는 패턴이다. 내 개인적인 생각으로 이 패턴은 매우 많이 쓰면 관리가 힘들 것 같다. 어댑터 패턴은 단방향?으로 구조여서 변환해야 할 클래스가 늘어날수록 코드가 많아질 것이다. 따라서 어댑터 패턴을 적용하기 전에 한 번쯤 몇 개의 클래스를 변환시켜야 하는지 판단해야 할 것 같다.
퍼사드 패턴은 여러 개로 산재되어 있는 인터페이스 구현체들을 가져와서 하나로 통합하는 패턴이다. 매크로 기능?? 을 수행할 때 필요할 것 같다. 하지만 굳이..? 커맨드 패턴에서 이미 매크로 같은 기능을 구현했는데 이 부분은 잘 모르겠다. 지금 알 수 있는 다른 점은 커맨드 패턴은 하나의 커맨드 인터페이스로 구현된 다양한 구현체를 다룰 때 사용했고, 퍼사드 패턴은 여러개의 인터페이스를 다룰때 사용했다.
요청 사항을 객체로 캡슐화하여 요청 사항 인스턴스를 체계적으로 관리하는 패턴이다. 체계적인 관리를 통해 요청 사항 실행뿐만 아니라 로그 기록, Undo 기능 등을 관리할 수 있다.
필요한 상황
1. Undo 기능, Log 기록, Macro 기능을 구현하고 관리하고 싶을때
2. 여러 요청 사항을 하나의 인스턴스에서 관리하고 싶을 때
3. 고객사의 요청 사항이 지속적으로 늘어나는 프로그램인 경우
Class 다이어그램
코드
Icommand 인터페이스
public interface Icommand
{
void excute();
void undo();
}
요청 사항 객체들
public class NullCommand : Icommand
{
public void excute()
{
Console.WriteLine("It's a null slot");
}
public void undo()
{
Console.WriteLine("It's a null slot");
}
}
public class ExampleOneClass : Icommand
{
public void excute()
{
Console.WriteLine("It's ExampleOneClass excute method");
}
public void undo()
{
Console.WriteLine("It's ExampleOneClass undo method");
}
}
public class ExampleTwoClass : Icommand
{
public void excute()
{
Console.WriteLine("It's ExampleTwoClass excute method");
}
public void undo()
{
Console.WriteLine("It's ExampleTwoClass undo method");
}
}
public class MacroClass : Icommand
{
List<Icommand> icommands;
public MacroClass(List<Icommand> icommands)
{
this.icommands = icommands;
}
public void excute()
{
this.icommands.ForEach(x => x.excute());
}
public void undo()
{
this.icommands.ForEach(x => x.undo());
}
}
중앙 관리 클래스
public class Invoker
{
List<Icommand> excuters;
int preSlot;
public Invoker(int slotSize)
{
excuters = new List<Icommand>();
for (int i = 0; i < slotSize; ++i)
{
excuters.Add(new NullCommand());
}
}
public void setCommand(int slot, Icommand command)
{
excuters[slot] = command;
}
public void undo()
{
excuters[preSlot].undo();
}
public void excute(int slot)
{
excuters[slot].excute();
this.preSlot = slot;
}
}
main 코드
Invoker invoker = new Invoker(3);
invoker.setCommand(0, new ExampleOneClass());
invoker.setCommand(1, new ExampleTwoClass());
invoker.excute(0);
invoker.excute(1);
invoker.undo();
MacroClass macroClass = new MacroClass(new List<Icommand>() { new ExampleOneClass(), new ExampleTwoClass(), new ExampleOneClass() });
invoker.setCommand(2, macroClass);
invoker.excute(2);
invoker.undo();
코드 설명
1. Icommand interface를 통해 중앙 관리 클래스 (Invoker class)는 다른 요청 사항 클래스들을 관리한다. 중요한 건 중앙 관리 클래스는 요청 사항 클래스들의 Icommand interface 에 의해 이용할 수 있는 함수만 알고 다른 것은 관여하지 않는다.
2. 요청 사항 클래스들은 Icommand interface 를 상속받기 때문에 Icommand interface의 규격을 맞춰서 코딩한다. 이때 Log 기능, Undo 기능, Excute 기능들을 구현해야 한다.
3. 중앙 관리 클래스는 Icommand interface를 리스트로 저장하고 있다가 실행이 필요할 때 리스트 안에 저장되어 있는 인스턴스를 실행시키면 된다. 중요 한건 요청 사항 클래스들의 내부 변수, 특징을 알 필요 없다는 것이다.
4. main 코드를 통해 해당 패턴을 어떻게 사용하는지 확인할 수 있다.
설명 보충을 위한 그림 자료
중앙 관리 클래스에게 3번째 인덱스의 매크로 요청 사항 클래스를 실행하는 경우
필요에 따라 추가 설명
x
정리 및 결론
1. 커맨드 패턴도 자주 사용하는 패턴이다. 대표적인 사용 사례로 WPF의 ICommand이다. 이를 통해 View와 이벤트 함수를 바인딩한다.
2. 다양한 요청 사항에 대해 Undo, Log, Macro 기능이 필요한 경우 해당 패턴을 사용하면 좋다.
3. 커맨드 패턴은 중앙 관리 클래스 <-> 요청 사항 인터페이스 <-> 요청 사항 클래스로 구분하여 구성과 상속을 적절히 사용한 패턴이다.
파생클래스의 생성자 파라미터에 덮어씌우고자 하는 인스턴스를 매개변수로 넣음으로써 재귀적으로 현재 인스턴스의 상태를 추가하는 방법이다.
필요한 상황
1. Open-Closed-Principle(OCP) 원칙을 지키면서 인스턴스의 현재 상태를 추가하고 싶을 때
2. 인스턴스의 상태를 자유롭게 누적시키는 로직이 필요할 때
Class 다이어그램
코드
1. Pizza class 코드
public abstract class Pizza
{
protected string? strDescription;
public abstract String getDescription();
public abstract double cost();
}
2. Topping class 코드
public abstract class Topping : Pizza
{
public override String getDescription() => this.strDescription;
}
3. Pizza class의 파생 코드
public class CheesePizza : Pizza
{
public CheesePizza()
{
base.strDescription = "CheesePizza";
}
public override double cost()
{
return 2.33;
}
public override string getDescription()
{
return base.strDescription;
}
}
public class MeatLoverPizza : Pizza
{
public MeatLoverPizza()
{
base.strDescription = "MeatLoverPizza";
}
public override double cost()
{
return 3.5;
}
public override string getDescription()
{
return base.strDescription;
}
}
4. Topping class의 파생 코드
public class CheeseTopping : Topping
{
Pizza pizza;
public CheeseTopping(Pizza pizza)
{
this.pizza = pizza;
}
public override double cost() => (pizza.cost() + 0.5);
public override String getDescription() => (pizza.getDescription() + " CheeseTopping");
}
public class TomatoTopping : Topping
{
Pizza pizza;
public TomatoTopping(Pizza pizza)
{
this.pizza = pizza;
}
public override double cost() => this.pizza.cost() + 0.2;
public override String getDescription() => this.pizza.getDescription() + " Tomato Topping";
}
5. main 코드
Pizza pizza = new CheesePizza();
Console.WriteLine($"{pizza.getDescription()} : {pizza.cost()}");
pizza = new CheeseTopping(pizza);
Console.WriteLine($"{pizza.getDescription()} : {pizza.cost()}");
pizza = new CheeseTopping(pizza);
Console.WriteLine($"{pizza.getDescription()} : {pizza.cost()}");
pizza = new TomatoTopping(pizza);
Console.WriteLine($"{pizza.getDescription()} : {pizza.cost()}");
코드 설명
1. Pizza class는 파생 클래스 모두 공통으로 사용할 클래스이다.
2. Topping class 는 Pizza class의 파생 클래스이다. Topping class는 계속 이전 인스턴스를 인자로 받아서 추가로 데이터를 추가한다.
3. CheesePizza, MeatLoverPizza class들은 Pizza class의 파생 클래스로써 기본 Pizza의 대분류로 나눈 것이다. 그 이상 그 이하도 없다.
4. Cheese Topping, Tomato Topping class들은 Topping class의 파생 클로스로써 중요한 점은 Pizza class의 인스턴스를 생성자에서 받아서 이전 상태의 인스턴스를 저장한다. 저장한 인스턴스는 다음 함수 호출 시 사용한다. 이는 결국 재귀적으로 내부 Pizza class의 인스턴스를 재귀적으로 호출하는 역할을 수행하게 된다.
5. 사용하는 코드이다.
설명 보충을 위한 그림 자료
클래스 다이어그램 하단에 별도 기입..
필요에 따라 추가 설명
딱히 어려운 건 없다.
정리 및 결론
데코레이터 패턴도 다양한 언어, API에서 제공하는 패턴 중 하나이다. 하지만 재귀함수적 특징으로 인해 코드의 가독성이 떨어지는 단점이 있다. 사용할지 말지는 본인 판단!!
