Lavorare con i database locali su Windows Phone 8

Nell'articolo precedente, hai imparato a memorizzare i dati nella memoria isolata della tua app. In questo articolo, ci concentriamo sul lavoro con database locali che vivono nella memoria isolata della tua app. Imparerai a conoscere le operazioni del database utilizzando LINQ, gli schemi di database e come recuperare i dati da un database locale.

1. Introduzione

È possibile memorizzare i dati relazionali in un database localeche vive nella memoria isolata della tua app. Tutte le operazioni di database su Windows Phone vengono eseguite utilizzando LINQ to SQL. Viene utilizzato per definire lo schema del database, selezionare i dati e salvare le modifiche nel file di database sottostante che risiede nella cartella locale. 

Il modello a oggetti LINQ to SQL utilizza il System.Data.Linq.DataContext spazio dei nomi per effettuare una chiamata proxy al database locale. Il runtime LINQ to SQL funge da ponte tra il contesto dati oggetto e il dati reali fare manipolazioni.

Quando si lavora con database locali su Windows Phone, è importante tenere presente quanto segue:

• Il database locale viene eseguito nel processo dell'app Windows Phone. Non funziona continuamente come servizio in background.
• È possibile accedervi solo dall'app di Windows Phone corrispondente.
  
• È accessibile solo con LINQ to SQL, Transact-SQL non è supportato.
• Per sincronizzare l'accesso alla cartella locale attraverso diversi thread, il mutex la classe è usata.
  
• Non è consigliabile crittografare il file di database di riferimento se si accederà esclusivamente dalla cartella di installazione. Ciò impedisce al sistema di eseguire operazioni di manutenzione ordinaria del database, come la reindicizzazione, alla prima connessione.

Questo articolo mostra come è possibile creare un database locale e inserire, aggiornare o eliminare dati da esso. Costruiremo un'applicazione di esempio con a Dettagli utente tabella ed eseguire varie operazioni su di esso. Separeremo i file di codice per diverse operazioni come l'inserimento, l'aggiornamento e l'eliminazione per comodità. 

2. Costruire il contesto dei dati

Le tabelle per il database possono essere definite ovunque nell'app purché siano accessibili a livello globale. Creiamo un file separato, DB.cs, per tutti i tavoli. In questo file specifichiamo un modello a oggetti che determina il schema del database e creare il contesto dati.

Passaggio 1: aggiunta di riferimenti

Aggiungi le seguenti direttive nella parte superiore del DB.cs file per fare riferimento all'assembly LINQ to SQL:

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

Passaggio 2: creazione di una tabella

Aggiungi una classe di entità chiamata User_details che rappresenta la tabella del database dell'app nel database locale. L'attributo [Tavolo] indica il runtime LINQ to SQL per associare la classe a una tabella di database locale.

[Tabella] public class User_details [Column (IsDbGenerated = true, IsPrimaryKey = true)] public int ID get; impostato;  [Column] public string user_name get; impostato;  [Colonna] stringa pubblica user_email get; impostato; 

Come puoi vedere, il User_details la classe ha tre proprietà pubbliche che corrispondono a tre colonne del database:

• ID è una colonna identificativa che viene automaticamente popolata dal database. È anche la chiave primaria per la quale viene creato automaticamente un indice di database. Queste impostazioni e altre sono specificate con l'attributo di mappatura della colonna LINQ to SQL scritto sopra la sintassi della proprietà.
• nome utente è una colonna per memorizzare il nome dell'utente.
• user_email è una colonna per memorizzare l'indirizzo email dell'utente.

Passaggio 1: definizione del contesto dei dati

La classe UserDataContext eredita da DataContext e viene indicato come il contesto dati. Questo codice chiama il costruttore di base e dichiara la tabella del database chiamata User_details. Il database locale viene archiviato nella memoria isolata dell'app e nel nostro esempio viene salvato come Databases.sdf. 

public class UserDataContext: DataContext stringa statica pubblica DBConnectionString = @ "isostore: /Databases.sdf"; public UserDataContext (string connectionString): base (connectionString)  tabella pubblica Gli utenti get return this.GetTable(); 

Si noti che la stringa di connessione al database non è necessaria per essere un campo statico. Noi usiamo DBConnectionString in questo caso solo per comodità.

3. Creazione del database

Per creare il database, apri il codice dietro il file dell'app, chiamato app.xaml.cs. Aggiungi il seguente codice alla fine del suo costruttore, chiamato App.

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

Il codice di creazione del database viene aggiunto qui in modo che il database sia presente prima dell'esecuzione del codice dalla pagina principale. Il codice controlla se il database esiste e, se non viene trovato alcun database, ne viene creato uno nuovo.

4. Operazioni del database

Una volta che il contesto dati è stato creato e il database è stato creato, possiamo eseguire operazioni su di esso. Puoi inserire, aggiornare ed eliminare i record dalla tabella appena creata. Abbiamo creato classi separate per conservare le funzioni per inserire, eliminare e aggiornare le operazioni.

Passaggio 1: inserimento dei record

È conveniente creare un file di classe separato, DatabaseAdd.cs, per aggiungere qualsiasi record al database. Definire una funzione Aggiungi utente ciò richiede nome e e-mail identificativo utente come parametri e aggiunge un record al User_details tavolo.

pubblico vuoto AddUser (Nome stringa, E-mail stringa) utilizzando (Contesto UserDataContext = nuovo UserDataContext (UserDataContext.DBConnectionString)) User_details du = new User_details (); du.user_name = nome; du.user_email = email; context.Users.InsertOnSubmit (du); context.SubmitChanges (); 

Il Aggiungi utente la funzione usa ilUserDataContext contesto dati per connettersi al database, crea una nuova istanza di User_details classe entità e inserisce un record.

I nuovi elementi che sono stati aggiunti al contesto dati non vengono salvati nel database fino al Inviare le modifiche la funzione è chiamata. Chiama il Aggiungi utente funzione per aggiungere un record al database.

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

Passaggio 2: recupero dei record

Crea un file di classe separato, FetchDatabase.cs, per il recupero dei record dal database. Questa classe contiene a GetAllUsers funzione che restituisce un IList istanza, contenente i record recuperati dalla tabella.

La connessione viene impostata utilizzando il contesto dati dopo il quale i record vengono recuperati dal User_details tavolo. La query LINQ restituisce un IList istanza contenente i record recuperati. Il IList istanza non è altro che una collezione di oggetti dello stesso tipo.

IList pubblico GetAllUsers () IList lista = null; utilizzo (contesto UserDataContext = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable query = da c in context.Users seleziona c; list = query.ToList ();  lista di ritorno; 

Nello snippet di codice seguente definiamo a utenti classe con i membri dei dati id, nome, e e-mail per mantenere i dettagli dai record recuperati.

classe Users public stringa id get; impostato;  nome stringa pubblico get; impostato;  public string email get; impostato; 

Crea un'altra funzione, GetAllUsers, che restituisce un elenco di utenti quando chiamato. La funzione crea un nuovo elenco per contenere i dettagli degli utenti recuperati. Si itera attraverso il IList istanza chiamata usrs e aggiunge i dettagli di ogni utente al tutti gli utenti esempio.

lista pubblica getUsers () IList usrs = this.GetAllUsers (); Elenco allUsers = new List(); 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; 

Nell'applicazione di esempio di questo articolo, il getusers la funzione è usata per impostare il ItemSource del listbox di nome tutti gli utenti come mostrato di seguito.

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

Passaggio 3: Aggiornamento dei record

L'aggiornamento dei record è molto simile all'aggiunta di record a una tabella. Continuando con il nostro approccio modulare, creiamo un nuovo file di classe, DatabaseUpdate.cs, per gli aggiornamenti del database. A differenza delle operazioni di cancellazione, non è possibile aggiornare più record contemporaneamente.

Aggiungi una funzione UpdateUsers che accetta un id, nome, e e-mail identificativo utente, e aggiorna la riga della tabella per il corrispondente id.

pubblico vuoto UpdateUser (int id, email stringa, nome stringa) utilizzando (contesto UserDataContext = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users where c.ID == id select c; User_details entityToUpdate = entityQuery.FirstOrDefault (); entityToUpdate.user_name = nome; entityToUpdate.user_email = email; context.SubmitChanges (); 

La funzione interroga il database e memorizza il primo record con corrispondenza nel file entityToUpdate variabile. Quindi aggiorna il record assegnando i nuovi valori e invia le modifiche per aggiornare il database.

Il database non è aggiornato fino a quando non chiamiamo il Inviare le modifiche funzione. Questa funzione aggiornerà solo il primo record abbinato. Il UpdateUser la funzione viene richiamata per aggiornare i record esistenti nel database come mostrato di seguito.

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

Per aggiornare più record, devi scorrere i record che desideri aggiornare uno alla volta. Nel seguente frammento di codice, aggiorniamo il nome di ogni utilizzo nel database rendendolo minuscolo.

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

Passaggio 4: eliminazione dei record

Crea un file di classe, DatabaseDelete.cs ,per le operazioni di cancellazione. Nel DatabaseDelete classe, aggiungi a deleteUser funzione che accetta un parametro id ed elimina un singolo utente di cui id corrisponde al parametro passato.

pubblico vuoto DeleteUser (String id) // cancella utente per id utilizzando (Contesto UserDataContext = new UserDataContext (UserDataContext.DBConnectionString)) IQueryable entityQuery = from c in context.Users dove c.ID.Equals (id) seleziona c; User_details entityToDelete = entityQuery.FirstOrDefault (); context.Users.DeleteOnSubmit (entityToDelete); context.SubmitChanges (); 

La funzione chiama DeleteOnSubmit, che elimina un singolo record dal database. Le modifiche vengono salvate quando il Inviare le modifiche la funzione è chiamata. Il deleteUser funzione cancella un singolo record dal database come mostrato di seguito.

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

Il System.Data.Linq l'assemblea fornisce una funzione DeleteAllOnSubmit per eliminare più record contemporaneamente. Il seguente frammento di codice tronca il User_details tavolo.

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

Questa funzione accetta un elenco di record ed elimina i record in quell'elenco. Si noti che in entrambi i casi le modifiche vengono salvate solo quando il Inviare le modifiche la funzione è chiamata.

Conclusione

Le app di Windows Phone utilizzano LINQ to SQL per tutte le operazioni del database. LINQ to SQL viene utilizzato per definire lo schema del database, selezionare i dati e, salvare le modifiche al file di database sottostante che risiede nella memoria isolata dell'app. LINQ to SQL fornisce un approccio orientato agli oggetti per lavorare con i dati memorizzati in un database e consiste in un modello di oggetto e un runtime. Vi consiglio di leggere questo articolo MSDN per le migliori pratiche sull'utilizzo dei database locali. Sentiti libero di scaricare i file sorgente del tutorial da usare come riferimento.