Providing a Localized Description with an Error Type in Swift

This tutorial will guide you through implementing localized error descriptions using LocalizedError and CustomNSError protocols, as well as handling errors with parameters.

In Swift, error handling is a crucial aspect of robust application development. Xcode 8 introduced the LocalizedError protocol, allowing Swift-defined error types to provide localized error descriptions.

Implementing Localized Error Descriptions

In this section, the tutorial introduces the concept of providing localized error descriptions using the LocalizedError protocol. The MyError enum is used as an example error type, and an extension is added to conform it to the LocalizedError protocol. The key code snippet is as follows:

public enum MyError: Error {
    case customError
}

extension MyError: LocalizedError {
    public var errorDescription: String? {
        switch self {
        case .customError:
            return NSLocalizedString("A user-friendly description of the error.", comment: "My error")
        }
    }
}

Explanation:

• MyError is a custom enum that conforms to the Error protocol, making it suitable for representing errors.
• An extension for MyError is provided to conform it to the LocalizedError protocol.
• The errorDescription property is implemented within the extension to return a localized description for the .customError case.

Handling Errors with Parameters

This section addresses scenarios where error types have parameters. The example uses the NetworkError enum, and the code snippet demonstrates how to include parameters in the localized description:

enum NetworkError: LocalizedError {
    case responseStatusError(status: Int, message: String)

    public var errorDescription: String? {
        switch self {
        case let .responseStatusError(status, message):
            return "Error with status \(status) and message \(message) was thrown"
        }
    }
}

Explanation:

• NetworkError is introduced as an example error type with parameters (status and message).
• The errorDescription property is implemented to construct a localized description using the provided parameters.

Providing Additional Information with CustomNSError

This section introduces the CustomNSError protocol, which allows the error type to provide additional information such as a domain, error code, and user info. The example uses the MyError enum:

extension MyError: CustomNSError {
    public static var errorDomain: String {
        return "myDomain"
    }

    public var errorCode: Int {
        switch self {
        case .customError:
            return 999
        }
    }

    public var errorUserInfo: [String: Any]? {
        switch self {
        case .customError:
            return ["line": 13]
        }
    }
}

Explanation:

• An extension for MyError is provided to conform it to the CustomNSError protocol.
• The errorDomain, errorCode, and errorUserInfo properties are implemented to provide additional information about the error.

Combining LocalizedError and CustomNSError

This section demonstrates how to combine both LocalizedError and CustomNSError protocols for comprehensive error handling. The MyBetterError enum is introduced as an example:

enum MyBetterError: CustomNSError, LocalizedError {
    case oops

    // CustomNSError
    static var errorDomain: String { return "MyDomain" }
    var errorCode: Int { return -666 }
    var errorUserInfo: [String: Any] { return ["Hey": "Ho"] }

    // LocalizedError
    var errorDescription: String? { return "This sucks" }
    var failureReason: String? { return "Because it sucks" }
    var recoverySuggestion: String? { return "Give up" }
}

Explanation:

• MyBetterError is introduced as an error type that adopts both CustomNSError and LocalizedError.
• Properties from both protocols are implemented to provide a combination of error information and localized descriptions.

Conclusion

The conclusion summarizes the key takeaways from the tutorial, emphasizing the importance of adopting LocalizedError and CustomNSError protocols to enhance error handling in Swift applications. These protocols allow developers to provide meaningful error messages and additional information for improved user experience and debugging.