Как можно наследовать состояния приложения?

Наследование состояний приложения в iOS-разработке

Наследование состояний приложения — это архитектурный подход, при котором состояние (state) передается от родительских компонентов к дочерним через иерархию объектов. В iOS-разработке этот паттерн часто реализуется через различные механизмы, в зависимости от выбранной архитектуры и парадигмы.

Основные подходы к наследованию состояния

1. Наследование через иерархию UIViewController

В традиционном MVC состояние часто передается от родительского к дочернему контроллеру через свойства или методы инициализации:

class ParentViewController: UIViewController {
    var appState: AppState
    
    func presentChild() {
        let childVC = ChildViewController()
        childVC.appState = self.appState // Передача состояния
        present(childVC, animated: true)
    }
}

class ChildViewController: UIViewController {
    var appState: AppState? // Наследованное состояние
    
    override func viewDidLoad() {
        super.viewDidLoad()
        guard let state = appState else { return }
        // Использование унаследованного состояния
        updateUI(with: state)
    }
}

2. Использование EnvironmentObject в SwiftUI

SwiftUI предоставляет встроенный механизм наследования состояния через @EnvironmentObject:

class AppState: ObservableObject {
    @Published var userSession: UserSession?
    @Published var settings: Settings = .default
}

struct ParentView: View {
    @StateObject var appState = AppState()
    
    var body: some View {
        ChildView()
            .environmentObject(appState) // Инъекция состояния в окружение
    }
}

struct ChildView: View {
    @EnvironmentObject var appState: AppState // Автоматическое наследование
    
    var body: some View {
        Text(appState.userSession?.username ?? "Guest")
    }
}

3. Наследование через Dependency Injection

Более гибкий подход, основанный на явной передаче зависимостей:

protocol StateContainer {
    var networkService: NetworkService { get }
    var userDefaults: UserDefaultsManager { get }
    var analytics: AnalyticsService { get }
}

class AppStateContainer: StateContainer {
    let networkService: NetworkService
    let userDefaults: UserDefaultsManager
    let analytics: AnalyticsService
    
    init() {
        self.networkService = NetworkService()
        self.userDefaults = UserDefaultsManager()
        self.analytics = AnalyticsService()
    }
}

class ViewModel {
    private let stateContainer: StateContainer
    
    init(stateContainer: StateContainer) {
        self.stateContainer = stateContainer
    }
    
    func fetchData() {
        stateContainer.networkService.request(...)
        stateContainer.analytics.trackEvent(...)
    }
}

Паттерны и архитектуры для управления состоянием

Redux-подобные паттерны

• Единый источник истины (Single Source of Truth): Состояние хранится в одном централизованном хранилище
• Неизменяемость состояния: Все изменения происходят через предсказуемые редьюсеры
• Наследование через подписку: Компоненты подписываются на изменения конкретных частей состояния

struct AppState {
    var authState: AuthState
    var userProfile: UserProfile
    var settings: Settings
}

protocol ReduxStore {
    var state: AppState { get }
    func dispatch(_ action: Action)
    func subscribe(_ subscriber: AnyObject, selector: @escaping (AppState) -> Void)
}

class ConnectedViewController: UIViewController {
    var store: ReduxStore
    private var unsubscribe: (() -> Void)?
    
    init(store: ReduxStore) {
        self.store = store
        super.init(nibName: nil, bundle: nil)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        unsubscribe = store.subscribe(self) { [weak self] state in
            self?.update(with: state)
        }
    }
}

Практические рекомендации

Когда использовать наследование состояния:

• При наличии четкой иерархии компонентов
• Когда дочерние компоненты логически зависят от родительского состояния
• Для избежания проп drilling (сквозной передачи пропсов через множество уровней)

Альтернативы наследованию:

• Глобальные синглтоны: Простота, но сложность тестирования
• Роутинг с инъекцией состояния: Каждый модуль получает необходимую часть состояния при создании
• Service Locator: Централизованный доступ к сервисам без явного наследования

Лучшие практики:

1. Минимизируйте область видимости состояния — передавайте только необходимые данные
2. Используйте протоколы для абстракции вместо конкретных типов
3. Тестируемость — обеспечьте возможность мокирования унаследованного состояния
4. Реактивность — используйте Combine или RxSwift для автоматического обновления UI
5. Разделение ответственности — разделяйте состояние на доменные модели

Пример современного подхода с Combine

class StateManager {
    static let shared = StateManager()
    
    @Published var user: User?
    @Published var theme: Theme = .light
    @Published var networkStatus: NetworkStatus = .connected
    
    private init() {}
}

class BaseViewController: UIViewController {
    var cancellables = Set<AnyCancellable>()
    let stateManager = StateManager.shared
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupStateObservers()
    }
    
    func setupStateObservers() {
        stateManager.$theme
            .receive(on: DispatchQueue.main)
            .sink { [weak self] theme in
                self?.applyTheme(theme)
            }
            .store(in: &cancellables)
    }
}

Наследование состояний — мощный инструмент, который требует баланса между удобством и сложностью. В современных iOS-приложениях предпочтительны декларативные подходы (SwiftUI + Combine) или архитектуры с явным управлением состоянием (Redux, MVVM), которые делают поток данных предсказуемым и тестируемым.