Gestion des fichiers dans Xamarin.Forms

  • Article

Télécharger l’exemple Télécharger l’exemple

La gestion des fichiers avec Xamarin.Forms peut être effectuée à l’aide du code dans une bibliothèque .NET Standard ou à l’aide de ressources incorporées.

Vue d’ensemble

Xamarin.Forms Le code s’exécute sur plusieurs plateformes, chacune ayant son propre système de fichiers. Auparavant, la lecture et l’écriture des fichiers étaient plus faciles à effectuer avec les API de fichiers natives à chaque plateforme. Pour distribuer des fichiers de données à l’aide d’une application, une solution plus simple consiste à utiliser des ressources incorporées. Toutefois, avec .NET Standard 2.0, il est possible de partager du code d’accès de fichier dans les bibliothèques .NET Standard.

Pour plus d’informations sur la gestion des fichiers image, consultez Utilisation des images.

Enregistrement et chargement de fichiers

Les classes System.IO peuvent être utilisées pour accéder au système de fichiers de chaque plateforme. La classe File permet de créer, supprimer et lire des fichiers, et la classe Directory permet de créer, supprimer ou énumérer le contenu des répertoires. Vous pouvez également utiliser les sous-classes Stream, qui fournissent un plus grand contrôle sur les opérations de fichier (par exemple, la compression ou la recherche de position dans un fichier).

Un fichier texte peut être écrit à l’aide de la méthode File.WriteAllText :

File.WriteAllText(fileName, text);

Un fichier texte peut être lu à l’aide de la méthode File.ReadAllText :

string text = File.ReadAllText(fileName);

En outre, la méthode File.Exists détermine si le fichier spécifié existe :

bool doesExist = File.Exists(fileName);

Sur chaque plateforme, le chemin du fichier peut être déterminé à partir d’une bibliothèque .NET Standard, à l’aide d’une valeur de l’énumération Environment.SpecialFolder, en tant que premier argument de la méthode Environment.GetFolderPath. Il peut être combiné avec un nom de fichier, à l’aide de la méthode Path.Combine :

string fileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "temp.txt");

Ces opérations sont démontrées dans l’exemple d’application, qui inclut une page qui enregistre et charge du texte :

Enregistrement et chargement de texte

Chargement de fichiers incorporés en tant que ressources

Pour incorporer un fichier dans un assembly .NET Standard, créez ou ajoutez un fichier, puis vérifiez que Action de génération = EmbeddedResource.

GetManifestResourceStream est utilisé pour accéder au fichier incorporé à l’aide de son ID de ressource. Par défaut, l’ID de ressource est le nom de fichier précédé de l’espace de noms par défaut pour le projet dans lequel il est incorporé. Dans ce cas, l’assembly est WorkingWithFiles et le nom de fichier est LibTextResource.txt, de sorte que l’ID de ressource est WorkingWithFiles.LibTextResource.txt.

var assembly = IntrospectionExtensions.GetTypeInfo(typeof(LoadResourceText)).Assembly;
Stream stream = assembly.GetManifestResourceStream("WorkingWithFiles.LibTextResource.txt");
string text = "";
using (var reader = new System.IO.StreamReader (stream))
{  
    text = reader.ReadToEnd ();
}

La variabletext peut ensuite être utilisée pour afficher le texte ou l’utiliser dans le code. Cette capture d’écran de l’exemple d’application montre le texte affiché dans un contrôle Label.

incorporé dans la bibliothèque .NET Standard

Le chargement et la désérialisation d’un document XML sont tout aussi simples. Le code suivant montre un fichier XML qui est chargé et désérialisé à partir d’une ressource, puis lié à un ListView pour l’affichage. Le fichier XML contient un tableau d’objets Monkey (la classe est définie dans l’exemple de code).

var assembly = IntrospectionExtensions.GetTypeInfo(typeof(LoadResourceText)).Assembly;
Stream stream = assembly.GetManifestResourceStream("WorkingWithFiles.LibXmlResource.xml");
List<Monkey> monkeys;
using (var reader = new System.IO.StreamReader (stream)) {
    var serializer = new XmlSerializer(typeof(List<Monkey>));
    monkeys = (List<Monkey>)serializer.Deserialize(reader);
}
var listView = new ListView ();
listView.ItemsSource = monkeys;

incorporé dans la bibliothèque .NET Standard, affiché dans le

Incorporation dans des projets partagés

Les projets partagés peuvent également contenir des fichiers agissant comme des ressources incorporées. Toutefois, étant donné que le contenu d’un projet partagé est compilé dans les projets de référence, le préfixe utilisé pour les ID de ressource des fichiers incorporés peut changer. Cela signifie que l’ID de ressource de chaque fichier incorporé peut être différent pour chaque plateforme.

Il existe deux solutions à ce problème de projet partagé :

  • Synchroniser les projets : modifiez les propriétés du projet pour chaque plateforme afin d’utiliser le même nom d’assembly et l’espace de noms par défaut. Cette valeur peut ensuite être « codée en dur » comme préfixe pour les ID de ressource incorporée dans le projet partagé.
  • Directives de compilateur #if : utilisez des directives de compilateur pour définir le préfixe d’ID de ressource approprié, et utilisez cette valeur pour construire de façon dynamique l’ID de ressource approprié.

Voici le code qui illustre la deuxième option : Les directives de compilateur sont utilisées pour sélectionner le préfixe de ressource codé en dur (qui est normalement le même que l’espace de noms par défaut du projet de référence). La variable resourcePrefix est ensuite utilisée pour créer un ID de ressource valide, en le concaténant avec le nom de fichier de la ressource incorporée.

#if __IOS__
var resourcePrefix = "WorkingWithFiles.iOS.";
#endif
#if __ANDROID__
var resourcePrefix = "WorkingWithFiles.Droid.";
#endif

Debug.WriteLine("Using this resource prefix: " + resourcePrefix);
// note that the prefix includes the trailing period '.' that is required
var assembly = IntrospectionExtensions.GetTypeInfo(typeof(SharedPage)).Assembly;
Stream stream = assembly.GetManifestResourceStream
    (resourcePrefix + "SharedTextResource.txt");

Organisation des ressources

Les exemples ci-dessus supposent que le fichier est incorporé dans la racine du projet bibliothèque .NET Standard, auquel cas l’ID de ressource est au format Namespace.Filename.Extension, tel que WorkingWithFiles.LibTextResource.txt et WorkingWithFiles.iOS.SharedTextResource.txt.

Il est possible d’organiser les ressources incorporées dans des dossiers. Lorsqu’une ressource incorporée est placée dans un dossier, le nom du dossier est intégré à l’ID de ressource (séparé par des points). Le format de l’ID de ressource devient alors EspaceDeNoms.Dossier.NomDeFichier.Extension. Si vous placez les fichiers de l’exemple d’application dans un dossier MyFolder, les ID de ressource correspondants deviennent WorkingWithFiles.MyFolder.LibTextResource.txt et WorkingWithFiles.iOS.MyFolder.SharedTextResource.txt.

Débogage des ressources incorporées

Il est parfois difficile de comprendre pourquoi une ressource n’est pas chargée. Pour vérifier que les ressources sont correctement configurées, vous pouvez ajouter temporairement le code de débogage suivant à une application. Il affichera toutes les ressources incorporées connues d’un assembly donné dans le volet Erreurs pour vous aider à déboguer les problèmes de chargement des ressources.

using System.Reflection;
// ...
// use for debugging, not in released app code!
var assembly = IntrospectionExtensions.GetTypeInfo(typeof(SharedPage)).Assembly;
foreach (var res in assembly.GetManifestResourceNames()) {
    System.Diagnostics.Debug.WriteLine("found resource: " + res);
}

Résumé

Cet article vous a montré certaines opérations de fichier simples pour enregistrer et charger du texte sur l’appareil, et pour charger des ressources incorporées. Avec .NET Standard 2.0, il est possible de partager du code d’accès de fichier dans les bibliothèques .NET Standard.