# Benefits of Using SectionKit Over Standard UICollectionView Implementation > Discover SectionKit's advantages over UICollectionView. Simplify your code with section isolation, type-safe generics, and declarative configuration for easier cell management and state updates. - Repository: [神奇/sectionkit](https://github.com/linhay/sectionkit) - Tags: comparison - Published: 2026-03-06 --- **SectionKit eliminates monolithic data-source boilerplate by introducing section-level isolation, type-safe generics, and declarative configuration that automatically handles cell registration, diff-based reloads, and Combine-based state management.** Managing complex collection views in UIKit often leads to massive view controllers filled with switch statements and index-path math. SectionKit, an open-source Swift library maintained at `linhay/sectionkit`, replaces this anti-pattern with a modular architecture where each logical section owns its data, layout, and behavior. By leveraging protocol-oriented design and Combine publishers, SectionKit delivers compile-time safety and high-performance caching without sacrificing flexibility. ## Section-Level Isolation and Clean Architecture Standard `UICollectionView` implementations typically rely on a single data source object that manages all sections through fragile index-path calculations. SectionKit inverts this model through the `SKCManager` class, which acts as a lightweight mediator rather than a monolithic controller. In [`Sources/SectionKit/CollectionBase/SKCManager.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionBase/SKCManager.swift), the manager maintains an array of `SKCBaseSectionProtocol` objects and routes delegate calls via specialized forwarders like `SKCDataSourceForward` and `SKCDelegateFlowLayoutForward`. When you call `bind(sections:start:)` or `setup(sectionView:)`, the manager automatically wires each section to the collection view, eliminating the need for massive switch statements in your view controller. This architecture makes sections truly self-contained. Each section handles its own cell registration, layout insets, and user interactions, allowing you to compose complex interfaces by simply appending sections to the manager. ## Type-Safe, Protocol-Oriented API SectionKit enforces compile-time safety through generic constraints that standard UIKit cannot provide. The `SKCSingleTypeSection` class, defined in [`Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift), declares a generic parameter `Cell` that must conform to `UICollectionViewCell`, `SKConfigurableView`, and `SKLoadViewProtocol`: ```swift open class SKCSingleTypeSection ``` This constraint guarantees that every cell can be configured with its associated model and registered automatically. The compiler prevents mismatches between cell types and data models, eliminating runtime casting errors and crashes caused by incorrect reuse identifiers. ## Declarative Configuration and Fluent API SectionKit adopts a chainable, declarative syntax that makes collection view setup self-documenting. Instead of implementing multiple delegate methods, you configure behavior through methods like `onCellAction`, `apply(models:)`, and conditional modifiers `if(_:_:)`: ```swift let todoSection = SKCSingleTypeSection(todos) .onCellAction(.selected) { ctx in print("Selected:", ctx.model.title) } .apply(models: todos) ``` The `apply(models:)` method triggers updates while `onCellAction` registers closures for specific interaction types. This pattern keeps configuration logic colocated with the section definition rather than scattered across a view controller. ## Automatic Cell Registration and Reuse Developer errors around cell registration are impossible in SectionKit. The framework calls `register(Cell.self)` inside the `config(sectionView:)` method of `SKCSingleTypeSection` automatically. You never manually register classes or NIBs with the collection view, and you never deal with string-based reuse identifiers. This automation extends to the `SKWrapperCell` utility (found in [`Sources/SectionUI/Sections/SKCWrapperCell.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionUI/Sections/SKCWrapperCell.swift)), which allows any `UIView` to function as a collection view cell without manual registration overhead. ## High-Performance Diffing and Caching SectionKit implements efficient batch updates through `ReloadKind.difference(by:)`. The `reload(models:by:)` method in `SKCSingleTypeSection` computes insert, delete, and move operations automatically, sparing you from manual `performBatchUpdates` calculations. For expensive layout operations, the `SKHighPerformanceStore` class (located in [`Sources/SectionKit/Common/SKHighPerformanceStore.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/Common/SKHighPerformanceStore.swift)) caches size calculations keyed by model identifiers. When `itemSize(at:)` executes, it checks the `highPerformance` cache via `cache(by:limit:)`, dramatically reducing layout passes for dynamic-height cells. ## Built-In Prefetching and Context Menus Modern collection view features require implementing numerous delegate methods. SectionKit provides these capabilities out of the box through `SKCPrefetch`, which exposes `prefetch` and `cancelPrefetching` Combine publishers for lazy loading of large datasets. Context menus, selection handling, and supplementary view actions are handled through methods like `contextMenu(row:)` and `cellShoulds` within the section class. These hooks remove the need to implement `UIContextMenuInteraction` delegates manually while providing type-safe access to the underlying model data. ## Layout Plugin System Unlike standard `UICollectionView` implementations that lock you into a single layout, SectionKit supports interchangeable layout plugins. The `SKWaterfallLayout` in [`Sources/SectionUI/Beta/SKWaterfallLayout.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionUI/Beta/SKWaterfallLayout.swift) demonstrates how custom layouts (including waterfall, pinning, or custom grid arrangements) attach to the collection view without modifying section code. Each section maintains its own layout properties (`sectionInset`, `minimumLineSpacing`) while the layout plugin arranges cells visually, allowing heterogeneous sections to coexist in a single collection view with different visual arrangements. ## Unified Lifecycle Management with Combine SectionKit exposes all state changes as Combine publishers through `SKCSingleTypePublishers`. The `modelsPulisher` (along with `cellActionPulisher`) emits values whenever data changes, enabling reactive UI updates: ```swift let cancellable = todoSection.publishers.modelsPulisher .sink { newModels in print("Models updated – count:", newModels.count) } ``` The framework tracks displayed times, deleted models, and safe-size providers automatically, preventing common bugs like double-configuration or stale data references that plague manual implementations. ## Practical Implementation Example Setting up a complete section requires minimal boilerplate. First, define a model and conforming cell: ```swift struct TodoItem: Identifiable, Equatable { let id: UUID var title: String } final class TodoCell: UICollectionViewCell, SKConfigurableView, SKLoadViewProtocol { static func preferredSize(limit: CGSize, model: TodoItem) -> CGSize { CGSize(width: limit.width, height: 44) } func config(_ model: TodoItem) { // Configure UI } func loadView() -> UIView { self.contentView } } ``` Then bind the section to a manager: ```swift let collectionView = UICollectionView(frame: .zero, collectionViewLayout: UICollectionViewFlowLayout()) let manager = SKCManager(sectionView: collectionView) let todoSection = SKCSingleTypeSection() .onCellAction(.selected) { ctx in // Handle selection } .apply(models: todos) manager.append(todoSection) ``` The manager now serves as the collection view's data source and delegate, while the section handles all cell logic automatically. ## Summary - **SectionKit** replaces monolithic `UICollectionViewDataSource` implementations with isolated, composable sections managed by `SKCManager`. - **Type-safe generics** in `SKCSingleTypeSection` enforce compile-time compatibility between cells and models, eliminating runtime casting. - **Automatic registration** via `config(sectionView:)` removes boilerplate and prevents reuse-identifier errors. - **Declarative API** with chainable methods like `onCellAction` and `apply(models:)` creates self-documenting configuration code. - **Performance optimizations** include diff-based reloads through `reload(models:by:)` and size caching via `SKHighPerformanceStore`. - **Combine integration** provides reactive streams for model changes and user interactions through `modelsPulisher`. - **Layout plugins** like `SKWaterfallLayout` enable custom arrangements without modifying section logic. ## Frequently Asked Questions ### How does SectionKit handle cell registration automatically? SectionKit calls `register(Cell.self)` inside the `config(sectionView:)` method of `SKCSingleTypeSection` during the binding process. This occurs in [`Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionKit/CollectionSingleTypeSection/Entities/SKCSingleTypeSection.swift), ensuring that every cell class is registered with the collection view before reuse without requiring manual `register(_:forCellWithReuseIdentifier:)` calls in your view controller. ### Can I use SectionKit with custom UICollectionViewLayouts? Yes. SectionKit's architecture separates section logic from layout concerns. You can assign any `UICollectionViewLayout`—including custom implementations like `SKWaterfallLayout` found in [`Sources/SectionUI/Beta/SKWaterfallLayout.swift`](https://github.com/linhay/sectionkit/blob/main/Sources/SectionUI/Beta/SKWaterfallLayout.swift)—to the collection view managed by `SKCManager`. Each section maintains its own layout insets and spacing properties while the layout plugin handles the visual arrangement. ### Is SectionKit compatible with Combine and reactive programming? SectionKit is built with Combine integration at its core. The `SKCSingleTypePublishers` struct exposes publishers like `modelsPulisher` and `cellActionPulisher` that emit values whenever models update or cell actions occur. This allows you to subscribe to collection view state changes and react accordingly without implementing delegate patterns or observer blocks throughout your codebase. ### When should I choose SectionKit over UICollectionViewDiffableDataSource? Choose SectionKit when you need **section-level modularity** and **type safety** beyond what `UICollectionViewDiffableDataSource` provides. While DiffableDataSource handles snapshot-based updates, it still requires a monolithic configuration and manual cell registration. SectionKit adds compile-time generic constraints, automatic registration, per-section caching via `SKHighPerformanceStore`, and built-in prefetching hooks that DiffableDataSource does not provide natively.