Comment un délégué travaille-t-il dans Objective-C?
- Est-ce que quelqu'un sait où je peux trouver une bonne explication/tutoriel sur quoi et comment fonctionne un délégué d'application dans
objective-C? - Les deux livres que j’ai abordés n’insistent pas assez sur
delegateset ne les expliquent pas très bien pour que je puisse vraiment comprendre leur pouvoir et leur fonction.
En cas de doute, consultez la docs !
Fondamentalement, la délégation est un moyen de permettre aux objets d'interagir les uns avec les autres sans créer d'interdépendances fortes entre eux, car cela rend la conception de votre application moins flexible. Au lieu d'objets se contrôlant les uns les autres, ils peuvent avoir un délégué auquel ils envoient (ou délégués) des messages, et le délégué fait ce qu'il fait pour répondre et agir sur ce message, puis retourne généralement quelque chose à l'autre objet. .
La délégation est également une meilleure alternative au sous-classement. Au lieu de devoir créer vos propres classes personnalisées afin de modifier légèrement le comportement des autres objets ou de leur transmettre des données, la délégation permet aux objets d'envoyer des messages à leurs délégués sans devoir créer des sous-classes pour y apporter des modifications mineures. autres objets.
Bien entendu, le principal inconvénient de la délégation est que les méthodes de délégation disponibles dépendent de ce que les ingénieurs Apple considèrent comme utile et des implémentations courantes dont ils ont besoin, ce qui impose une restriction à ce que vous pouvez réaliser. Comme Quinn Taylor l'a fait remarquer, cela est spécifique aux frameworks Cocoa et ne s'applique donc pas dans toutes les situations.
Si la délégation est une option sur le sous-classement, prenez-la, car il s'agit d'un moyen beaucoup plus simple de gérer votre code et les interactions entre les objets.
Comme décrit ci-dessus, un délégué n'est pas une fonctionnalité d'iOS ou d'Objective-C, mais simplement une technique de programmation et ne nécessite aucun support de langage spécifique.
Une classe (e, g, classA) peut être écrite de telle sorte que ses méthodes getData et doSomething puissent être implémentées non par elle-même, mais par un délégué (peut-être parce que classA ne sait pas ce que les données être ou ce qu'il devra faire).
Pour ce faire, classA fournit une propriété, généralement appelée delegate (qui est simplement un pointeur sur la classe - le délégué - qui implémente les méthodes déléguées), puis, lorsqu'elle appelle ces méthodes, elle appelle les méthodes dans le délégué:
[self.delegate getData];
et
[self.delegate doSomething];
self.delegate peut être initialement défini sur self:
self.delegate = self;
en d'autres termes, classA implémente sa propre version de ces méthodes, à moins qu'elles ne soient déléguées.
Toute autre classe souhaitant implémenter les méthodes (c'est-à-dire être le délégué et éventuellement substituer l'implémentation par défaut de classA), définirait d'abord le délégué de classA comme étant elle-même. donc si classB voulait être le délégué de ces méthodes, dans classB, nous aurions:
classA.delegate = self;
Ainsi, lorsque classA appelle ces méthodes déléguées, il appelle en réalité classB pour les implémenter, sans rien connaître de classB ni même de son existence et classB n'a pas à sous-classe classA.
La limitation est que classB ne peut remplacer que les méthodes que classA veut déléguer - avec un sous-classement, vous pouvez remplacer n'importe quelle méthode.
Les protocoles sont utilisés pour formaliser le processus de délégation en définissant une liste de méthodes que/ doit être implémentées par le délégué (le délégant ne fournit aucune version par défaut de la méthode et cette méthode doit être implémentée quelque part) ou peut être éventuellement implémenté par le délégué (c'est-à-dire que le délégant a sa propre version ou peu importe si la méthode n'est pas implémentée).
Les délégués sont un modèle de conception; il n'y a pas de support de syntaxe ou de langage particulier.
Un délégué est simplement un objet auquel un autre objet envoie des messages lorsque certaines choses se produisent, afin que le délégué puisse gérer les détails spécifiques à l'application pour lesquels l'objet d'origine n'a pas été conçu. C'est une façon de personnaliser le comportement sans sous-classer.
J'essaie de l'élaborer à travers un programme simple
Deux classes
Étudiant.h
#import <Foundation/Foundation.h>
@interface Student : NSObject
@property (weak) id delegate;
- (void) studentInfo;
@end
Étudiant.m
#import "Student.h"
@implementation Student
- (void) studentInfo
{
NSString *teacherName;
if ([self.delegate respondsToSelector:@selector(teacherName)]) {
teacherName = [self.delegate performSelector:@selector(teacherName)];
}
NSLog(@"\n Student name is XYZ\n Teacher name is %@",teacherName);
}
@end
Professeur.h
#import <Foundation/Foundation.h>
#import "Student.h>
@interface Teacher: NSObject
@property (strong,nonatomic) Student *student;
- (NSString *) teacherName;
- (id) initWithStudent:(Student *)student;
@end
Professeur.m
#import "Teacher.h"
@implementation Teacher
- (NSString *) teacherName
{
return @"ABC";
}
- (id) initWithStudent:(Student *)student
{
self = [ super init];
if (self) {
self.student = student;
self.student.delegate = self;
}
return self;
}
@end
main.m
#import <Foundation/Foundation.h>
#import "Teacher.h"
int main ( int argc, const char* argv[])
{
@autoreleasepool {
Student *student = [[Student alloc] init];
Teacher *teacher = [[Teacher alloc] initWithStudent:student];
[student studentInfo];
}
return 0;
}
EXPLICATION :::
Depuis la méthode principale quand initWithStudent: student s’exécutera
1.1 La propriété de l'objet de l'enseignant 'étudiant' sera assignée à un objet étudiant.
1.2 self.student.delegate = self signifie que le délégué de l'objet étudiant pointe sur l'objet enseignant
Depuis la méthode principale quand [student studentInfo] sera appelé
2.1 [self.delegate respondToSelector: @selector (teacherName)] Ici, déléguez déjà pointe sur un objet enseignant pour qu'il puisse invoquer la méthode d'instance 'teacherName'.
2.2 so [self.delegate performSelector: @selector (teacherName)] s'exécutera facilement.
Il semble que l'objet Enseignant affecte un objet délégué à l'appel de sa propre méthode.
C'est une idée relative, où nous voyons cet objet étudiant appelé la méthode 'teacherName' mais il est essentiellement fait par l'objet teacher lui-même.
Imaginez simplement que vous appeliez par téléphone et que vous commandiez une pizza… .. Ensuite, un livreur de pizzas arrive chez vous (il s’agit d’un délégué), et lorsque l'argent à son restaurant.
vous = objet livreur = délégué restaurant = objet