Share
À un moment donné de votre carrière dans le développement mobile, vous devrez traiter des données. Traiter des données signifie plus que traiter et afficher des informations à l'utilisateur final. Vous allez avoir besoin de stocker cette information quelque part et de pouvoir y accéder facilement. Grâce à Xamarin et aux logiciels open source, vous pouvez facilement stocker vos données avec une plate-forme testée dans le secteur, SQLite..
Alors, pourquoi avez-vous besoin de vous soucier des données en ce qui concerne votre application? Parce que tout est autour de toi. Vous ne pouvez pas y échapper. Quel que soit le type d'application que vous écrivez, qu'il s'agisse d'un jeu ou d'un utilitaire, vous allez avoir besoin de stocker des données à un moment donné. Ces données peuvent être des données utilisateur, des statistiques ou tout autre élément d’intérêt susceptible de vous intéresser, vous ou l’utilisateur, à un moment donné dans l’utilisation de votre application..
À ce stade, supposons que vous ayez choisi la route Xamarin.Forms, car vous souhaitez cibler plusieurs plates-formes non seulement dans la logique de votre application, mais également dans la couche d'interface utilisateur..
Génial. Mais que faites-vous maintenant pour stocker des informations dans votre application? Ne vous inquiétez pas, il existe une solution très simple à ce problème, SQLite.
Vous avez maintenant vu le terme SQLite à quelques reprises dans ce tutoriel, il est temps de passer à la bonne viande. Qu'est-ce que SQLite? SQLite est un moteur de base de données SQL transactionnel de domaine public, à configuration zéro. Tout cela signifie que vous disposez d'un mécanisme complet pour stocker vos données de manière structurée. Non seulement vous obtenez tout cela, mais vous avez également accès au code source, car il est open source.
Nous ne couvrirons pas toutes les fonctionnalités de SQLite dans ce tutoriel simplement parce qu'il y en a trop à parcourir. Soyez assuré que vous aurez la possibilité de créer facilement une structure de table pour stocker des données et les récupérer dans votre application. Ce sont les concepts sur lesquels nous allons nous concentrer dans ce tutoriel.
Dans le monde de Xamarin.Forms, SQLite est un choix naturel pour une raison très simple. Le moteur SQLite est facilement disponible sur iOS et Android. Cela signifie que vous pouvez utiliser cette technologie immédiatement lorsque vous choisissez d'écrire une application Xamarin.Forms..
L'accès à la fonctionnalité SQLite dans les applications Windows Phone nécessite une étape supplémentaire sur laquelle nous reviendrons un peu plus tard. Toutes ces fonctionnalités et l'accessibilité entre plates-formes sont excellentes, mais comment allons-nous accéder aux implémentations de plate-forme native à partir de notre code C # dans Xamarin.Forms? Dans un joli paquet NuGet, c'est comme ça. Nous allons jeter un coup d'oeil.
Commençons par créer une simple application Xamarin.Forms. Dans ce tutoriel, j'utiliserai un Mac exécutant Xamarin Studio, mais vous pourrez tout aussi facilement utiliser Xamarin Studio ou Visual Studio s'exécutant sur un PC..
Nous commençons le processus en créant une nouvelle application Xamarin.Forms. Pour ce faire, sélectionnez simplement le Application mobile famille de modèles de projet à gauche et choisissez l’un des modèles Xamarin.Forms à droite. Vous pouvez utiliser soit le PCL ou partagé version du modèle, mais dans ce cas, je vais utiliser le PCL. Vous pouvez suivre l’un ou l’autre, mais il y aura une légère différence si vous choisissez la partagé modèle plus tard.
Vous pouvez donner au projet le nom de votre choix. Je vais appeler ce projet IntroToSQLite. Après avoir cliqué sur le D'accord bouton, votre IDE passera par le processus de création de votre solution. Votre solution contiendra quatre projets:
Maintenant que notre structure de projet de base est configurée, nous pouvons commencer à ajouter un accès à SQLite à notre projet PCL. Nous devons installer un nouveau package dans notre projet nommé SQLite.Net. Il s’agit d’un wrapper .NET autour de SQLite qui nous permettra d’accéder aux fonctionnalités natives de SQLite à partir d’un projet PCL ou partagé Xamarin.Forms..
Nous accédons à ce paquet NuGet en faisant un clic droit sur Paquets ou Références, en fonction de l'EDI que vous utilisez, et sélectionnez Ajouter un paquet (ou Référence). Dans le champ de recherche, tapez sqlite.net. Cela vous montrera une assez grande collection de paquets que vous pourrez inclure dans votre projet..
Depuis que j’ai choisi d’emprunter la voie PCL pour mon projet Xamarin.Forms, je devrai sélectionner le SQLite.Net PCL package à inclure dans mon projet. Lequel choisissez-vous si vous avez choisi la route du projet partagé? Aucun.
Si vous avez choisi le modèle de projet partagé précédemment dans le didacticiel, vous vous demandez peut-être comment accéder au package SQLite. La réponse courte est que vous ne pouvez pas. Si vous vous souvenez d'un tutoriel précédent, vous ne pouvez pas ajouter de références à un projet partagé. Pour accéder à SQLite à partir d'un projet partagé, il vous suffit d'ajouter le code source au projet..
La dernière étape de l’ajout de la fonctionnalité SQLite au projet PCL consiste à créer une interface nous permettant d’accéder au monde SQLite. Cela s'explique par le fait que nous devons accéder aux fonctionnalités natives des différentes plates-formes, comme nous l'avons vu dans un précédent tutoriel..
Commençons par définir une interface qui va nous donner accès à la connexion à la base de données SQLite. Dans votre projet PCL, créez une nouvelle interface nommée ISQLite et remplacez la mise en oeuvre par la suivante:
en utilisant le système; using SQLite.Net; espace de noms IntroToSQLite interface publique ISQLite SQLiteConnection GetConnection ();
C’est l’interface que nous allons implémenter et à laquelle nous aurons accès via le DependencyService des implémentations natives.
Nous avons maintenant accès à la fonctionnalité SQLite, définissons notre base de données. Cette application particulière sera assez simple et nous allons simplement stocker certaines de nos pensées aléatoires au fur et à mesure que nous les imaginons..
Nous commençons par créer une classe qui représentera les données stockées dans une table particulière. Appelons cette classe AléatoireThought.
en utilisant le système; using SQLite.Net.Attributes; namespace IntroToSQLite public class RandomThought [PrimaryKey, AutoIncrement] public int ID get; ensemble; chaîne publique Thought get; ensemble; public DateTime CreatedOn get; ensemble; public RandomThought ()
Comme vous pouvez le constater, cette classe est très simple et possède trois propriétés. Deux de ces propriétés ne sont que les propriétés de votre quotidien, Pensée et Créé sur. Ces deux propriétés vont représenter des colonnes dans la base de données SQLite, qui contiendra une table nommée AléatoireThought. La troisième propriété, ID, va également représenter une colonne dans la table et contenir un identifiant unique que nous pouvons utiliser pour faire référence à un AléatoireThought rangée dans la table.
La chose intéressante à propos de la ID la propriété est qu'il est décoré avec deux attributs, Clé primaire et Incrémentation automatique. Clé primaire indique à SQLite que cette colonne sera la clé primaire de la table, ce qui signifie que, par défaut, elle doit être unique et qu'un index lui est appliqué pour accélérer les extractions de cette table lorsque vous vous référez à une ligne. colonne.
Incrémentation automatique signifie que, lorsque nous insérons un nouveau AléatoireThought dans cette table, le ID La colonne sera automatiquement renseignée avec la prochaine valeur entière disponible. L'étape suivante consiste à créer cette table dans la base de données..
J'aime créer une classe qui représente ma base de données et garder toute la logique pour accéder à la base de données et à ses tables au sein de cette classe. Pour cela, je vais créer une classe nommée RandomThoughtDatabase:
en utilisant le système; using SQLite.Net; using Xamarin.Forms; using System.Collections.Generic; using System.Linq; espace de noms IntroToSQLite public class RandomThoughtDatabase private SQLiteConnection _connection; public RandomThoughtDatabase () _connection = DependencyService.Get() .GetConnection (); _connection.CreateTable (); public IEnumerable GetThoughts () return (de t dans _connection.Table () sélectionnez t) .ToList (); public RandomThought GetThought (id int) return _connection.Table () .FirstOrDefault (t => t.ID == id); public void DeleteThought (int id) _connection.Delete (id); public void AddThought (pensée de chaîne) var newThought = new RandomThought Pensée = pensée, CreatedOn = DateTime.Now; _connection.Insert (newThought);
Ceci est une implémentation très simple car elle ne contient que quelques méthodes. Ce sont généralement certaines des opérations de base que vous effectuez lorsque vous utilisez une base de données. Un point à noter est le constructeur. Au sein du constructeur, nous faisons deux choses.
Premièrement, nous utilisons le DependencyService classe pour obtenir une classe enregistrée qui implémente la ISQLite interface et appeler son GetConnection méthode.
Deuxièmement, nous utilisons le CreateTable méthode sur le SQLiteConnection classe pour créer une table appelée AléatoireThought. Cette méthode va créer la table, si elle n'existe pas déjà, et se fermer normalement si elle existe déjà.
Il est évident que vous pouvez obtenir le niveau de sophistication souhaité avec cette classe en ajoutant toutes sortes de fonctionnalités, mais ces opérations constituent généralement un bon point de départ..
La plupart du code que nous utilisons pour interagir avec la base de données se trouve dans le projet PCL (ou partagé). Mais nous avons encore besoin de faire un peu de câblage dans les implémentations natives pour que tout fonctionne correctement.
Le principal obstacle sur lequel nous devons travailler du côté natif lors de l'utilisation de SQLite est l'emplacement où nous allons stocker le fichier de base de données proprement dit. Cela diffère d'une plateforme à l'autre. Voici ce dont nous avons besoin pour iOS.
Avant de pouvoir ajouter une quelconque fonctionnalité SQLite au projet iOS, nous devons ajouter le SQLite.Net PCL aussi bien que SQLite.NET PCL - Plateforme XamarinIOS paquets à ce projet. Vous pouvez suivre les mêmes étapes que vous avez prises dans Étape 2, en veillant à ajouter les deux au projet. Une fois que vous avez ajouté ce paquet, vous pouvez commencer à écrire du code SQLite dans le projet iOS..
Créons une implémentation du ISQLite interface pour iOS. Commencez par créer une nouvelle classe, en la nommant SQLite_iOS.
en utilisant le système; using System.IO; en utilisant SQLite; using IntroToSQLite.iOS; using Xamarin.Forms; [assembly: Dependency (typeof (SQLite_iOS))] espace de nom IntroToSQLite.iOS classe publique SQLite_iOS: ISQLite public SQLite_iOS () # région Implémentation ISQLite publique SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); var libraryPath = Path.Combine (documentsPath, "…", "Bibliothèque"); var path = Path.Combine (libraryPath, fileName); var plateforme = nouvelle SQLite.Net.Platform.XamarinIOS.SQLitePlatformIOS (); var connection = new SQLite.Net.SQLiteConnection (plate-forme, chemin); connexion de retour; #endregion
Nous avons accès au bon emplacement pour stocker le fichier de base de données, créer un nouveau SQLiteConnection objet et le renvoyer à notre projet PCL (ou partagé). L’attribut assembly en haut du fichier est utilisé pour identifier cette classe en tant que Dépendance qui peut être récupéré via le Obtenir méthode sur le DependencyService classe.
Cette étape est très similaire à la précédente. La seule différence est que le code changera un peu en raison du fait que l'emplacement du fichier de base de données sera différent. Vous devrez toujours ajouter les packages appropriés au projet Android (SQLite.Net PCL et SQLite.NET PCL - XamarinAndroid) comme vous l'avez fait auparavant. Une fois que vous avez terminé, vous pouvez ajouter le code approprié dans une nouvelle classe nommée SQLite_Android.
en utilisant le système; using System.IO; using Xamarin.Forms; using IntroToSQLite.Android; [assembly: Dependency (typeof (SQLite_Android))] espace de noms IntroToSQLite.Android classe publique SQLite_Android: ISQLite public SQLite_Android () #region Implémentation ISQLite publique SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThoughtbb" ; var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); var path = Path.Combine (documentsPath, fileName); var plate-forme = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid (); var connection = new SQLite.Net.SQLiteConnection (plate-forme, chemin); connexion de retour; #endregion
Vous avez maintenant une implémentation fonctionnelle de l'interface ISQLite du point de vue de votre application Android..
Depuis que je lance cette application depuis un Mac, je ne créerai pas l'implémentation Windows Phone, mais si vous le souhaitez, vous pouvez.
La première étape consiste à ajouter un support à votre projet Windows Phone pour SQLite. Comme mentionné précédemment, SQLite est fourni par défaut sur iOS et Android. Ce n'est pas vrai pour Windows Phone, mais c'est supporté. Pour l’installer, vous pouvez suivre les instructions fournies sur le site Web de Xamarin..
Après avoir installé SQLite, le processus d’ajout de fonctionnalités pour Windows Phone sera presque identique, à la différence que les packages à installer sont: SQLite.Net PCL et SQLite.Net PCL - Plateforme WindowsPhone 8. Avec ces packages installés, vous pouvez créer l’implémentation Windows Phone du ISQLite interface.
en utilisant le système; using System.IO; using Xamarin.Forms; using IntroToSQLite.WinPhone; [assembly: Dependency (typeof (SQLite_WinPhone)] espace de nom IntroToSQLite.WinPhone classe publique SQLite_WinPhone: ISQLite public SQLite_WinPhone () #region Implémentation ISQLite publique SQLite.Net.SQLiteConnectionConnection (Connection) var path = Path.Combine (ApplicationData.Current.LocalFolder.Path, fileName); var plate-forme = new SQLite.Net.Platform.WindowsPhone8.SQLitePlatformWP8 (); var connexion = new SQLite.Net.SQLiteConnection (plate-forme, chemin);; return connexion; #endregion
Voilà. Maintenant, toutes vos implémentations natives sont terminées. Il est temps de donner à cette application une interface utilisateur et de transférer vos données dans la base de données..
Étant donné que ce didacticiel aborde bien le sujet de Xamarin.Forms, je suppose que vous avez au moins une connaissance de base de Xamarin.Forms. Avec cette hypothèse à l'esprit, je ne vais pas entrer dans les détails du processus de création de l'interface utilisateur. Si vous avez besoin de plus d'informations de base sur Xamarin.Forms, consultez mes autres tutoriels Xamarin.Forms sur Tuts+.
L'interface utilisateur sera composée de deux pages distinctes. La première page contient une liste de toutes les pensées que nous avons entrées dans une liste, tandis que la deuxième page permet à l'utilisateur d'entrer une nouvelle pensée. Construisons ces pages.
Nous allons d’abord nous concentrer sur la création de la première page qui contiendra une liste de AléatoireThought objets. Commencez par créer un nouveau fichier dans le projet PCL (ou partagé) et nommez-le. RandomThoughtsPage. Remplacez l'implémentation par défaut par ce qui suit:
en utilisant le système; using Xamarin.Forms; espace de nom IntroToSQLite public class RandomThoughtsPage: ContentPage private RandomThoughtDatabase _database; liste privée _thoughtList; public RandomThoughtsPage (base de données RandomThoughtDatabase) _database = base de données; Title = "Pensées aléatoires"; var pensées = _database.GetThoughts (); _thoughtList = new ListView (); _thoughtList.ItemsSource = pensées; _thoughtList.ItemTemplate = new DataTemplate (typeof (TextCell)); _thoughtList.ItemTemplate.SetBinding (TextCell.TextProperty, "Pensée"); _thoughtList.ItemTemplate.SetBinding (TextCell.DetailProperty, "CreatedOn"); var toolbarItem = new ToolbarItem Name = "Ajouter", commande = new commande (() => Navigation.PushAsync (new ThoughtEntryPage (this, base de données))); ToolbarItems.Add (toolbarItem); Content = _thoughtList; public void Refresh () _thoughtList.ItemsSource = _database.GetThoughts ();
La plupart des travaux effectués dans cette classe sont dans le constructeur. Le constructeur nous permet de passer dans une instance du RandomThoughtsDatabase pour obtenir toutes les pensées sauvegardées. Nous avons mis le Titre propriété de la page à "Pensées aléatoires", récupérer toutes les pensées existantes, créer une nouvelle instance d'un ListView, et créer un ToolbarItem cela nous permettra de cliquer sur un bouton pour afficher la page de saisie. Nous n'avons pas encore implémenté cela, mais nous allons bientôt.
Pour obtenir notre nouveau RandomThoughtsPage sur l'écran, nous devons apporter une petite modification à la App.cs fichier. Dans ce fichier, modifiez le GetMainPage méthode pour ressembler à ce qui suit:
page statique publique GetMainPage () var database = new RandomThoughtDatabase (); renvoyer new NavigationPage (new RandomThoughtsPage (database));
le GetMainPage méthode crée maintenant une nouvelle instance de notre RandomThoughtDatabase classe et retourne une nouvelle instance du RandomThoughtsPage. Avec ce changement, nos applications iOS et Android devraient ressembler à ceci:
Nous avons maintenant une page de liste pour tous nos AléatoireThought objets, mais nous n'avons pas le moyen d'en saisir de nouveaux. Pour cela, nous allons créer une autre page similaire à la page précédente. Créez un nouveau fichier dans votre projet PCL (ou partagé) et appelez-le. PenséeEntréePage. Remplacez l'implémentation par défaut par ce qui suit:
en utilisant le système; using Xamarin.Forms; espace de noms IntroToSQLite public class ThoughtEntryPage: ContentPage private RandomThoughtsPage _parent; private RandomThoughtDatabase _database; public ThoughtEntryPage (parent RandomThoughtsPage, base de données RandomThoughtDatabase) _parent = parent; _database = base de données; Title = "Entrez une pensée"; var entry = nouvelle entrée (); var button = new Button Text = "Ajouter"; button.Clicked + = async (expéditeur d'objet, EventArgs e) => var pensé = entry.Text; _database.AddThought (pensée); attendez Navigation.PopAsync (); _parent.Refresh (); ; Contenu = new StackLayout Espacement = 20, Padding = nouvelle épaisseur (20), Enfants = entrée, bouton,;
Dans cette classe, tout le travail est effectué dans le constructeur. Nous obtenons une référence à la page parente, RandomThoughtsPage, ainsi que la base de données. Le reste est du code de configuration de base avec un Entrée objet pour la saisie de texte et une Bouton.
Une fois que l'utilisateur appuie sur le Bouton, nous utilisons la base de données pour ajouter la nouvelle pensée, fermer la page, revenir à la page de la liste et appeler le Rafraîchir méthode pour mettre à jour le ListView. Une fois que tout cela est câblé, nous pouvons l'exécuter pour entrer certaines valeurs.
Voici à quoi cela ressemble sur iOS et Android pour entrer dans certaines de vos pensées:
Après avoir entré quelques réflexions, votre liste ressemblera à ceci:
Voilà. Vous avez maintenant la possibilité d'ajouter des fonctionnalités de base de données à votre application Xamarin.Forms pour stocker et récupérer tout type de données en toute simplicité..
Pour continuer votre parcours d’apprentissage avec Xamarin.Forms et SQLite, je vous lance le défi suivant. Voyez si vous pouvez améliorer cette application pour permettre la suppression d’opinions et mettre à jour la page de liste de la même manière que la page de saisie. Bonne chance et bon codage.
Accentsconagua