swift - 尾随闭包传递给不接受闭包的 'Set' 类型的参数

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 {那有什么不对呢。我已经尝试删除它们/添加新的。不知道这里有什么问题。我目前无法运行此错误的构建原因。
这是 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)
}