Comment implémenter une liste avec un grand nombre de…

Pour afficher de longues listes, on utilise UITableView ou UICollectionView. Ils implémentent le pattern de réutilisation des cellules (Cell Reuse), ce qui permet de gérer efficacement la mémoire et la performance.

Étapes principales :

Créer un UITableView ou UICollectionView : Placez une instance de la classe correspondante à l'écran.
Attribuer DataSource et Delegate : Définissez le contrôleur ou un autre objet comme dataSource et delegate.
```
// Exemple pour UITableView
tableView.dataSource = self 
tableView.delegate = self
```
- dataSource est responsable de fournir les données pour la liste (nombre de sections/lignes, contenu des cellules).
- delegate gère les événements liés à l'interaction de l'utilisateur avec les cellules (sélection, glissements, etc.) et l'apparence.

Enregistrer les cellules : Enregistrez les classes de cellules (UITableViewCell ou UICollectionViewCell) pour la réutilisation. Vous pouvez utiliser des classes ou des nibs.

// Exemple d'enregistrement d'une cellule personnalisée de UITableView
tableView.register(MyCustomCell.self, forCellReuseIdentifier: "MyCellIdentifier")

// Exemple d'enregistrement d'une cellule personnalisée depuis un nib
tableView.register(UINib(nibName: "MyCustomCell", bundle: nil), forCellReuseIdentifier: "MyCellIdentifier")

Implémenter les méthodes dataSource : Méthodes obligatoires pour UITableViewDataSource :

numberOfSections(in:) : Retourne le nombre de sections.
tableView(_:numberOfRowsInSection:) : Retourne le nombre de lignes dans la section.
tableView(_:cellForRowAt:) : Méthode clé pour la réutilisation. Ici, la cellule est demandée dans le pool.

// Exemple d'implémentation de tableView(_:cellForRowAt:)
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    // Obtenir la cellule du pool pour réutilisation
    guard let cell = tableView.dequeueReusableCell(withIdentifier: "MyCellIdentifier", for: indexPath) as? MyCustomCell else {
        fatalError("Impossible de déquencer MyCustomCell") // Gestion d'erreur
    }
    
    // Configurer le contenu de la cellule basé sur les données
    let item = data[indexPath.row] // On suppose un tableau de données
    cell.configure(with: item) // Exemple de méthode de configuration
    
    return cell
}

Implémenter les méthodes delegate (optionnel) : Par exemple, pour gérer la sélection d'une cellule :

// Exemple de gestion de la sélection d'une cellule
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let selectedItem = data[indexPath.row]
    // Effectuer une action avec l'élément sélectionné
    print("Sélectionné : \(selectedItem)")
}

Principe de réutilisation des cellules :

Le système iOS maintient un pool de cellules qui ne sont plus affichées à l'écran. Lorsqu'il faut afficher une nouvelle cellule (par exemple, lors du défilement), au lieu d'en créer une nouvelle, le système utilise une cellule déjà créée dans ce pool. La méthode dequeueReusableCell(withIdentifier:for:) en demande une. Cela économise considérablement la mémoire et les ressources.

UICollectionView :

Fonctionne de façon similaire à UITableView, mais offre une plus grande flexibilité dans la disposition des éléments (grilles, mises en page personnalisées). Nécessite l'implémentation de UICollectionViewDataSource et UICollectionViewDelegate. Au lieu de lignes et de cellules, elle opère avec des éléments (items) et des sections.

L'utilisation de UITableView ou UICollectionView avec réutilisation des cellules est la méthode standard et la plus efficace pour afficher de longues listes dans iOS.

Comment implémenter une liste avec un grand nombre de cellules sur iOS?