## Mettre en cache des données qui coutent cher à instancier ou qui sont fréquemment consultées

### Identifiants

// TODO

### Catégories

| Cycle de vie |  Tiers  |  Responsable  |
|:---------:|:----:|:----:|
| 3. Réalisation (fabrication / développement) | Utilisateur/Terminal | Architecte Logiciel/Développeur |

### Indications

| Degré de priorité |      Mise en oeuvre       |  Impact écologique    |
|:-------------------:|:-------------------------:|:---------------------:|
| 4 | 3 | 4 |

|Ressources Economisées                                      |
|:----------------------------------------------------------:|
|  Processeur / Mémoire vive |

### Description

Lorsque des calculs de valeurs sont coûteux en ressources, les mettre en cache si les valeurs demeurent inchangées afin de ne pas réitérer ces opérations. De même, mettre en cache des données qui sont fréquemment consultées permet de réduire le nombre de lectures sur le disque ou sur le réseau.

Plusieurs options pour mettre en cache ce type de données. Par exemple : 
A l'échelle de la vue :
* Au sein du `ViewModel` associée à la vue.
* Avec Jetpack Compose, les fonctions `remember{}` ou `rememberSaveable{}` permet de maintenir en cache un objet au delà des Recompositions de son composant parent.

Si cette valeur est utilisée par plusieurs écrans de notre application :
* Dans un singleton au niveau de la couche data, exposée par exemple via un observable (Kotlin Flow ou RX). Par exemple un singleton `ConfigManager` pourra exposer un observable contenant un objet `Config` contenant la configuration globale de l'application.


### Exemple

#### Avec Jetpack Compose

* Stocker en mémoire un objet qui coute cher à instancier (traitement trop lourd) : 
_Avant :_
```kotlin
@Composable
fun MyComponent(){
  /*...*/
  val expensive = BigObject()
}
```

_Après :_

```kotlin
@Composable
fun MyComponent(){
  /*...*/
  val expensive = remember { BigObject() }
  
}
```

* Exécuter un traitement couteux sur un état uniquement lorsque cet état change
  _Avant :_

```kotlin
Box(modifier = modifier.fillMaxSize()) { 
    LazyColumn( 
        state = listState, 
        reverseLayout = true, 
        verticalArrangement = Arrangement.spacedBy(16.dp) 
    ) { 
        items( 
            items = messages.sortedByDescending { it.dateTime } 
        ) { message -> 
            ClickableChatMessage( 
                message = message 
            ) 
        } 
    } 
}
```

Problème, a chaque recomposition de ce composant, la liste de message est à nouveau triée. Même si celle-ci n'a pas changé.

_Après :_

```kotlin
Box(modifier = modifier.fillMaxSize()) { 
    val sortedMessages = remember(messages) { 
        messages.sortedByDescending { it.dateTime } 
    } 
 
    LazyColumn( 
        state = listState, 
        reverseLayout = true, 
        verticalArrangement = Arrangement.spacedBy(16.dp) 
    ) { 
        items( 
            items = sortedMessages  
        ) { message -> 
            ClickableChatMessage( 
                message = message 
            ) 
        } 
    } 
}
```

### Principe de validation

| Le nombre ...     | est inférieur ou égal à   |  
|-------------------|:-------------------------:|
| de données peu volatiles, demandant un calcul et accédées plusieurs fois, non mises dans un système de cache  |  0 |