Delegate: mi ez, delegációs minta és iOS protokollok

Mi a Delegate minta?

Delegate — egy viselkedéstervezési minta, amely lehetővé teszi egy objektum számára, hogy felelősségeinek egy részét egy másik objektumra ruházza. Az örökléstől eltérően, ahol a gyermekosztály felülírja a szülő metódusait, a delegált kompozíciót használ: a tulajdonos objektum tárol egy referenciát a delegáltra, és meghívja annak metódusait meghatározott pontokon.

A delegált meghatározza a protokollt — egy metóduskészletet, amelyet a delegált megvalósíthat. A metódusok kötelező (required) és opcionális (optional) kategóriákra oszlanak. Swift-ben a protokoll opcionális metódusait az @objc optional kulcsszó jelöli.

A delegált működési elve

Az A objektum (tulajdonos) tartalmazza a delegate tulajdonságot — egy weak referenciát a B objektumra (delegált). Amikor egy esemény történik, A ellenőrzi, hogy B implementálja-e a megfelelő protokollmetódust, és meghívja azt. A weak referencia kötelező: nélküle a delegált nem szabadítható fel a memóriából, mivel a tulajdonos erős referenciával tartja.

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)
        // aszinkron betöltés
    }
}

A DataLoader osztály meghatározza a LoaderDelegate protokollt, és meghívja a delegált metódusait a betöltési életciklus kulcsfontosságú pontjain. Az AnyObject garantálja, hogy a protokoll csak osztályok által implementálható — ez szükséges a weak referenciához.

Hogyan működik a Delegate Swift-ben?

A delegált megvalósítása Swift-ben három lépést foglal magában: a protokoll deklarálása, a weak delegate tulajdonság létrehozása a tulajdonosban, és a protokoll implementálása a delegált osztályban. Tekintsük meg egy egyéni UITextField példáján validációval.

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("Érvényesítés sikertelen: a bemenet túl rövid")
    }
}

A LoginViewController implementálja a ValidatorDelegate protokollt, és beállítja magát a textField delegáltjának. Minden szövegváltozáskor a ValidatedTextField meghívja a validate(_:)-t, és ha a validáció sikertelen — validatorDidFail(_:)-t. A Controller közvetítőként működik a View és a validációs logika között.

Delegate vs NotificationCenter vs Closure

A választás delegált, értesítések és closure-ök között a címzettek számától és a komponensek kapcsolódási fokától függ. Minden mechanizmus megoldja az objektumok közötti kommunikáció problémáját, de különböző kompromisszumokkal.

Delegate optimális, amikor egy sor kapcsolódó eseményt kell továbbítani egy címzettnek. NotificationCenter jobb broadcast értesítésekhez. Closure — egyszerű aszinkron műveletekhez, mint a completion handler az URLSession-ben.

Delegate megvalósítása Objective-C-ben

Objective-C a @protocol és @optional használatával deklarálja a delegáltakat. A Swift-től eltérően a protokoll összes metódusa alapértelmezés szerint opcionális. A legfontosabb különbség — a respondsToSelector: meghívása, mielőtt üzenetet küldene a delegáltnak, mivel a metódus lehet, hogy nincs implementálva.

@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];
    }
    // aszinkron képbetöltés
}
@end

A legfontosabb különbség Objective-C-ben: egy opcionális metódus meghívása előtt ellenőrizni kell a respondsToSelector:-t. Swift-ben a protokoll opcionális metódusai kiküszöbölik ezt az ellenőrzést — az optional chaining (?.) automatikusan kezeli az implementáció hiányának esetét.

Tipikus hibák a delegáltakkal való munka során

A delegáltak használatának hibái memóriaszivárgáshoz, az alkalmazás összeomlásához és nem nyilvánvaló hibákhoz vezetnek. Tekintsük az öt leggyakoribb problémát.

Erős referencia a delegáltra

Retain cycle — a leggyakoribb hiba. Ha a delegate tulajdonság strong-ként van deklarálva, és a delegált pedig a tulajdonos objektum tulajdonosa, egy megtartási ciklus jön létre. Mindkét objektum soha nem szabadul fel a memóriából. Megoldás: mindig deklarálja a delegáltat weak var-ként Swift-ben vagy @property (weak)-ként Objective-C-ben.

A delegált nem nullázódott a dealloc után

Ha a tulajdonos objektum túléli a delegáltat, és a referencia megmarad, a delegált metódusának meghívása EXC_BAD_ACCESS-t okoz. A weak referencia automatikusan megoldja ezt a problémát: a delegált felszabadítása után a tulajdonság nil lesz. Többszálú forgatókönyvekben azonban érdemes a delegáltat a fő szálon is ellenőrizni.

Túlzott metódusszám a protokollban

A 20+ metódussal rendelkező protokoll megsérti az interfész elkülönítés elvét (ISP). Az UITableViewDelegate körülbelül 30 opcionális metódust tartalmaz — ez történelmi kivétel. Saját protokolljaiban jobb a felelősséget több kis protokollra osztani, mindegyiknek saját szereppel.

Delegate példák iOS rendszer API-kban

Az Apple rendszer API-i aktívan használják a Delegate mintát. Tekintsünk három kulcsfontosságú példát az UIKit-ből, amelyek minden iOS alkalmazásban megtalálhatók.

Ezen protokollok mindegyike a viselkedés különböző aspektusait valósítja meg: UITableViewDelegate kezeli a megjelenést és az érintésre adott reakciót, UITextFieldDelegate vezérli a szövegbevitelt, URLSessionDelegate feldolgozza a hálózati eseményeket. Ez mutatja a minta rugalmasságát: a delegált bármilyen felelősségi területhez igazítható.