FileManager — qu'est-ce que c'est, travailler avec le système de fichiers iOS

Qu'est-ce que FileManager

FileManager est une classe singleton du framework Foundation qui fournit une API unifiée pour interagir avec le système de fichiers sur toutes les plateformes Apple. Elle est disponible via FileManager.default ou en créant une instance avec un délégué personnalisé.

Les principales capacités de la classe incluent : vérifier l'existence d'un fichier (fileExists), créer des répertoires (createDirectory), copier et déplacer (copyItem, moveItem), supprimer (removeItem), obtenir des attributs (attributesOfItem) et le contenu des répertoires (contentsOfDirectory). FileManager est étroitement lié à NSData, String et JSONEncoder/Decoder pour la sérialisation des données.

FileManager est thread-safe : Apple garantit des appels de méthode sécurisés depuis différents threads. Cependant, les opérations du système de fichiers peuvent être lentes sur les gros fichiers, c'est pourquoi Apple recommande de les exécuter sur une file d'attente en arrière-plan (DispatchQueue.global) et d'appeler les méthodes FileManagerDelegate pour signaler la progression.

let fileManager = FileManager.default
let documentsURL = fileManager.urls(
    for: .documentDirectory,
    in: .userDomainMask
).first!

let fileURL = documentsURL.appendingPathComponent("data.plist")

if fileManager.fileExists(atPath: fileURL.path) {
    print("File exists at \(fileURL.path)")
}

Principaux répertoires des applications iOS

Chaque application iOS a trois répertoires principaux accessibles via FileManager dans le Sandbox : Documents, Library et tmp. Chacun a son propre objectif et ses règles de sauvegarde qu'il est essentiel de respecter pour passer la révision de l'App Store.

Documents — pour les données utilisateur qui doivent persister entre les lancements et être sauvegardées sur iCloud. Library — pour les fichiers de l'application : caches (Caches), paramètres (Preferences), bases de données (Application Support). tmp — pour les fichiers temporaires qui peuvent être supprimés par le système à tout moment entre les lancements de l'application.

Règle d'Apple : si un fichier peut être récupéré depuis Internet ou recréé — il doit être stocké dans Caches (sans sauvegarde). Si un fichier contient des données utilisateur — Documents (avec sauvegarde). Un placement incorrect des fichiers est l'une des raisons courantes de rejet d'application, car Apple vérifie la conformité aux directives de stockage et de sauvegarde iCloud.

Lecture et écriture de fichiers

FileManager lui-même ne fournit pas de méthodes pour lire le contenu des fichiers — pour cela, utilisez NSData(contentsOf), String(contentsOf) ou les méthodes FileHandle. FileManager est responsable de la gestion des fichiers : vérification d'existence, déplacement, copie, suppression.

Pour écrire des données, utilisez la méthode createFile(atPath:contents:attributes:) ou les API de haut niveau — data.write(to:), JSONEncoder.encode et PropertyListEncoder. FileManager fournit également FileHandle pour la lecture et l'écriture en streaming de gros fichiers, qui ne charge pas l'intégralité du fichier en mémoire.

struct UserSettings: Codable {
    let username: String
    let isDarkMode: Bool
    let fontSize: Int
}

let settings = UserSettings(
    username: "developer",
    isDarkMode: true,
    fontSize: 16
)

// Écrire JSON dans Documents
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let data = try encoder.encode(settings)
let url = documentsURL.appendingPathComponent("settings.json")
try data.write(to: url, options: .atomic)

// Lire JSON
let loadedData = try Data(contentsOf: url)
let loadedSettings = try JSONDecoder()
    .decode(UserSettings.self, from: loadedData)

Lors de l'écriture, utilisez options: .atomic — cela garantit que le fichier ne sera pas corrompu en cas d'échec d'écriture : les données sont d'abord enregistrées dans un fichier temporaire, puis déplacées de manière atomique vers le chemin de destination. Pour lire de gros fichiers, utilisez FileHandle avec .readingMode et lisez les données par morceaux, en contrôlant la consommation mémoire.

Gestion des répertoires

FileManager fournit des méthodes pour la gestion complète des répertoires : createDirectory (création de tous les dossiers intermédiaires via withIntermediateDirectories), contentsOfDirectory (obtention d'une liste de fichiers), enumeratorAt (parcours récursif) et subpathsOfDirectory (tous les chemins dans un répertoire).

La méthode enumeratorAt retourne un DirectoryEnumerator, qui permet de parcourir efficacement de grands répertoires sans charger tout le contenu en mémoire. Il prend en charge le filtrage via skipDescendants et fournit les attributs de chaque élément sans requête supplémentaire au système de fichiers.

// Parcours récursif de répertoire
if let enumerator = fileManager.enumerator(
    at: documentsURL,
    includingPropertiesForKeys: [.fileSizeKey, .isDirectoryKey]
) {
    for case let fileURL as URL in enumerator {
        let attrs = try fileURL.resourceValues(
            for: [.fileSizeKey, .isDirectoryKey]
        )
        if attrs.isDirectory == false {
            let size = attrs.fileSize ?? 0
            print("File: \(fileURL.lastPathComponent), Size: \(size) bytes")
        }
    }
}

Pour supprimer un répertoire, utilisez removeItem(at:). Attention : la suppression d'un répertoire sur iOS est irréversible — les fichiers ne vont pas dans la corbeille comme sur macOS. Avant de supprimer, assurez-vous de ne plus avoir besoin des fichiers de ce répertoire et effectuez l'opération sur un thread d'arrière-plan, car la suppression de nombreux fichiers peut bloquer l'interface utilisateur.

FileManager et iCloud

FileManager s'intègre avec iCloud Drive via la méthode URLForUbiquityContainerIdentifier, qui retourne l'URL du répertoire iCloud pour l'application. Cela nécessite d'activer la capacité iCloud dans le projet et d'ajouter l'entitlement approprié.

Les fichiers iCloud se synchronisent automatiquement, mais FileManager fournit des méthodes pour le contrôle manuel : startDownloadingUbiquitousItem force le téléchargement, evictUbiquitousItem supprime la copie locale et urlOfItem(at:) retourne l'URL locale d'un fichier iCloud. NSMetadataQuery est utilisé pour rechercher des fichiers dans iCloud.

Limitation critique : iCloud Drive n'est pas pris en charge pour les fichiers dans le répertoire Documents — uniquement pour les fichiers dans ubiquityContainer. N'essayez pas de synchroniser Documents via iCloud ; utilisez plutôt NSUbiquitousKeyValueStore pour de petites quantités de données ou Core Data avec CloudKit pour des structures complexes.

Performance de FileManager

Les opérations avec FileManager peuvent être coûteuses, en particulier sur les appareils avec une mémoire flash lente. Les principales recommandations d'Apple incluent l'exécution de toutes les opérations sur des files d'attente en arrière-plan, la minimisation du nombre d'appels fileExistsAtPath et la mise en cache des résultats.

La méthode fileExists effectue un appel système stat(), qui est relativement lent. Si vous vérifiez l'existence d'un fichier avant de le lire, il est préférable d'essayer de le lire directement et de gérer l'erreur — cela effectue le même stat mais évite un double appel système. Pour les vérifications en masse, utilisez enumeratorAt avec resourceValues.

Pour optimiser le travail avec de grands volumes de données :

• Utilisez FileHandle pour le traitement en streaming des gros fichiers
• Mettez en cache les résultats de fileManager.urls pour les répertoires fréquemment utilisés
• Effectuez les opérations par lot dans une file d'attente granulaire, en évitant de bloquer le thread principal
• Utilisez CoordinatedFileManager pour un accès sécurisé depuis plusieurs threads

Apple Instruments fournit le modèle File Activity pour le profilage des opérations sur les fichiers. Utilisez-le pour identifier les goulots d'étranglement — par exemple, des appels fréquents à fileExists dans une boucle ou des opérations d'écriture sur le thread principal. Les problèmes de performance les plus courants sont liés à l'écriture synchrone de gros fichiers lors de la mise en veille de l'application.