내가 달성하려는 URLSession것은 신속한 3 요청을 수행하는 것 입니다. 별도의 함수에서이 작업을 수행하고 (GET 및 POST에 대한 코드를 별도로 작성하지 않도록) 종료 URLSessionDataTask에서 성공 및 실패를 반환 하고 처리합니다. 이런 식으로

let task = URLSession.shared.dataTask(with: request) { (data, uRLResponse, responseError) in

     DispatchQueue.main.async {

          var httpResponse = uRLResponse as! HTTPURLResponse

          if responseError != nil && httpResponse.statusCode == 200{

               successHandler(data!)

          }else{

               if(responseError == nil){
                     //Trying to achieve something like below 2 lines
                     //Following line throws an error soo its not possible
                     //var errorTemp = Error(domain:"", code:httpResponse.statusCode, userInfo:nil)

                     //failureHandler(errorTemp)

               }else{

                     failureHandler(responseError!)
               }
          }
     }
}

이 함수에서 오류 조건을 처리하고 싶지 않고 응답 코드를 사용하여 오류를 생성하고이 함수가 호출 될 때마다 처리하기 위해이 오류를 반환하고 싶습니다. 아무도 이것에 대해 어떻게 나에게 말할 수 있습니까? 아니면 이러한 상황을 처리하는 "신속한"방법이 아닙니까?

LocalizedError다음 값 을 사용하여 Swift 프로토콜을 준수하는 프로토콜을 만들 수 있습니다 .

protocol OurErrorProtocol: LocalizedError {

    var title: String? { get }
    var code: Int { get }
}

그러면 다음과 같은 구체적인 오류를 만들 수 있습니다.

struct CustomError: OurErrorProtocol {

    var title: String?
    var code: Int
    var errorDescription: String? { return _description }
    var failureReason: String? { return _description }

    private var _description: String

    init(title: String?, description: String, code: Int) {
        self.title = title ?? "Error"
        self._description = description
        self.code = code
    }
}

귀하의 경우 오류는 Error인스턴스 생성을 시도하고 있다는 것 입니다. ErrorSwift 3에서 사용자 지정 오류를 정의하는 데 사용할 수있는 프로토콜입니다. 이 기능은 특히 순수한 Swift 애플리케이션이 다른 OS에서 실행되는 데 적합합니다.

iOS 개발에서 NSError클래스는 계속 사용할 수 있으며 Error프로토콜을 준수 합니다.

따라서이 오류 코드를 전파하는 것이 목적이라면

var errorTemp = Error(domain:"", code:httpResponse.statusCode, userInfo:nil)

와

var errorTemp = NSError(domain:"", code:httpResponse.statusCode, userInfo:nil)

그렇지 않으면 사용자 지정 오류 유형을 만드는 방법에 대한 Sandeep Bhandari 의 답변을 확인하십시오.

오류를 처리하기 위해 열거 형을 만들 수 있습니다. :)

enum RikhError: Error {
    case unknownError
    case connectionError
    case invalidCredentials
    case invalidRequest
    case notFound
    case invalidResponse
    case serverError
    case serverUnavailable
    case timeOut
    case unsuppotedURL
 }

그런 다음 enum 내부에 메서드를 만들어 http 응답 코드를 받고 해당 오류를 반환합니다. :)

static func checkErrorCode(_ errorCode: Int) -> RikhError {
        switch errorCode {
        case 400:
            return .invalidRequest
        case 401:
            return .invalidCredentials
        case 404:
            return .notFound
        //bla bla bla
        default:
            return .unknownError
        }
    }

마지막으로 RikhError 유형의 단일 매개 변수를 허용하도록 실패 블록을 업데이트하십시오.

기존 Objective-C 기반 Object Oriented 네트워크 모델을 Swift3를 사용하여 현대적인 Protocol Oriented 모델로 재구성하는 방법에 대한 자세한 자습서가 있습니다 https://learnwithmehere.blogspot.in 살펴보세요 :)

도움이되기를 바랍니다 :)

NSError 객체를 사용해야합니다.

let error = NSError(domain:"", code:401, userInfo:[ NSLocalizedDescriptionKey: "Invalid access token"])

그런 다음 NSError를 Error 객체로 캐스팅합니다.

세부

• Xcode 버전 10.2.1 (10E1001)
• 스위프트 5

앱의 구성 오류 해결 방법

import Foundation

enum AppError {
    case network(type: Enums.NetworkError)
    case file(type: Enums.FileError)
    case custom(errorDescription: String?)

    class Enums { }
}

extension AppError: LocalizedError {
    var errorDescription: String? {
        switch self {
            case .network(let type): return type.localizedDescription
            case .file(let type): return type.localizedDescription
            case .custom(let errorDescription): return errorDescription
        }
    }
}

// MARK: - Network Errors

extension AppError.Enums {
    enum NetworkError {
        case parsing
        case notFound
        case custom(errorCode: Int?, errorDescription: String?)
    }
}

extension AppError.Enums.NetworkError: LocalizedError {
    var errorDescription: String? {
        switch self {
            case .parsing: return "Parsing error"
            case .notFound: return "URL Not Found"
            case .custom(_, let errorDescription): return errorDescription
        }
    }

    var errorCode: Int? {
        switch self {
            case .parsing: return nil
            case .notFound: return 404
            case .custom(let errorCode, _): return errorCode
        }
    }
}

// MARK: - FIle Errors

extension AppError.Enums {
    enum FileError {
        case read(path: String)
        case write(path: String, value: Any)
        case custom(errorDescription: String?)
    }
}

extension AppError.Enums.FileError: LocalizedError {
    var errorDescription: String? {
        switch self {
            case .read(let path): return "Could not read file from \"\(path)\""
            case .write(let path, let value): return "Could not write value \"\(value)\" file from \"\(path)\""
            case .custom(let errorDescription): return errorDescription
        }
    }
}

용법

//let err: Error = NSError(domain:"", code: 401, userInfo: [NSLocalizedDescriptionKey: "Invaild UserName or Password"])
let err: Error = AppError.network(type: .custom(errorCode: 400, errorDescription: "Bad request"))

switch err {
    case is AppError:
        switch err as! AppError {
        case .network(let type): print("Network ERROR: code \(type.errorCode), description: \(type.localizedDescription)")
        case .file(let type):
            switch type {
                case .read: print("FILE Reading ERROR")
                case .write: print("FILE Writing ERROR")
                case .custom: print("FILE ERROR")
            }
        case .custom: print("Custom ERROR")
    }
    default: print(err)
}

LocalizedError 구현 :

struct StringError : LocalizedError
{
    var errorDescription: String? { return mMsg }
    var failureReason: String? { return mMsg }
    var recoverySuggestion: String? { return "" }
    var helpAnchor: String? { return "" }

    private var mMsg : String

    init(_ description: String)
    {
        mMsg = description
    }
}

예를 들어, 답변 중 하나에 설명 된대로 단순히 Error를 구현하면 실패하고 (적어도 Swift 3에서는) localizedDescription을 호출하면 "The operation could not be completed. (. StringError error 1)"라는 문자열이 생성됩니다. "

 let error = NSError(domain:"", code:401, userInfo:[ NSLocalizedDescriptionKey: "Invaild UserName or Password"]) as Error
            self.showLoginError(error)

NSError 객체를 생성하고 그것을 Error로 형변환하고, 어디서나 보여줍니다.

private func showLoginError(_ error: Error?) {
    if let errorObj = error {
        UIAlertController.alert("Login Error", message: errorObj.localizedDescription).action("OK").presentOn(self)
    }
}

나는 여전히 Harry의 대답이 가장 간단하고 완성되었다고 생각하지만 더 간단한 것이 필요하면 다음을 사용하십시오.

struct AppError {
    let message: String

    init(message: String) {
        self.message = message
    }
}

extension AppError: LocalizedError {
    var errorDescription: String? { return message }
//    var failureReason: String? { get }
//    var recoverySuggestion: String? { get }
//    var helpAnchor: String? { get }
}

다음과 같이 사용하거나 테스트하십시오.

printError(error: AppError(message: "My App Error!!!"))

func print(error: Error) {
    print("We have an ERROR: ", error.localizedDescription)
}

protocol CustomError : Error {

    var localizedTitle: String
    var localizedDescription: String

}

enum RequestError : Int, CustomError {

    case badRequest         = 400
    case loginFailed        = 401
    case userDisabled       = 403
    case notFound           = 404
    case methodNotAllowed   = 405
    case serverError        = 500
    case noConnection       = -1009
    case timeOutError       = -1001

}

func anything(errorCode: Int) -> CustomError? {

      return RequestError(rawValue: errorCode)
}

이미 답변에 만족하신 것을 알고 있지만 올바른 접근 방식을 알고 싶다면이 방법이 도움이 될 수 있습니다. http- 응답 오류 코드와 오류 개체의 오류 코드를 혼합하지 않는 것이 좋습니다 (혼란 스럽습니까? 계속해서 조금 읽으십시오 ...).

http 응답 코드는 응답이 수신 될 때 일반적인 상황을 정의하는 http 응답에 대한 표준 오류 코드이며 1xx에서 5xx까지 다양합니다 (예 : 200 OK, 408 Request timed, 504 Gateway timeout 등-http: //www.restapitutorial.com/) httpstatuscodes.html )

NSError 개체의 오류 코드는 개체가 응용 프로그램 / 제품 / 소프트웨어의 특정 도메인에 대해 설명하는 오류 유형에 대한 매우 구체적인 식별을 제공합니다. 예를 들어 애플리케이션에서 "죄송합니다. 하루에 두 번 이상이 레코드를 업데이트 할 수 없습니다."에 1000을 사용하거나 "이 리소스에 액세스하려면 관리자 역할이 필요합니다."에 대해 1001이라고 말할 수 있습니다. 이는 도메인 / 애플리케이션에 고유합니다. 논리.

매우 작은 응용 프로그램의 경우 때때로이 두 개념이 병합됩니다. 그러나 보시다시피 완전히 다르며 대형 소프트웨어를 설계하고 작업하는 데 매우 중요하고 도움이됩니다.

따라서 코드를 더 나은 방식으로 처리하는 두 가지 기술이 있습니다.

1. 완료 콜백이 모든 검사를 수행합니다.

completionHandler(data, httpResponse, responseError) 

2. 당신의 방법은 성공과 오류 상황을 결정한 다음 해당 콜백을 호출합니다.

if nil == responseError { 
   successCallback(data)
} else {
   failureCallback(data, responseError) // failure can have data also for standard REST request/response APIs
}

해피 코딩 :)