Werken met lokale databases op Windows Phone 8

In het vorige artikel hebt u geleerd hoe u gegevens kunt opslaan in de geïsoleerde opslag van uw app. In dit artikel richten we ons op het werken met lokale databases die zich in de geïsoleerde opslag van uw app bevinden. U leert over databasebewerkingen met LINQ, databaseschema's en ook hoe u gegevens uit een lokale database ophaalt.

1. Inleiding

U kunt relationele gegevens opslaan in een lokale databasedie in de geïsoleerde opslagruimte van uw app woont. Alle databasebewerkingen op Windows Phone worden uitgevoerd met LINQ to SQL. Het wordt gebruikt om het databaseschema te definiëren, gegevens te selecteren en wijzigingen op te slaan in het onderliggende databasebestand dat zich in de lokale map bevindt. 

Het LINQ to SQL-objectmodel gebruikt de System.Data.Linq.DataContext naamruimte om een ​​proxy-oproep naar de lokale database te maken. De LINQ-naar-SQL-runtime fungeert als een brug tussen de gegevenscontext object en de echte gegevens om manipulaties te doen.

Bij het werken met lokale databases op Windows Phone is het belangrijk om het volgende in gedachten te houden:

• De lokale database wordt uitgevoerd in het proces van de Windows Phone-app. Het werkt niet continu als achtergrondservice.
• Het is alleen toegankelijk via de bijbehorende Windows Phone-app.
  
• Het is alleen toegankelijk met LINQ to SQL, Transact-SQL wordt niet ondersteund.
• Om de toegang tot de lokale map over verschillende threads te synchroniseren, de mutex klasse wordt gebruikt.
  
• Het wordt niet aanbevolen om het referentiedatabasebestand te coderen als u het uitsluitend vanuit de installatiemap wilt openen. Hierdoor wordt voorkomen dat het systeem tijdens de eerste verbinding routinematige onderhoudswerkzaamheden aan de database uitvoert, zoals opnieuw indexeren.

Dit artikel laat zien hoe u een lokale database kunt maken en er gegevens uit kunt invoegen, bijwerken of verwijderen. We zullen een voorbeeldtoepassing bouwen met een gebruikersdetails tabel en voer verschillende bewerkingen uit. We zullen de codebestanden scheiden voor verschillende handelingen, zoals invoegen, bijwerken en verwijderen voor het gemak. 

2. De gegevenscontext opbouwen

De tabellen voor de database kunnen overal in de app worden gedefinieerd, zolang deze wereldwijd toegankelijk zijn. We maken een afzonderlijk bestand, DB.cs, voor alle tafels. In dit bestand specificeren we een objectmodel dat de databaseschema en maak de gegevenscontext.

Stap 1: Verwijzingen toevoegen

Voeg de volgende richtlijnen toe aan de bovenkant van de DB.cs bestand om naar LINQ to SQL assembly te verwijzen:

met behulp van System.Data.Linq; using System.Data.Linq.Mapping;

Stap 2: Een tabel maken

Voeg een entiteitenklasse toe met de naam Gebruikersdetails dat staat voor de databasetabel van de app in de lokale database. Het kenmerk [Tafel] geeft de LINQ to SQL-runtime aan om de klasse toe te wijzen aan een lokale databasetabel.

[Tabel] public class User_details [Column (IsDbGenerated = true, IsPrimaryKey = true)] public int ID get; vast te stellen;  [Column] public string user_name get; vast te stellen;  [Kolom] openbare tekenreeks user_email get; vast te stellen; 

Zoals u kunt zien, de Gebruikersdetails class heeft drie openbare eigenschappen die overeenkomen met drie databasekolommen:

• ID kaart is een kolom voor identificaties die automatisch wordt ingevuld door de database. Het is ook de primaire sleutel waarvoor automatisch een database-index wordt gemaakt. Deze instellingen en meer worden gespecificeerd met het kenmerk LINQ to SQL column mapping dat is geschreven boven de eigenschapsyntaxis.
• user_name is een kolom om de naam van de gebruiker op te slaan.
• user_email is een kolom om het e-mailadres van de gebruiker op te slaan.

Stap 1: gegevenscontext definiëren

De klas UserDataContext erft van DataContext en wordt de gegevenscontext. Deze code roept de basisconstructor aan en declareert de databasetabel met de naam Gebruikersdetails. De lokale database wordt opgeslagen in de geïsoleerde opslag van de app en wordt in ons voorbeeld opgeslagen als Databases.sdf. 

public class UserDataContext: DataContext public static string DBConnectionString = @ "isostore: /Databases.sdf"; public UserDataContext (string connectionString): base (connectionString)  openbare tabel Gebruikers krijgen return this.GetTable(); 

Merk op dat de databaseverbindingsreeks geen statisch veld hoeft te zijn. We gebruiken DBConnectionString in dit geval voor het gemak.

3. De database maken

Om de database te maken, opent u de code achter het bestand van de app, genaamd App.xaml.cs. Voeg de volgende code aan het einde van de constructor, genaamd App.

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

De code voor het maken van de database wordt hier toegevoegd, zodat de database aanwezig is voordat de code van de hoofdpagina wordt uitgevoerd. De code controleert of de database bestaat en, als er geen database wordt gevonden, wordt een nieuwe gemaakt.

4. Databasebewerkingen

Nadat de gegevenscontext is opgebouwd en de database is gemaakt, kunnen we er bewerkingen op uitvoeren. U kunt records invoegen, bijwerken en verwijderen uit de tabel die we zojuist hebben gemaakt. We hebben aparte klassen gemaakt om functies bij te houden voor het invoegen, verwijderen en bijwerken van bewerkingen.

Stap 1: Records invoegen

Het is handig om een ​​apart klassenbestand te maken, DatabaseAdd.cs, voor het toevoegen van records aan de database. Definieer een functie Voeg gebruiker toe dat duurt naam en e-mail identiteit als parameters en voegt een record toe aan de Gebruikersdetails tafel.

public void AddUser (String naam, String email) using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) User_details du = new User_details (); du.user_name = naam; du.user_email = e-mail; context.Users.InsertOnSubmit (du); context.SubmitChanges (); 

De Voeg gebruiker toe functie gebruikt deUserDataContext gegevenscontext om verbinding te maken met de database, maakt een nieuw exemplaar van de Gebruikersdetails entiteitsklasse en voegt een record in.

Nieuwe items die aan de gegevenscontext zijn toegevoegd, worden pas in de database opgeslagen SubmitChanges functie wordt aangeroepen. Bel de Voeg gebruiker toe functie om een ​​record aan de database toe te voegen.

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

Stap 2: Records ophalen

Maak een apart klassenbestand, FetchDatabase.cs, voor het ophalen van records uit de database. Deze klasse bevat een GetAllUsers functie die een retourneert IList bijvoorbeeld, die de records bevat die zijn opgehaald uit de tabel.

De verbinding wordt opgezet met behulp van de gegevenscontext waarna records worden opgehaald uit de Gebruikersdetails tafel. De LINQ-query retourneert een IList exemplaar met de opgehaalde records. De IList instance is niets meer dan een verzameling objecten van hetzelfde type.

openbare IList GetAllUsers () IList lijst = null; using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable query = from c in context.Users selecteren c; list = query.ToList ();  retourlijst; 

In het onderstaande codefragment definiëren we a gebruikers klasse met data-leden ID kaart, naam, en e-mail om de details van de opgehaalde records te bewaren.

class Users public string id get; vast te stellen;  openbare tekenreeksnaam get; vast te stellen;  openbare reeks e-mail get; vast te stellen; 

Maak een andere functie, getAllUsers, dat geeft een lijst van gebruikers wanneer gebeld. De functie maakt een nieuwe lijst met de details van de opgehaalde gebruikers. Het itereert door de IList exemplaar genoemd USR en voegt de details van elke gebruiker toe aan de alle gebruikers aanleg.

openbare lijst getUsers () IList usrs = this.GetAllUsers (); Lijst allUsers = nieuwe lijst(); foreach (User_details m in usrs) Users n = new Users (); n.id = m.ID.ToString (); n.name = m.user_name; n.email = m.user_email; allUsers.Add (n);  return allUsers; 

In de voorbeeldtoepassing van dit artikel, de getUsers functie wordt gebruikt om de ItemSource van de Keuzelijst genaamd alle gebruikers zoals hieronder getoond.

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

Stap 3: Records bijwerken

Het bijwerken van records lijkt sterk op het toevoegen van records aan een tabel. Voortbouwend op onze modulaire aanpak, creëren we een nieuw klassenbestand, DatabaseUpdate.cs, voor database-updates. In tegenstelling tot verwijderbewerkingen, is er geen functie om meerdere records tegelijk bij te werken.

Voeg een functie toe UpdateUsers dat accepteert een ID kaart, naam, en e-mail identiteit, en werkt de tabelrij bij voor de bijbehorende ID kaart.

public void UpdateUser (int id, String email, String naam) using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users waarbij c.ID == id c selecteert; User_details entityToUpdate = entityQuery.FirstOrDefault (); entityToUpdate.user_name = naam; entityToUpdate.user_email = e-mail; context.SubmitChanges (); 

De functie ondervraagt ​​de database en slaat de eerste overeenkomende record op in de entityToUpdate variabel. Vervolgens wordt de record bijgewerkt door de nieuwe waarden toe te wijzen en worden de wijzigingen ingediend om de database bij te werken.

De database wordt niet bijgewerkt totdat we de SubmitChanges functie. Deze functie werkt alleen de eerste overeenkomende record bij. De UpdateUser functie wordt aangeroepen om bestaande records in de database bij te werken zoals hieronder getoond.

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

Als u meerdere records wilt bijwerken, moet u de records herhalen die u een voor een wilt bijwerken. In het volgende codefragment werken we de naam bij van elk gebruik in de database door deze in kleine letters te maken.

using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users selecteren c; IList entityToUpdate = entityQuery.ToList (); foreach (User_details user in entityToUpdate) user.user_name = user.user_name.ToLower ();  context.SubmitChanges (); 

Stap 4: Records verwijderen

Maak een klassenbestand, DatabaseDelete.cs ,voor wisbewerkingen. In de DatabaseDelete klasse, voeg een toe Verwijder gebruiker functie die een parameter accepteert ID kaart en verwijdert een enkele gebruiker wiens ID kaart komt overeen met de ingevoerde parameter.

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

De functie roept op DeleteOnSubmit, waarmee één record uit de database wordt verwijderd. De wijzigingen worden opgeslagen wanneer de SubmitChanges functie wordt aangeroepen. De Verwijder gebruiker functie verwijdert een enkel record uit de database zoals hieronder getoond.

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

De System.Data.Linq montage biedt een functie DeleteAllOnSubmit om meerdere records tegelijk te verwijderen. Met het volgende codefragment wordt het. Afgekapt Gebruikersdetails tafel.

using (UserDataContext context = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users selecteren c; IList entityToDelete = entityQuery.ToList (); context.Users.DeleteAllOnSubmit (entityToDelete); context.SubmitChanges (); 

Deze functie accepteert een lijst met records en verwijdert de records in die lijst. Merk op dat in beide gevallen de wijzigingen alleen worden opgeslagen als de SubmitChanges functie wordt aangeroepen.

Conclusie

Windows Phone-apps gebruiken LINQ to SQL voor alle databasebewerkingen. LINQ to SQL wordt gebruikt om het databaseschema te definiëren, gegevens te selecteren en wijzigingen op te slaan in het onderliggende databasebestand dat zich in de geïsoleerde opslag van de app bevindt. LINQ to SQL biedt een objectgerichte benadering voor het werken met gegevens die zijn opgeslagen in een database en bestaat uit een objectmodel en een runtime. Ik raad u aan dit MSDN-artikel te lezen voor praktische tips voor het gebruik van lokale databases. Download de bronbestanden van de zelfstudie om deze als referentie te gebruiken.