Swift 6.0 Tam Rehber: Concurrency, Typed Throws ve Daha Fazlası

1// ✅ Swift 6 Best Practice: Actor ile güvenli state yönetimi
2actor UserSessionManager {
3    private var currentUser: User?
4    private var authToken: String?
5    private var loginAttempts: Int = 0
6    
7    // Actor-isolated method - otomatik thread-safe
8    func login(credentials: Credentials) async throws -> User {
9        loginAttempts += 1
10        
11        guard loginAttempts <= 3 else {
12            throw AuthError.tooManyAttempts
13        }
14        
15        // Network çağrısı - actor isolation korunur
16        let response = try await AuthService.authenticate(credentials)
17        
18        currentUser = response.user
19        authToken = response.token
20        
21        return response.user
22    }
23    
24    // nonisolated - actor isolation gerektirmeyen methodlar
25    nonisolated func getMaxLoginAttempts() -> Int {
26        return 3 // Sabit değer, isolation gereksiz
27    }
28    
29    // Computed property ile güvenli erişim
30    var isLoggedIn: Bool {
31        currentUser != nil && authToken != nil
32    }
33}
34 
35// Kullanım - tamamen thread-safe
36let sessionManager = UserSessionManager()
37 
38Task {
39    do {
40        let user = try await sessionManager.login(
41            credentials: Credentials(email: "[email protected]", password: "***")
42        )
43        print("Hoşgeldin, \(user.name)!")
44    } catch AuthError.tooManyAttempts {
45        print("Çok fazla deneme! Lütfen bekle.")
46    }
47}

1// ❌ Swift 6'da derleme hatası - Sendable olmayan tip
2class UserManager {
3    var currentUser: User?
4    
5    func updateUser(_ user: User) {
6        currentUser = user
7    }
8}
9 
10// ✅ Doğru yaklaşım - Actor kullanımı
11actor UserManager {
12    var currentUser: User?
13    
14    func updateUser(_ user: User) {
15        currentUser = user
16    }
17}

1// ❌ Swift 6'da DERLEME HATASI
2class UserPreferences {
3    var theme: Theme = .light
4    var fontSize: Int = 14
5}
6 
7// Neden? class mutable ve Sendable değil.
8// Thread A theme'i değiştirirken Thread B fontSize'ı okuyabilir = DATA RACE
9 
10// ✅ Çözüm 1: Struct kullan (value type)
11struct UserPreferences: Sendable {
12    var theme: Theme
13    var fontSize: Int
14}
15 
16// ✅ Çözüm 2: Actor kullan
17actor UserPreferencesManager {
18    var theme: Theme = .light
19    var fontSize: Int = 14
20    
21    func updateTheme(_ newTheme: Theme) {
22        theme = newTheme
23    }
24}
25 
26// ✅ Çözüm 3: @unchecked Sendable (dikkatli kullan!)
27final class UserPreferences: @unchecked Sendable {
28    private let lock = NSLock()
29    private var _theme: Theme = .light
30    
31    var theme: Theme {
32        get {
33            lock.lock()
34            defer { lock.unlock() }
35            return _theme
36        }
37        set {
38            lock.lock()
39            defer { lock.unlock() }
40            _theme = newValue
41        }
42    }
43}

1// ✅ Swift 6 Pattern: ViewModel'ler @MainActor olmalı
2@MainActor
3final class ProductListViewModel: ObservableObject {
4    @Published private(set) var products: [Product] = []
5    @Published private(set) var isLoading = false
6    @Published private(set) var error: Error?
7    
8    private let productService: ProductService
9    
10    init(productService: ProductService = .shared) {
11        self.productService = productService
12    }
13    
14    func loadProducts() async {
15        isLoading = true
16        error = nil
17        
18        do {
19            // Network çağrısı background'da çalışır
20            // ama sonuç otomatik main thread'e gelir
21            products = try await productService.fetchProducts()
22        } catch {
23            self.error = error
24        }
25        
26        isLoading = false
27    }
28}

1// Hata tipleri tanımla
2enum NetworkError: Error, Sendable {
3    case noConnection
4    case timeout(seconds: Int)
5    case invalidResponse(statusCode: Int)
6    case decodingFailed(underlying: Error)
7}
8 
9// ✅ Typed throws ile fonksiyon tanımı
10func fetchUser(id: String) throws(NetworkError) -> User {
11    guard NetworkMonitor.isConnected else {
12        throw .noConnection
13    }
14    
15    let response = try await URLSession.shared.data(from: userURL(id))
16    
17    guard response.statusCode == 200 else {
18        throw .invalidResponse(statusCode: response.statusCode)
19    }
20    
21    return try JSONDecoder().decode(User.self, from: response.data)
22}
23 
24// ✅ Hata yakalama - artık exhaustive olabilir!
25func displayUser(id: String) async {
26    do {
27        let user = try await fetchUser(id: id)
28        showUserProfile(user)
29    } catch .noConnection {
30        showOfflineBanner()
31    } catch .timeout(let seconds) {
32        showRetryButton(message: "\(seconds) saniye sonra tekrar dene")
33    } catch .invalidResponse(let code) {
34        if code == 404 {
35            showUserNotFound()
36        } else {
37            showServerError(code: code)
38        }
39    } catch .decodingFailed(let underlying) {
40        logError(underlying)
41        showGenericError()
42    }
43}

1import Synchronization
2 
3// ✅ Modern Swift 6 Mutex kullanımı
4final class Counter: Sendable {
5    private let mutex = Mutex<Int>(0)
6    
7    func increment() {
8        mutex.withLock { value in
9            value += 1
10        }
11    }
12    
13    func decrement() {
14        mutex.withLock { value in
15            value -= 1
16        }
17    }
18    
19    var currentValue: Int {
20        mutex.withLock { $0 }
21    }
22}
23 
24// Kullanım - tamamen thread-safe
25let counter = Counter()
26 
27DispatchQueue.concurrentPerform(iterations: 1000) { _ in
28    counter.increment()
29}
30 
31print("Final: \(counter.currentValue)") // Her zaman 1000

1import Synchronization
2 
3// ✅ High-performance atomic counter
4final class AtomicCounter: Sendable {
5    private let _value = Atomic<Int>(0)
6    
7    func increment() -> Int {
8        _value.wrappingAdd(1, ordering: .relaxed).oldValue + 1
9    }
10    
11    func load() -> Int {
12        _value.load(ordering: .acquiring)
13    }
14}

1// ✅ File handle örneği - kopyalanamaz, tek sahip
2struct FileHandle: ~Copyable {
3    private let descriptor: Int32
4    
5    init(path: String) throws {
6        descriptor = open(path, O_RDONLY)
7        guard descriptor >= 0 else {
8            throw FileError.cannotOpen(path)
9        }
10    }
11    
12    consuming func close() {
13        Darwin.close(descriptor)
14    }
15    
16    borrowing func read(into buffer: UnsafeMutableRawPointer, count: Int) -> Int {
17        Darwin.read(descriptor, buffer, count)
18    }
19    
20    deinit {
21        Darwin.close(descriptor)
22    }
23}
24 
25// Kullanım
26func processFile() throws {
27    let handle = try FileHandle(path: "/tmp/data.txt")
28    
29    // ❌ Derleme hatası - kopyalanamaz
30    // let copy = handle
31    
32    var buffer = [UInt8](repeating: 0, count: 1024)
33    let bytesRead = handle.read(into: &buffer, count: buffer.count)
34    
35    // Explicit close - handle tüketilir
36    handle.close()
37}

1// Package.swift
2.target(
3    name: "MyApp",
4    swiftSettings: [
5        .enableExperimentalFeature("StrictConcurrency")
6    ]
7)
8 
9// Veya Xcode Build Settings:
10// SWIFT_STRICT_CONCURRENCY = targeted

1// ❌ Hata: Capture of non-Sendable type
2class UserCache {
3    var users: [User] = []
4}
5 
6// ✅ Çözüm 1: Actor yap
7actor UserCache {
8    var users: [User] = []
9}
10 
11// ✅ Çözüm 2: @MainActor ekle (UI katmanı için)
12@MainActor
13class UserCache {
14    var users: [User] = []
15}
16 
17// ✅ Çözüm 3: Sendable struct'a dönüştür
18struct UserCache: Sendable {
19    let users: [User]
20}

1// ✅ Tercih et
2struct User: Sendable {
3    let id: UUID
4    let name: String
5    let email: String
6}
7 
8// ❌ Gerekmedikçe kaçın
9class User { ... }

1// ✅ Doğru: State yönetimi için
2actor ShoppingCart {
3    private var items: [CartItem] = []
4    func add(_ item: CartItem) { ... }
5}
6 
7// ❌ Yanlış: Stateless işlemler için
8actor MathUtils { // Gereksiz overhead
9    func add(_ a: Int, _ b: Int) -> Int { a + b }
10}

1// ✅ ViewModel'ler @MainActor olmalı
2@MainActor
3final class HomeViewModel: ObservableObject { ... }
4 
5// ✅ UI callback'leri MainActor'e isolate et
6func fetchData() async {
7    let data = await networkService.fetch()
8    
9    await MainActor.run {
10        self.updateUI(with: data)
11    }
12}