come utilizzare blocco/chiusura in swift

Question

In una delle mie app ho utilizzato il blocco per le chiamate al servizio web e ottenere risposta. Ora voglio scrivere questa app in modo rapido, ma sto riscontrando problemi nell'usare i blocchi/Chiusura in Swift. Ecco il mio codice C obiettivo che voglio migrare a Swift: -

// chiamando un metodo di classe di Communicator

[[Communicator sharedInstance]callWebService:WS_LOGIN withMethod:POST_METHOD andParams:params showLoader:YES completionBlockSuccess:^(id obj) { 
    //Do play with data 
}completionBlockFailiure:^(id obj) { 
    //Show alert with error 
}]; 

// in classe comunicatore

-(void)callWebService:(NSString *)serviceName withMethod:(NSString *)methodName andParams:(NSDictionary *)params showLoader:(BOOL)showLoader completionBlockSuccess:(void (^)(id))aBlock completionBlockFailiure:(void (^)(id))aFailBlock 
{ 
    if (showLoader) { 
    // show loader 
    } 
    [self performRequestWithServiceName:serviceName method:methodName andParams:params successblock:aBlock failureblock:aFailBlock]; 
} 

- (void)performRequestWithServiceName:(NSString *)serviceName method:(NSString*)methodName andParams:(NSDictionary*)params 
       successblock:(void (^)(id obj))successBlock 
       failureblock:(void (^)(id obj))failBlock { 
    if(callSuceess){ 
     successBlock(@"Success"); 
    }else{ 
     successBlock(nil); 
    } 
} 

Può uno aiutami ?

Qualsiasi aiuto su questo sarà apprezzato.

Grazie in anticipo.

Answer 1

Per Swift. Utilizzare AnyObject per il tipo di oggetto idjc.

func callWebservice (serviceName: String, withMethod method: String, andParams params: NSDictionary, showLoader loader: Bool, completionBlockSuccess aBlock: ((AnyObject) -> Void), andFailureBlock failBlock: ((AnyObject) -> Void)) { 
    if loader { 
     // Show loader 
    } 

    performRequestWithServiceName(serviceName, method: method, andParams: params, success: aBlock, failure: failBlock) 
} 

func performRequestWithServiceName(serviceName: String, method methodName: String, andParams params: NSDictionary, success successBlock: ((AnyObject) -> Void), failure failureBlock: ((AnyObject) -> Void)) { 
    if callSuceess { 
     successBlock("Success") 
    }else { 
     successBlock(nil) 
    } 
} 

AGGIORNAMENTO: Un esempio quando si desidera chiamare web service. Vedere codice qui sotto

callWebservice("your-service-name", withMethod: "your-method", andParams: ["your-dic-key": "your dict value"], showLoader: true/*or false*/, completionBlockSuccess: { (success) -> Void in 
    // your successful handle 
}) { (failure) -> Void in 
    // your failure handle 
} 

Answer 2

Per Swift Closures dobbiamo usare() ->()

Ad esempio:

func yourFunction(success: (response: AnyObject!) -> Void, failure: (error: NSError?) -> Void) { 

} 

si può chiamare come:

yourFunction({(response) -> Void in 
    // Success 
}) { (error) -> Void in 
    // Handle Errors 
} 

Spero che vi aiuterà a crea chiusure con le tue esigenze.

Answer 3

Il codice potrebbe essere simile a questo:

func callWebService(serviceName: String, method: String, params: [String : AnyObject], showLoader: Bool, success: (responseObject: AnyObject) -> Void, failure: (responseObject: AnyObject) -> Void) { 
    if showLoader { 
     // show loader 
    } 

    performRequest(serviceName, method: method, params: params, success: success, failure: failure) 
} 

func performRequest(serviceName: String, method: String, params: [String : AnyObject], success: (responseObject: AnyObject) -> Void, failure: (responseObject: AnyObject) -> Void) { 

} 

ho sostituito con NSDictionary[String : AnyObject]. Se è possibile sostituire uno qualsiasi degli usi di AnyObject con tipi più specifici, il codice sarà più pulito e più stabile.

Answer 4

Nella classe comunicatore il metodo che CALS il webservice sarebbe definito qualcosa di simile a seconda del tipo di oggetto che si desidera tornare

func performRequest(serviceName: NSString, methodName: NSString,paramaters:NSDictionary, successblock: (String)->(), failureBlock:() ->()) { 
    if(callSuccess) { 
     successblock("Success") 
    } else { 
     failureBlock() 
} 

Definiamo i tipi di successo e fallimento blocchi con le loro firme di funzione nel caso sopra, il successo è definito come un metodo che accetta una stringa come parametro di input e non restituisce nulla, quindi possiamo chiamare successBlock passando in una stringa. Il blocco di errore è definito sopra come un blocco che non accetta parametri e non restituisce nulla.

richiamarlo

func callWebService(serviceName: NSString, method: NSString and parameters: NSDictionary, showLoader: Bool, completionBlockSuccess:(String) ->(), completionBlockFailiure:() ->()) { 
    if (showLoader) { 
    // show loader 
    } 
    performRequest(serviceName: serviceName, methodName: method, parameters, successBlock:completionBlockSuccess, failureBlock: completionBlockFailiure) 
} 

fine di chiamare questa

Communicator.sharedInstance().callWebService(serviceName: WS_LOGIN , method: POST_METHOD and parameters: params, showLoader: true, completionBlockSuccess:{ returnedString in 

    //Do play with data 

}, completionBlockFailiure:{ 

    //Show alert with error 

}) 

Per il blocco completamento definiamo un returnedString variabile per consentire di manipolare il parametro di ingresso (nell'esempio precedente sarebbe essere la stringa "Success").Presumo che i tuoi dati non stiano semplicemente restituendo una stringa, quindi probabilmente dovrai giocare con loro a seconda di cosa restituirà il servizio.

Anche qui ho provato ad abbinare le firme dei metodi usando NSString e NSDictionary anche se a seconda delle esigenze le stringhe Swift equivalenti e [String: AnyObject] potrebbero essere più appropriate.