Utilisation de bases de données locales sur Windows Phone 8

Dans l'article précédent, vous avez appris à stocker des données dans le stockage isolé de votre application. Dans cet article, nous nous concentrons sur l'utilisation de bases de données locales qui résident dans le stockage isolé de votre application. Vous en apprendrez davantage sur les opérations de base de données à l'aide de LINQ, les schémas de base de données, ainsi que sur la procédure d'extraction des données d'une base de données locale..

1. Introduction

Vous pouvez stocker des données relationnelles dans une base de données localequi vit dans le stockage isolé de votre application. Toutes les opérations de base de données sur Windows Phone sont effectuées à l'aide de LINQ to SQL. Il est utilisé pour définir le schéma de base de données, sélectionner des données et enregistrer les modifications apportées au fichier de base de données sous-jacent résidant dans le dossier local.. 

Le modèle objet LINQ to SQL utilise le System.Data.Linq.DataContext namespace pour faire un appel proxy à la base de données locale. Le runtime LINQ to SQL agit comme un pont entre le contexte de données objet et le données réelles faire des manipulations.

Lorsque vous travaillez avec des bases de données locales sur Windows Phone, il est important de garder à l'esprit les points suivants:

• La base de données locale s'exécute dans le processus de l'application Windows Phone. Il ne fonctionne pas en permanence en tant que service d'arrière-plan.
• Vous ne pouvez y accéder que par l'application Windows Phone correspondante..
  
• On ne peut y accéder qu'avec LINQ to SQL, Transact-SQL n'est pas pris en charge..
• Pour synchroniser l’accès au dossier local à travers différents threads, le Mutex la classe est utilisée.
  
• Il n'est pas recommandé de chiffrer le fichier de base de données de référence si vous souhaitez y accéder exclusivement à partir du dossier d'installation. Cela empêche le système d'effectuer des opérations de maintenance de base de la base de données, telles que la réindexation, lors de la première connexion..

Cet article explique comment créer une base de données locale et y insérer, mettre à jour ou supprimer des données. Nous allons construire un exemple d’application avec un Détails de l'utilisateur table et effectuer diverses opérations dessus. Nous allons séparer les fichiers de code pour différentes opérations telles que insérer, mettre à jour et supprimer pour des raisons de commodité.. 

2. Construire le contexte de données

Les tables de la base de données peuvent être définies n’importe où dans l’application, à condition qu’elles soient accessibles globalement. Nous créons un fichier séparé, DB.cs, pour toutes les tables. Dans ce fichier, nous spécifions un modèle d'objet qui détermine la schéma de base de données et créer le contexte de données.

Étape 1: Ajout de références

Ajoutez les directives suivantes en haut de la DB.cs fichier pour référencer l'assemblage LINQ to SQL:

using System.Data.Linq; using System.Data.Linq.Mapping;

Étape 2: Créer une table

Ajouter une classe d'entité nommée Détails utilisateur qui représente la table de base de données de l'application dans la base de données locale. L'attribut [Table] indique le runtime LINQ to SQL pour mapper la classe sur une table de base de données locale.

[Table] public class User_details [[Column (IsDbGenerated = true, IsPrimaryKey = true)] public int ID get; ensemble;  [Colonne] chaîne publique nom_utilisateur get; ensemble;  [Column] public string user_email get; ensemble; 

Comme vous pouvez le voir, le Détails utilisateur La classe a trois propriétés publiques qui correspondent à trois colonnes de la base de données:

• ID est une colonne d'identifiant qui est automatiquement renseignée par la base de données. C'est également la clé primaire pour laquelle un index de base de données est créé automatiquement. Ces paramètres et plus encore sont spécifiés avec l'attribut de mappage de colonne LINQ to SQL écrit au-dessus de la syntaxe de la propriété..
• Nom d'utilisateur est une colonne pour stocker le nom de l'utilisateur.
• utilisateur_email est une colonne pour stocker l'adresse email de l'utilisateur.

Étape 1: Définition du contexte de données

La classe UserDataContext hérite de DataContext et est appelé le contexte de données. Ce code appelle le constructeur de base et déclare la table de base de données nommée Détails utilisateur. La base de données locale est stockée dans la mémoire de stockage isolée de l'application. Dans notre exemple, elle est enregistrée sous le nom Bases de données.sdf. 

Classe publique UserDataContext: DataContext chaîne statique publique DBConnectionString = @ "isostore: /Databases.sdf"; public UserDataContext (string connectionString): base (connectionString)  table publique Les utilisateurs get return this.GetTable(); 

Notez qu'il n'est pas nécessaire que la chaîne de connexion à la base de données soit un champ statique. Nous utilisons DBConnectionString dans ce cas juste pour plus de commodité.

3. Création de la base de données

Pour créer la base de données, ouvrez le fichier de code derrière l'application, nommé App.xaml.cs. Ajoutez le code suivant à la fin de son constructeur, nommé App.

using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) if (! context.DatabaseExists ()) context.CreateDatabase (); 

Le code de création de base de données est ajouté ici pour que la base de données soit présente avant l'exécution du code de la page principale. Le code vérifie si la base de données existe et, si aucune base de données n'est trouvée, une nouvelle est créée.

4. Opérations de base de données

Une fois le contexte de données créé et la base de données créée, nous pouvons effectuer des opérations dessus. Vous pouvez insérer, mettre à jour et supprimer des enregistrements de la table que nous venons de créer. Nous avons créé des classes séparées pour contenir des fonctions pour les opérations d'insertion, de suppression et de mise à jour..

Étape 1: Insérer des enregistrements

C'est pratique de créer un fichier de classe séparé, DatabaseAdd.cs, pour ajouter des enregistrements à la base de données. Définir une fonction AddUser qui prend prénom et email_id en tant que paramètres et ajoute un enregistrement à la Détails utilisateur table.

public void AddUser (Nom de chaîne, Adresse électronique de chaîne) using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) User_details du = new User_details (); du.user_name = name; du.user_email = email; context.Users.InsertOnSubmit (du); context.SubmitChanges (); 

le AddUser la fonction utilise leUserDataContext contexte de données pour se connecter à la base de données, crée une nouvelle instance du Détails utilisateur classe d'entité et insère un enregistrement.

Les nouveaux éléments ajoutés au contexte de données ne sont pas enregistrés dans la base de données tant que la Soumettre des changements la fonction est appelée. Appeler le AddUser fonction pour ajouter un enregistrement à la base de données.

DatabaseAdd add = new DatabaseAdd (); add.AddUser ("vivek", "[email protected]");

Étape 2: Récupération des enregistrements

Créer un fichier de classe séparé, FetchDatabase.cs, pour récupérer des enregistrements de la base de données. Cette classe contient un GetAllUsers fonction qui retourne un IListe exemple, contenant les enregistrements extraits de la table.

La connexion est établie à l’aide du contexte de données après lequel les enregistrements sont extraits de la Détails utilisateur table. La requête LINQ renvoie un IListe instance contenant les enregistrements récupérés. le IListe l'instance n'est rien de plus qu'une collection d'objets du même type.

publiciste GetAllUsers () IList list = null; using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable query = de c dans le contexte.Les utilisateurs sélectionnent c; list = query.ToList ();  liste de retour; 

Dans l’extrait de code ci-dessous, nous définissons un Utilisateurs classe avec des membres de données identifiant, prénom, et email pour conserver les détails des enregistrements récupérés.

utilisateurs de classe public string id get; ensemble;  nom de chaîne publique get; ensemble;  chaîne publique email get; ensemble; 

Créer une autre fonction, getAllUsers, qui retourne une liste de Utilisateurs quand appelé. La fonction crée une nouvelle liste pour contenir les détails des utilisateurs récupérés. Il itère à travers le IListe instance nommée usrs et ajoute les détails de chaque utilisateur au tous les utilisateurs exemple.

liste publique getUsers () IList usrs = this.GetAllUsers (); liste allUsers = nouvelle liste(); foreach (User_details m in usrs) Utilisateurs n = nouveaux utilisateurs (); n.id = m.ID.ToString (); n.name = m.user_name; n.email = m.user_email; allUsers.Add (n);  return allUsers; 

Dans l'exemple d'application de cet article, le getUtilisateurs fonction est utilisée pour définir la ItemSource du Zone de liste nommé tous les utilisateurs comme indiqué ci-dessous.

FetchDatabase fetch = new FetchDatabase (); allusers.ItemsSource = fetch.getUsers ();

Étape 3: Mise à jour des enregistrements

La mise à jour des enregistrements est très similaire à l'ajout d'enregistrements à une table. Poursuivant notre approche modulaire, nous créons un nouveau fichier de classe., DatabaseUpdate.cs, pour les mises à jour de la base de données. Contrairement aux opérations de suppression, aucune fonction ne permet de mettre à jour plusieurs enregistrements à la fois..

Ajouter une fonction UpdateUsers qui accepte un identifiant, prénom, et email_id, et met à jour la ligne de la table pour le correspondant identifiant.

public void UpdateUser (int id, Chaîne email, Nom chaîne) utilisant (UserDataContext contexte = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users où c.ID == id sélectionne c; User_details entityToUpdate = entityQuery.FirstOrDefault (); entityToUpdate.user_name = nom; entityToUpdate.user_email = email; context.SubmitChanges (); 

La fonction interroge la base de données et stocke le premier enregistrement correspondant dans la entité à mettre à jour variable. Il met ensuite à jour l'enregistrement en attribuant les nouvelles valeurs et soumet les modifications pour mettre à jour la base de données..

La base de données n’est mise à jour que lorsque nous appelons le Soumettre des changements une fonction. Cette fonction ne mettra à jour que le premier enregistrement correspondant. le UpdateUser la fonction est appelée pour mettre à jour les enregistrements existants dans la base de données, comme indiqué ci-dessous.

DatabaseUpdate update = new DatabaseUpdate (); update.UpdateUser (1, "[email protected]", "vivek.maskara");

Pour mettre à jour plusieurs enregistrements, vous devez parcourir les enregistrements que vous souhaitez mettre à jour un par un. Dans l'extrait de code suivant, nous mettons à jour le nom de chaque utilisation de la base de données en le mettant en minuscule..

using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = à partir de c dans le contexte.Les utilisateurs sélectionnent c; IListe entityToUpdate = entityQuery.ToList (); foreach (User_details utilisateur dans entityToUpdate) user.name_user = user.name_user.ToLower ();  context.SubmitChanges (); 

Étape 4: Suppression des enregistrements

Créer un fichier de classe, DatabaseDelete.cs ,pour les opérations de suppression. dans le DatabaseDelete classe, ajouter un Supprimer l'utilisateur fonction qui accepte un paramètre identifiant et supprime un utilisateur unique dont identifiant correspond au paramètre transmis.

public void DeleteUser (String id) // delete user by id using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString))) IQueryable entityQuery = from c in context.Users où c.ID.Equals (id), sélectionnez c; User_details entityToDelete = entityQuery.FirstOrDefault (); context.Users.DeleteOnSubmit (entityToDelete); context.SubmitChanges (); 

Les appels de fonction DeleteOnSubmit, qui supprime un seul enregistrement de la base de données. Les modifications sont enregistrées lorsque le Soumettre des changements la fonction est appelée. le Supprimer l'utilisateur fonction supprime un seul enregistrement de la base de données, comme indiqué ci-dessous.

DatabaseDelete delete = new DatabaseDelete (); delete.DeleteUser ("1");

le System.Data.Linq l'assemblage fournit une fonction DeleteAllOnSubmit supprimer plusieurs enregistrements à la fois. L’extrait de code suivant tronque la Détails utilisateur table.

using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = à partir de c dans le contexte.Les utilisateurs sélectionnent c; IListe entityToDelete = entityQuery.ToList (); context.Users.DeleteAllOnSubmit (entityToDelete); context.SubmitChanges (); 

Cette fonction accepte une liste d'enregistrements et supprime les enregistrements de cette liste. Notez que dans les deux cas, les modifications ne sont enregistrées que lorsque Soumettre des changements la fonction s'appelle.

Conclusion

Les applications Windows Phone utilisent LINQ to SQL pour toutes les opérations de base de données. LINQ to SQL est utilisé pour définir le schéma de base de données, sélectionner des données et enregistrer les modifications apportées au fichier de base de données sous-jacent résidant dans la mémoire de stockage isolée de l'application. LINQ to SQL fournit une approche orientée objet pour travailler avec des données stockées dans une base de données et consiste en un modèle objet et un environnement d'exécution. Je vous recommande de lire cet article MSDN pour connaître les meilleures pratiques d'utilisation des bases de données locales. N'hésitez pas à télécharger les fichiers sources du didacticiel à utiliser comme référence.