Share
La un moment dat în cariera dvs. de dezvoltare mobilă, veți avea nevoie să vă ocupați de date. Gestionarea datelor înseamnă mai mult decât prelucrarea și afișarea informațiilor către utilizatorul final. Va trebui să stocați aceste informații undeva și să puteți obține cu ușurință. Datorită programului Xamarin și a software-ului open source, puteți stoca cu ușurință datele dvs. cu o platformă testată în industrie, SQLite.
Deci, de ce trebuie să vă interesați de date atunci când vine vorba de aplicația dvs.? Pentru că este în jurul tău. Nu puteți scăpa de el. Indiferent de ce aplicație scrieți, indiferent dacă este vorba de un joc sau de un fel de utilitate, va trebui să stocați date la un moment dat. Aceste date ar putea fi date de utilizator, statistici sau orice altceva de interes pe care dvs. sau utilizatorul îl veți interesa la un moment dat în utilizarea aplicației dvs..
În acest moment, să presupunem că ați decis să mergeți pe ruta Xamarin.Forms, deoarece sunteți interesat de direcționarea mai multor platforme nu numai în logica aplicației dvs., ci și în stratul interfeței utilizator.
Grozav. Dar ce faceți acum că aveți nevoie pentru a stoca informații în aplicația dvs.? Nu vă faceți griji, există o soluție foarte simplă la această problemă, SQLite.
Acum ați văzut termenul SQLite de câteva ori în acest tutorial, este timpul să ajungeți la carne. Ce este exact SQLite? SQLite este un domeniu public, configurație zero, motor de bază de date SQL tranzacțional. Toate acestea înseamnă că aveți un mecanism plin de funcții pentru stocarea datelor într-un mod structurat. Nu numai că obțineți toate acestea, de asemenea, aveți acces la codul sursă, deoarece este o sursă deschisă.
Nu vom acoperi toate caracteristicile SQLite în acest tutorial pur și simplu pentru că sunt prea multe pentru a trece prin. Fii sigur că vei avea capacitatea de a crea cu ușurință o structură de tabelă pentru a stoca date și a le recupera în aplicație. Acestea sunt conceptele pe care le vom concentra în acest tutorial.
În lumea Xamarin.Forms, SQLite este o potrivire naturală pentru un motiv foarte simplu. Motorul SQLite este disponibil imediat pe iOS și Android. Acest lucru înseamnă că puteți utiliza această tehnologie chiar din cutie atunci când alegeți să scrieți o aplicație Xamarin.Forms.
Obținerea accesului la funcțiile SQLite în aplicațiile Windows Phone necesită un pas suplimentar pe care îl vom trece mai târziu. Toate aceste funcționalități și accesibilitatea pe mai multe platforme sunt minunate, dar cum vom avea acces la implementările platformei native din codul nostru C # în Xamarin.Forms? De la un pachet frumos NuGet, așa este. Hai să aruncăm o privire.
Să începem prin crearea unei aplicații simple Xamarin.Forms. În acest tutorial, voi folosi un Mac care rulează Xamarin Studio, dar puteți folosi cu ușurință Xamarin Studio sau Visual Studio care rulează pe un PC.
Începem procesul prin crearea unei noi aplicații Xamarin.Forms. Pentru aceasta, trebuie doar să selectați Aplicații pentru mobil familia de șabloane de proiect din stânga și alegeți unul din șabloanele Xamarin.Forms din dreapta. Puteți utiliza fie PCL sau Impartit versiune a șablonului, dar pentru acest caz, voi folosi PCL. Puteți urmări de-a lungul fiecăruia, dar va fi o mică diferență dacă alegeți Impartit șablon mai târziu.
Puteți da proiectului orice nume doriți. Voi numi acest proiect IntroToSQLite. După ce faceți clic pe O.K , IDE va trece prin procesul de creare a soluției. Soluția dvs. va conține patru proiecte:
Acum, când avem structura de bază a proiectului, putem începe să adăugăm accesul la SQLite la proiectul nostru PCL. Trebuie să instalăm un nou pachet în proiectul nostru numit SQLite.Net. Acesta este un .NET wrapper în jurul SQLite, care ne va permite să accesăm funcționalitatea nativă SQLite dintr-un proiect Xamarin.Forms PCL sau Shared.
Accesăm acest pachet NuGet făcând clic cu butonul din dreapta pe oricare dintre ele pachete sau Referințe, în funcție de IDE pe care îl utilizați și selectați Adăugați pachetul (sau Referinţă). În caseta de căutare, tastați sqlite.net. Acest lucru vă va arăta o colecție destul de mare de pachete pe care le puteți include în proiectul dvs..
Din moment ce am ales să merg pe ruta PCL pentru proiectul meu Xamarin.Forms, va trebui să selectez SQLite.Net PCL pachet pentru a include în proiectul meu. Care dintre ele alegeți dacă ați parcurs ruta de proiect comun? Nici unul.
Dacă ați ales șablonul de proiect Împărțit mai devreme în tutorial, s-ar putea să vă întrebați cum să obțineți accesul la pachetul SQLite. Răspunsul scurt este că nu puteți. Dacă vă amintiți dintr-un tutorial anterior, nu puteți adăuga referințe la un proiect partajat. Pentru a obține acces la SQLite dintr-un proiect partajat, pur și simplu adăugați codul sursă la proiect.
Pasul final în adăugarea funcționalității SQLite la proiectul PCL este crearea unei interfețe care să ne permită accesul în lumea SQLite. Motivul pentru care facem acest lucru este că avem nevoie să accesăm funcționalitatea nativă pe diferite platforme așa cum am văzut într-un tutorial anterior.
Să începem prin definirea unei interfețe care ne va oferi acces la conexiunea la baza de date SQLite. În cadrul proiectului dvs. PCL, creați o nouă interfață numită ISQLite și înlocuiți implementarea cu următoarele:
utilizând Sistemul; folosind SQLite.Net; namespace IntroToSQLite interfață publică ISQLite SQLiteConnection GetConnection ();
Aceasta este interfața pe care o vom implementa și vom avea acces prin intermediul DependencyService din implementările native.
Acum avem acces la funcția SQLite, să definim baza noastră de date. Această aplicație specială va fi destul de simplă și vom stoca doar câteva dintre gândurile noastre aleatorii pe măsură ce vom veni cu ei.
Începem prin crearea unei clase care va reprezenta datele stocate într-un anumit tabel. Să numim această clasă RandomThought.
utilizând Sistemul; folosind SQLite.Net.Attributes; namespace IntroToSQLite clasa publică RandomThought [PrimaryKey, AutoIncrement] public int ID get; a stabilit; șir public Thought get; a stabilit; public DateTime CreatedOn get; a stabilit; public RandomThought ()
După cum puteți vedea, aceasta este o clasă foarte simplă, cu trei proprietăți. Două dintre aceste proprietăți sunt doar proprietățile obișnuite de zi cu zi, Gândire și Creat in. Aceste două proprietăți vor reprezenta coloane în baza de date SQLite, care va conține un tabel numit RandomThought. A treia proprietate, ID-ul, va reprezenta, de asemenea, o coloană din cadrul tabelului și va conține un id unic pe care îl putem folosi pentru a vă referi la un anumit RandomThought rând în cadrul mesei.
Lucru interesant despre ID-ul proprietatea este că este decorat cu două atribute, Cheia principala și Increment auto. Cheia principala spune SQLite că această coloană va fi cheia primară a tabelului, ceea ce înseamnă că, în mod implicit, trebuie să fie unic și să existe un index aplicat acestuia pentru a accelera recuperările din acest tabel atunci când face trimitere la un rând de la acesta coloană.
Increment auto înseamnă că atunci când introducem un nou RandomThought în acest tabel, ID-ul coloana va fi populate automat cu următoarea valoare integeră disponibilă. Următorul pas este să creați acest tabel în baza de date.
Îmi place să creez o clasă care să reprezinte baza mea de date și să păstreze toată logica pentru a accesa baza de date și tabelele din cadrul acestei clase. Pentru aceasta, voi crea o clasă numită RandomThoughtDatabase:
utilizând Sistemul; folosind SQLite.Net; folosind Xamarin.Forms; folosind System.Collections.Generic; folosind System.Linq; namespace IntroToSQLite clasă publică RandomThoughtDatabase private SQLiteConnection _connection; public RandomThoughtDatabase () _connection = DependencyService.Get() .GetConnection (); _connection.CreateTable (); public IEnumerable GetThoughts () return (din t în _connection.Table () selectați t) .ToList (); public RandomThought GetThought (int id) întoarcere _connection.Table () .FirstOrDefault (t => t.ID == id); void public DeleteThought (int id) _connection.Delete (Id); void publice AddThought (gândire șir) var newThought = new RandomThought Gândire = gândire, CreatedOn = DateTime.Now; _connection.Insert (newThought);
Aceasta este o implementare foarte simplă, deoarece conține numai câteva metode. Acestea sunt, de obicei, unele dintre operațiile de bază pe care le efectuați atunci când se ocupă de o bază de date. Un punct de vedere este constructorul. În cadrul constructorului facem două lucruri.
În primul rând, folosim DependencyService clasa pentru a obține o clasă înregistrată care implementează ISQLite interfață și apelați-o getConnection metodă.
În al doilea rând, vom folosi CreateTable metoda pe SQLiteConnection pentru a crea o tabelă numită RandomThought. Această metodă va crea tabelul, dacă nu există deja, și va ieși grațios dacă există deja.
Evident, puteți obține atât de sofisticat cu această clasă cum doriți, prin adăugarea de tot felul de funcționalități, dar aceste operațiuni sunt de obicei un bun punct de plecare.
Majoritatea codului pe care îl folosim pentru a interacționa cu baza de date vor fi găsite în proiectul PCL (sau în comun). Dar, în continuare, trebuie să facem o mică conexiune în implementările native pentru ca totul să funcționeze corect.
Principalul obstacol pe care trebuie să-l ocupăm de partea nativă atunci când folosim SQLite este locul unde vom stoca dosarul actual al bazei de date. Acest lucru diferă de la platformă la platformă. Iată ce avem nevoie pentru iOS.
Înainte de a putea adăuga orice fel de funcționalitate SQLite la proiectul iOS, trebuie să adăugăm SQLite.Net PCL la fel de bine ca Platforma SQLite.NET PCL - XamarinIOS pachete pentru acest proiect. Puteți urma aceiași pași pe care i-ați luat Pasul 2, asigurându-vă că adăugați atât la proiect. După ce ați adăugat acest pachet, puteți începe să scrieți un cod SQLite în cadrul proiectului iOS.
Să creați o punere în aplicare a ISQLite pentru interfața iOS. Începeți prin a crea o nouă clasă, numind-o SQLite_iOS.
utilizând Sistemul; utilizând System.IO; folosind SQLite; utilizând IntroToSQLite.iOS; folosind Xamarin.Forms; [assembling: dependență (typeof (SQLite_iOS))] spațiu de nume IntroToSQLite.iOS public class SQLite_iOS: ISQLite public SQLite_iOS () #regiunea ISQLite implementare publică SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Mediu.GetFolderPath (Environment.SpecialFolder.Personal); var libraryPath = Path.Combine (documentPath, "...", "Biblioteca"); var path = Path.Combine (bibliotecăPath, fileName); var platform = nou SQLite.Net.Platform.XamarinIOS.SQLitePlatformIOS (); var conexiune = nou SQLite.Net.SQLiteConnection (platformă, cale); retur conexiune; #endregion
Avem acces la locația corectă pentru a stoca fișierul bazei de date, pentru a crea un nou SQLiteConnection obiect și îl reintroduceți în proiectul PCL (sau partajat). Atributul de asamblare din partea de sus a fișierului este utilizat pentru a identifica această clasă ca a Dependenţă care poate fi recuperat prin obține metoda pe DependencyService clasă.
Acest pas este foarte similar cu cel precedent. Singura diferență este că codul se va schimba puțin datorită faptului că locația fișierului bazei de date va fi diferită. Încă mai trebuie să adăugați pachetele corespunzătoare pentru proiectul Android (SQLite.Net PCL și SQLite.NET PCL - XamarinAndroid) așa cum ați făcut înainte. După ce ați terminat acest lucru, puteți adăuga codul corespunzător într-o nouă clasă numită SQLite_Android.
utilizând Sistemul; utilizând System.IO; folosind Xamarin.Forms; utilizând IntroToSQLite.Android; [assembling: Dependență (typeof (SQLite_Android))] namespace IntroToSQLite.Android public clasa SQLite_Android: ISQLite public SQLite_Android () #regiunea ISQLite implementare publică SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Mediu.GetFolderPath (Environment.SpecialFolder.Personal); var path = Path.Combine (documentPath, fileName); var platform = nou SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid (); var conexiune = nou SQLite.Net.SQLiteConnection (platformă, cale); retur conexiune; #endregion
Acum aveți o implementare funcțională a interfeței ISQLite din perspectiva aplicației Android.
Din moment ce rulez această aplicație de pe un Mac, nu voi crea implementarea Windows Phone, dar dacă vrei să faci asta, poți.
Primul pas este să adăugați suport pentru proiectul Windows Phone pentru SQLite. Așa cum am menționat mai devreme, SQLite vine în mod implicit pe iOS și Android. Acest lucru nu este valabil pentru Windows Phone, dar este acceptat. Pentru ao instala, puteți urma instrucțiunile de pe site-ul Xamarin.
După instalarea SQLite, procesul de adăugare a funcționalității pentru Windows Phone va fi aproape exact același lucru, cu excepția pachetelor de instalat SQLite.Net PCL și SQLite.Net PCL - Platforma WindowsPhone 8. Cu aceste pachete instalate, puteți crea Windows Phone implementarea ISQLite interfață.
utilizând Sistemul; utilizând System.IO; folosind Xamarin.Forms; utilizând IntroToSQLite.WinPhone; [assembling: Spațiu de nume de dependență (typeof (SQLite_WinPhone)] nume de domeniu IntroToSQLite.WinPhone public class SQLite_WinPhone: ISQLite public SQLite_WinPhone () #regiunea ISQLite implementare publică SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3"; var path = Path.Combine (ApplicationData.Current.LocalFolder.Path, fileName); var platform = nou SQLite.Net.Platform.WindowsPhone8.SQLitePlatformWP8 (); varconnect = new SQLite.Net.SQLiteConnection (platformă, cale); return conexiune; #regiuneregion
Acolo îl aveți. Acum aveți toate implementările native complete. Este timpul să oferiți acestei aplicații o interfață de utilizator și să introduceți datele în baza de date.
Din moment ce acest tutorial este bine în subiectul Xamarin.Forms, voi presupune că aveți cel puțin o cunoaștere de bază a Xamarin.Forms. Având în vedere această ipoteză, nu voi intra în detaliu despre procesul de creare a interfeței cu utilizatorul. Dacă aveți nevoie de informații suplimentare despre Xamarin.Forms, consultați alte tutoriale Xamarin.Forms pe Tuts+.
Interfața cu utilizatorul va consta în două pagini separate. Prima pagină va conține o listă cu toate gândurile pe care le-am introdus într-o listă, în timp ce a doua pagină va permite utilizatorului să introducă un nou gând. Să construim aceste pagini.
Ne vom concentra în primul rând pe crearea primei pagini care va conține o listă de RandomThought obiecte. Începeți prin crearea unui nou fișier în proiectul PCL (sau în comun) și denumiți-l RandomThoughtsPage. Înlocuiți implementarea implicită cu următoarele:
utilizând Sistemul; folosind Xamarin.Forms; namespace IntroToSQLite clasă publică RandomThoughtsPage: ContentPage private RandomThoughtDatabase _database; privat ListView _thoughtList; public RandomThoughtsPage (bază de date RandomThoughtDatabase) _database = bază de date; Titlu = "Gânduri aleatorii"; var gânduri = _database.GetThoughts (); _thoughtList = nou ListView (); _thoughtList.ItemsSource = gânduri; _thoughtList.ItemTemplate = nou DataTemplate (typeof (TextCell)); _thoughtList.ItemTemplate.SetBinding (TextCell.TextProperty, "Gândire"); _thoughtList.ItemTemplate.SetBinding (TextCell.DetailProperty, "CreatedOn"); var toolbarItem = ToolbarItem nou Name = "Add", Command = comanda nouă (() => Navigation.PushAsync (această bază de date ThoughtEntryPage))); ToolbarItems.Add (toolbarItem); Conținut = _thoughtList; public void Refresh () _thoughtList.ItemsSource = _database.GetThoughts ();
Majoritatea lucrărilor efectuate în această clasă se află în constructor. Constructorul ne permite să trecem printr-o instanță a RandomThoughtsDatabase pentru a obține toate gândurile salvate. Am setat Titlu proprietatea paginii la "Gânduri aleatorii", a prelua toate gândurile existente, a crea o nouă instanță a unui ListView, și de a crea un ToolbarItem care ne va permite să faceți clic pe un buton pentru a afișa pagina de intrare. Nu am implementat încă acest lucru, dar vom trece în curând.
Pentru a ne aduce noi RandomThoughtsPage pe ecran, trebuie să facem o mică modificare la App.cs fişier. În acest fișier, modificați GetMainPage metoda de a arata dupa cum urmeaza:
pagina statică publică GetMainPage () var database = new RandomThoughtDatabase (); returnați noua NavigationPage (nouă bază de date RandomThoughtsPage (baza de date));
GetMainPage metoda creează acum o nouă instanță a noastră RandomThoughtDatabase și returnează o nouă instanță a RandomThoughtsPage. Cu această modificare, aplicațiile noastre iOS și Android ar trebui să pară așa:
Acum avem o pagină de listă pentru toți RandomThought obiecte, dar nu avem o cale de a intra în noi. Pentru aceasta, vom crea o altă pagină similară celei anterioare. Creați un fișier nou în proiectul PCL (sau partajat) și sunați-l ThoughtEntryPage. Înlocuiți implementarea implicită cu următoarele:
utilizând Sistemul; folosind Xamarin.Forms; namespace IntroToSQLite clasă publică ThoughtEntryPage: ContentPage private RandomThoughtsPage _parent; private RandomThoughtDatabase _database; public ThoughtEntryPage (parinte RandomThoughtsPage, baza de date RandomThoughtDatabase) _parent = parent; _database = bază de date; Titlul = "Introduceți o gândire"; var intra = noua intrare (); buton var = buton nou Text = "Add"; button.Clicked + = async (expeditor obiect, EventArgs e) => var thought = entry.Text; _database.AddThought (gândire); așteaptă Navigation.PopAsync (); _parent.Refresh (); ; Continut = StackLayout nou Spacing = 20, Padding = Nou Grosime (20), Children = entry, button,;
În această clasă, toată lucrarea se face în interiorul constructorului. Obținem o referință la pagina părinte, RandomThoughtsPage, precum și baza de date. Restul este codul de bază de configurare cu un Intrare obiect pentru introducerea textului și a Buton.
Odată ce utilizatorul pictură Buton, folosim baza de date pentru a adăuga gândul nou, respingeți pagina, reveniți la pagina de listă și apelați Reîmprospăta de actualizare a metodei ListView. Odată ce acest lucru este conectat, putem rula să introducă anumite valori.
Iată cum arată pe iOS și Android să introduceți câteva dintre gândurile dvs.:
După ce ați introdus câteva gânduri, lista dvs. va arăta astfel:
Acolo îl aveți. Aveți acum posibilitatea de a adăuga funcționalitatea bazei de date în aplicația dvs. Xamarin.Forms pentru a stoca și a prelua orice tip de date cu ușurință.
Pentru a continua călătoria dvs. de învățare cu Xamarin.Forms și SQLite, vă ofer următoarea provocare. Vedeți dacă puteți îmbunătăți această aplicație pentru a permite ștergerea gândurilor și actualizarea paginii de listă într-un mod similar cu pagina de intrare. Coduri de noroc și fericit.
Accentsconagua