Hacer que los bloques de iOS se ejecuten sincrónicamente

Question

¿Cómo puedo hacer que un bloque se ejecute sincrónicamente, o hacer que la función espere el controlador antes de la declaración de devolución, para que los datos puedan pasarse desde el bloque?

-(id)performRequest:(id)args 
{ 
__block NSData *data = nil; 

    [xyzclass requestAccessToAccountsWithType:accountType withCompletionHandler:^(BOOL granted, NSError *error) { 
     data = [NSData dataWithData:responseData]; 
    }]; 

    return data; 
} 

Answer 1

Usted puede hacer petición síncrona en otro hilo, como a continuación código

-(void)performRequest:(id)args 
{ 

NSURLResponse *response = nil; 
NSError *error = nil; 
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url]; 
data = [NSURLConnection sendSynchronousRequest:request returningResponse:&response error:&error]; 
} 

De hilo principal se puede llamar a este

[self performSelectorInBackground:@selector(performRequest:) withObject:args]; 

o de lo que puede hacer solicitud asincrónica utilizando siguiente método

[NSURLConnection alloc]initWithRequest:request delegate:self]; 

e implementar métodos de delegado para NSURLConnection

Answer 2

¿Seguro que quieres hacerlo de forma síncrona? en caso afirmativo, puede llamar al (o poner) la función de controlador en su bloque o utilización del conocimiento de Jignesh (y utiliza “performSelectorInMainThread” cuando se acaba su manejador y desea devolver valores.

la manera asíncrona es (un poco poco) más difícil, pero mejor como:. - te obliga a escribir código limpio (sin paso de las variables convenientes) - se puede ejecutar otra cosa por lo que los usuarios no van a esperar y pensar que su aplicación es lenta

se realmente debería darle dos o tres horas para ir asincrónico. Pequeño dolor para una ganancia completa. También puede echarle un vistazo a Observación de valores-clave

Answer 3

Puede hacer esto.

-(id)performRequest:(id)args 
{ 
__block NSData *data = nil; 

[xyzclass performRequestWithHandler:^(NSData *responseData, NSHTTPURLResponse   *urlResponse, NSError *error) { 

    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),^{ 

    data = [NSData dataWithData:responseData]; 

    }); 

}]; 

return data; 
} 

Answer 4

Se podía añadir un método que procesa los datos devueltos y llamas que, en su bloque:

-(void)performRequest:(id)args{ 
    __block NSData *data = nil; 

    [xyzclass requestAccessToAccountsWithType:accountType withCompletionHandler:^(BOOL granted, NSError *error) { 
     data = [NSData dataWithData:responseData]; 
     [self processData:data]; //method does something with the data 
    }]; 
} 

Answer 5

asíncrono es casi siempre mejor. pero si quieres sincrónica:

-(id)performRequest:(id)args 
{ 
__block NSData *data = nil; 

    [xyzclass requestAccessToAccountsWithType:accountType withCompletionHandler:^(BOOL granted, NSError *error) { 
     data = [NSData dataWithData:responseData]; 
    }]; 

    while(!data) { 
     [[NSRunLoop currentRunLoop] runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.1]]; 
    } 
    return data; 
} 

---

responsabilidad: CocoaCouchDeveloper dice que, por supuesto, esto sólo funcionará si el bloque de terminación y la runloop están en el mismo hilo. Supuse que porque muchos (la mayoría) de los manejadores de COMPLECIÓN sé que funcionan de esa manera, pero que son válidos en principio.

La anterior no es seguro para subprocesos uso
un semáforo o algo tal vez.
también dije que no promuevo esto

Answer 6

Puede usar semáforos en este caso.

-(id)performRequest:(id)args 
{ 
    __block NSData *data = nil; 
    dispatch_semaphore_t sem = dispatch_semaphore_create(0); 
    [xyzclass requestAccessToAccountsWithType:accountType withCompletionHandler:^(BOOL granted, NSError *error) { 
     data = [NSData dataWithData:responseData]; 
     dispatch_semaphore_signal(sem); 
    }]; 
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER); 
    return data; 
} 

semáforo bloqueará la ejecución de otras declaraciones hasta que se recibe la señal, esto va a asegurarse de que su función no devuelve prematuramente.