performance-optimization

Performance Optimization Guidelines

Memory Management

Avoid Retain Cycles

// Use weak/unowned references appropriately
class ViewController: UIViewController {
    private var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Bad - Creates retain cycle
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
            self.updateUI()
        }
        
        // Good - Weak reference prevents retain cycle
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.updateUI()
        }
    }
    
    deinit {
        timer?.invalidate()
    }
}

Lazy Loading

class DataManager {
    // Load expensive resources only when needed
    private lazy var database: Database = {
        return Database()
    }()
    
    // Use computed properties for lightweight calculations
    var itemCount: Int {
        return items.count
    }
    
    // Cache expensive computations
    private var _processedData: [ProcessedItem]?
    var processedData: [ProcessedItem] {
        if let cached = _processedData {
            return cached
        }
        let processed = items.map { ProcessedItem($0) }
        _processedData = processed
        return processed
    }
}

Memory-Efficient Collections

// Use appropriate collection types
struct LargeDataSet {
    // Bad - Loads all data into memory
    var allItems: [Item] {
        return database.fetchAll()
    }
    
    // Good - Use lazy sequences
    var items: LazySequence<[Item]> {
        return database.fetchAll().lazy
    }
    
    // Better - Use pagination
    func items(page: Int, pageSize: Int = 50) -> [Item] {
        return database.fetch(offset: page * pageSize, limit: pageSize)
    }
}

UI Performance

Main Thread Protection

class ImageLoader {
    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
        Task {
            // Perform heavy work on background queue
            let data = try? await URLSession.shared.data(from: url).0
            let image = data.flatMap { UIImage(data: $0) }
            
            // Always update UI on main thread
            await MainActor.run {
                completion(image)
            }
        }
    }
}