pantalla - recuperar notificaciones iphone

¿Cuál es la diferencia entre Delegado y Notificación?

Question

¿Cuál es la diferencia entre Delegado y Notificación?

Entendí como delegado y protocolo,

@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];

    }

}

Mi duda es

1 ¿Por qué no usamos en clase A de esta manera?

classA{

**classB** <classADelegate> delegate;


[self.delegate DelegateMethod];

}

¿Cuál es la razón para usar " id " y cuál es la diferencia entre ellos?

2 hemos llamado al método de la función DelegateMethod de classB que proviene de la definición del protocolo.

en su lugar, podemos llamar directamente a ese método definiendo ese método de instancia de classB. porque tenemos el puntero para el classB en la variable delegada de classA.

Me gusta esto.

classB{

-(void)DelegateMethod;

}

y luego llama a esto

classA{

       classB delegate;

       -(void)viewdidload{

            [self.delegate DelegateMethod];

        }

    }

así que de lo anterior hemos evitado el protocolo y la variable id .

pero sabía que muchos de nosotros usamos delegado y protocolo. Aquí llegué a conocer cualquier ventaja al usar delegado y protocolo

aquí, ¿cuál es el uso de la implementación del protocolo para el método de la función DelegateMethod?

En su lugar, instancia definición.

¿Cuál es el uso de esos por @protocol.

por favor que alguien me guíe en la dirección correcta ...

Soy nuevo en el desarrollo de iPhone.

En este momento supe cómo crear delegado. Pero mientras vine a estudiar sobre la NSNotificación

Eso también es hacer el trabajo casi correcto como delegado.

así que cuando debo usar el delgate o NSnotification.

Gracias

Answer 1

El delegado está pasando el mensaje de un objeto a otro objeto. Es como una comunicación uno a uno, mientras que la notificación es como pasar un mensaje a varios objetos al mismo tiempo. Todos los demás objetos que se hayan suscrito a esa notificación u observadores activos de esa notificación pueden o no pueden responder a ese evento. Las notificaciones son más fáciles, pero puede meterse en problemas al usar arquitectura como la mala. Los delegados se usan con más frecuencia y se usan con ayuda de protocolos.

Answer 2

Podemos usar notificaciones por una variedad de razones. Por ejemplo , podría transmitir una notificación para cambiar la forma en que los elementos de la interfaz de usuario muestran la información en función de un evento determinado en otra parte del programa. O puede usar las notificaciones como una forma de asegurarse de que los objetos en un documento guarden su estado antes de que se cierre la ventana del documento.

El propósito general de las notificaciones es informar a otros objetos de eventos del programa para que puedan responder adecuadamente. Pero los objetos que reciben notificaciones pueden reaccionar solo después de que haya ocurrido el evento. Esta es una diferencia significativa de delegación.

El delegado tiene la oportunidad de rechazar o modificar la operación propuesta por el objeto delegante. Observar objetos, por otro lado, no puede afectar directamente una operación inminente.

Answer 3

Simplemente podemos decir,

Delegados:

Doce y cincuenta y nueve de la noche

Notificación:

Uno a muchos

Declarar delegado

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

Y declarar una propiedad para protocolo.

@property id <DelegateName> delegate;

Puedes usar

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

Declaración de NSNotification

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

Entonces implementa

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

Puedes publicar notificaciones desde cualquier lugar usando,

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

llame a removeObserver: cuando haya terminado.

Answer 4

Un delegado usa protocolos y crea una relación de has-a entre las dos clases. Uno de los otros beneficios de los delegados es que puede devolver algo a la clase propietaria.

Las notificaciones, por otro lado, están más orientadas hacia la comunicación punto a multipunto. Un ejemplo de uso de una NSNotification podría estar en una aplicación de controlador de la barra de pestañas, donde es posible que deba notificar a varios controladores de vista de un evento en particular para que puedan actualizar los datos, etc. Esto es ideal para las clases que no se conocen entre sí y No tendría sentido si lo hicieran.

Ahora, a tus otras preguntas:

¿Por qué usamos id ?
En su clase, desea un identificador para un objeto de tipo indeterminado, pero que implementa el protocolo que define. Tome UIWebView , por ejemplo. Puede haber tipos infinitesimales de clases que pueden ser un delegado para él, por lo tanto, no debe nombrar un tipo específico de clase, sino especificar que la clase debe implementar el protocolo UIWebViewDelegate . Esto reduce el acoplamiento a un mínimo absoluto y crea una aplicación altamente cohesiva donde se crea una interacción basada en el comportamiento , no en el estado.

Entonces, veamos un ejemplo:

@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

La implementación de 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

En el encabezado, declaramos que la clase implementará el protocolo ClassADelegate :

#import "ClassA.h"

@interface ClassB : NSObject <ClassADelegate>
{
}

- (void) someMethod;

@end

En la implementación de ClassB creamos una instancia de ClassA y establecemos B como el delegado de 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

Answer 5

Respuesta corta: Puede pensar en los delegados como en una llamada telefónica. Llamas a tu amigo y específicamente quieres hablar con ellos. Puedes decir algo, y ellos pueden responder. Puedes hablar hasta que cuelgues el teléfono. Los delegados, de la misma manera, crean un enlace entre dos objetos, y no es necesario saber qué tipo de delegado será, simplemente tiene que implementar el protocolo. Por otro lado, las notificaciones NS son como una estación de radio. Transmiten su mensaje a quien quiera escuchar. La estación de radio no puede recibir comentarios de sus oyentes (a menos que tenga un teléfono o un delegado). Los oyentes pueden ignorar el mensaje, o pueden hacer algo con él. NSNotifications le permite enviar un mensaje a cualquier objeto, pero no tendrá un enlace entre ellos para comunicarse de un lado a otro. Si necesita esta comunicación, probablemente debería implementar un delegado. De lo contrario, las NSNotifications son más simples y fáciles de usar, pero pueden causarle problemas.

Respuesta larga:

Los delegados suelen ser una forma más adecuada de manejar las cosas, especialmente si está creando un marco para que otros puedan usar. Gana tiempo de compilación para verificar los métodos requeridos cuando usas protocolos con tus delegados, de modo que sabes cuándo compilas si te falta algún método requerido. Con NSNotificationCenter usted no tiene dicha garantía.

NSNotificationCenter es una especie de "hack-ish" y se usa frecuentemente en programadores novatos que pueden llevar a una arquitectura pobre. Muchas veces estas dos características son intercambiables, pero los desarrolladores más "hardcore" pueden burlarse del uso del NSNotificationCenter.

P: ¿Cuál es la razón para usar "id" y cuál es la diferencia de ellos?

R: Usar id permite enviar cualquier objeto al método como un parámetro. Tenga en cuenta que no puede enviar primitivas como bools, flotadores, dobles, ints, etc. a menos que estén envueltos en sus respectivos envoltorios de objetos.

classB{

-(void)DelegateMethod;

}

y luego llama a esto

classA{

   classB delegate;

   -(void)viewdidload{

        [self.delegate DelegateMethod];

    }

}

El ejemplo anterior que proporcionó requeriría que el delegado de classB siempre sea del tipo classB , lo que no es ventajoso. En lugar de utilizar delegados en este escenario, probablemente solo use una variable que se refiera a su otra clase, por ejemplo, myClassB . La belleza de los delegados es que puede pasar alrededor de cualquier objeto, y el código simplemente funciona siempre y cuando implementen los métodos necesarios (que el compilador garantiza, siempre y cuando esté marcado como el tipo de delegado correcto).