Eine Einführung in Xamarin.Forms und SQLite

Irgendwann in Ihrer Karriere als Entwickler von Mobilgeräten müssen Sie sich mit Daten befassen. Der Umgang mit Daten bedeutet mehr als die Verarbeitung und Anzeige von Informationen für den Endbenutzer. Sie müssen diese Informationen irgendwo speichern und können sie leicht abrufen. Dank Xamarin und Open Source-Software können Sie Ihre Daten problemlos auf einer branchenerprobten Plattform, SQLite, speichern.

1. Speichern von Daten

Warum müssen Sie sich also um Daten kümmern, wenn es um Ihre App geht? Weil es überall um dich herum ist. Du kannst ihm nicht entkommen. Egal, welche Art von App Sie schreiben, ob es sich um ein Spiel oder ein Dienstprogramm handelt, Sie müssen irgendwann Daten speichern. Diese Daten können Benutzerdaten, Statistiken oder andere interessante Daten sein, an denen Sie oder der Benutzer irgendwann bei der Verwendung Ihrer App interessiert sein werden.

Nehmen wir an dieser Stelle an, dass Sie sich für die Xamarin.Forms-Route entschieden haben, da Sie nicht nur in der Logik für Ihre App, sondern auch für die Benutzeroberfläche mehrere Plattformen ansprechen möchten.

Toll. Aber was machen Sie jetzt, wo Sie Informationen in Ihrer App speichern müssen? Keine Sorge, es gibt eine sehr einfache Lösung für dieses Problem, SQLite.

2. Einführung in SQLite

Sie haben den Begriff SQLite jetzt ein paar Mal in diesem Tutorial gesehen. Es ist Zeit, sich dem Fleisch zu widmen. Was genau ist SQLite? SQLite ist ein gemeinfreies Transaktions-SQL-Datenbankmodul ohne Konfiguration. Dies bedeutet lediglich, dass Sie über einen voll ausgestatteten Mechanismus verfügen, um Ihre Daten strukturiert zu speichern. Sie erhalten nicht nur all dies, sondern haben auch Zugriff auf den Quellcode, da dieser Open Source ist.

Wir werden in diesem Tutorial nicht alle Funktionen von SQLite behandeln, nur weil es zu viele gibt, um sie durchzuarbeiten. Seien Sie versichert, dass Sie auf einfache Weise eine Tabellenstruktur erstellen können, um Daten zu speichern und in Ihrer App abzurufen. Dies sind die Konzepte, auf die wir uns in diesem Tutorial konzentrieren werden.

In der Welt von Xamarin.Forms ist SQLite aus einem sehr einfachen Grund eine natürliche Lösung. Die SQLite-Engine ist sowohl für iOS als auch für Android verfügbar. Dies bedeutet, dass Sie diese Technologie sofort verwenden können, wenn Sie eine Xamarin.Forms-App schreiben.

Um Zugriff auf SQLite-Funktionen in Windows Phone-Apps zu erhalten, ist ein zusätzlicher Schritt erforderlich, den wir etwas später ausführen werden. All diese Funktionen und die plattformübergreifende Zugänglichkeit sind großartig, aber wie erhalten wir über unseren C#-Code in Xamarin.Forms Zugriff auf die nativen Plattformimplementierungen? Aus einem schönen NuGet-Paket geht das so. Lassen Sie uns einen Blick darauf werfen.

3. Erstellen einer App

Beginnen wir mit der Erstellung einer einfachen Xamarin.Forms-Anwendung. In diesem Tutorial verwende ich einen Mac mit Xamarin Studio, aber Sie können genauso einfach Xamarin Studio oder Visual Studio auf einem PC verwenden.

Schritt 1: Erstellen Sie ein Projekt

Wir beginnen den Prozess mit der Erstellung einer neuen Xamarin.Forms-App. Wählen Sie dazu einfach links die Mobile Apps-Projektvorlagenfamilie und rechts eine der Xamarin.Forms-Vorlagen aus. Sie können entweder die PCL- oder die freigegebene Version der Vorlage verwenden, aber in diesem Fall verwende ich die PCL. Sie können beide verwenden, aber es gibt einen kleinen Unterschied, wenn Sie später die freigegebene Vorlage auswählen.

Sie können dem Projekt einen beliebigen Namen geben. Ich werde dieses Projekt IntroToSQLite nennen. Nachdem Sie auf die Schaltfläche OK geklickt haben, durchläuft Ihre IDE den Prozess der Erstellung Ihrer Lösung. Ihre Lösung enthält vier Projekte:

1. IntroToSQLite - PCL-Projekt
2. IntroToSQLite.Android - Android-Projekt
3. IntroToSQLite.iOS - iOS-Projekt
4. IntroToSQLite.WinPhone - Windows Phone-Projekt (nur auf einem PC)

Schritt 2: SQLite-Unterstützung hinzufügen

Nachdem wir unsere grundlegende Projektstruktur eingerichtet haben, können wir unserem PCL-Projekt den Zugriff auf SQLite hinzufügen. Wir müssen ein neues Paket mit dem Namen SQLite.Net in unser Projekt installieren. Dies ist ein .NET-Wrapper für SQLite, mit dem wir über ein Xamarin.Forms-PCL- oder Shared-Projekt auf die native SQLite-Funktionalität zugreifen können.

Wir greifen auf dieses NuGet-Paket zu, indem wir mit der rechten Maustaste auf Pakete oder Referenzen klicken, je nachdem, welche IDE Sie verwenden, und Paket hinzufügen (oder Referenz hinzufügen) auswählen. Geben Sie im Suchfeld sqlite.net ein. Dies zeigt Ihnen eine ziemlich große Sammlung von Paketen, die Sie in Ihr Projekt aufnehmen können.

Da ich mich für die PCL-Route für mein Xamarin.Forms-Projekt entschieden habe, muss ich das SQLite.Net-PCL-Paket auswählen, das in mein Projekt aufgenommen werden soll. Welches wählen Sie, wenn Sie die gemeinsame Projektroute gewählt haben? Keiner.

SQLite und gemeinsam genutzte Projekte

Wenn Sie zuvor im Lernprogramm die Vorlage für freigegebene Projekte ausgewählt haben, fragen Sie sich möglicherweise, wie Sie auf das SQLite-Paket zugreifen können. Die kurze Antwort ist, dass Sie nicht können. Wenn Sie sich an ein vorheriges Tutorial erinnern, können Sie einem freigegebenen Projekt keine Verweise hinzufügen. Um von einem freigegebenen Projekt aus auf SQLite zuzugreifen, fügen Sie einfach den Quellcode zum Projekt hinzu.

Fügen Sie Code hinzu

Der letzte Schritt beim Hinzufügen von SQLite-Funktionen zum PCL-Projekt besteht darin, eine Schnittstelle zu erstellen, über die wir auf die SQLite-Welt zugreifen können. Der Grund dafür ist, dass wir auf die nativen Funktionen auf den verschiedenen Plattformen zugreifen müssen, wie wir in einem vorherigen Tutorial gesehen haben.

Beginnen wir mit der Definition einer Schnittstelle, über die wir auf die SQLite-Datenbankverbindung zugreifen können. Erstellen Sie in Ihrem PCL-Projekt eine neue Schnittstelle mit dem Namen ISQLite und ersetzen Sie die Implementierung durch die folgende:

1

using System;

2

using SQLite.Net;

3

4

namespace IntroToSQLite

5

{

6

    public interface ISQLite

7

	{

8

		SQLiteConnection GetConnection();

9

	}

10

}

Dies ist die Schnittstelle, die wir implementieren und über den DependencyService von den nativen Implementierungen aus auf sie zugreifen können.

Schritt 3: Definieren Sie die Datenbank

Wir haben jetzt Zugriff auf die SQLite-Funktionalität. Definieren wir unsere Datenbank. Diese spezielle Anwendung wird recht einfach sein und wir werden nur einige unserer zufälligen Gedanken speichern, wenn wir sie entwickeln.

Wir beginnen mit der Erstellung einer Klasse, die die in einer bestimmten Tabelle gespeicherten Daten darstellt. Nennen wir diese Klasse RandomThought.

1

using System;

2

using SQLite.Net.Attributes;

3

4

namespace IntroToSQLite

5

{

6

    public class RandomThought

7

	{

8

		[PrimaryKey, AutoIncrement]

9

		public int ID { get; set; }

10

		public string Thought { get; set; }

11

		public DateTime CreatedOn { get; set; }

12

13

		public RandomThought ()

14

		{

15

		}

16

	}

17

}

Wie Sie sehen können, ist dies eine sehr einfache Klasse mit drei Eigenschaften. Zwei dieser Eigenschaften sind nur Ihre normalen Alltagseigenschaften, Thought und CreatedOn. Diese beiden Eigenschaften werden Spalten in der SQLite-Datenbank darstellen, die eine Tabelle mit dem Namen RandomThought enthalten. Die dritte Eigenschaft, ID, wird ebenfalls eine Spalte in der Tabelle darstellen und eine eindeutige ID enthalten, mit der wir auf eine bestimmte RandomThought-Zeile in der Tabelle verweisen können.

Das Interessante an der ID-Eigenschaft ist, dass sie mit zwei Attributen versehen ist: PrimaryKey und AutoIncrement. PrimaryKey teilt SQLite mit, dass diese Spalte der Primärschlüssel der Tabelle sein wird. Dies bedeutet, dass sie standardmäßig eindeutig sein muss und auf sie ein Index angewendet wird, um das Abrufen aus dieser Tabelle zu beschleunigen, wenn auf eine Zeile von verwiesen wird diese Spalte.

AutoIncrement bedeutet, dass beim Einfügen eines neuen RandomThought in diese Tabelle die ID-Spalte automatisch mit dem nächsten verfügbaren ganzzahligen Wert gefüllt wird. Der nächste Schritt besteht darin, diese Tabelle in der Datenbank zu erstellen.

Ich möchte eine Klasse erstellen, die meine Datenbank darstellt, und die gesamte Logik für den Zugriff auf die Datenbank und ihre Tabellen in dieser Klasse beibehalten. Dazu werde ich eine Klasse namens RandomThoughtDatabase erstellen:

1

using System;

2

using SQLite.Net;

3

using Xamarin.Forms;

4

using System.Collections.Generic;

5

using System.Linq;

6

7

namespace IntroToSQLite

8

{

9

    public class RandomThoughtDatabase

10

	{

11

		private SQLiteConnection _connection;

12

13

		public RandomThoughtDatabase ()

14

		{

15

			_connection = DependencyService.Get<ISQLite> ().GetConnection ();

16

			_connection.CreateTable<RandomThought> ();

17

		}

18

19

		public IEnumerable<RandomThought> GetThoughts() {

20

			return (from t in _connection.Table<RandomThought> ()

21

			        select t).ToList ();

22

		}

23

24

		public RandomThought GetThought(int id) {

25

			return _connection.Table<RandomThought> ().FirstOrDefault (t => t.ID == id);

26

		}

27

28

		public void DeleteThought(int id) {

29

			_connection.Delete<RandomThought> (id);

30

		}

31

32

		public void AddThought(string thought) {

33

			var newThought = new RandomThought {

34

				Thought = thought,

35

				CreatedOn = DateTime.Now

36

			};

37

38

			_connection.Insert (newThought);

39

		}

40

	}

41

}

Dies ist eine sehr einfache Implementierung, da sie nur wenige Methoden enthält. Dies sind normalerweise einige der grundlegenden Vorgänge, die Sie beim Umgang mit einer Datenbank ausführen. Ein wichtiger Punkt ist der Konstruktor. Innerhalb des Konstruktors machen wir zwei Dinge.

Zunächst verwenden wir die DependencyService-Klasse, um eine registrierte Klasse abzurufen, die die ISQLite-Schnittstelle implementiert, und rufen die GetConnection-Methode auf.

Zweitens verwenden wir die CreateTable-Methode für die SQLiteConnection-Klasse, um eine Tabelle mit dem Namen RandomThought zu erstellen. Diese Methode erstellt die Tabelle, falls sie noch nicht vorhanden ist, und beendet sie ordnungsgemäß, wenn sie bereits vorhanden ist.

Natürlich können Sie mit dieser Klasse so anspruchsvoll werden, wie Sie möchten, indem Sie alle Arten von Funktionen hinzufügen, aber diese Operationen sind normalerweise ein guter Ausgangspunkt.

Schritt 4: Fügen Sie die iOS-Implementierung hinzu

Der größte Teil des Codes, den wir für die Interaktion mit der Datenbank verwenden, befindet sich im PCL-Projekt (oder Shared-Projekt). Aber wir müssen noch ein wenig Verkabelung in den nativen Implementierungen vornehmen, damit alles richtig funktioniert.

Das Haupthindernis, das wir bei der Verwendung von SQLite auf der nativen Seite umgehen müssen, ist, wo wir die eigentliche Datenbankdatei speichern. Dies unterscheidet sich von Plattform zu Plattform. Folgendes brauchen wir für iOS.

Bevor wir dem iOS-Projekt tatsächlich SQLite-Funktionen hinzufügen können, müssen wir diesem Projekt die Pakete SQLite.Net PCL sowie SQLite.NET PCL - XamarinIOS Platform hinzufügen. Sie können die gleichen Schritte wie in Schritt 2 ausführen und sicherstellen, dass Sie beide zum Projekt hinzufügen. Sobald Sie dieses Paket hinzugefügt haben, können Sie mit dem Schreiben von SQLite-Code innerhalb des iOS-Projekts beginnen.

Lassen Sie uns eine Implementierung der ISQLite-Schnittstelle für iOS erstellen. Erstellen Sie zunächst eine neue Klasse und nennen Sie sie SQLite_iOS.

1

using System;

2

using System.IO;

3

using SQLite;

4

using IntroToSQLite.iOS;

5

using Xamarin.Forms;

6

7

[assembly: Dependency(typeof(SQLite_iOS))]

8

9

namespace IntroToSQLite.iOS

10

{

11

    public class SQLite_iOS: ISQLite

12

	{

13

		public SQLite_iOS ()

14

		{

15

		}

16

17

		#region ISQLite implementation

18

19

		public SQLite.Net.SQLiteConnection GetConnection ()

20

		{

21

			var fileName = "RandomThought.db3";

22

			var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal);

23

			var libraryPath = Path.Combine (documentsPath, "..", "Library");

24

			var path = Path.Combine (libraryPath, fileName);

25

26

			var platform = new SQLite.Net.Platform.XamarinIOS.SQLitePlatformIOS ();

27

			var connection = new SQLite.Net.SQLiteConnection (platform, path);

28

29

			return connection;

30

		}

31

32

		#endregion

33

	}

34

}

35

Wir erhalten Zugriff auf den richtigen Speicherort, um die Datenbankdatei zu speichern, ein neues SQLiteConnection-Objekt zu erstellen und es an unser PCL-Projekt (oder Shared-Projekt) zurückzugeben. Das Assembly-Attribut oben in der Datei wird verwendet, um diese Klasse als Dependency zu identifizieren, die über die Get-Methode für die DependencyService-Klasse abgerufen werden kann.

Schritt 5: Fügen Sie die Android-Implementierung hinzu

Dieser Schritt ist dem vorherigen sehr ähnlich. Der einzige Unterschied besteht darin, dass sich der Code ein wenig ändert, da der Speicherort der Datenbankdatei unterschiedlich ist. Sie müssen dem Android-Projekt weiterhin die entsprechenden Pakete hinzufügen (SQLite.Net PCL und SQLite.NET PCL - XamarinAndroid), wie Sie es zuvor getan haben. Sobald Sie dies abgeschlossen haben, können Sie den entsprechenden Code in einer neuen Klasse mit dem Namen SQLite_Android hinzufügen.

1

using System;

2

using System.IO;

3

using Xamarin.Forms;

4

using IntroToSQLite.Android;

5

6

[assembly: Dependency(typeof(SQLite_Android))]

7

8

namespace IntroToSQLite.Android

9

{

10

    public class SQLite_Android: ISQLite

11

	{

12

		public SQLite_Android ()

13

		{

14

		}

15

16

		#region ISQLite implementation

17

18

		public SQLite.Net.SQLiteConnection GetConnection ()

19

		{

20

			var fileName = "RandomThought.db3";

21

			var documentsPath = Environment.GetFolderPath (Environment.SpecialFolder.Personal);

22

			var path = Path.Combine (documentsPath, fileName);

23

24

			var platform = new SQLite.Net.Platform.XamarinAndroid.SQLitePlatformAndroid ();

25

			var connection = new SQLite.Net.SQLiteConnection (platform, path);

26

27

			return connection;

28

		}

29

30

		#endregion

31

	}

32

}

33

Sie haben jetzt eine funktionierende Implementierung der ISQLite-Oberfläche aus der Sicht Ihrer Android-App.

Schritt 6: Fügen Sie die Windows Phone-Implementierung hinzu

Da ich diese App von einem Mac aus starte, werde ich die Windows Phone-Implementierung nicht erstellen, aber wenn Sie dies möchten, können Sie dies tun.

Der erste Schritt besteht darin, Ihrem Windows Phone-Projekt für SQLite Unterstützung hinzuzufügen. Wie bereits erwähnt, ist SQLite standardmäßig unter iOS und Android verfügbar. Dies gilt nicht für Windows Phone, wird jedoch unterstützt. Befolgen Sie zur Installation die Anweisungen auf der Xamarin-Website.

Nach der Installation von SQLite ist der Vorgang zum Hinzufügen der Funktionen für Windows Phone nahezu identisch, mit der Ausnahme, dass die zu installierenden Pakete SQLite.Net PCL und SQLite.Net PCL - WindowsPhone 8 Platform sind. Mit diesen installierten Paketen können Sie die Windows Phone-Implementierung der ISQLite-Schnittstelle erstellen.

1

using System;

2

using System.IO;

3

using Xamarin.Forms;

4

using IntroToSQLite.WinPhone;

5

6

[assembly: Dependency(typeof(SQLite_WinPhone)]

7

8

namespace IntroToSQLite.WinPhone

9

{

10

    public class SQLite_WinPhone: ISQLite

11

    {

12

		public SQLite_WinPhone ()

13

		{

14

		}

15

16

		#region ISQLite implementation

17

18

		public SQLite.Net.SQLiteConnection GetConnection ()

19

		{

20

			var fileName = "RandomThought.db3";

21

			var path = Path.Combine (ApplicationData.Current.LocalFolder.Path, fileName);

22

23

			var platform = new SQLite.Net.Platform.WindowsPhone8.SQLitePlatformWP8 ();

24

			var connection = new SQLite.Net.SQLiteConnection (platform, path);

25

26

			return connection;

27

		}

28

29

		#endregion

30

	}

31

}

32

Hier hast du es. Jetzt haben Sie alle Ihre nativen Implementierungen abgeschlossen. Es ist Zeit, dieser App eine Benutzeroberfläche zu geben und Ihre Daten in die Datenbank zu übertragen.

Schritt 7: Hinzufügen der Benutzeroberfläche

Da sich dieses Tutorial gut mit dem Thema Xamarin.Forms befasst, gehe ich davon aus, dass Sie mindestens über Grundkenntnisse in Xamarin.Forms verfügen. Unter dieser Annahme werde ich nicht sehr detailliert auf den Prozess der Erstellung der Benutzeroberfläche eingehen. Wenn Sie weitere Hintergrundinformationen zu Xamarin.Forms benötigen, lesen Sie meine anderen Xamarin.Forms-Tutorials zu Tuts+.

Die Benutzeroberfläche wird aus zwei separaten Seiten bestehen. Die erste Seite enthält eine Liste aller Gedanken, die wir in eine Liste eingegeben haben, während die zweite Seite den Benutzer die Eingabe eines neuen Gedankens ermöglicht. Lassen Sie uns diese Seiten erstellen.

Erstellen Sie die ListView

Wir werden uns zunächst darauf konzentrieren, die erste Seite zu erstellen, die eine Liste von RandomThought-Objekten enthält. Erstellen Sie zunächst eine neue Datei im PCL-Projekt (oder im freigegebenen Projekt) und nennen Sie sie RandomThoughtsPage. Ersetzen Sie die Standardimplementierung durch Folgendes:

1

using System;

2

using Xamarin.Forms;

3

4

namespace IntroToSQLite

5

{

6

    public class RandomThoughtsPage: ContentPage {

7

		private RandomThoughtDatabase _database;

8

		private ListView _thoughtList;

9

10

		public RandomThoughtsPage (RandomThoughtDatabase database)

11

		{

12

			_database = database;

13

			Title = "Random Thoughts";

14

			var thoughts = _database.GetThoughts ();

15

16

			_thoughtList = new ListView ();

17

			_thoughtList.ItemsSource = thoughts;

18

			_thoughtList.ItemTemplate = new DataTemplate (typeof(TextCell));

19

			_thoughtList.ItemTemplate.SetBinding (TextCell.TextProperty, "Thought");

20

			_thoughtList.ItemTemplate.SetBinding (TextCell.DetailProperty, "CreatedOn");

21

22

			var toolbarItem = new ToolbarItem {

23

				Name = "Add",

24

				Command = new Command(() => Navigation.PushAsync(new ThoughtEntryPage(this, database)))

25

			};

26

27

			ToolbarItems.Add (toolbarItem);

28

29

			Content = _thoughtList;

30

		}

31

32

		public void Refresh() {

33

			_thoughtList.ItemsSource = _database.GetThoughts ();

34

		}

35

	}

36

}

37

Die meiste Arbeit in dieser Klasse befindet sich im Konstruktor. Der Konstruktor ermöglicht es uns, eine Instanz der RandomThoughtsDatabase zu übergeben, um alle gespeicherten Gedanken abzurufen. Wir setzen die Title-Eigenschaft der Seite auf "Random Thoughts", rufen alle vorhandenen Gedanken ab, erstellen eine neue Instanz einer ListView und erstellen ein ToolbarItem, mit dem wir auf eine Schaltfläche klicken können, um die Einstiegsseite aufzurufen. Wir haben das noch nicht implementiert, werden es aber in Kürze tun.

Um unsere neue RandomThoughtsPage auf dem Bildschirm anzuzeigen, müssen wir die Datei App.cs ein wenig ändern. Ändern Sie in dieser Datei die GetMainPage-Methode wie folgt:

1

public static Page GetMainPage ()

2

{ 

3

    var database = new RandomThoughtDatabase ();

4

5

    return new NavigationPage (new RandomThoughtsPage (database));

6

}

Die GetMainPage-Methode erstellt jetzt eine neue Instanz unserer RandomThoughtDatabase-Klasse und gibt eine neue Instanz der RandomThoughtsPage zurück. Mit dieser Änderung sollten unsere iOS- und Android-Apps ungefähr so aussehen:

Erstellen Sie die Einstiegsseite

Wir haben jetzt eine Listenseite für alle unsere RandomThought-Objekte, aber wir haben keine Möglichkeit, neue einzugeben. Dazu erstellen wir eine weitere Seite ähnlich der vorherigen Seite. Erstellen Sie eine neue Datei in Ihrem PCL- (oder freigegebenen) Projekt und nennen Sie sie ThoughtEntryPage. Ersetzen Sie die Standardimplementierung durch Folgendes:

1

using System;

2

using Xamarin.Forms;

3

4

namespace IntroToSQLite

5

{

6

    public class ThoughtEntryPage: ContentPage {

7

		private RandomThoughtsPage _parent;

8

		private RandomThoughtDatabase _database;

9

10

		public ThoughtEntryPage ( RandomThoughtsPage parent, RandomThoughtDatabase database)

11

		{

12

			_parent = parent;

13

			_database = database;

14

			Title = "Enter a Thought";

15

16

			var entry = new Entry ();

17

			var button = new Button {

18

				Text = "Add"

19

			};

20

21

			button.Clicked += async (object sender, EventArgs e) => {

22

				var thought = entry.Text;

23

24

				_database.AddThought(thought);

25

26

				await Navigation.PopAsync();

27

28

29

				_parent.Refresh();

30

			};

31

32

			Content = new StackLayout {

33

				Spacing = 20,

34

				Padding = new Thickness(20),

35

				Children = { entry, button },

36

			};

37

		}

38

	}

39

}

40

In dieser Klasse wird die gesamte Arbeit im Konstruktor ausgeführt. Wir erhalten einen Verweis auf die übergeordnete Seite RandomThoughtsPage sowie die Datenbank. Der Rest ist ein grundlegender Setup-Code mit einem Entry-Objekt zur Texteingabe und einer Button.

Sobald der Benutzer auf die Button tippt, verwenden wir die Datenbank, um den neuen Gedanken hinzuzufügen, die Seite zu schließen, zur Listenseite zurückzukehren und die Refresh-Methode aufzurufen, um die ListView zu aktualisieren. Sobald dies alles verkabelt ist, können wir es ausführen, um tatsächlich einige Werte einzugeben.

Gedanken eingeben

So sieht es unter iOS und Android aus, um einige Ihrer Gedanken einzugeben:

Anzeigen der Liste

Nachdem Sie einige Gedanken eingegeben haben, sieht Ihre Liste ungefähr so aus:

Schlussfolgerung

Hier haben Sie es. Sie haben jetzt die Möglichkeit, Ihrer Xamarin.Forms-App Datenbankfunktionen hinzuzufügen, um problemlos alle Arten von Daten zu speichern und abzurufen.

Um Ihre Lernreise mit Xamarin.Forms und SQLite fortzusetzen, gebe ich Ihnen die folgende Herausforderung. Überprüfen Sie, ob Sie diese Anwendung erweitern können, um das Löschen von Gedanken zu ermöglichen und die Listenseite auf ähnliche Weise wie die Einstiegsseite zu aktualisieren. Viel Glück und viel Spaß beim Codieren.