Warten auf Abschluss-block komplett in ein AFNetworking Anfrage

Dieser arbeitet mit AFNetworking eingerichtet, die Anfragen, aber eine synchrone rufen Sie dann die Handhabung der Fertigstellung der Blöcke manuell. Sehr einfach. AFNetworking nicht scheinen, um dies zu unterstützen https://github.com/AFNetworking/AFNetworking/wiki/AFNetworking-FAQ, aber die Arbeit ist einfach genug.

#import "SimpleClient.h"

#import "AFHTTPClient.h"
#import "AFJSONRequestOperation.h"
#import "AFJSONUtilities.h"

@implementation SimpleClient

+ (void) makeRequestTo:(NSString *) urlStr
        parameters:(NSDictionary *) params
        successCallback:(void (^)(id jsonResponse)) successCallback 
        errorCallback:(void (^)(NSError * error, NSString *errorMsg)) errorCallback {

   NSURLResponse *response = nil;
   NSError *error = nil;

   NSURL *url = [NSURL URLWithString:urlStr];

   AFHTTPClient *httpClient = [[AFHTTPClient alloc] initWithBaseURL:url];

   httpClient.parameterEncoding = AFFormURLParameterEncoding;

   NSMutableURLRequest *request = [httpClient requestWithMethod:@"POST" path:[url path] parameters:params];
   NSData *data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error];

   if(error) {
      errorCallback(error, nil);
   } else {
      id JSON = AFJSONDecode(data, &error);
      successCallback(JSON);
   }
}

@end

Ich hatte gerade das gleiche problem und finden eine andere Lösung. Ich hatte zwei Operationen, die voneinander abhängen, aber laden kann, parallel. Aber der Abschluss-block der zweiten operation kann nicht ausgeführt werden, bevor der Abschluss-block der erste fertig ist.

Als Colin wies darauf hin, es könnte eine schlechte Wahl, um eine web-Anfrage blockieren. Dies war entscheidend für mich, also hab ich es asynchron.

Dies ist meine Lösung:

//This is our lock
@interface SomeController () {
    NSLock *_dataLock;
}
@end

@implementation

//This is just an example, you might as well trigger both operations in separate
//places if you get the locking right
//This might be called e.g. in awakeFromNib
- (void)someStartpoint {
    AFJSONRequestOperation *operation1 = [AFJSONRequestOperation JSONRequestOperationWithRequest:[NSURLRequest requestWithURL:url1]
                                                                                         success:^(NSURLRequest *request, NSHTTPURLResponse *response, id data) {
        //We're done, we unlock so the next operation can continue its
        //completion block
        [_dataLock unlock];
    } failure:^(NSURLRequest *request, NSHTTPURLResponse *response, NSError *error, id data) {
        //The request has failed, so we need to unlock for the next try
        [_dataLock unlock];
    }];

    AFJSONRequestOperation *operation2 = [AFJSONRequestOperation JSONRequestOperationWithRequest:[NSURLRequest requestWithURL:url2]
                                                                                         success:^(NSURLRequest *request, NSHTTPURLResponse *response, id data) {
        //The completion block (or at least the blocking part must be run in a
        //separate thread
        [NSThread detachNewThreadSelector:@selector(completionBlockOfOperation2:) toTarget:self withObject:data];
    } failure:^(NSURLRequest *request, NSHTTPURLResponse *response, NSError *error, id data) {
        //This second operation may fail without affecting the lock
    }];

    //We need to lock before both operations are started
    [_dataLock lock];

    //Order does not really matter here
    [operation2 start];
    [operation1 start];
}

- (void)completionBlockOfOperation2:(id)data {
    //We wait for the first operation to finish its completion block
    [_dataLock lock];

    //It's done, so we can continue

    //We need to unlock afterwards, so a next call to one of the operations
    //wouldn't deadlock
    [_dataLock unlock];
}

@end