Dans le framework Combine, j'ai trouvé le texte suivant
Le framework Combine fournit une approche déclarative de la manière dont votre application traite les événements. Plutôt que de mettre en œuvre potentiellement plusieurs déléguer les rappels ou le gestionnaire d'achèvement
Quelqu'un peut-il me dire quelle est la différence entre le gestionnaire d'achèvement et le rappel dans Swift?
5 Réponses :
Les rappels et les gestionnaires d'achèvement sont synonymes quand on fait référence aux méthodes asynchrones.
J'ai trouvé que la principale différence réside dans la façon dont il est utilisé pour définir ce qui est retourné à l'appelant où un rappel est utilisé pour faire référence à une méthode où la portée est retournée à la méthode d'appel précédente et un gestionnaire d'achèvement fait référence à une méthode lorsqu'il renvoie un type de Résultat à l'appelant.
Ce n'est pas vrai. Par exemple, URLSession utilise des délégués et ce qu'il appelle ne sont pas des gestionnaires d'achèvement; ce sont des rappels délégués.
Un rappel de délégué se produit lorsque vous avez un délégué que vous savez à l'avance implémente une méthode (par exemple parce qu'il adopte un protocole), et que vous appelez cette méthode par son nom.
Un gestionnaire de complétion, c'est quand quelqu'un vous donne une fonction et que vous l'appelez simplement aveuglément par référence.
Un rappel de délégué est une communication individuelle entre différents ViewControllers et classes. Cela vous permet essentiellement de savoir qu'une modification particulière a été effectuée dans une vue particulière ou n'importe où ailleurs et vous pouvez maintenant effectuer une modification après cette action.
Alors que le gestionnaire d'achèvement est un bloc exécuté après avoir terminé un processus ou une tâche particulier.
Le rappel est un moyen de renvoyer des données à une autre fonction à une occasion particulière. il existe 2 façons d'implémenter les rappels dans swift.
Utilisation de protocoles / exemple de délégué:
Declare Protocol
method(param: String, completionHandler: { (result, alreadyUserId) in
// here you will receive callback
});
Votre ViewController doit étendre le délégué
public func method(param: String, completionHandler: @escaping (_ param: String) -> Void)
{
...
// now you can send data back to the caller function using completionHandler on some particular occasion
completionHandler("param");
}
Désormais, dans vos autres classes, vous pouvez envoyer un rappel à ViewController via un objet délégué tel que
delegate.method(param: "your_param");
Utilisation du gestionnaire de complétion Exemple:
class YourViewController: MyDelegate {
// Your Other methods
func method(param: String) {
// Do your stuff
}
}
Nous pouvons appeler cette fonction comme
protocol MyDelegate {
public method(param: String);
}
as-tu compris? faites-moi savoir si vous avez d'autres questions.
pour être clair, vous pouvez obtenir la même fonctionnalité dans les deux sens, mais il existe une approche complètement différente pour la conception de votre application
laissez-moi clarifier avec un exemple simple la différence entre les deux avec la même fonction consiste à effectuer un appel réseau p>
class ViewController: UIViewController {
override func viewDidLoad() {
super.viewDidLoad()
fetchNewData()
}
func fetchNewData(){
let service = BaseService<YourModel>()
service.FireRequest(completion: { [weak self] (response) in
// yourModel Available here once the request completed
})
}
}
class BaseService<ResponseModel: Codable> {
var session: URLSession!
// MARK: Rebuilt Methods
func FireRequest(completion: ((ResponseModel?) -> Void)?){
// Request Preparation
let serviceUrl = URL(string: /* your url */)!
var request = URLRequest(url: serviceUrl)
request.httpMethod = "GET"
// Firing the request
session = URLSession.init(configuration: URLSessionConfiguration.default)
session.dataTask(with: request) { (data, response, error) in
if let data = data {
do {
guard let object = try? JSONDecoder().decode(ResponseModel.self , from: data) else {/* handle error or call delegate error method here */ return }
DispatchQueue.main.async {
completion?(object)
}
}
}
}.resume()
}
}
class ViewController: UIViewController, ServiceDelegate {
override func viewDidLoad() {
super.viewDidLoad()
fetchNewData()
}
func fetchNewData(){
let service = BaseService<YourModel>()
service.delegate = self
service.FireRequest()
}
func didCompleteRequest(responseModel: AnyObject, tag: RequestTypes) {
if tag == /* the tag you are waiting */ .UserLogin {
// YourModel is available here
}
}
}
class BaseService<ResponseModel: Codable> {
var session: URLSession!
var delegate: ServiceDelegate?
// MARK: Rebuilt Methods
func FireRequest(){
// Request Preparation
let serviceUrl = URL(string: /* your url */)!
var request = URLRequest(url: serviceUrl)
request.httpMethod = "GET"
// Firing the request
session = URLSession.init(configuration: URLSessionConfiguration.default)
session.dataTask(with: request) { (data, response, error) in
if let data = data {
do {
guard let object = try? JSONDecoder().decode(ResponseModel.self , from: data) else {/* handle error or call delegate error method here */ return }
delegate?.didCompleteRequest(responseModel: object, tag: .UserLogin)
}
}
}.resume()
}
}
protocol ServiceDelegate {
func didCompleteRequest(responseModel: AnyObject, tag: RequestTypes)
}
// you can also add default impl to the methods here
extension ServiceDelegate {
func didCompleteRequest(responseModel: AnyObject, tag: RequestTypes){}
}
// enum to define the request type
enum RequestTypes {
case UserRegister
case UserLogin
}