Question

在Combine框架中，我找到了以下文本

Combine框架为您的应用程序提供了一种声明式方法处理事件。而不是潜在地实施多个委托回调或完成处理程序

有人可以告诉我Swift中的完成处理程序和回调之间有什么区别吗？

Answer 1

在引用异步方法时，回调和完成处理程序是同义词。

我发现主要区别在于它在定义返回给调用方的内容时所使用的方式，在引用将范围返回到先前调用方法且完成处理程序引用方法的方法时使用回调当它向调用者返回某种Result类型时。

Answer 2

委托回调是指当您事先知道一个实现一个方法的委托（例如，因为它采用了协议），并按名称调用该方法时。

完成处理程序是当有人向您提供一个函数，而您只是通过引用盲目调用它时。

Answer 3

委托回调是各种ViewController和类之间的一对一通信。它基本上可以让您知道在特定视图或其他任何地方都进行了特定更改，现在您可以在执行此操作之后进行更改。

虽然完成处理程序是在完成特定过程或任务之后执行的块。

Answer 4

回调是一种在特定情况下将数据发送回其他功能的方法。快速实现回调有两种方法。

使用协议/委托
使用完成处理程序

使用协议/委托示例：

声明协议

protocol MyDelegate {
     public method(param: String);
}

您的ViewController应该扩展委托

class YourViewController: MyDelegate {
     // Your Other methods

     func method(param: String) {
      // Do your stuff
     }
 }

现在在其他类中，您可以通过委托对象将回调发送给ViewController，例如

delegate.method(param: "your_param");

使用完成处理程序示例：

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");
}

我们可以像这样调用该函数

method(param: String, completionHandler: { (result, alreadyUserId) in
      // here you will receive callback
});

Answer 5

实际上，您可以通过两种方式实现相同的功能，但是设计应用程序的方式完全不同

让我用一个简单的例子说明一下，具有相同功能的两者之间的区别在于进行网络通话

代理协议

    // enum to define the request type

enum RequestTypes {

    case UserRegister
    case UserLogin

}


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){}

}


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()
    }

}



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!

    // 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 {

    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
        })

    }

}

Swift中回调和竞争处理程序之间的区别

5 个答案: