Share
Op een bepaald moment in je loopbaan als mobiele ontwikkelaar, moet je omgaan met gegevens. Data behandelen betekent meer dan alleen het verwerken en weergeven van informatie aan de eindgebruiker. Je zult deze informatie ergens moeten opslaan en er gemakkelijk bij kunnen komen. Dankzij Xamarin en open source-software kunt u eenvoudig uw gegevens opslaan met een in de industrie getest platform, SQLite.
Dus waarom zou u om gegevens moeten geven als het op uw app aankomt? Omdat het overal om je heen is. Je kunt er niet aan ontsnappen. Het maakt niet uit wat voor soort app je schrijft, of het nu een spel of een soort hulpprogramma is, je zult op een gegeven moment gegevens moeten opslaan. Die gegevens kunnen gebruikersgegevens, statistieken of iets anders van belang zijn waar u of de gebruiker op een bepaald moment in geïnteresseerd is om uw app te gebruiken.
Laten we op dit punt aannemen dat je hebt besloten om de Xamarin.Forms-route te gebruiken, omdat je geïnteresseerd bent in het targeten van verschillende platforms, niet alleen in de logica van je app, maar ook voor de gebruikersinterfacelaag.
Super goed. Maar wat doe je nu dat je nodig hebt om informatie op te slaan in je app? Maak je geen zorgen, er is een heel eenvoudige oplossing voor dit probleem, SQLite.
Je hebt de term SQLite nu een paar keer gezien in deze tutorial, het is tijd om aan het werk te gaan. Wat is precies SQLite? SQLite is een public domain, zero configuration, transactional SQL database engine. Dit betekent dat u over een volledig uitgerust mechanisme beschikt om uw gegevens op een gestructureerde manier op te slaan. Niet alleen krijg je dit allemaal, je hebt ook toegang tot de broncode, omdat het open source is.
We zullen niet alle functies van SQLite in deze tutorial behandelen, simpelweg omdat er te veel zijn om door te nemen. U kunt er zeker van zijn dat u gemakkelijk een tabelstructuur kunt maken om gegevens op te slaan en op te halen in uw app. Dit zijn de concepten waar we ons in deze tutorial op zullen concentreren.
In de wereld van Xamarin.Forms is SQLite om een heel eenvoudige reden een natuurlijke oplossing. De SQLite-engine is direct beschikbaar op zowel iOS als Android. Dit betekent dat u deze technologie direct uit de doos kunt gebruiken wanneer u ervoor kiest om een Xamarin.Forms-app te schrijven.
Voor toegang tot SQLite-functionaliteit in Windows Phone-apps is een extra stap nodig die we later zullen bespreken. Al deze functionaliteit en cross-platform-toegankelijkheid is geweldig, maar hoe krijgen we toegang tot de native platformimplementaties van onze C # -code in Xamarin.Forms? Van een leuk NuGet-pakket, dat is hoe. Laten we kijken.
Laten we beginnen met het maken van een eenvoudige Xamarin.Forms-toepassing. In deze tutorial gebruik ik een Mac met Xamarin Studio, maar je kunt net zo goed Xamarin Studio of Visual Studio op een pc gebruiken.
We starten het proces door een nieuwe Xamarin.Forms-app te maken. Om dit te doen, selecteert u gewoon de Mobiele apps project sjabloonfamilie aan de linkerkant en kies een van de Xamarin.Forms-sjablonen aan de rechterkant. U kunt de PCL of gedeelde versie van de sjabloon, maar in dit geval zal ik de PCL. Je kunt beide gebruiken, maar er zal een klein verschil zijn als je de gedeelde sjabloon later.
U kunt het project elke gewenste naam geven. Ik zal dit project noemen IntroToSQLite. Nadat u op de knop hebt geklikt OK knop, zal uw IDE het proces van het maken van uw oplossing doorlopen. Uw oplossing zal vier projecten bevatten:
Nu we onze basisprojectstructuur hebben ingesteld, kunnen we beginnen met het toevoegen van toegang tot SQLite aan ons PCL-project. We moeten een nieuw pakket installeren in ons project genaamd SQLite.Net. Dit is een .NET-wrapper rond SQLite waarmee we de oorspronkelijke SQLite-functionaliteit kunnen openen vanuit een Xamarin.Forms PCL of gedeeld project.
We hebben toegang tot dit NuGet-pakket door met de rechtermuisknop op een van beide te klikken Pakketjes of Referenties, afhankelijk van welke IDE u gebruikt en selecteer Voeg pakket toe (of Referentie). Typ in het zoekvak sqlite.net. Hiermee wordt een vrij grote verzameling pakketten getoond die u in uw project kunt opnemen.
Omdat ik ervoor gekozen heb om de PCL-route te gaan gebruiken voor mijn Xamarin.Forms-project, moet ik de SQLite.Net PCL pakket om in mijn project op te nemen. Welke kies je als je de Shared project-route hebt afgelegd? Geen.
Als u eerder in de zelfstudie de gedeelde projectsjabloon hebt gekozen, vraagt u zich misschien af hoe u toegang kunt krijgen tot het SQLite-pakket. Het korte antwoord is dat je dat niet kunt. Als u het zich herinnert van een eerdere zelfstudie, kunt u geen verwijzingen naar een gedeeld project toevoegen. Om toegang te krijgen tot SQLite vanuit een gedeeld project, voegt u eenvoudig de broncode toe aan het project.
De laatste stap bij het toevoegen van SQLite-functionaliteit aan het PCL-project is het maken van een interface die ons toegang tot de SQLite-wereld biedt. De reden dat we dit doen is omdat we toegang moeten hebben tot de native functionaliteit op de verschillende platforms zoals we in een eerdere tutorial hebben gezien.
Laten we beginnen met het definiëren van een interface die ons toegang geeft tot de SQLite-databaseverbinding. Maak binnen uw PCL-project een nieuwe interface met de naam ISQLite en vervang de implementatie door het volgende:
systeem gebruiken; met behulp van SQLite.Net; naamruimte IntroToSQLite openbare interface ISQLite SQLiteConnection GetConnection ();
Dit is de interface die we zullen implementeren en toegang zullen krijgen via de DependencyService van de native implementaties.
We hebben nu toegang tot de SQLite-functionaliteit, laten we onze database definiëren. Deze specifieke applicatie zal vrij eenvoudig zijn en we gaan gewoon wat van onze willekeurige gedachten opslaan als we ermee komen.
We beginnen met het maken van een klasse die de gegevens vertegenwoordigt die zijn opgeslagen in een bepaalde tabel. Laten we deze klas noemen Willekeurige gedachte.
systeem gebruiken; met behulp van SQLite.Net.Attributes; naamruimte IntroToSQLite public class RandomThought [PrimaryKey, AutoIncrement] public int ID get; vast te stellen; openbare string Gedachte krijg; vast te stellen; public DateTime CreatedOn get; vast te stellen; public RandomThought ()
Zoals u kunt zien, is dit een heel eenvoudige klasse met drie eigenschappen. Twee van die eigenschappen zijn gewoon uw normale alledaagse eigenschappen, Gedachte en Gemaakt op. Deze twee eigenschappen zullen kolommen vertegenwoordigen in de SQLite-database, die een tabel met de naam zal bevatten Willekeurige gedachte. De derde eigenschap, ID kaart, zal ook een kolom in de tabel voorstellen en een unieke id bevatten die we kunnen gebruiken om naar een specifiek te verwijzen Willekeurige gedachte rij binnen de tabel.
Het interessante aan het ID kaart eigendom is dat het is versierd met twee attributen, Hoofdsleutel en AutoIncrement. Hoofdsleutel vertelt SQLite dat deze kolom de primaire sleutel van de tabel wordt, wat betekent dat deze standaard uniek moet zijn en dat er een index op wordt toegepast om het ophalen van deze tabel te versnellen wanneer naar een rij wordt verwezen door deze tabel. kolom.
AutoIncrement betekent dat wanneer we een nieuwe invoegen Willekeurige gedachte in deze tabel, de ID kaart kolom wordt automatisch ingevuld met de eerstvolgende beschikbare integerwaarde. De volgende stap is om deze tabel in de database te maken.
Ik maak graag een klasse die mijn database vertegenwoordigt en bewaar alle logica om toegang te krijgen tot de database en de tabellen binnen deze klasse. Hiervoor maak ik een klasse genaamd RandomThoughtDatabase:
systeem gebruiken; met behulp van SQLite.Net; gebruikmakend van Xamarin.Forms; met behulp van System.Collections.Generic; met behulp van System.Linq; naamruimte IntroToSQLite openbare klasse RandomThoughtDatabase private SQLiteConnection _connection; openbare RandomThoughtDatabase () _connection = DependencyService.Get(). GetConnection (); _connection.CreateTable (); openbaar IEnumerable GetThoughts () return (from t in _connection.Table () selecteer t) .ToList (); public RandomThought GetThought (int id) return _connection.Table () .FirstOrDefault (t => t.ID == id); public void DeleteThought (int id) _connection.Delete (ID kaart); public void AddThought (string thought) var newThought = new RandomThought Thought = thought, CreatedOn = DateTime.Now; _connection.Insert (newThought);
Dit is een zeer eenvoudige implementatie omdat het slechts een paar methoden bevat. Dit zijn meestal enkele van de basishandelingen die u uitvoert bij het omgaan met een database. Een punt van aandacht is de constructeur. Binnen de constructor doen we twee dingen.
Ten eerste gebruiken we de DependencyService klasse om een geregistreerde klasse te krijgen die de. implementeert ISQLite interface en bel zijn getConnection methode.
Ten tweede gebruiken we de CreateTable methode op de SQLiteConnection klasse om een tabel te maken met de naam Willekeurige gedachte. Met deze methode wordt de tabel gemaakt, als deze nog niet bestaat, en wordt deze netjes afgesloten als deze al bestaat.
Vanzelfsprekend kun je zo verfijnd worden met deze klasse als je wilt door allerlei functies toe te voegen, maar deze bewerkingen zijn meestal een goed startpunt.
Het merendeel van de code die we gebruiken om te communiceren met de database zal gevonden worden in het PCL (of Shared) project. Maar we moeten nog steeds een beetje bekabelen in de native implementaties om alles correct te laten werken.
Het belangrijkste obstakel dat we nodig hebben om aan de native kant te werken bij het gebruik van SQLite is waar we het eigenlijke databasebestand gaan opslaan. Dit verschilt van platform tot platform. Dit is wat we nodig hebben voor iOS.
Voordat we daadwerkelijk een soort SQLite-functionaliteit aan het iOS-project kunnen toevoegen, moeten we de SQLite.Net PCL net als de SQLite.NET PCL - XamarinIOS Platform pakketten voor dit project. U kunt dezelfde stappen volgen die u hebt genomen Stap 2, zorg ervoor dat beide aan het project worden toegevoegd. Nadat u dit pakket hebt toegevoegd, kunt u beginnen met het schrijven van een SQLite-code in het iOS-project.
Laten we een implementatie van de maken ISQLite interface voor iOS. Begin met het maken van een nieuwe klasse door deze een naam te geven SQLite_iOS.
systeem gebruiken; met behulp van System.IO; met behulp van SQLite; met behulp van IntroToSQLite.iOS; gebruikmakend van Xamarin.Forms; [assembly: Dependency (typeof (SQLite_iOS))] naamruimte IntroToSQLite.iOS public class SQLite_iOS: ISQLite public SQLite_iOS () #region ISQLite implementatie 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, bestandsnaam); var platform = nieuw SQLite.Net.Platform.XamarinIOS.SQLitePlatformIOS (); var connection = new SQLite.Net.SQLiteConnection (platform, pad); terugkeer verbinding; #endregion
We krijgen toegang tot de juiste locatie om het databasebestand op te slaan, een nieuw te maken SQLiteConnection object en geef het door aan ons PCL (of Shared) project. Het assembly-attribuut bovenaan het bestand wordt gebruikt om deze klasse te identificeren als een Afhankelijkheid die kan worden opgehaald via de Krijgen methode op de DependencyService klasse.
Deze stap lijkt veel op de vorige. Het enige verschil is dat de code een beetje zal veranderen vanwege het feit dat de locatie van het databasebestand anders zal zijn. U moet nog steeds de juiste pakketten toevoegen aan het Android-project (SQLite.Net PCL en SQLite.NET PCL - XamarinAndroid) zoals je eerder deed. Als u dit hebt voltooid, kunt u de juiste code toevoegen aan een nieuwe klasse met de naam SQLite_Android.
systeem gebruiken; met behulp van System.IO; gebruikmakend van Xamarin.Forms; met behulp van IntroToSQLite.Android; [assembly: Dependency (typeof (SQLite_Android))] naamruimte IntroToSQLite.Android public class SQLite_Android: ISQLite public SQLite_Android () #region ISQLite implementatie public SQLite.Net.SQLiteConnection GetConnection () var fileName = "RandomThought.db3" ; var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal); var path = Path.Combine (documentsPath, bestandsnaam); var platform = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid (); var connection = new SQLite.Net.SQLiteConnection (platform, pad); terugkeer verbinding; #endregion
U hebt nu een werkende implementatie van de ISQLite-interface vanuit het perspectief van uw Android-app.
Omdat ik deze app vanaf een Mac gebruik, zal ik de Windows Phone-implementatie niet maken, maar als je dit wilt doen, kun je.
De eerste stap is om ondersteuning toe te voegen aan uw Windows Phone-project voor SQLite. Zoals eerder vermeld, wordt SQLite standaard geleverd op iOS en Android. Dit geldt niet voor Windows Phone, maar het wordt wel ondersteund. Om het te installeren, volg je de instructies op de Xamarin-website.
Na het installeren van SQLite, zal het proces van het toevoegen van de functionaliteit voor Windows Phone vrijwel exact hetzelfde zijn, behalve dat de pakketten die moeten worden geïnstalleerd SQLite.Net PCL en SQLite.Net PCL - Windows Phone 8 Platform. Met deze pakketten geïnstalleerd, kunt u de Windows Phone-implementatie van de ISQLite interface.
systeem gebruiken; met behulp van System.IO; gebruikmakend van Xamarin.Forms; met behulp van IntroToSQLite.WinPhone; [assembly: Dependency (typeof (SQLite_WinPhone)] namespace IntroToSQLite.WinPhone public class SQLite_WinPhone: ISQLite public SQLite_WinPhone () #region ISQLite implementatie 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 (platform, pad); ga terug verbinding; #endregion
Daar heb je het. Nu hebt u al uw native-implementaties voltooid. Het is tijd om deze app een gebruikersinterface te geven en uw gegevens in de database te krijgen.
Aangezien deze tutorial goed ingaat op het onderwerp Xamarin.Forms, ga ik ervan uit dat je op zijn minst een basiskennis van Xamarin.Forms hebt. Met deze veronderstelling in gedachten zal ik niet in detail ingaan op het proces van het maken van de gebruikersinterface. Als je meer achtergrondinformatie wilt over Xamarin.Forms, bekijk dan mijn andere tutorials over Xamarin.Forms over Tuts+.
De gebruikersinterface zal uit twee afzonderlijke pagina's bestaan. De eerste pagina bevat een lijst met alle gedachten die we in een lijst hebben ingevoerd, terwijl de tweede pagina de gebruiker een nieuwe gedachte laat invoeren. Laten we deze pagina's bouwen.
We zullen eerst focussen op het creëren van de eerste pagina die een lijst van bevat Willekeurige gedachte voorwerpen. Begin met het aanmaken van een nieuw bestand in het PCL (of Shared) project en noem het RandomThoughtsPage. Vervang de standaardimplementatie door het volgende:
systeem gebruiken; gebruikmakend van Xamarin.Forms; naamruimte IntroToSQLite public class RandomThoughtsPage: ContentPage private RandomThoughtDatabase _database; private ListView _thoughtList; openbare RandomThoughtsPage (RandomThoughtDatabase-database) _database = database; Title = "willekeurige gedachten"; var thoughts = _database.GetThoughts (); _thoughtList = new ListView (); _thoughtList.ItemsSource = gedachten; _thoughtList.ItemTemplate = nieuwe DataTemplate (typeof (TextCell)); _thoughtList.ItemTemplate.SetBinding (TextCell.TextProperty, "Thought"); _thoughtList.ItemTemplate.SetBinding (TextCell.DetailProperty, "CreatedOn"); var toolbarItem = new ToolbarItem Name = "Toevoegen", Command = new Command (() => Navigation.PushAsync (new ThoughtEntryPage (this, database))); ToolbarItems.Add (toolbarItem); Inhoud = _thoughtList; public void Refresh () _thoughtList.ItemsSource = _database.GetThoughts ();
Het meeste werk in deze klas zit in de constructor. De constructor laat ons toe om in een instantie van de RandomThoughtsDatabase om alle opgeslagen gedachten te krijgen. We hebben de Titel eigenschap van de pagina naar "willekeurige gedachten", haal alle bestaande gedachten op, maak een nieuw exemplaar van a Lijstweergave, en maak een ToolbarItem waarmee we op een knop kunnen klikken om de invoerpagina te openen. We hebben dat nog niet geïmplementeerd, maar dat zullen we binnenkort doen.
Om ons nieuw te krijgen RandomThoughtsPage op het scherm moeten we een kleine wijziging aanbrengen in de App.cs het dossier. Wijzig in dit bestand de GetMainPage methode om er als volgt uit te zien:
public static Pagina GetMainPage () var database = new RandomThoughtDatabase (); retourneer nieuwe NavigationPage (nieuwe RandomThoughtsPage (database));
De GetMainPage methode maakt nu een nieuw exemplaar van onze RandomThoughtDatabase class en geeft een nieuw exemplaar van de RandomThoughtsPage. Met deze wijziging zouden onze iOS- en Android-apps er ongeveer zo uit moeten zien:
We hebben nu een lijstpagina voor al onze Willekeurige gedachte objecten, maar we hebben geen manier om nieuwe in te voeren. Daarvoor zullen we een andere pagina maken die lijkt op de vorige pagina. Maak een nieuw bestand in uw PCL (of Shared) project en noem het ThoughtEntryPage. Vervang de standaardimplementatie door het volgende:
systeem gebruiken; gebruikmakend van Xamarin.Forms; naamruimte IntroToSQLite public class ThoughtEntryPage: ContentPage private RandomThoughtsPage _parent; private RandomThoughtDatabase _database; public ThoughtEntryPage (RandomThoughtsPage bovenliggende, RandomThoughtDatabase-database) _parent = bovenliggende; _database = database; Title = "Enter a Thought"; var entry = new Entry (); var button = new Button Text = "Toevoegen"; button.Clicked + = async (object afzender, EventArgs e) => var thought = entry.Text; _database.AddThought (denken); wacht op Navigation.PopAsync (); _parent.Refresh (); ; Content = new StackLayout Spacing = 20, Padding = new Thickness (20), Children = entry, button,;
In deze klas wordt al het werk gedaan binnen de constructor. We krijgen een verwijzing naar de bovenliggende pagina, RandomThoughtsPage, evenals de database. De rest is de basisinstellingencode met een binnenkomst object voor het invoeren van tekst en een Knop.
Zodra de gebruiker op de Knop, we gebruiken de database om de nieuwe gedachte toe te voegen, de pagina te sluiten, terug te gaan naar de lijstpagina en de verversen methode om de Lijstweergave. Zodra dit allemaal is aangesloten, kunnen we het uitvoeren om enkele waarden in te voeren.
Hier is hoe het er uitziet op iOS en Android om enkele van uw gedachten in te voeren:
Nadat je een paar gedachten hebt ingevoerd, ziet je lijst er ongeveer zo uit:
Daar heb je het. U hebt nu de mogelijkheid om databasefunctionaliteit toe te voegen aan uw Xamarin.Forms-app om elke soort gegevens gemakkelijk op te slaan en op te halen.
Om je leerreis voort te zetten met Xamarin.Forms en SQLite, geef ik je de volgende uitdaging. Kijk of je deze applicatie kunt verbeteren om gedachten te verwijderen en de lijstpagina op dezelfde manier bij te werken als de startpagina. Veel geluk en fijne codering.
Accentsconagua