Delegate: wat is het, delegatiepatroon en iOS-protocollen

Wat is het Delegate-patroon?

Delegate — is een gedragsontwerppatroon waarmee een object een deel van zijn verantwoordelijkheden kan overdragen aan een ander object. In tegenstelling tot overerving, waarbij de subclass methoden van de ouder overschrijft, gebruikt de delegaat compositie: het eigenaars-object slaat een referentie naar de delegaat op en roept zijn methoden op specifieke punten aan.

De delegaat definieert een protocol — een reeks methoden die de delegaat kan implementeren. Methoden zijn onderverdeeld in verplichte (required) en optionele (optional). In Swift worden optionele protocolmethoden gemarkeerd met het sleutelwoord @objc optional.

Werkingsprincipe van de delegaat

Object A (eigenaar) bevat de eigenschap delegate — een weak-referentie naar object B (delegaat). Wanneer een gebeurtenis plaatsvindt, controleert A of B de bijbehorende protocolmethode implementeert en roept deze aan. Weak-referentie is verplicht: zonder deze kan de delegaat niet uit het geheugen worden bevrijd, omdat de eigenaar hem met een strong-referentie vasthoudt.

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)
        // asynchrone load
    }
}

De klasse DataLoader definieert het protocol LoaderDelegate en roept de methoden van de delegaat aan op belangrijke punten in de laadcyclus. AnyObject garandeert dat het protocol alleen door klassen kan worden geïmplementeerd — dit is noodzakelijk voor de weak-referentie.

Hoe werkt Delegate in Swift?

Implementatie van de delegaat in Swift omvat drie stappen: het declareren van het protocol, het creëren van de weak delegate-eigenschap in de eigenaar en het implementeren van het protocol in de delegatenklasse. Laten we het bekijken aan de hand van een aangepaste UITextField met validatie.

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("Validatie mislukt: invoer te kort")
    }
}

LoginViewController implementeert het protocol ValidatorDelegate en stelt zichzelf aan als delegaat van textField. Bij elke tekstwijziging roept ValidatedTextField validate(_:) aan, en als de validatie mislukt — validatorDidFail(_:). Controller fungeert als tussenpersoon tussen de View en de validatielogica.

Delegate vs NotificationCenter vs Closure

De keuze tussen delegaten, meldingen en closures hangt af van het aantal ontvangers en de mate van koppeling van componenten. Elk mechanisme lost het probleem van communicatie tussen objecten op, maar met verschillende afwegingen.

Delegate is optimaal wanneer een reeks gerelateerde gebeurtenissen aan één ontvanger moet worden doorgegeven. NotificationCenter is beter voor broadcast-meldingen. Closure — voor eenvoudige asynchrone bewerkingen, zoals een completion handler in URLSession.

Implementatie van Delegate in Objective-C

Objective-C gebruikt @protocol en @optional voor het declareren van delegaten. In tegenstelling tot Swift zijn alle methoden van het protocol standaard optioneel. Het belangrijkste verschil is de aanroep van respondsToSelector: voordat een bericht naar de delegaat wordt gestuurd, omdat de methode mogelijk niet is geïmplementeerd.

@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];
    }
    // asynchrone afbeelding laden
}
@end

Het belangrijkste verschil in Objective-C: vóór het aanroepen van een optionele methode is controle met respondsToSelector: vereist. In Swift elimineren optionele protocolmethoden deze controle — optional chaining (?.) handelt automatisch het geval van ontbrekende implementatie af.

Typische fouten bij het werken met delegaten

Fouten bij het gebruik van delegaten leiden tot geheugenlekken, crashes van de app en onduidelijke bugs. Laten we de vijf meest voorkomende problemen bekijken.

Strong-referentie naar de delegaat

Retain cycle — de meest voorkomende fout. Als de eigenschap delegate is gedeclareerd als strong en de delegaat op zijn beurt het eigenaars-object bezit, ontstaat er een retentiecyclus. Beide objecten worden nooit uit het geheugen bevrijd. Oplossing: declareer de delegaat altijd als weak var in Swift of @property (weak) in Objective-C.

Delegaat niet gereset na dealloc

Als het eigenaars-object de delegaat overleeft en de referentie blijft bestaan, leidt het aanroepen van de delegatenmethode tot EXC_BAD_ACCESS. Weak-referentie lost dit probleem automatisch op: na het vrijgeven van de delegaat wordt de eigenschap nil. In multithreading-scenario's is het echter raadzaam om de delegaat ook in de hoofdthread te controleren.

Overmatig aantal methoden in het protocol

Een protocol met meer dan 20 methoden schendt het principe van interfacescheiding (ISP). UITableViewDelegate bevat ongeveer 30 optionele methoden — dit is een historische uitzondering. In eigen protocollen is het beter om de verantwoordelijkheid te verdelen over meerdere kleine protocollen, elk met zijn eigen rol.

Voorbeelden van Delegate in systeem-API's van iOS

Systeem-API's van Apple gebruiken actief het Delegate-patroon. Laten we drie belangrijke voorbeelden uit UIKit bekijken die in elke iOS-app voorkomen.

Elk van deze protocollen implementeert verschillende aspecten van gedrag: UITableViewDelegate beheert het uiterlijk en de reactie op aanrakingen, UITextFieldDelegate controleert de tekstinvoer, URLSessionDelegate verwerkt netwerkgebeurtenissen. Dit toont de flexibiliteit van het patroon: de delegaat kan worden aangepast aan elk verantwoordelijkheidsgebied.