[Design Patterns] 델리게이트 패턴(Delegate Pattern)

---

💬  Introduction

 

텍스트필드 : 유저로부터 입력을 받는다. 

 

입력된 동작들을 뷰컨트롤러에 전달한다.

이때, 델리게이트(대리자) 패턴이 필요하다. 

즉, 텍스트 필드의 대리자는 뷰컨트롤러가 된다. 

 

텍스트필드라는 객체와 뷰컨트롤러라는 객체가 있을 때

텍스트필드와 뷰컨트롤러의 의사소통을 위해 사용하는게 델리게이트 패턴

이 의사소통을 하기 위해서 중간의 대리자(델리게이트)는 프로토콜 타입으로 설정하고

프로토콜 타입으로 동작이 전달된다.

 

객체 내에서 델리게이트를 설정한다면 self라고 설정할 수 있다. 

없다면 델리게이트를 직접적으로 설정

 

뷰컨트롤러는 텍스트 필드의 프로토콜을 채택해야 한다. 

이 프로토콜이 가지고 있는 선택적인 요구사항들(메서드)을 구현하면

텍스트필드에서 발생한 내용들을 뷰컨트롤러에 전달할 수 있다. 

 

 

 

 

🔎  1 . 델리게이트 패턴

---

Delegate : 대리자, 대신 수행하는 사람, 위임자

 

protocol에 대신 처리해주길 바라는 내용을 작성해서 위임한다. 

그 일을 위임 받은 객체는 그 일을 구체적으로 대신 처리한다. 

 

 

델리게이트 패턴의 구성 

1. 델리게이트 프로토콜 정의

델리게이트 객체가 구현해야 할 메서드를 정의하는 프로토콜을 만듭니다.

protocol MyDelegate: AnyObject {
    func didPerformAction()
}

 

 

2. 델리게이트 프로퍼티 정의

델리게이트 객체를 참조할 프로퍼티를 정의합니다. 보통 weak로 선언하여 강한 참조 순환(메모리 누수)을 방지합니다.

class MyClass {
    weak var delegate: MyDelegate?
    
    func performAction() {
        // 어떤 작업을 수행한 후 델리게이트 메서드를 호출
        delegate?.didPerformAction()
    }
}

 

 

weak 키워드의 역할과 사용 이유

weak 키워드의 역할

weak 키워드는 참조 순환(reference cycle)을 방지하기 위해 사용됩니다. 참조 순환은 두 객체가 서로를 강하게 참조하고 있어, 둘 다 메모리에서 해제되지 않는 상황을 말합니다. 이는 메모리 누수를 유발할 수 있습니다. weak 키워드를 사용하면 강한 참조를 생성하지 않기 때문에 이러한 문제를 피할 수 있습니다.

 

 

사용 이유

참조 순환 방지: weak 참조는 객체가 다른 객체를 강하게 참조하지 않도록 하여 참조 순환을 방지합니다.

자동 해제: weak 참조는 참조하고 있는 객체가 메모리에서 해제될 때, 자동으로 nil로 설정됩니다.

 

 

예시

델리게이트 패턴에서 weak 키워드를 사용하는 이유는 주로 참조 순환을 방지하기 위함입니다. 델리게이트 패턴에서 객체 A가 객체 B를 참조하고, 객체 B가 객체 A를 참조하는 경우가 발생할 수 있습니다. 이러한 상황을 방지하기 위해 델리게이트 프로퍼티를 weak로 선언합니다.

 

protocol MyDelegate: AnyObject {
    func didPerformAction()
}

class MyClass {
    weak var delegate: MyDelegate?
    
    func performAction() {
        delegate?.didPerformAction()
    }
}

class MyDelegateClass: MyDelegate {
    func didPerformAction() {
        print("Action was performed")
    }
}

let myObject = MyClass()
let delegateObject = MyDelegateClass()

myObject.delegate = delegateObject
myObject.performAction()

여기서 MyClass의 delegate 프로퍼티를 weak로 선언함으로써 delegateObject가 메모리에서 해제될 때 delegate 프로퍼티가 자동으로 nil로 설정됩니다. 이를 통해 메모리 누수를 방지할 수 있습니다.

 

 

 

3. 델리게이트 객체 구현

델리게이트 프로토콜을 채택하고 프로토콜의 메서드를 구현하는 객체를 만듭니다.

class MyDelegateClass: MyDelegate {
    func didPerformAction() {
        print("Action was performed")
    }
}

 

 

 

4. 델리게이트 설정 및 사용

델리게이트 객체를 생성하고 델리게이트 프로퍼티에 할당합니다.

let myObject = MyClass()
let delegateObject = MyDelegateClass()

myObject.delegate = delegateObject
myObject.performAction()  // "Action was performed" 출력

 

 

 

 

델리게이트 패턴의 장단점

장점

객체 간의 책임 분리: 객체 간의 역할과 책임을 분리하여 코드의 재사용성과 유지보수성을 높입니다.

유연성 증가: 델리게이트 패턴을 사용하면 동일한 작업을 여러 다른 방식으로 처리할 수 있어 유연성이 증가합니다.

강한 결합도 감소: 델리게이트 패턴은 객체 간의 결합도를 낮추어 코드의 유연성과 확장성을 높입니다.

 

단점

복잡성 증가: 델리게이트 패턴을 잘못 사용하면 코드의 복잡성이 증가할 수 있습니다.

추적 어려움: 델리게이트 메서드가 여러 곳에서 호출될 경우, 코드의 흐름을 추적하기 어려울 수 있습니다.

 

 

 

 

 

🔎 2. 델리게이트 패턴에서 프로토콜을 사용하는 이유?

 

1. 유연성과 확장성

프로토콜을 사용하면 객체 간의 결합도를 낮출 수 있습니다. 프로토콜을 채택한 객체들은 특정 클래스나 타입에 종속되지 않고, 델리게이트 메서드만 구현하면 되므로 다양한 객체와 함께 사용할 수 있습니다. 이는 유연성과 확장성을 높입니다.

 

2. 명확한 계약

프로토콜은 객체가 반드시 구현해야 하는 메서드를 정의하는 일종의 계약(Contract)입니다. 델리게이트 패턴에서 프로토콜을 사용하면 델리게이트 객체가 구현해야 할 메서드가 명확히 정의되어, 델리게이트 역할을 수행하는 데 필요한 메서드들이 빠짐없이 구현될 수 있도록 합니다.

 

3. 코드 재사용성

프로토콜을 사용하면 여러 클래스에서 동일한 프로토콜을 채택하여, 중복된 코드를 줄이고 코드의 재사용성을 높일 수 있습니다. 동일한 동작을 다양한 클래스에 걸쳐 쉽게 적용할 수 있습니다.

 

4. 객체 간 의존성 감소

프로토콜을 사용하면 객체 간의 강한 의존성을 피할 수 있습니다. 객체는 특정 프로토콜을 채택한 다른 객체와만 상호작용하므로, 객체 간의 결합도가 낮아집니다. 이는 코드의 유지보수성을 높이고, 객체 교체나 변경이 용이해집니다.

 

5. 인터페이스의 분리

프로토콜을 통해 특정 역할에 필요한 메서드만 정의할 수 있습니다. 이는 단일 책임 원칙(Single Responsibility Principle)을 지키는 데 도움이 됩니다. 객체는 여러 프로토콜을 채택하여 각각의 역할을 수행할 수 있으며, 불필요한 기능을 포함하지 않도록 합니다.

 

 

 

델리게이트 패턴을 사용하지 않는 경우

class SpecificDelegateClass {
    func didPerformAction() {
        print("Action performed")
    }
}

class MyClass {
    var delegate: SpecificDelegateClass?
    
    func performAction() {
        delegate?.didPerformAction()
    }
}

만약 프로토콜 없이 델리게이트 패턴을 구현하려면, 특정 클래스 타입을 직접 참조해야 합니다. 이는 객체 간의 결합도를 높이고, 코드의 유연성과 재사용성을 떨어뜨립니다.

 

이 경우, MyClass는 SpecificDelegateClass에 강하게 결합되어 있습니다. 만약 다른 클래스가 이 역할을 수행해야 한다면 MyClass를 수정해야 합니다.

 

 

 

 

프로토콜을 사용한 델리게이트 패턴

protocol MyDelegate: AnyObject {
    func didPerformAction()
}

class MyClass {
    weak var delegate: MyDelegate?
    
    func performAction() {
        delegate?.didPerformAction()
    }
}

class DelegateClassA: MyDelegate {
    func didPerformAction() {
        print("Action performed by DelegateClassA")
    }
}

class DelegateClassB: MyDelegate {
    func didPerformAction() {
        print("Action performed by DelegateClassB")
    }
}

let myObject = MyClass()
let delegateA = DelegateClassA()
let delegateB = DelegateClassB()

myObject.delegate = delegateA
myObject.performAction() // "Action performed by DelegateClassA"

myObject.delegate = delegateB
myObject.performAction() // "Action performed by DelegateClassB"

프로토콜을 사용하면, 어떤 클래스가 델리게이트 역할을 수행할지에 대해 유연하게 결정할 수 있습니다.

 

DelegateClassA와 DelegateClassB가 모두 MyDelegate 프로토콜을 채택하여 구현하고 있으며, MyClass는 특정 델리게이트 클래스에 종속되지 않고 유연하게 델리게이트 객체를 교체할 수 있습니다.

 

 

🔎  3. 델리게이트 패턴과 클로저(Completion Handler) 비교

---

델리게이트 패턴과 클로저는 각각 특정 작업을 다른 객체에 위임하거나 완료 시 특정 동작을 실행하기 위해 사용됩니다. 둘의 장단점을 비교해보겠습니다.

 

델리게이트 패턴

protocol DataFetcherDelegate: AnyObject {
    func didFetchData(_ data: Data)
}

class DataFetcher {
    weak var delegate: DataFetcherDelegate?
    
    func fetchData() {
        // 데이터 요청 코드
        let data = Data() // 예제 데이터
        delegate?.didFetchData(data)
    }
}

class ViewController: DataFetcherDelegate {
    func didFetchData(_ data: Data) {
        print("Data received")
    }
}

장점:

책임 분리: 델리게이트 패턴은 역할과 책임을 명확히 분리합니다.

유연성: 하나의 객체가 여러 델리게이트 메서드를 구현하여 다양한 동작을 수행할 수 있습니다.

재사용성: 델리게이트 패턴을 통해 객체 간의 결합도를 낮춰 코드의 재사용성을 높일 수 있습니다.

 

단점:

복잡성 증가: 델리게이트 프로토콜을 정의하고, 객체 간의 관계를 설정하는 과정에서 코드가 복잡해질 수 있습니다.

추적 어려움: 여러 객체가 델리게이트 메서드를 구현하는 경우, 호출되는 메서드를 추적하기 어려울 수 있습니다.

 

 

 

클로저(Completion Handler)

class DataFetcher {
    func fetchData(completion: @escaping (Data) -> Void) {
        // 데이터 요청 코드
        let data = Data() // 예제 데이터
        completion(data)
    }
}

class ViewController {
    func loadData() {
        let dataFetcher = DataFetcher()
        dataFetcher.fetchData { data in
            print("Data received")
        }
    }
}

장점:

간결함: 클로저는 코드 블록 자체로 바로 전달할 수 있어, 간단한 작업을 처리하는 데 적합합니다.

코드 가독성: 코드의 흐름을 따라가기가 쉬워, 클로저를 사용하면 가독성이 향상됩니다.

일회성 작업에 적합: 특정 작업 완료 후 한 번만 실행되는 로직에 적합합니다.

 

단점:

확장성 제한: 클로저는 일회성 작업에 적합하지만, 복잡한 로직이나 여러 메서드를 포함하는 경우 확장성이 떨어집니다.

메모리 관리: 클로저에서 self를 캡처할 때 강한 참조 순환이 발생할 수 있어, 이를 방지하기 위해 [weak self]나 [unowned self]를 사용해야 합니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

🔗 Reference