Bekijk bij twijfel de docs!
Kortom, delegatie is een manier om objecten met elkaar te laten communiceren zonder dat er sterke onderlinge afhankelijkheden ontstaan, aangezien dit het ontwerp van uw toepassing minder flexibel maakt. In plaats van dat objecten elkaar besturen, kunnen ze een afgevaardigde hebben naar wie ze berichten sturen (of delegeren), en de afgevaardigde doet wat ze doen, om op dit bericht te reageren en ernaar te handelen, en dan meestal iets terug te sturen naar het andere object .
Delegeren is ook een beter alternatief voor subclassificatie. In plaats van dat u uw eigen aangepaste klassen moet maken om de manier waarop andere objecten zich gedragen enigszins te veranderen, of om ze gegevens door te geven, stelt delegatie objecten in staat berichten naar hun gemachtigden te sturen om werk voor hen te doen zonder de overhead van het maken van subklassen om kleine wijzigingen aan te brengen in andere objecten.
Natuurlijk is het grootste nadeel van delegatie dat de beschikbare methoden voor gedelegeerden afhankelijk zijn van wat de Apple-technici als nuttig beschouwen en welke algemene implementaties ze verwachten dat mensen nodig hebben, wat een beperking oplegt aan wat je kunt bereiken. Hoewel, zoals Quinn Taylor opmerkte, dit specifiek is voor de Cocoa-frameworks en dus niet in alle situaties van toepassing is.
Als delegatie een optie is boven subklassen, neem het dan, want het is een veel schonere manier om uw code en interacties tussen objecten te beheren.
Antwoord 1, autoriteit 100%
Zoals hierboven beschreven, is een gedelegeerde geen functie van iOS of Objective-C, maar slechts een programmeertechniek en vereist geen specifieke taalondersteuning.
Een klasse (bijv. classA) kan zo worden geschreven dat de methoden getDataen doSomethingniet alleen kunnen worden geïmplementeerd, maar door een gemachtigde (misschien omdat classA weet niet wat de gegevens zullen zijn of wat het moet doen).
Om dit te bereiken biedt classA een eigenschap, gewoonlijk delegategenaamd, (die slechts een verwijzing is naar de klasse – de gedelegeerde – die de gedelegeerde methoden implementeert) en vervolgens, wanneer het wil aanroepen die methoden, roept het eigenlijk de methoden in de gedelegeerde aan:
[self.delegate getData];
en
[self.delegate doSomething];
self.delegatekan aanvankelijk worden ingesteld op self:
self.delegate = self;
d.w.z. classA implementeert zijn eigen versie van deze methoden, tenzij ze gedelegeerd zijn.
Elke andere klasse die de uitvoerder van de methoden wil zijn (d.w.z. de gedelegeerde wil zijn en mogelijk de standaardimplementatie van klasseA wil overschrijven), zou eerst de gedelegeerde van klasseA als zichzelf instellen. dus als classB de afgevaardigde voor deze methoden zou willen zijn, in classB, zouden we hebben:
classA.delegate = self;
Dus als classA deze gedelegeerde methoden aanroept, roept het eigenlijk classB aan om deze methoden te implementeren, zonder iets te weten over classB of zelfs maar dat het bestaat en classB classA niet hoeft te subklassen.
De beperking is dat klasseB alleen methoden kan overschrijven die klasseA wil delegeren – met subklassen kunt u elke methode overschrijven.
Protocollenworden gebruikt om het delegatieproces te formaliseren door een lijst met methoden te definiëren die ofwel moetenworden geïmplementeerd door de gedelegeerde (de delegator geeft geen standaardversie van de methode en de methode moet ergens worden geïmplementeerd) of kan optioneel worden geïmplementeerd door de gemachtigde (dwz de delegator heeft zijn eigen versie of het maakt niet uit of de methode niet is geïmplementeerd).
Antwoord 2, autoriteit 55%
Afgevaardigden zijn een ontwerppatroon; er is geen speciale syntaxis of taalondersteuning.
Een gemachtigde is slechts een object waarnaar een ander object berichten verzendt wanneer bepaalde dingen gebeuren, zodat de gemachtigde app-specifieke details kan verwerken waarvoor het oorspronkelijke object niet is ontworpen. Het is een manier om gedrag aan te passen zonder subclassificatie.
Antwoord 3, autoriteit 18%
Ik probeer het uit te werken met een eenvoudig programma
Twee klassen
Student.h
#import <Foundation/Foundation.h>
@interface Student : NSObject
@property (weak) id delegate;
- (void) studentInfo;
@end
Student.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
Leraar.h
#import <Foundation/Foundation.h>
#import "Student.h>
@interface Teacher: NSObject
@property (strong,nonatomic) Student *student;
- (NSString *) teacherName;
- (id) initWithStudent:(Student *)student;
@end
Teacher.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
hoofd.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;
}
UITLEG :::
-
Van de hoofdmethode wanneer initWithStudent:student wordt uitgevoerd
1.1 De eigenschap ‘student’ van het object van de leraar wordt toegewezen aan het object van de student.
1.2 zelf.student.delegate = zelf
betekent dat de afgevaardigde van het leerlingobject wijst naar het docentobject -
Van hoofdmethode wanneer [student studentInfo] wordt aangeroepen
2.1 [self.delegate respondToSelector:@selector(teacherName)] Hier al gedelegeerd
verwijst naar het leraar-object zodat het de instantiemethode ‘teacherName’ kan aanroepen.2.2 dus [self.delegate performSelector:@selector(teacherName)]
zal gemakkelijk worden uitgevoerd.
Het lijkt erop dat het Leraar-object de gedelegeerde aan het leerling-object toewijst om zijn eigen methode aan te roepen.
Het is een relatief idee, waarbij we dat leerlingobject met de naam ‘teacherName’-methode zien, maar het wordt in feite gedaan door het docentobject zelf.
Antwoord 4
Stel je voor dat je belt en een pizza bestelt.
Dan komt er een pizzabezorger bij je thuis (dit is een afgevaardigde), en wanneer?
jij betaalt voor de pizza, de bezorger van pizza geeft het geld terug aan zijn restaurant.
jij = object bezorger = afgevaardigde restaurant = object