Какая будет диспетчеризация, если объекту добавить расширение NSObject?

Разбор диспетчеризации методов при добавлении наследования от NSObject

Чтобы дать точный ответ, нужно понимать ключевое различие между статической (прямой) и динамической диспетчеризацией в Swift, и как на это влияет наследование от NSObject.

1. Базовые типы диспетчеризации в Swift

В "чистом" Swift (без Objective-C runtime) действуют следующие правила:

• Статическая диспетчеризация (Direct Dispatch): Самый быстрый способ. Компилятор на этапе компиляции точно знает, какую реализацию метода вызвать. Используется для:

    *   **`struct`** и **`enum`** (значимые типы).
    *   **`final`** методы и классы.
    *   **`private`** и **`fileprivate`** методы (когда компилятор может гарантировать отсутствие переопределений).
    *   Методы в **расширениях (`extension`)** для нативных Swift-типов (кроме `@objc` методов).

• Динамическая диспетчеризация по таблице виртуальных функций (Table Dispatch): Используется для полиморфизма в классах. Для каждого класса компилятор создает таблицу указателей на функции (vtable). Вызов метода — это поиск по этой таблице во время выполнения. Используется для:

    *   Не-`final` методов в не-`final` классах.

• Динамическая диспетчеризация через механизм сообщений (Message Dispatch): Наследие Objective-C Runtime. Самый гибкий, но и самый медленный способ. Вызов метода — это отправка сообщения (objc_msgSend) объекту, который ищет реализацию в цепочке классов во время выполнения. Позволяет делать такие вещи, как method swizzling и динамическое добавление методов (class_addMethod).

2. Влияние наследования от NSObject

Когда класс в Swift наследуется от NSObject (или любого другого класса, который в итоге наследуется от NSObject), он автоматически подключается к Objective-C Runtime.

Это меняет правила диспетчеризации для методов, которые потенциально могут быть видны Objective-C:

import Foundation

// Этот класс теперь является частью Objective-C runtime
class MyClass: NSObject {
    // 1. Обычный метод Swift-класса
    func swiftMethod() {
        print("Swift Method")
        // Диспетчеризация: Table Dispatch (динамическая через vtable)
    }

    // 2. Метод, помеченный для Objective-C runtime
    @objc func objcMethod() {
        print("Objective-C Method")
        // Диспетчеризация: Message Dispatch (через objc_msgSend)
    }

    // 3. Динамический метод
    @objc dynamic func dynamicMethod() {
        print("Dynamic Method")
        // Диспетчеризация: Message Dispatch. Ключевое слово `dynamic` явно указывает
        // на использование механизма сообщений, даже если метод не помечен @objc.
    }
}

Ключевые изменения:

• Методы, помеченные @objc, всегда используют Message Dispatch. Objective-C runtime управляет их вызовом.
• Методы с модификатором dynamic также всегда используют Message Dispatch, даже если они не помечены @objc. Это необходимо для совместимости с KVO, Cocoa Bindings и другими динамическими функциями runtime.
• "Обычные" Swift-методы в классе, наследующем от NSObject, по-прежнему в основном используют Table Dispatch (если они не final). Однако сам факт принадлежности к Objective-C runtime может влиять на некоторые оптимизации компилятора.

3. А если добавить расширение (extension)?

Вопрос немного неточен: "объекту добавить расширение NSObject" — скорее всего, имеется в виду "сделать класс наследником NSObject". Но если рассматривать буквально добавление расширения к существующему типу, то:

// Исходный класс
class PureSwiftClass {
    func method() {}
}

// Расширяем его и добавляем соответствие NSObjectProtocol?
// Это НЕ сделает диспетчеризацию динамической.
extension PureSwiftClass: NSObjectProtocol {}

// Наследуем от NSObject — это КОРЕННО меняет природу класса.
class MyClass: NSObject {
    func method() {}
}

Важный нюанс с расширениями (extension): Методы, объявленные в расширении для класса (даже наследующего от NSObject), по умолчанию используют Direct Dispatch (статическую диспетчеризацию), если они не помечены как @objc или dynamic. Это ограничение Swift, связанное с тем, что расширения не могут переопределять существующие методы (без @objc), и компилятор оптимизирует их вызов.

extension MyClass {
    func extensionMethod() {
        // Диспетчеризация: Direct Dispatch (если метод не @objc/dynamic)
    }

    @objc func extensionObjcMethod() {
        // Диспетчеризация: Message Dispatch
    }
}

Итог и практические выводы

1. Наследование от NSObject подключает класс к Objective-C Runtime.
2. Диспетчеризация для каждого метода определяется индивидуально:

    *   `@objc` метод → **Message Dispatch** (динамическая через `objc_msgSend`).
    *   `dynamic` метод → **Message Dispatch**.
    *   Обычный не-`final` метод Swift-класса → **Table Dispatch** (виртуальная таблица).
    *   Метод в `extension` (без `@objc`) → **Direct Dispatch** (статическая).

1. Для чего это нужно? Наследование от NSObject необходимо, если вы:

    *   Используете **KVO (Key-Value Observing)** (требует `@objc dynamic` свойств).
    *   Работаете со старыми **Objective-C API** (делегаты, цели-действия в UIKit/AppKit).
    *   Хотите применять низкоуровневые техники Objective-C runtime (**method swizzling**).

Современный тренд: В новых Swift-проектах, особенно с SwiftUI, стараются избегать наследования от NSObject без необходимости, чтобы оставаться в рамках более быстрой и безопасной модели Swift. Классы, не наследующие от NSObject, используют только Table или Direct Dispatch, что дает выигрыш в производительности. Наследование от NSObject — это сознательный выбор для интеграции с динамическими возможностями Objective-C экосистемы Cocoa/CocoaTouch.