Delegate : qu'est-ce que c'est, le motif de délégation et les protocoles iOS

Qu'est-ce que le motif Delegate ?

Delegate est un motif de conception comportemental qui permet à un objet de déléguer une partie de ses responsabilités à un autre objet. Contrairement à l'héritage, où une classe enfant redéfinit les méthodes parentes, le délégué utilise la composition : l'objet propriétaire conserve une référence au délégué et appelle ses méthodes à des points spécifiques.

Le délégué définit un protocole — un ensemble de méthodes que le délégué peut implémenter. Les méthodes sont divisées en obligatoires (required) et optionnelles (optional). En Swift, les méthodes optionnelles du protocole sont marquées avec le mot-clé @objc optional.

Comment fonctionne le délégué

L'objet A (propriétaire) contient une propriété delegate — une référence faible à l'objet B (délégué). Lorsqu'un événement se produit, A vérifie si B implémente la méthode de protocole correspondante et l'appelle. La référence faible est obligatoire : sans elle, le délégué ne peut pas être libéré de la mémoire car le propriétaire le retient avec une référence 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)
        // chargement asynchrone
    }
}

La classe DataLoader définit le protocole LoaderDelegate et appelle les méthodes du délégué aux points clés du cycle de chargement. AnyObject garantit que le protocole ne peut être implémenté que par des classes — ceci est nécessaire pour la référence faible.

Comment fonctionne Delegate en Swift ?

L'implémentation du délégué en Swift comprend trois étapes : déclarer le protocole, créer une propriété delegate faible dans le propriétaire et implémenter le protocole dans la classe déléguée. Prenons l'exemple d'un UITextField personnalisé avec validation.

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("Échec de la validation : saisie trop courte")
    }
}

LoginViewController implémente le protocole ValidatorDelegate et se désigne comme délégué de textField. À chaque modification de texte, ValidatedTextField appelle validate(_:), et si la validation échoue — validatorDidFail(_:). Le contrôleur agit comme intermédiaire entre la Vue et la logique de validation.

Delegate vs NotificationCenter vs Closure

Le choix entre délégué, notifications et closures dépend du nombre de destinataires et du couplage des composants. Chaque mécanisme résout le problème de communication entre objets, mais avec des compromis différents.

Delegate est optimal lorsque vous devez transmettre une série d'événements liés à un seul destinataire. NotificationCenter est mieux pour les notifications broadcast. Closure est pour les opérations asynchrones simples, comme les gestionnaires d'achèvement dans URLSession.

Implémentation de Delegate en Objective-C

Objective-C utilise @protocol et @optional pour déclarer les délégués. Contrairement à Swift, toutes les méthodes du protocole sont optionnelles par défaut. La principale différence est l'appel respondsToSelector: avant d'envoyer un message au délégué, car la méthode peut ne pas être implémentée.

@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];
    }
    // chargement asynchrone d'image
}
@end

La principale différence en Objective-C : avant d'appeler une méthode optionnelle, une vérification respondsToSelector: est nécessaire. En Swift, les méthodes optionnelles du protocole éliminent cette vérification — l'optional chaining (?.) gère automatiquement l'absence d'implémentation.

Erreurs courantes avec les délégués

Les erreurs d'utilisation des délégués entraînent des fuites mémoire, des crashs de l'application et des bugs non évidents. Examinons les cinq problèmes les plus courants.

Référence forte au délégué

Le cycle de rétention est l'erreur la plus courante. Si la propriété delegate est déclarée comme strong, et que le délégué possède à son tour l'objet propriétaire, un cycle de rétention se forme. Les deux objets ne seront jamais libérés de la mémoire. Solution : déclarez toujours le délégué comme weak var en Swift ou @property (weak) en Objective-C.

Délégué non nul après dealloc

Si l'objet propriétaire survit au délégué et que la référence reste, l'appel de la méthode du délégué entraînera EXC_BAD_ACCESS. La référence faible résout ce problème automatiquement : après la libération du délégué, la propriété devient nil. Cependant, dans les scénarios multithread, vous devez vérifier supplémentairement le délégué sur le thread principal.

Nombre excessif de méthodes dans le protocole

Un protocole avec plus de 20 méthodes viole le principe de ségrégation des interfaces (ISP). UITableViewDelegate contient environ 30 méthodes optionnelles — c'est une exception historique. Dans vos propres protocoles, il est préférable de diviser la responsabilité en plusieurs petits protocoles, chacun avec son propre rôle.

Exemples de Delegate dans les API système iOS

Les API système Apple utilisent activement le motif Delegate. Examinons trois exemples clés d'UIKit qui apparaissent dans chaque application iOS.

Chacun de ces protocoles implémente différents aspects du comportement : UITableViewDelegate gère l'apparence et la réponse tactile, UITextFieldDelegate contrôle la saisie de texte, URLSessionDelegate traite les événements réseau. Cela démontre la flexibilité du motif : le délégué peut être adapté à tout domaine de responsabilité.