传递给不接受闭包的 'Set<HTTPMethod>' 类型参数的尾随闭包

Question

正在检查我的同事代码，出现此错误。

有什么问题吗？正在尝试运行构建，不幸的是出现此错误

错误 -> Trailing closure passed to parameter of type 'Set<HTTPMethod>' that does not accept a closure

试图在 DataResponseSerializer<T> 上更改它对我来说不起作用

错误行 -> let responseSerializer = DataResponseSerializer { (request, response, data, error) in

代码在这里

import Foundation
import Alamofire

extension DataRequest {
    /// @Returns - DataRequest
    /// completionHandler handles JSON Object T
    /// - Returns: `DataRequest`
    @discardableResult func responseObject<T: Decodable> (
        queue: DispatchQueue? = nil,
        _ type: T.Type,
        completionHandler: @escaping (AFDataResponse<T>) -> Void
        ) -> Self {
        
        let responseSerializer = DataResponseSerializer { (_, response, data, error) in
            if let err = error {
                return .failure(err)
            }
            
            let result = DataRequest.serializeResponseData(response: response, data: data, error: error)
            let jsonData: Data
            switch result {
            case .failure(let error):
                return .failure(error)
            case .success(let data):
                jsonData = data
            }
            
            // (1)- Json Decoder. Decodes the data object into expected type T
            // throws error when failes
            let decoder = JSONCoders.snakeCaseDecoder
            do {
                let decoded = try decoder.decode(T.self, from: jsonData)
                return .success(decoded)
            } catch let error {
                return .failure(error)
            }
        }
        
        return response(queue: queue, responseSerializer: responseSerializer, completionHandler: completionHandler)
    }
}

编辑 1：

错误仍然出现，它特别指出了这个括号 - DataResponseSerializer { 它有问题。我已经尝试删除 them/add 个新的。不知道这里有什么问题。我目前无法运行构建此错误的原因。

这是 DataResponseSerializer 的定义

/// A `ResponseSerializer` that performs minimal response checking and returns any response data as-is. By default, a
/// request returning `nil` or no data is considered an error. However, if the response is has a status code valid for
/// empty responses (`204`, `205`), then an empty `Data` value is returned.
public final class DataResponseSerializer: ResponseSerializer {
    public let dataPreprocessor: DataPreprocessor
    public let emptyResponseCodes: Set<Int>
    public let emptyRequestMethods: Set<HTTPMethod>

    /// Creates an instance using the provided values.
    ///
    /// - Parameters:
    ///   - dataPreprocessor:    `DataPreprocessor` used to prepare the received `Data` for serialization.
    ///   - emptyResponseCodes:  The HTTP response codes for which empty responses are allowed. `[204, 205]` by default.
    ///   - emptyRequestMethods: The HTTP request methods for which empty responses are allowed. `[.head]` by default.
    public init(dataPreprocessor: DataPreprocessor = DataResponseSerializer.defaultDataPreprocessor,
                emptyResponseCodes: Set<Int> = DataResponseSerializer.defaultEmptyResponseCodes,
                emptyRequestMethods: Set<HTTPMethod> = DataResponseSerializer.defaultEmptyRequestMethods) {
        self.dataPreprocessor = dataPreprocessor
        self.emptyResponseCodes = emptyResponseCodes
        self.emptyRequestMethods = emptyRequestMethods
    }

    public func serialize(request: URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) throws -> Data {
        guard error == nil else { throw error! }

        guard var data = data, !data.isEmpty else {
            guard emptyResponseAllowed(forRequest: request, response: response) else {
                throw AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength)
            }

            return Data()
        }

        data = try dataPreprocessor.preprocess(data)

        return data
    }
}

Answer 1

您现在可能正在使用的 Alamofire 版本 5 与以前的版本相比有一些重大变化。 DataResponseSerializer 的初始化器不再像 Alamofire 4 那样获取闭包参数。

然而，你可以更容易地实现你想要的，因为 Alamofire 5 已经有一个 responseDecodable(of:queue:decoder:completionHandler:) 函数，你可以在其中传递你的自定义 JSONDecoder 并为你进行解码过程:

extension DataRequest {
    /// @Returns - DataRequest
    /// completionHandler handles JSON Object T
    /// - Returns: `DataRequest`
    @discardableResult func responseObject<T: Decodable> (
        queue: DispatchQueue? = nil,
        _ type: T.Type,
        completionHandler: @escaping (AFDataResponse<T>) -> Void
    ) -> Self {
        let decoder = JSONCoders.snakeCaseDecoder
        return responseDecodable(
            of: T.self,
            queue: queue ?? .main,
            decoder: decoder,
            completionHandler: completionHandler
        )
    }
}

您甚至可以在提出请求时直接在没有 DataRequest 扩展名的情况下执行此操作。如果假设您正在为所有请求使用通用函数，您的代码可能如下所示：

func myGenericRequest<T: Decodable>(url: URL, completionHandler: @escaping (DataResponse<T, AFError>) -> Void) {
    let decoder = JSONCoders.snakeCaseDecoder
    AF.request(url).responseDecodable(decoder: decoder, completionHandler: completionHandler)
}

传递给不接受闭包的 'Set<HTTPMethod>' 类型参数的尾随闭包

Trailing closure passed to parameter of type 'Set<HTTPMethod>' that does not accept a closure

swift

alamofire

decodable