Do-Catch: Nedir, Swift'te Yapı ve Hata Yönetimi

Do-Catch Nedir?

Do-Catch, hata fırlatabilen kodun yürütüldüğü bir do bloğu ve bu hatayı yöneten bir veya daha fazla catch bloğundan oluşan Swift'teki bir yapıdır. Do bloğu, try ile işaretlenmiş throwing işlevlerine çağrılar içerir ve catch blokları hatayı türe göre eşleştirir.

Swift, Objective-C'deki istisnalardan farklı olarak yapılandırılmış hata yönetimi modeli uygular. Burada bir hata, yığın açma ile bir istisna değil, Error protokolüne uyan bir değerdir. Throw ile hata fırlatmak, yığın açma yükü olmadan denetimi en yakın catch bloğuna aktarır.

Swift'in temel bir özelliği açık yönetimdir. Derleyici, try, do-catch veya alternatif bir mekanizma (try?, try!) olmadan bir throwing işlevinin çağrılmasına izin vermez. Bu, bir hatanın fark edilmemesi durumlarını ortadan kaldırır.

Swift'te Hata Modeli: Error Protokolü ve Throwing İşlevler

Swift'te hata yönetiminin merkezinde Error protokolü bulunur. Bu protokole uyan herhangi bir tür, throw aracılığıyla fırlatılabilir. Hatalar tipik olarak Error'a uyan bir enum olarak tanımlanır.

Error Protokolü

Error, boş (işaretçi) bir protokoldür. Yöntem uygulaması gerektirmez, yalnızca uygunluk gerektirir. Swift derleyicisi statik denetim için Error'u kullanır: throws'a sahip bir işlev yalnızca Error'a uyan bir değer fırlatabilir.

Throwing İşlevler

throws ile işaretlenmiş bir işlev, try ile çağrılmalıdır. Böyle bir işlev içinde throw oluşursa, denetim çağıran do-catch'e aktarılır. Hata, çağrı zincirinin hiçbir yerinde yönetilmezse, bir üst düzeye yayılır.

enum FileError: Error {
    case notFound
    case permissionDenied
    case corrupted(String)
}

func readFile(path: String) throws -> String {
    guard FileManager.default.fileExists(atPath: path) else {
        throw FileError.notFound
    }
    return try String(contentsOfFile: path)
}

Rethrows

rethrows, parametre olarak bir throwing closure kabul eden işlevler için bir değiştiricidir. Geçirilen closure bir hata fırlatmazsa, rethrows işlevi try olmadan çağrılabilir. Bu, hem throwing hem de non-throwing closure'larla uyumlu genel üst düzey işlevler yazmayı sağlar.

Do-Catch Sözdizimi: Birden Çok Catch Bloğu

Swift, tür tabanlı hata eşleme ile birden çok catch bloğunu destekler. Bu, Kotlin'deki when veya türe göre switch'e benzer: eşleşen ilk catch yürütülür, geri kalanı atlanır.

Türe Göre Eşleme

Her catch bloğu, belirli bir hata türüyle eşleşen bir desen içerebilir. Swift blokları sırayla kontrol eder, bu nedenle daha belirli türler genel olanlardan önce gelmelidir. Hiçbir desen eşleşmezse, desensiz catch bloğu yürütülür.

Birden Çok Türü Yönetme

Do-Catch'in tür güvenliği, her hatayı ayrı ayrı yönetmeye veya virgülle ayrılmış desen eşleme yoluyla bir blokta birden çok türü birleştirmeye olanak tanır. Bu, hata analizinin dönüş kodları veya domain ve code denetimi ile NSError aracılığıyla yapıldığı Objective-C'ye özgü hantal if-else zincirlerini ortadan kaldırır.

Swift ayrıca catch where — ek bir koşul ile eşleme — destekler. Örneğin, hataları belirli bir koda veya metne göre filtreleyebilirsiniz: catch URLError where error.code == .notConnectedToInternet. Bu, hassasiyeti korurken catch bloğu sayısını azaltır.

Throwing işlevlerinde hata ayıklama için Swift, hatalar ve istisnalar arasında bir ayrım sağlar. Bir Swift hatası, yığın açma gerektirmeyen bir dönüş değeridir. Objective-C istisnaları (@try/@catch) çalışma zamanı düzeyinde çalışır ve yalnızca ölümcül hatalar için kullanılır. Do-Catch, istisnaları değil hataları yönetir, bu da onu öngörülebilir ve verimli kılar.

Kitaplıklar ve SDK'lar geliştirirken, throwing işlevlerinin genel sözleşmenin bir parçası olduğunu hatırlamak önemlidir. Hata türü imzada belirtilmez, bu nedenle bir işlevin hangi hataları fırlatabileceğini yorumlarda veya Result benzeri enum'lar aracılığıyla belgeleyin. Bu, API kullanıcılarının uygulamaya bakmadan doğru catch blokları yazmasına yardımcı olur.

Eşzamansız programlama bağlamında, async/await ile Do-Catch, callback hell sorununu çözer. Daha önce Swift'te, eşzamansız kodda hata yönetimi, tamamlama işleyicilerinde Error? denetimi içeren iç içe closure'lar gerektiriyordu. Async/await ve Do-Catch ile eşzamansız throwing kodu, senkron kod gibi görünür ve her adımda hata yönetimi ile karmaşık istek zincirlerinin okunmasını ve bakımını basitleştirir.

do {
    let content = try readFile(path: "/data/config.json")
    process(content)
} catch FileError.notFound {
    createDefaultConfig()
} catch FileError.permissionDenied {
    requestAccess()
} catch FileError.corrupted(let detail) {
    logCorruption(detail)
} catch {
    print("Bilinmeyen hata: \(error)")
}

Try Varyasyonları: try, try?, try! ve Ne Zaman Kullanılır

Swift, throwing işlevlerini çağırmak için üç yol sunar: try, try? ve try!. Her seçenek belirli bir görevi çözer ve sınırlamaları vardır.

try — Standart Çağrı

try bir do bloğu içinde kullanılır ve hata catch'te yönetilir. Bu, throwing işlevlerini çağırmanın birincil yoludur. Derleyici, try'nin hatanın yakalanabileceği bir bağlamda olmasını gerektirir.

try? — Optional'a Dönüştürme

try?, bir throwing işlevinin sonucunu Optional'a dönüştürür. İşlev bir hata fırlatırsa, try? nil döndürür, aksi takdirde başarılı değerle bir Optional döndürür. Hatasının görmezden gelinebileceği ancak bir başarı göstergesinin gerekli olduğu çağrılar için kullanışlıdır.

try! — Zorunlu Yürütme

try! hata yönetimini bastırır. Throwing işlevi bir hata fırlatırsa, uygulama bir çalışma zamanı hatası ile sonlanır. Try!'yi yalnızca hatanın kesinlikle imkansız olduğuna emin olduğunuzda kullanın — örneğin, paketlenmiş bir kaynağı yüklerken.

// try? — hatayı görmezden geliriz, başarısızlıkta nil alırız
if let data = try? Data(contentsOf: url) {
    processData(data)
}

// try! — yalnızca hata garantili olarak imkansızsa
let bundled = try! String(contentsOfFile: "Assets/default.txt")

// try — do-catch'te standart seçenek
do {
    let result = try performNetworkRequest()
    updateUI(result)
} catch {
    showError(error)
}

iOS Geliştirmede Do-Catch: Pratik Örnekler

Do-Catch, iOS geliştirmede sistem API'leri ile çalışmak için aktif olarak kullanılır. Tipik senaryoları ele alalım: dosya sistemi, Core Data ve ağ istekleri ile çalışma.

Dosya Sistemi

FileManager'ın birçok yöntemi throwing'dir. Do-Catch, dosyanın bulunmaması, kaynağın meşgul olması veya yetersiz izinlerin doğru şekilde yönetilmesini sağlar.

Codable ile Ağ İstekleri

JSONDecoder aracılığıyla JSON ayrıştırma, bir throwing işlemidir. Do-Catch, kod çözme hatalarını ve ağ arızalarını ayrı ayrı yakalayarak kullanıcıya doğru bir hata mesajı sağlar.

struct User: Codable {
    let id: Int
    let name: String
}

func fetchUser(id: Int) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode(User.self, from: data)
}

// Yönetimli çağrı
do {
    let user = try await fetchUser(id: 42)
    showUser(user)
} catch let error as URLError {
    showNetworkAlert(error)
} catch let error as DecodingError {
    showParseError(error)
} catch {
    showGenericError(error)
}

Do-Catch ile Sık Yapılan Hatalar

Özellikle diğer dillerden geçiş yapan geliştiriciler, Do-Catch'i kullanırken sıkça karakteristik hatalar yaparlar. En yaygın olanları inceleyelim.

• Unutulan try — try olmadan bir throwing işlevini çağırmak derleme hatasına neden olur. Swift, hataları örtük olarak görmezden gelmeye izin vermez.
• Boş catch — yönetimi olmayan bir catch bloğu hatayı gizler. İmkansız görünse bile her zaman hatayı kaydedin veya yönetin.
• Eşlemesiz catch — tüm hatalar için tek bir genel catch, tür güvenliğinin avantajlarını kaybeder. Birden çok blok kullanarak yönetimi türlere göre ayırın.
• Try!'nin aşırı kullanımı — üretim kodunda try! beklenmeyen çökmelerin kaynağıdır. Yalnızca paketlenmiş kaynaklar veya testler için kullanın.