Зачем нужна диспетчеризация?

Зачем нужна диспетчеризация в iOS

Диспетчеризация (dispatch) — это механизм, позволяющий вызывать правильный метод объекта в runtime. Это фундаментальный концепт объектно-ориентированного программирования и ключ к полиморфизму.

Что такое диспетчеризация

Когда мы вызываем метод на объекте, система должна понять:

1. Какой КОНКРЕТНЫЙ метод вызвать?
2. Какого класса это метод?

Это решение происходит в runtime благодаря диспетчеризации.

Статическая vs Динамическая диспетчеризация

Статическая (Static Dispatch) — Compile Time

Компилятор ТОЧНО знает какой метод вызвать, потому что тип известен в compile time.

struct Point {
    func distance() -> Double {
        return 0.0
    }
}

let p = Point()
p.distance()  // Компилятор ТОЧНО знает вызовет Point.distance()
// Статическая диспетчеризация — быстро и эффективно

Динамическая (Dynamic Dispatch) — Runtime

Компилятор не знает точный тип, поэтому решение принимается в runtime.

class Animal {
    func makeSound() {
        print("Generic sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Woof!")
    }
}

class Cat: Animal {
    override func makeSound() {
        print("Meow!")
    }
}

// Переменная может быть Dog или Cat
let animal: Animal = Dog()  // Runtime решает
animal.makeSound()  // Динамическая диспетчеризация
// В runtime система смотрит на реальный тип (Dog) и вызывает Dog.makeSound()

Почему это нужно

1. Полиморфизм

Без диспетчеризации полиморфизм невозможен.

protocol Shape {
    func area() -> Double
}

struct Circle: Shape {
    let radius: Double
    func area() -> Double { 3.14 * radius * radius }
}

struct Rectangle: Shape {
    let width: Double
    let height: Double
    func area() -> Double { width * height }
}

func printArea(shape: Shape) {
    print(shape.area())
    // Динамическая диспетчеризация определит,
    // вызвать ли Circle.area() или Rectangle.area()
}

printArea(shape: Circle(radius: 5))
printArea(shape: Rectangle(width: 10, height: 20))

2. Гибкость

Можно передавать разные реализации без изменения кода.

protocol DataProvider {
    func fetchData() async throws -> [Item]
}

class APIDataProvider: DataProvider {
    func fetchData() async throws -> [Item] {
        // Реальный API запрос
    }
}

class MockDataProvider: DataProvider {
    func fetchData() async throws -> [Item] {
        // Тестовые данные
    }
}

class ViewController {
    let dataProvider: DataProvider  // Не знаем что это
    
    func load() async {
        let items = try await dataProvider.fetchData()
        // Работает и с API и с Mock благодаря диспетчеризации
    }
}

Как работает динамическая диспетчеризация

1. В Objective-C (VTable не используется)

Объекты содержат указатель на объект класса (isa), содержащий таблицу методов.

class Animal {
    dynamic func makeSound() {  // dynamic = диспетчеризируется через Objective-C
        print("Sound")
    }
}

// Runtime система:
// 1. Берёт указатель на реальный класс (Dog или Cat)
// 2. Ищет метод в таблице методов класса
// 3. Вызывает найденный метод

2. В Swift (Protocol Witness Table для Protocols)

Для protocol'ей Swift использует таблицы conformance'а.

protocol Drawable {
    func draw()
}

struct Circle: Drawable {
    func draw() { print("Drawing circle") }
}

let shape: Drawable = Circle()  // Существует Witness Table для Circle: Drawable
shape.draw()  // Через таблицу вызывается Circle.draw()

Производительность диспетчеризации

Статическая (очень быстрая)

struct Value {
    func process() { }  // Встраивается (inlined) компилятором
}

Динамическая (медленнее, но приемлемо)

class Reference {
    func process() { }  // Indirect функция, поиск в таблице
}

protocol Protocol {
    func process()
}

func call(_ p: Protocol) {
    p.process()  // Поиск в Protocol Witness Table
}

Разница минимальна для настоящих приложений, но важна для performance-critical кода.

Оптимизация: Finalizing

Если знаем что метод не переопределяется, можно запретить динамическую диспетчеризацию:

class Parent {
    final func neverOverridden() {  // Compile-time dispatch
        // Компилятор может встроить этот вызов
    }
    
    func mayBeOverridden() {  // Dynamic dispatch (VTable lookup)
        // Может быть переопределён в подклассе
    }
}

Оптимизация: @inlinable

Для public методов можно позволить инлайнирование:

public struct Container {
    @inlinable
    public func isEmpty() -> Bool {
        return count == 0
    }
}

Практический пример

protocol NetworkClient {
    func request(_ url: String) async throws -> Data
}

class URLSessionClient: NetworkClient {
    func request(_ url: String) async throws -> Data {
        // URLSession реализация
    }
}

class AuthNetworkClient: NetworkClient {
    let baseClient: NetworkClient
    
    init(baseClient: NetworkClient) {
        self.baseClient = baseClient
    }
    
    func request(_ url: String) async throws -> Data {
        // Добавляем authentication header'ы
        // Затем вызываем базовый клиент
        return try await baseClient.request(url)  // Диспетчеризируется!
    }
}

// Использование
let client: NetworkClient = URLSessionClient()
let authed = AuthNetworkClient(baseClient: client)

let data = try await authed.request("https://api.example.com/data")
// Работает Decorator pattern благодаря диспетчеризации

Когда диспетчеризация вызывает проблемы

// Бесконечная рекурсия через диспетчеризацию
class Base {
    func process() { self.step() }  // Dynamic dispatch
    func step() { print("Base") }
}

class Derived: Base {
    override func step() {
        print("Derived")
        process()  // Вызывает Base.process() → self.step() (Derived.step())
        // Может быть бесконечная рекурсия!
    }
}

Вывод

Диспетчеризация нужна для:

1. Полиморфизма — вызовов правильного метода в runtime
2. Гибкости — использования разных реализаций одного интерфейса
3. Расширяемости — добавления новых типов без изменения существующего кода
4. Testability — использования mock'ов и stub'ов

Два типа:

• Статическая (compile-time) — быстрая, используется для struct'ур
• Динамическая (runtime) — гибкая, используется для class'ов и protocol'ей

Это основа OOP в Swift и iOS разработке.