Share
Ad un certo punto della tua carriera di sviluppo mobile, avrai bisogno di gestire i dati. Gestire i dati significa più che elaborare e visualizzare le informazioni all'utente finale. Dovrai memorizzare queste informazioni da qualche parte ed essere in grado di affrontarle facilmente. Grazie a Xamarin e al software open source, puoi facilmente archiviare i tuoi dati con una piattaforma testata sul mercato, SQLite.
Quindi, perché hai bisogno di preoccuparti dei dati quando si tratta della tua app? Perché è tutto intorno a te. Non puoi sfuggirlo. Indipendentemente dal tipo di app che stai scrivendo, che si tratti di un gioco o di una sorta di utilità, dovrai archiviare i dati ad un certo punto. Tali dati potrebbero essere dati dell'utente, statistiche o qualsiasi altra cosa di interesse a cui l'utente o l'utente saranno interessati ad un certo punto nell'utilizzo della propria app.
A questo punto, supponiamo che tu abbia deciso di seguire il percorso Xamarin.Forms, perché sei interessato a indirizzare diverse piattaforme non solo nella logica della tua app, ma anche per il livello dell'interfaccia utente.
Grande. Ma cosa fai ora che hai bisogno di memorizzare le informazioni all'interno della tua app? Non preoccuparti, c'è una soluzione molto semplice a questo problema, SQLite.
Ora hai visto il termine SQLite un paio di volte in questo tutorial, è ora di prendere la carne. Cosa è esattamente SQLite? SQLite è un motore di database SQL transazionale, a configurazione zero, transazionale. Tutto ciò significa che hai un meccanismo completo per archiviare i tuoi dati in modo strutturato. Non solo ottieni tutto questo, hai anche accesso al codice sorgente, perché è open source.
In questo tutorial non tratteremo tutte le funzionalità di SQLite semplicemente perché ce ne sono troppe da esaminare. Ti assicuriamo che avrai la possibilità di creare facilmente una struttura di tabelle per archiviare i dati e recuperarli nella tua app. Questi sono i concetti su cui ci concentreremo in questo tutorial.
Nel mondo di Xamarin.Forms, SQLite è un adattamento naturale per una ragione molto semplice. Il motore SQLite è facilmente disponibile su iOS e Android. Ciò significa che puoi utilizzare questa tecnologia immediatamente quando scegli di scrivere un'app Xamarin.Forms.
Ottenere l'accesso alle funzionalità SQLite nelle app di Windows Phone richiede un ulteriore passaggio che andremo a fare un po 'più tardi. Tutta questa funzionalità e l'accessibilità multipiattaforma sono ottime, ma come potremo accedere alle implementazioni native della piattaforma dal nostro codice C # in Xamarin.Forms? Da un bel pacchetto NuGet, ecco come. Diamo un'occhiata.
Iniziamo creando una semplice applicazione Xamarin.Forms. In questo tutorial userò un Mac con Xamarin Studio, ma puoi tranquillamente usare Xamarin Studio o Visual Studio su un PC.
Iniziamo il processo creando una nuova app Xamarin.Forms. Per fare ciò, basta selezionare il App per dispositivi mobili gruppo di modelli di progetto a sinistra e scegliere uno dei modelli Xamarin.Forms sulla destra. Puoi usare il PCL o Condivisa versione del modello, ma per questo caso, userò il PCL. Puoi seguirlo usando uno dei due, ma ci sarà una leggera differenza se scegli il Condivisa modello più avanti.
Puoi dare al progetto qualsiasi nome che ti piace. Chiamerò questo progetto IntroToSQLite. Dopo aver fatto clic sul ok pulsante, l'IDE passerà attraverso il processo di creazione della soluzione. La tua soluzione conterrà quattro progetti:
Ora che abbiamo impostato la nostra struttura di progetto di base, possiamo iniziare ad aggiungere l'accesso a SQLite al nostro progetto PCL. Abbiamo bisogno di installare un nuovo pacchetto nel nostro progetto chiamato SQLite.Net. Questo è un wrapper .NET su SQLite che ci permetterà di accedere alle funzionalità native di SQLite da un progetto PCL o condiviso Xamarin.Forms.
Accediamo a questo pacchetto NuGet facendo clic con il tasto destro su entrambi Pacchi o Riferimenti, a seconda dell'IDE che si sta utilizzando e selezionare Aggiungi pacchetto (o Riferimento). Nella casella di ricerca, digita sqlite.net. Questo ti mostrerà una raccolta piuttosto ampia di pacchetti che puoi includere nel tuo progetto.
Dal momento che ho scelto di seguire il percorso PCL per il mio progetto Xamarin.Forms, dovrò selezionare il file SQLite.Net PCL pacchetto da includere nel mio progetto. Quale scegliere se si è passati al percorso del progetto condiviso? Nessuna.
Se hai scelto il modello di progetto condiviso in precedenza nel tutorial, potresti chiederti come ottenere l'accesso al pacchetto SQLite. La risposta breve è che non puoi. Se ricordi da un tutorial precedente, non puoi aggiungere riferimenti a un progetto condiviso. Per accedere a SQLite da un progetto condiviso, è sufficiente aggiungere il codice sorgente al progetto.
Il passaggio finale per aggiungere funzionalità SQLite al progetto PCL è creare un'interfaccia che ci consenta di accedere al mondo SQLite. Il motivo per cui lo stiamo facendo è che dobbiamo accedere alle funzionalità native su piattaforme diverse come abbiamo visto in un precedente tutorial.
Iniziamo definendo un'interfaccia che ci darà accesso alla connessione al database SQLite. All'interno del tuo progetto PCL, crea una nuova interfaccia chiamata ISQLite e sostituire l'implementazione con quanto segue:
usando il sistema; utilizzando SQLite.Net; namespace IntroToSQLite interfaccia pubblica ISQLite SQLiteConnection GetConnection ();
Questa è l'interfaccia che implementeremo e otterremo l'accesso tramite DependencyService dalle implementazioni native.
Ora abbiamo accesso alle funzionalità SQLite, definiamo il nostro database. Questa particolare applicazione sarà abbastanza semplice e stiamo solo andando a memorizzare alcuni dei nostri pensieri casuali mentre li inventiamo.
Iniziamo creando una classe che rappresenterà i dati memorizzati in una determinata tabella. Chiamiamo questa classe RandomThought.
usando il sistema; utilizzando SQLite.Net.Attributes; namespace IntroToSQLite public class RandomThought [PrimaryKey, AutoIncrement] public int ID get; impostato; stringa pubblica Thought get; impostato; public DateTime CreatedOn get; impostato; public RandomThought ()
Come puoi vedere, questa è una classe molto semplice con tre proprietà. Due di queste proprietà sono solo le normali proprietà quotidiane, Pensiero e Creato. Queste due proprietà rappresenteranno le colonne nel database SQLite, che conterrà una tabella denominata RandomThought. La terza proprietà, ID, rappresenterà anche una colonna all'interno della tabella e contiene un ID univoco che possiamo utilizzare per fare riferimento a uno specifico RandomThought fila all'interno del tavolo.
La cosa interessante di ID la proprietà è che è decorata con due attributi, Chiave primaria e Incremento automatico. Chiave primaria dice a SQLite che questa colonna sarà la chiave primaria della tabella, il che significa che, per impostazione predefinita, deve essere univoco e vi è applicato un indice per accelerare i recuperi da questa tabella quando ci si riferisce a una riga da questo colonna.
Incremento automatico significa che, quando inseriamo un nuovo RandomThought in questo tavolo, il ID la colonna verrà popolata automaticamente con il successivo valore intero disponibile. Il prossimo passo è creare questa tabella nel database.
Mi piace creare una classe che rappresenta il mio database e mantenere tutta la logica per accedere al database e alle sue tabelle all'interno di questa classe. Per questo, creerò una classe chiamata RandomThoughtDatabase:
usando il sistema; utilizzando SQLite.Net; usando Xamarin.Forms; using System.Collections.Generic; using System.Linq; namespace IntroToSQLite public class RandomThoughtDatabase private SQLiteConnection _connection; public RandomThoughtDatabase () _connection = DependencyService.Get() .GetConnection (); _connection.CreateTable (); IEnumerable pubblico GetThoughts () return (from t in _connection.Table () seleziona t) .ToList (); public RandomThought GetThought (int id) return _connection.Table () .FirstOrDefault (t => t.ID == id); public void DeleteThought (int id) _connection.Delete (Id); public void AddThought (stringa pensata) var newThought = new RandomThought Thought = thought, CreatedOn = DateTime.Now; _connection.Insert (newThought);
Questa è un'implementazione molto semplice in quanto contiene solo alcuni metodi. Queste sono in genere alcune delle operazioni di base che si eseguono quando si ha a che fare con un database. Un punto di nota è il costruttore. All'interno del costruttore stiamo facendo due cose.
In primo luogo, stiamo usando il DependencyService classe per ottenere una classe registrata che implementa il ISQLite interfaccia e chiama il suo GetConnection metodo.
Secondo, usiamo il Crea tabella metodo sul SQLiteConnection classe per creare una tabella chiamata RandomThought. Questo metodo creerà la tabella, se non esiste già, e uscirà correttamente se già esiste.
Ovviamente, puoi ottenere il massimo con questa classe come desideri aggiungendo ogni sorta di funzionalità, ma queste operazioni sono in genere un buon punto di partenza.
La maggior parte del codice che usiamo per interagire con il database si troverà nel progetto PCL (o Shared). Ma dobbiamo ancora fare un po 'di cablaggio nelle implementazioni native per far funzionare tutto correttamente.
L'ostacolo principale su cui dobbiamo lavorare sul lato nativo quando si usa SQLite è dove andremo a memorizzare il vero file di database. Questo differisce da piattaforma a piattaforma. Ecco di cosa abbiamo bisogno per iOS.
Prima di poter effettivamente aggiungere qualsiasi tipo di funzionalità SQLite al progetto iOS, è necessario aggiungere il SQLite.Net PCL così come il SQLite.NET PCL - Piattaforma XamarinIOS pacchetti per questo progetto. Puoi seguire gli stessi passaggi che hai seguito Passo 2, assicurandosi di aggiungere entrambi al progetto. Una volta aggiunto questo pacchetto, puoi iniziare a scrivere del codice SQLite all'interno del progetto iOS.
Creiamo un'implementazione del ISQLite interfaccia per iOS. Inizia creando una nuova classe, nominandola SQLite_iOS.
usando il sistema; using System.IO; usando SQLite; utilizzando IntroToSQLite.iOS; usando Xamarin.Forms; [assembly: Dependency (typeof (SQLite_iOS))] namespace IntroToSQLite.iOS public class SQLite_iOS: ISQLite public SQLite_iOS () #region ISQLite implementation public SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); var libraryPath = Path.Combine (documentsPath, "...", "Library"); var path = Path.Combine (libraryPath, fileName); var platform = new SQLite.Net.Platform.XamarinIOS.SQLitePlatformIOS (); var connection = new SQLite.Net.SQLiteConnection (piattaforma, percorso); connessione di ritorno; #endregion
Otteniamo l'accesso alla posizione corretta per archiviare il file del database, creare un nuovo SQLiteConnection oggetto e restituirlo al nostro progetto PCL (o condiviso). L'attributo assembly nella parte superiore del file viene utilizzato per identificare questa classe come a Dipendenza che può essere recuperato tramite il Ottenere metodo sul DependencyService classe.
Questo passaggio è molto simile a quello precedente. L'unica differenza è che il codice cambierà leggermente a causa del fatto che la posizione del file del database sarà diversa. Sarà comunque necessario aggiungere i pacchetti appropriati al progetto Android (SQLite.Net PCL e SQLite.NET PCL - XamarinAndroid) come hai fatto prima. Una volta completato, è possibile aggiungere il codice appropriato in una nuova classe denominata SQLite_Android.
usando il sistema; using System.IO; usando Xamarin.Forms; utilizzando IntroToSQLite.Android; [assembly: Dependency (typeof (SQLite_Android))] namespace IntroToSQLite.Android public class SQLite_Android: ISQLite public SQLite_Android () #region Implementazione ISQLite public SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); var path = Path.Combine (documentsPath, fileName); var platform = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid (); var connection = new SQLite.Net.SQLiteConnection (piattaforma, percorso); connessione di ritorno; #endregion
Ora hai un'implementazione funzionante dell'interfaccia ISQLite dal punto di vista della tua app Android.
Poiché eseguo questa app da un Mac, non creerò l'implementazione di Windows Phone, ma se vuoi farlo, puoi.
Il primo passo è aggiungere il supporto al progetto Windows Phone per SQLite. Come accennato in precedenza, SQLite viene di default su iOS e Android. Questo non è vero per Windows Phone, ma è supportato. Per installarlo, puoi seguire le istruzioni trovate sul sito Web di Xamarin.
Dopo aver installato SQLite, il processo di aggiunta della funzionalità per Windows Phone sarà quasi identico, tranne per il fatto che i pacchetti da installare lo sono SQLite.Net PCL e SQLite.Net PCL - Piattaforma WindowsPhone 8. Con questi pacchetti installati, è possibile creare l'implementazione di Windows Phone del ISQLite interfaccia.
usando il sistema; using System.IO; usando Xamarin.Forms; utilizzando IntroToSQLite.WinPhone; [assembly: Dipendenza (typeof (SQLite_WinPhone)] namespace IntroToSQLite.WinPhone public class SQLite_WinPhone: ISQLite public SQLite_WinPhone () #region ISQLite implementation public SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3"; var path = Path.Combine (ApplicationData.Current.LocalFolder.Path, fileName); var platform = new SQLite.Net.Platform.WindowsPhone8.SQLitePlatformWP8 (); var connection = new SQLite.Net.SQLiteConnection (piattaforma, percorso); return connessione; #endregion
Ecco qua. Ora hai completato tutte le tue implementazioni native. È ora di dare a questa app un'interfaccia utente e ottenere i dati nel database.
Dato che questo tutorial è ben inserito nell'argomento di Xamarin.Forms, assumerò che tu abbia almeno una conoscenza di base di Xamarin.Forms. Tenendo presente questo presupposto, non ho intenzione di approfondire il processo di creazione dell'interfaccia utente. Se hai bisogno di ulteriori informazioni di base su Xamarin.Forms, dai un'occhiata agli altri tutorial su Xamarin.Forms su Tuts+.
L'interfaccia utente sarà composta da due pagine separate. La prima pagina conterrà un elenco di tutti i pensieri che abbiamo inserito in una lista mentre la seconda pagina consentirà all'utente di inserire un nuovo pensiero. Costruiamo queste pagine.
Ci concentreremo innanzitutto sulla creazione della prima pagina che conterrà un elenco di RandomThought oggetti. Inizia creando un nuovo file nel progetto PCL (o condiviso) e nominalo RandomThoughtsPage. Sostituisci l'implementazione predefinita con quanto segue:
usando il sistema; usando Xamarin.Forms; namespace IntroToSQLite public class RandomThoughtsPage: ContentPage private RandomThoughtDatabase _database; ListView _thoughtList privato; public RandomThoughtsPage (database RandomThoughtDatabase) _database = database; Title = "Random Thoughts"; var thoughts = _database.GetThoughts (); _thoughtList = new ListView (); _thoughtList.ItemsSource = pensieri; _thoughtList.ItemTemplate = new DataTemplate (typeof (TextCell)); _thoughtList.ItemTemplate.SetBinding (TextCell.TextProperty, "Thought"); _thoughtList.ItemTemplate.SetBinding (TextCell.DetailProperty, "CreatedOn"); var toolbarItem = new ToolbarItem Name = "Aggiungi", Command = new Command (() => Navigation.PushAsync (new ThoughtEntryPage (this, database))); ToolbarItems.Add (toolbarItem); Contenuto = _thoughtList; public void Refresh () _thoughtList.ItemsSource = _database.GetThoughts ();
La maggior parte del lavoro svolto in questa classe è nel costruttore. Il costruttore ci permette di passare in un'istanza del RandomThoughtsDatabase per ottenere tutti i pensieri salvati. Abbiamo impostato il Titolo proprietà della pagina a "Random Thoughts", recupera tutti i pensieri esistenti, crea una nuova istanza di a Visualizzazione elenco, e creare a ToolbarItem questo ci permetterà di cliccare su un pulsante per far apparire la pagina di entrata. Non l'abbiamo ancora implementato, ma lo faremo a breve.
Per ottenere il nostro nuovo RandomThoughtsPage sullo schermo, dobbiamo fare una piccola modifica al App.cs file. All'interno di questo file, modificare il file GetMainPage metodo per apparire come il seguente:
public static Pagina GetMainPage () var database = new RandomThoughtDatabase (); restituire la nuova NavigationPage (nuova RandomThoughtsPage (database));
Il GetMainPage il metodo ora crea una nuova istanza del nostro RandomThoughtDatabase class e restituisce una nuova istanza di RandomThoughtsPage. Con questo cambiamento, le nostre app per iOS e Android dovrebbero assomigliare a questo:
Ora abbiamo una pagina di elenco per tutti i nostri RandomThought oggetti, ma non abbiamo un modo per inserirne di nuovi. Per questo, creeremo un'altra pagina simile alla pagina precedente. Crea un nuovo file nel tuo progetto PCL (o condiviso) e chiamalo ThoughtEntryPage. Sostituisci l'implementazione predefinita con quanto segue:
usando il sistema; usando Xamarin.Forms; namespace IntroToSQLite public class ThoughtEntryPage: ContentPage private RandomThoughtsPage _parent; privato RandomThoughtDatabase _database; public ThoughtEntryPage (RandomThoughtsPage parent, RandomThoughtDatabase database) _parent = parent; _database = database; Title = "Enter a Thought"; var entry = new Entry (); var button = new Button Text = "Aggiungi"; button.Clicked + = async (mittente dell'oggetto, EventArgs e) => var thought = entry.Text; _database.AddThought (pensiero); attende Navigation.PopAsync (); _parent.Refresh (); ; Content = new StackLayout Spacing = 20, Padding = new Thickness (20), Children = entry, button,;
In questa classe, tutto il lavoro viene svolto all'interno del costruttore. Otteniamo un riferimento alla pagina principale, RandomThoughtsPage, così come il database. Il resto è codice di installazione di base con un Iscrizione oggetto per l'immissione di testo e a Pulsante.
Una volta che l'utente tocca il Pulsante, usiamo il database per aggiungere il nuovo pensiero, chiudere la pagina, tornare alla pagina di elenco e chiamare il ricaricare metodo per aggiornare il Visualizzazione elenco. Una volta che tutto è cablato, possiamo eseguirlo per inserire effettivamente alcuni valori.
Ecco come appare su iOS e Android per inserire alcuni dei tuoi pensieri:
Dopo aver inserito alcuni pensieri, il tuo elenco sarà simile a questo:
Ecco qua. Ora hai la possibilità di aggiungere funzionalità di database all'app Xamarin.Forms per archiviare e recuperare facilmente qualsiasi tipo di dati.
Per continuare il tuo percorso di apprendimento con Xamarin.Forms e SQLite, ti fornisco la seguente sfida. Verifica se è possibile migliorare questa applicazione per abilitare la cancellazione di pensieri e aggiornare la pagina di elenco in modo simile alla pagina di ingresso. Buona fortuna e buona programmazione.
Accentsconagua