Delegate: co to jest, wzorzec delegowania i protokoły iOS

Czym jest wzorzec Delegate?

Delegate — to wzorzec projektowania behawioralnego, pozwalający obiektowi przekazać część swoich obowiązków innemu obiektowi. W przeciwieństwie do dziedziczenia, gdzie klasa potomna nadpisuje metody rodzica, delegat używa kompozycji: obiekt-właściciel przechowuje referencję do delegata i wywołuje jego metody w określonych punktach.

Delegat określa protokół — zestaw metod, które delegat może zaimplementować. Metody dzielą się na obowiązkowe (required) i opcjonalne (optional). W Swift opcjonalne metody protokołu są oznaczane słowem kluczowym @objc optional.

Zasada działania delegata

Obiekt A (właściciel) zawiera właściwość delegate — słabą referencję (weak) do obiektu B (delegat). Gdy następuje zdarzenie, A sprawdza, czy B implementuje odpowiednią metodę protokołu, i wywołuje ją. Słaba referencja jest obowiązkowa: bez niej delegat nie może zostać zwolniony z pamięci, ponieważ właściciel utrzymuje go silną referencją.

protocol LoaderDelegate: AnyObject {
    func loaderDidStart(_ loader: DataLoader)
    func loader(_ loader: DataLoader, didLoad data: Data)
    func loader(_ loader: DataLoader, didFailWith error: Error)
}

class DataLoader {
    weak var delegate: LoaderDelegate?
    
    func start() {
        delegate?.loaderDidStart(self)
        // ładowanie asynchroniczne
    }
}

Klasa DataLoader definiuje protokół LoaderDelegate i wywołuje metody delegata w kluczowych punktach cyklu życia ładowania. AnyObject gwarantuje, że protokół może być zaimplementowany tylko przez klasy — jest to konieczne dla słabej referencji.

Jak działa Delegate w Swift?

Implementacja delegata w Swift obejmuje trzy kroki: zadeklarowanie protokołu, utworzenie słabej właściwości delegate we właścicielu i implementacja protokołu w klasie-delegacie. Rozważmy na przykładzie niestandardowego UITextField z walidacją.

protocol ValidatorDelegate: AnyObject {
    func validate(_ input: String) -> Bool
    func validatorDidFail(_ input: String)
}

class ValidatedTextField: UITextField {
    weak var validator: ValidatorDelegate?
    
    override func textDidChange() {
        guard let text = self.text else { return }
        if validator?.validate(text) == false {
            validator?.validatorDidFail(text)
            self.layer.borderColor = UIColor.red.cgColor
        }
    }
}

class LoginViewController: UIViewController, ValidatorDelegate {
    let textField = ValidatedTextField()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        textField.validator = self
    }
    
    func validate(_ input: String) -> Bool {
        return input.count >= 6
    }
    
    func validatorDidFail(_ input: String) {
        print("Walidacja nie powiodła się: zbyt krótkie dane wejściowe")
    }
}

LoginViewController implementuje protokół ValidatorDelegate i ustawia siebie jako delegata textField. Przy każdej zmianie tekstu ValidatedTextField wywołuje validate(_:), a jeśli walidacja się nie powiedzie — validatorDidFail(_:). Controller działa jako pośrednik między View a logiką walidacji.

Delegate vs NotificationCenter vs Closure

Wybór między delegatem, powiadomieniami i domknięciami zależy od liczby odbiorców i stopnia powiązania komponentów. Każdy mechanizm rozwiązuje problem komunikacji między obiektami, ale z różnymi kompromisami.

Delegate jest optymalny, gdy trzeba przekazać serię powiązanych zdarzeń jednemu odbiorcy. NotificationCenter lepszy do broadcast-owych powiadomień. Closure — do prostych operacji asynchronicznych, takich jak completion handler w URLSession.

Implementacja Delegate w Objective-C

Objective-C używa @protocol i @optional do deklarowania delegatów. W przeciwieństwie do Swift, wszystkie metody protokołu są domyślnie opcjonalne. Kluczowa różnica — wywołanie respondsToSelector: przed wysłaniem wiadomości do delegata, ponieważ metoda może nie być zaimplementowana.

@protocol ImageCacheDelegate 
@optional
- (void)cacheDidStartDownload: (ImageCache *)cache;
- (void)cache: (ImageCache *)cache didCacheImage: (UIImage *)image;
@required
- (void)cache: (ImageCache *)cache didFailWithError: (NSError *)error;
@end

@interface ImageCache : NSObject
@property (nonatomic, weak) id<ImageCacheDelegate> delegate;
- (void)downloadImageAtURL: (NSURL *)url;
@end

@implementation ImageCache
- (void)downloadImageAtURL: (NSURL *)url {
    if ([self.delegate respondsToSelector:@selector(cacheDidStartDownload:)]) {
        [self.delegate cacheDidStartDownload:self];
    }
    // asynchroniczne ładowanie obrazu
}
@end

Kluczowa różnica w Objective-C: przed wywołaniem metody opcjonalnej konieczna jest kontrola respondsToSelector:. W Swift opcjonalne metody protokołu eliminują tę kontrolę — optional chaining (?.) automatycznie obsługuje przypadek braku implementacji.

Typowe błędy przy pracy z delegatami

Błędy używania delegatów prowadzą do wycieków pamięci, crashy aplikacji i nieoczywistych bugów. Rozważmy pięć najczęstszych problemów.

Silna referencja do delegata

Retain cycle — najczęstszy błąd. Jeśli właściwość delegate jest zadeklarowana jako strong, a delegat z kolei posiada obiekt-właściciela, powstaje cykl utrzymania. Oba obiekty nigdy nie zostaną zwolnione z pamięci. Rozwiązanie: zawsze deklarować delegata jako weak var w Swift lub @property (weak) w Objective-C.

Delegat nie wyzerowany po dealloc

Jeśli obiekt-właściciel przeżywa delegata, a referencja pozostała, wywołanie metody delegata doprowadzi do EXC_BAD_ACCESS. Słaba referencja rozwiązuje ten problem automatycznie: po zwolnieniu delegata właściwość staje się nil. Jednak w scenariuszach wielowątkowych warto dodatkowo sprawdzać delegata w głównym wątku.

Nadmierna liczba metod w protokole

Protokół z 20+ metodami narusza zasadę separacji interfejsów (ISP). UITableViewDelegate zawiera około 30 opcjonalnych metod — to historyczny wyjątek. We własnych protokołach lepiej podzielić odpowiedzialność na kilka mniejszych protokołów, każdy z własną rolą.

Przykłady Delegate w systemowych API iOS

Systemowe API Apple aktywnie używają wzorca Delegate. Rozważmy trzy kluczowe przykłady z UIKit, które występują w każdej iOS-owej aplikacji.

Każdy z tych protokołów realizuje różne aspekty zachowania: UITableViewDelegate zarządza wyglądem i reakcją na dotknięcia, UITextFieldDelegate kontroluje wprowadzanie tekstu, URLSessionDelegate obsługuje zdarzenia sieciowe. To demonstruje elastyczność wzorca: delegat może być dostosowany do dowolnego obszaru odpowiedzialności.