Différence entre le gestionnaire d'achèvement et les blocs: [iOS]

Je suis sali avec à la fois gestionnaire d'achèvement et bloque alors que je les utilise dans Swift et Objective-C. Et quand je suis à la recherche de blocs dans Swift sur google c'est de montrer le résultat pour le gestionnaire d'achèvement! Quelqu'un peut-il me dire quelle est la différence entre le gestionnaire d'achèvement et de blocs à l'égard de Swift et Objective-C ?

source d'informationauteur shubham mishra

19

Ici, vous pouvez facilement différencier entre les blocs et l'achèvement des gestionnaires en fait les deux sont des blocs de voir détail ci-dessous.

Blocs:

Blocs sont une langue niveau fonctionnalité ajoutée à C, Objective-C et C++, qui vous permettent de créer des segments de code qui peuvent être passés à des méthodes ou des fonctions comme s'ils étaient des valeurs. Les blocs sont en Objective-C des objets, ce qui signifie qu'ils peuvent être ajoutés aux collections comme NSArray ou NSDictionary.
- Ils peuvent être exécutées dans un temps plus tard, et non pas lorsque le code de la
  ils ont été mises en œuvre est en cours d'exécution.
- Leur utilisation conduit finalement à une présentation plus claire et plus propre code
  l'écriture, car ils peuvent être utilisés à la place de délégué méthodes, écrit
  en un seul endroit et ne pas s'étendre à de nombreux fichiers.
Syntaxe: ReturnType (^blockName)(Paramètres) voir l'exemple:
```
int anInteger = 42;

void (^testBlock)(void) = ^{

    NSLog(@"Integer is: %i", anInteger);   //anInteger outside variables

};

//calling blocks like
testBlock();
```
Bloc avec l'argument:
```
double (^multiplyTwoValues)(double, double) =

                          ^(double firstValue, double secondValue) {

                              return firstValue * secondValue;

                          };
//calling with parameter
double result = multiplyTwoValues(2,4);

NSLog(@"The result is %f", result);
```
Gestionnaire d'achèvement:

Alors que gestionnaire d'achèvement est une façon (la technique) pour la mise en œuvre de fonctionnalités de rappel à l'aide de blocs.

Un gestionnaire d'achèvement n'est rien de plus qu'un simple bloc de déclaration transmis comme paramètre à une méthode qui a besoin de faire un rappel à une date ultérieure.

Remarque: gestionnaire d'achèvement doit toujours être le dernier paramètre d'une méthode. Une méthode peut avoir autant d'arguments que vous voulez, mais toujours le gestionnaire d'achèvement comme le dernier argument dans la liste des paramètres.

Exemple:
```
- (void)beginTaskWithName:(NSString *)name completion:(void(^)(void))callback;

//calling
[self beginTaskWithName:@"MyTask" completion:^{

    NSLog(@"Task completed ..");

}];
```
Plus exemple avec UIKit classes de méthodes.
```
[self presentViewController:viewController animated:YES completion:^{
        NSLog(@"xyz View Controller presented ..");

        //Other code related to view controller presentation...
    }];
```
```
[UIView animateWithDuration:0.5
                     animations:^{
                         //Animation-related code here...
                         [self.view setAlpha:0.5];
                     }
                     completion:^(BOOL finished) {
                         //Any completion handler related code here...

                         NSLog(@"Animation over..");
                     }];
```
6

En bref : l'Achèvement des gestionnaires sont une manière de mettre en œuvre les fonctionnalités de rappel à l'aide de blocs ou de fermetures. Les blocs et les Fermetures sont des morceaux de code qui peuvent être passés à des méthodes ou des fonctions comme s'ils étaient des valeurs (en d'autres termes, "les fonctions anonymes" qui on peut donner des noms à et se faire passer).
5

Blocs: Obj-c
```
- (void)hardProcessingWithString:(NSString *)input withCompletion:(void (^)(NSString *result))block;

[object hardProcessingWithString:@"commands" withCompletion:^(NSString *result){
    NSLog(result);
}];
```
Fermetures: Swift
```
func hardProcessingWithString(input: String, completion: (result: String) -> Void) {
    ...
    completion("we finished!")
}
```
La achèvement de fermeture icipar exemple, est seulement une fonction qui prend en argument la chaîne et renvoie void.

Fermetures sont autonomes blocs de fonctionnalités qui peuvent être transmis
et utilisé dans votre code. Fermetures de Swift sont semblables à des blocs
en C et Objective-C et à des lambdas dans d'autres langages de programmation.

https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Closures.html

Fermetures
sont des objets de première classe, de sorte qu'ils peuvent être imbriquées et passé autour
(comme le font les blocs en Objective-C). En Swift, les fonctions sont juste un spécial
cas de fermeture.

Je suis espérons que cela aidera.

Première Étape:

#import <UIKit/UIKit.h>

@interface ViewController : UIViewController


-(void)InsertUser:(NSString*)userName InsertUserLastName:(NSString*)lastName  widthCompletion:(void(^)(NSString* result))callback;

@end

Deuxième Étape :

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

-(void)InsertUser:(NSString *)userName InsertUserLastName:(NSString*)lastName widthCompletion:(void (^)(NSString* result))callback{

    callback(@"User inserted successfully");

}
- (void)viewDidLoad {
    [super viewDidLoad];
    //Do any additional setup after loading the view, typically from a nib.

    [self InsertUser:@"Ded" InsertUserLastName:@"Moroz" widthCompletion:^(NSString *result) {

        NSLog(@"Result:%@",result);

    }];

}


- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    //Dispose of any resources that can be recreated.
}


@end

Vous devez vous connecter pour publier un commentaire.