Delegate: cos'è, pattern di delegazione e protocolli iOS

Cos'è il pattern Delegate?

Delegate è un pattern di progettazione comportamentale che permette a un oggetto di delegare parte delle sue responsabilità a un altro oggetto. A differenza dell'ereditarietà, dove una classe figlia sovrascrive i metodi del genitore, il delegato utilizza la composizione: l'oggetto proprietario mantiene un riferimento al delegato e chiama i suoi metodi in punti specifici.

Il delegato definisce un protocollo — un insieme di metodi che il delegato può implementare. I metodi sono divisi in obbligatori (required) e opzionali (optional). In Swift, i metodi opzionali del protocollo sono contrassegnati con la parola chiave @objc optional.

Come funziona il delegato

L'oggetto A (proprietario) contiene una proprietà delegate — un riferimento debole all'oggetto B (delegato). Quando si verifica un evento, A controlla se B implementa il metodo del protocollo corrispondente e lo chiama. Il riferimento debole è obbligatorio: senza di esso, il delegato non può essere rilasciato dalla memoria perché il proprietario lo trattiene con un riferimento forte.

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)
        // caricamento asincrono
    }
}

La classe DataLoader definisce il protocollo LoaderDelegate e chiama i metodi del delegato nei punti chiave del ciclo di caricamento. AnyObject garantisce che il protocollo possa essere implementato solo da classi — questo è necessario per il riferimento debole.

Come funziona Delegate in Swift?

L'implementazione del delegato in Swift include tre passaggi: dichiarazione del protocollo, creazione di una proprietà delegate debole nel proprietario e implementazione del protocollo nella classe delegata. Consideriamo un esempio di UITextField personalizzato con validazione.

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("Convalida fallita: input troppo breve")
    }
}

LoginViewController implementa il protocollo ValidatorDelegate e si assegna come delegato di textField. Ad ogni modifica del testo, ValidatedTextField chiama validate(_:), e se la validazione fallisce — validatorDidFail(_:). Il controller funge da intermediario tra la Vista e la logica di validazione.

Delegate vs NotificationCenter vs Closure

La scelta tra delegato, notifiche e closures dipende dal numero di destinatari e dall'accoppiamento dei componenti. Ogni meccanismo risolve il problema della comunicazione tra oggetti, ma con diversi compromessi.

Delegate è ottimale quando è necessario passare una serie di eventi correlati a un singolo destinatario. NotificationCenter è migliore per notifiche broadcast. Closure è per operazioni asincrone semplici, come i completion handler in URLSession.

Implementazione di Delegate in Objective-C

Objective-C utilizza @protocol e @optional per dichiarare i delegati. A differenza di Swift, tutti i metodi del protocollo sono opzionali per impostazione predefinita. La differenza principale è la chiamata respondsToSelector: prima di inviare un messaggio al delegato, poiché il metodo potrebbe non essere implementato.

@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];
    }
    // caricamento asincrono dell'immagine
}
@end

La differenza principale in Objective-C: prima di chiamare un metodo opzionale, è necessario un controllo respondsToSelector:. In Swift, i metodi opzionali del protocollo eliminano questo controllo — l'optional chaining (?.) gestisce automaticamente l'assenza di implementazione.

Errori comuni nell'uso dei delegati

Gli errori nell'uso dei delegati portano a perdite di memoria, crash dell'applicazione e bug non ovvi. Esaminiamo i cinque problemi più comuni.

Riferimento forte al delegato

Il ciclo di ritenzione è l'errore più comune. Se la proprietà delegate è dichiarata come strong e il delegato a sua volta possiede l'oggetto proprietario, si forma un ciclo di ritenzione. Entrambi gli oggetti non verranno mai rilasciati dalla memoria. Soluzione: dichiarare sempre il delegato come weak var in Swift o @property (weak) in Objective-C.

Delegato non azzerato dopo dealloc

Se l'oggetto proprietario sopravvive al delegato e il riferimento rimane, chiamare il metodo del delegato provocherà EXC_BAD_ACCESS. Il riferimento debole risolve automaticamente questo problema: dopo il rilascio del delegato, la proprietà diventa nil. Tuttavia, in scenari multithread, è necessario verificare ulteriormente il delegato nel thread principale.

Numero eccessivo di metodi nel protocollo

Un protocollo con oltre 20 metodi viola il Principio di Segregazione delle Interfacce (ISP). UITableViewDelegate contiene circa 30 metodi opzionali — questa è un'eccezione storica. Nei tuoi protocolli, è meglio suddividere la responsabilità in più protocolli più piccoli, ciascuno con il proprio ruolo.

Esempi di Delegate nelle API di sistema iOS

Le API di sistema Apple utilizzano attivamente il pattern Delegate. Esaminiamo tre esempi chiave di UIKit che appaiono in ogni applicazione iOS.

Ciascuno di questi protocolli implementa diversi aspetti del comportamento: UITableViewDelegate gestisce l'aspetto e la risposta al tocco, UITextFieldDelegate controlla l'input di testo, URLSessionDelegate gestisce gli eventi di rete. Questo dimostra la flessibilità del pattern: il delegato può essere adattato a qualsiasi area di responsabilità.