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

问题描述

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

任何想法有什么问题吗？尝试运行构建，不幸的是出现此错误

错误-> 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 { (_,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)
    }
}

EDIT1：

仍然出现错误，仍然在该括号中指出了我的意思-DataResponseSerializer {出了点问题。我已经尝试删除它们/添加新的。不知道这是什么问题。我目前无法运行导致此错误的生成原因。

这是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
    }
}

解决方法

您现在可能正在使用的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)
}