it-swarm.com.de

was ist der Unterschied zwischen Delegieren und Benachrichtigung?

was ist der Unterschied zwischen Delegieren und Benachrichtigung?

ich verstand wie Delegierter und Protokoll,

@protocol classADelegate

-(void)DelegateMethod;


@end



classB <classADelegate>{

   classA *ObjOfclassA=[[classA alloc]init];

    ObjOfclassA.delegate=self;

//while Push later, here we have taken the pointer of classB(self) to classA and stored in delegate variable of classA. so from classA we can call the function in classB

   Push:classA from here.


   -(void)DelegateMethod{

        nslog(@"i am rithik from India");


     }

}


classA{

   id <classADelegate> delegate;

   -(void)viewdidload{

        [self.delegate DelegateMethod];

    }

}

Mein Zweifel ist

1 warum verwenden wir nicht in classA so

classA{

**classB** <classADelegate> delegate;


[self.delegate DelegateMethod];

}

was ist der Grund für die Verwendung von " id " und worin besteht der Unterschied?

2 Wir haben die Methode der DelegateMethod-Funktion der Klasse B aufgerufen, die aus der Protokolldefinition stammt.

stattdessen können wir diese Methode direkt aufrufen, indem wir die Instanzmethode von classB definieren. Denn wir haben den Zeiger für classB in der Delegatenvariablen von classA.

so was.

classB{

-(void)DelegateMethod;

}

und dann rufen Sie diese in

classA{

       classB delegate;

       -(void)viewdidload{

            [self.delegate DelegateMethod];

        }

    }

also aus dem oben genannten haben wir das Protokoll und die ID-Variable vermieden .

aber ich wusste, dass viele von uns delegieren und protokollieren. hier habe ich die vorteile von delegate und protocol kennengelernt

hier ist die Verwendung der Protokollimplementierung für die Methode der DelegateMethod-Funktion.

stattdessen Instanzdefinition.

was ist die Verwendung von denen von @protocol.

bitte irgendjemand führt mich in die richtige Richtung ...

ich bin neu in der iPhone-Entwicklung.

im Moment wusste ich, wie man einen Delegaten erstellt, aber als ich kam, um über die NSNotification zu lernen

das ist auch der fast richtige job wie delegieren.

also wann soll ich das delgate oder die nsnotification benutzen.

Danke

19
rithik

Kurze Antwort: Sie können sich die Delegierten wie ein Telefongespräch vorstellen. Sie rufen Ihren Kumpel an und möchten ausdrücklich mit ihnen sprechen. Sie können etwas sagen und sie können antworten. Sie können sprechen, bis Sie den Hörer auflegen. Delegaten erstellen auf ähnliche Weise eine Verknüpfung zwischen zwei Objekten, und Sie müssen nicht wissen, um welchen Typ es sich bei dem Delegierten handelt. Er muss lediglich das Protokoll implementieren. Auf der anderen Seite sind NS-Benachrichtigungen wie ein Radiosender. Sie senden ihre Botschaft an jeden, der zuhören möchte. Der Radiosender kann keine Rückmeldungen von seinen Zuhörern empfangen (es sei denn, er hat ein Telefon oder einen Delegierten). Die Hörer können die Nachricht ignorieren oder damit etwas anfangen. NS-Benachrichtigungen ermöglichen es Ihnen, eine Nachricht an beliebige Objekte zu senden, aber Sie haben keine Verbindung zwischen ihnen, um hin und her zu kommunizieren. Wenn Sie diese Kommunikation benötigen, sollten Sie wahrscheinlich einen Delegierten implementieren. Ansonsten sind NS-Benachrichtigungen einfacher und benutzerfreundlicher, können jedoch zu Problemen führen.

Lange Antwort:

Delegierte sind in der Regel eine angemessenere Methode für den Umgang mit Dingen, insbesondere wenn Sie ein Framework erstellen, das andere Personen verwenden können. Wenn Sie Protokolle mit Ihren Delegierten verwenden, erhalten Sie die Möglichkeit, die Kompilierzeit auf erforderliche Methoden zu überprüfen, sodass Sie beim Kompilieren wissen, ob erforderliche Methoden fehlen. Mit dem NSNotificationCenter haben Sie keine solche Garantie.

NSNotificationCenter ist eine Art von "hack-ish" und wird häufig von unerfahrenen Programmierern verwendet, die can zu einer schlechten Architektur führen können. Oft sind diese beiden Funktionen austauschbar, aber mehr "Hardcore" -Entwickler könnten sich über die Verwendung des NSNotificationCenter lustig machen.


Q: was ist der Grund für die Verwendung von "id" und was ist der Unterschied zwischen ihnen?

A: Mit id können Sie jedes Objekt als Parameter an die Methode senden. Beachten Sie, dass Sie keine primitiven Elemente wie Bools, Floats, Doubles, Ints usw. senden können, es sei denn, sie sind in ihren jeweiligen Object-Wrappern verpackt.


classB{

-(void)DelegateMethod;

}

und dann rufen Sie das an

classA{

   classB delegate;

   -(void)viewdidload{

        [self.delegate DelegateMethod];

    }

}

Das obige Beispiel, das Sie angegeben haben, würde erfordern, dass der Delegierte von classA immer vom Typ classB ist, was nicht vorteilhaft ist. Anstelle der Verwendung von Delegaten in diesem Szenario würden Sie wahrscheinlich nur eine Variable verwenden, die auf Ihre andere Klasse verweist, beispielsweise myClassB. Das Schöne an Delegaten ist, dass Sie jedes Objekt übergeben können und der Code funktioniert, solange er die erforderlichen Methoden implementiert (die der Compiler sicherstellt, solange er als der richtige Delegatetyp markiert ist).

105
FreeAsInBeer

Ein Delegat verwendet Protokolle und erstellt eine has-a-Beziehung zwischen den beiden Klassen. Ein weiterer Vorteil von Delegierten ist, dass Sie etwas an die Klasse zurückgeben können, die sie besitzt.

Auf der anderen Seite sind Benachrichtigungen eher auf Punkt-zu-Mehrpunkt-Kommunikation ausgerichtet. Ein Beispiel für die Verwendung einer NSNotification kann in einer Steuerelementanwendung für eine Registerkartenleiste enthalten sein, in der Sie möglicherweise mehrere Ansichtssteuerungen über ein bestimmtes Ereignis benachrichtigen müssen, damit sie Daten usw. aktualisieren können. Dies ist besonders für Klassen geeignet, die sich untereinander nicht kennen würde keinen Sinn machen, wenn sie es tun würden.

Nun zu deinen anderen Fragen:

Warum benutzen wir id?
In Ihrer Klasse möchten Sie ein Handle für ein Objekt mit unbestimmten type , das jedoch das von Ihnen definierte Protokoll implementiert. Nehmen Sie zum Beispiel UIWebView. Es können unendlich viele Arten von Klassen vorhanden sein, die ein Delegat sein können. Daher sollte es keinen bestimmten Klassentyp angeben, sondern angeben, dass die Klasse das Protokoll UIWebViewDelegate implementieren muss. Dies reduziert die Kopplung auf ein absolutes Minimum und erstellt eine äußerst zusammenhängende Anwendung, bei der Sie Interaktionen auf der Basis von behaviour , nicht state erstellen.

Gehen wir also ein Beispiel durch:

@protocol ClassADelegate
- (NSString*) determineValue;
@end

@interface ClassA : NSObject
{
    id<ClassADelegate> delegate;
}
//  Make sure you are using assign, not retain or copy
@property (nonatomic, assign) id<ClassADelegate> delegate;

@end

Die Implementierung von ClassA:

import "ClassA.h"

@implementation ClassA
@synthesize delegate;

- (void) somePrivateMethod
{
    if (self.delegate && [self.delegate implementsProtocol:@protocol(ClassADelegate)])
    {
        NSString* value = [self.delegate determineValue];

        // Do other work
    }
}

- (void) dealloc
{
    delegate = nil;
}

@end

Im Header erklären wir, dass die Klasse das ClassADelegate-Protokoll implementiert:

#import "ClassA.h"

@interface ClassB : NSObject <ClassADelegate>
{
}

- (void) someMethod;

@end

In der Implementierung von ClassB erstellen wir eine Instanz von ClassA und setzen B als Delegat von A:

#import "ClassB.h"
@implementation ClassB

- (void) someMethod
{
    ClassA* aClass = [[ClassA alloc] init];

    aClass.delegate = self;

   // Other work and memory clean up of A.
   // Some logic occurs in A where it calls the delegate (self) which will 
   // call the `determineValue` method of this class.
}

//  Here's the delegate method we implement
- (NSString*) determineValue
{
    return @"I did some work!";
}

@end
13
Wayne Hartman

Delegat übergibt Nachricht von einem Objekt an ein anderes Objekt. Es ist wie eine 1: 1-Kommunikation, während nsnotification eine Nachricht an mehrere Objekte gleichzeitig weitergibt. Alle anderen Objekte, die diese Benachrichtigung abonniert haben, oder diese Beobachter handelnde Beobachter können auf dieses Ereignis nicht reagieren. Benachrichtigungen sind einfacher, aber Sie können in Schwierigkeiten geraten, wenn Sie beispielsweise schlechte Architektur verwenden. Delegierte werden häufiger verwendet und mit Hilfe von Protokollen verwendet.

3
Aman Pathak

Wir können Benachrichtigungen aus verschiedenen Gründen verwenden. Zum Beispiel Sie könnten eine Benachrichtigung senden, um zu ändern, wie Elemente der Benutzeroberfläche Informationen anzeigen, die auf einem bestimmten Ereignis an anderer Stelle im Programm basieren. Sie können auch Benachrichtigungen verwenden, um sicherzustellen, dass Objekte in einem Dokument ihren Status speichern, bevor das Dokumentfenster geschlossen wird. 

Der allgemeine Zweck von Benachrichtigungen besteht darin, andere Objekte über Programmereignisse zu informieren, damit diese angemessen reagieren können. Aber Objekte, die Benachrichtigungen erhalten, können nur reagieren, nachdem das Ereignis eingetreten ist. Dies ist ein wesentlicher Unterschied zur Delegation. 

Der Delegierte hat die Möglichkeit, die vom delegierenden Objekt vorgeschlagene Operation abzulehnen oder zu ändern. Das Beobachten von Objekten hingegen kann einen bevorstehenden Vorgang nicht direkt beeinflussen.

0

Wir können einfach sagen:

Delegierte:

Eins zu eins

Benachrichtigung:

Eins-zu-Viele

Delegierte zu erklären

@protocol DelegateName
@required
- (void)method:(NSString *)param;
@optional
- (void)methodOptional:(NSString *)param;
@end

Und eine Eigenschaft für Protocol deklarieren

@property id <DelegateName> delegate;

Sie können verwenden

myObject.delegate = <# some object conforming to DelegateName #>;

NS-Benachrichtigungserklärung

[[NSNotificationCenter defaultCenter] addObserver:self
                                         selector:@selector(notificationHappened:)
                                             name:MyCustomNotificationName
                                           object:nil];

Dann implementieren

- (void)notificationHappened:(NSNotification *)notification {
    // do work here
}

Sie können Benachrichtigungen von überall aus posten, indem Sie

[[NSNotificationCenter defaultCenter] postNotificationName:MyCustomNotificationName
                                                    object:self
                                                  userInfo:nil];

rufen Sie removeObserver: auf, wenn Sie fertig sind.

0
Lal Krishna