Delegate: ce este, modelul de delegare și protocoalele iOS

Ce este modelul Delegate?

Delegate — este un model de proiectare comportamentală care permite unui obiect să transfere o parte din responsabilitățile sale altui obiect. Spre deosebire de moștenire, unde clasa copil suprascrie metodele părintelui, delegatul folosește compoziția: obiectul-proprietar stochează o referință către delegat și apelează metodele acestuia în puncte specifice.

Delegatul definește un protocol — un set de metode pe care delegatul le poate implementa. Metodele sunt împărțite în obligatorii (required) și opționale (optional). În Swift, metodele opționale ale protocolului sunt marcate cu cuvântul cheie @objc optional.

Principiul de funcționare al delegatului

Obiectul A (proprietarul) conține proprietatea delegate — o referință weak către obiectul B (delegatul). Când are loc un eveniment, A verifică dacă B implementează metoda corespunzătoare a protocolului și o apelează. Referința weak este obligatorie: fără ea, delegatul nu poate fi eliberat din memorie, deoarece proprietarul îl menține cu o referință strong.

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)
        // încărcare asincronă
    }
}

Clasa DataLoader definește protocolul LoaderDelegate și apelează metodele delegatului în punctele cheie ale ciclului de viață al încărcării. AnyObject garantează că protocolul poate fi implementat doar de clase — acest lucru este necesar pentru referința weak.

Cum funcționează Delegate în Swift?

Implementarea delegatului în Swift include trei pași: declararea protocolului, crearea proprietății weak delegate în proprietar și implementarea protocolului în clasa-delegat. Să analizăm pe exemplul unui UITextField personalizat cu validare.

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("Validare eșuată: intrare prea scurtă")
    }
}

LoginViewController implementează protocolul ValidatorDelegate și se setează ca delegat al textField. La fiecare modificare a textului, ValidatedTextField apelează validate(_:), iar dacă validarea eșuează — validatorDidFail(_:). Controller acționează ca intermediar între View și logica de validare.

Delegate vs NotificationCenter vs Closure

Alegerea între delegat, notificări și closure-uri depinde de numărul de destinatari și gradul de cuplare al componentelor. Fiecare mecanism rezolvă problema comunicării între obiecte, dar cu compromisuri diferite.

Delegate este optim când trebuie transmisă o serie de evenimente conexe unui singur destinatar. NotificationCenter este mai bun pentru notificări de tip broadcast. Closure — pentru operații asincrone simple, cum ar fi completion handler în URLSession.

Implementarea Delegate în Objective-C

Objective-C folosește @protocol și @optional pentru declararea delegaților. Spre deosebire de Swift, toate metodele protocolului sunt implicit opționale. Diferența cheie — apelul respondsToSelector: înainte de a trimite un mesaj delegatului, deoarece metoda poate să nu fie implementată.

@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];
    }
    // încărcare asincronă a imaginii
}
@end

Diferența cheie în Objective-C: înainte de apelarea unei metode opționale este necesară verificarea respondsToSelector:. În Swift, metodele opționale ale protocolului elimină această verificare — optional chaining (?.) gestionează automat cazul lipsei implementării.

Erori tipice la lucrul cu delegații

Erorile de utilizare a delegaților duc la scurgeri de memorie, crash-uri ale aplicației și bug-uri neevidente. Să analizăm cinci dintre cele mai frecvente probleme.

Referința strong la delegat

Retain cycle — cea mai frecventă eroare. Dacă proprietatea delegate este declarată ca strong, iar delegatul la rândul său deține obiectul-proprietar, se formează un ciclu de reținere. Ambele obiecte nu vor fi niciodată eliberate din memorie. Soluție: declarați întotdeauna delegatul ca weak var în Swift sau @property (weak) în Objective-C.

Delegatul nu este anulat după dealloc

Dacă obiectul-proprietar supraviețuiește delegatului, iar referința rămâne, apelarea metodei delegatului va duce la EXC_BAD_ACCESS. Referința weak rezolvă această problemă automat: după eliberarea delegatului, proprietatea devine nil. Totuși, în scenarii multi-thread, este recomandat să verificați delegatul în firul principal.

Număr excesiv de metode în protocol

Un protocol cu peste 20 de metode încalcă principiul separării interfețelor (ISP). UITableViewDelegate conține aproximativ 30 de metode opționale — aceasta este o excepție istorică. În protocoalele proprii, este mai bine să împărțiți responsabilitatea în mai multe protocoale mici, fiecare cu propriul rol.

Exemple Delegate în API-urile de sistem iOS

API-urile de sistem Apple utilizează activ modelul Delegate. Să analizăm trei exemple cheie din UIKit care apar în fiecare aplicație iOS.

Fiecare dintre aceste protocoale implementează aspecte diferite ale comportamentului: UITableViewDelegate gestionează aspectul și reacția la atingeri, UITextFieldDelegate controlează introducerea textului, URLSessionDelegate procesează evenimentele de rețea. Aceasta demonstrează flexibilitatea modelului: delegatul poate fi adaptat oricărui domeniu de responsabilitate.