Erste Schritte mit EF Core und Xamarin

  • Artikel

In diesem Tutorial erstellen Sie eine Xamarin.Forms-Anwendung, die den Datenzugriff auf eine SQLite-Datenbank mithilfe von Entity Framework Core durchführt.

Sie können dieses Tutorial mit Visual Studio unter Windows oder Visual Studio für Mac abschließen.

Tipp

Das in diesem Artikel verwendete Beispiel finden Sie auf GitHub.

Voraussetzungen

Installieren Sie eines der folgenden Tools:

In dieser Dokumentation finden Sie ausführliche Installationsanweisungen für jede Plattform.

Herunterladen und Ausführen des Beispielprojekts

Laden Sie den Code von GitHub herunter, um diese Beispielanwendung auszuführen und zu untersuchen.

Sobald Sie sie heruntergeladen haben, öffnen Sie die Projektmappendatei EFGettingStarted.sln in Visual Studio oder Visual Studio für Mac, und führen Sie die Anwendung auf der Plattform Ihrer Wahl aus.

Beim ersten Start der App wird die lokale SQLite-Datenbank mit zwei Einträgen aufgefüllt, die Blogs darstellen.

Screenshot of all blogs list page

Klicken Sie in der Symbolleiste auf Hinzufügen.

Daraufhin wird eine neue Seite angezeigt, auf der Sie Informationen über einen neuen Blog eingeben können.

Screenshot of new blog edit page

Geben Sie alle Informationen ein, und klicken Sie in der Symbolleiste auf Speichern. Der neue Blog wird in der SQLite-Datenbank der App gespeichert und in der Liste angezeigt.

Sie können auf einen der Blogeinträge in der Liste klicken, um alle Beiträge für diesen Blog anzuzeigen.

Screenshot of blog posts list page

Klicken Sie auf der Symbolleiste auf Hinzufügen.

Dann wird eine Seite angezeigt, auf der Sie Informationen über einen neuen Blogbeitrag eingeben können.

Screenshot of add new post page

Geben Sie alle Informationen ein, und klicken Sie in der Symbolleiste auf Speichern.

Der neue Beitrag wird dem Blogbeitrag zugeordnet, auf den Sie im vorherigen Schritt geklickt haben, und dann in der SQLite-Datenbank der App gespeichert und in der Liste angezeigt.

Wechseln Sie zurück zur Seite mit der Liste der Blogs. Klicken Sie dann auf der Symbolleiste auf Alle löschen. Daraufhin werden alle Blogs und ihre zugehörigen Beiträge aus der SQLite-Datenbank der App gelöscht.

Screenshot of app with all blogs deleted

Untersuchen des Codes

In den folgenden Abschnitten durchlaufen Sie den Code im Beispielprojekt, der Daten aus einer SQLite-Datenbank mithilfe von EF Core mit Xamarin.Forms liest, erstellt, aktualisiert und löscht.

Dabei wird davon ausgegangen, dass Sie mit den Xamarin.Forms-Themen zum Anzeigen von Daten und zum Navigieren zwischen Seiten vertraut sind.

Wichtig

Entity Framework Core verwendet Reflektion, um Funktionen aufzurufen, die der Xamarin.iOS-Linker in Release-Moduskonfigurationen möglicherweise entfernen könnte. Sie können eine von zwei Möglichkeiten auswählen, dies zu vermeiden.

  • Die erste ist, --linkskip System.Core zu Weitere mtouch-Argumente in den iOS-Build-Optionen hinzuzufügen.
  • Alternativ können Sie das Xamarin.iOS-Linkerverhalten in den iOS-Build-Optionen auf Don't Link festlegen. Dieser Artikel enthält weitere Informationen zum Xamarin.iOS-Linker, unter anderem zum Festlegen des Verhaltens in Xamarin.iOS. (Dieser Ansatz ist nicht ideal, da er möglicherweise zu einer Ablehnung durch den Speicher führt).

NuGet-Pakete für Entity Framework Core

Zum Erstellen von Xamarin.Forms-Apps mit EF Core installieren Sie das Paket für den EF Core-Datenbankanbieter, den Sie als Ziel für alle Projekte in der Xamarin.Forms-Projektmappe verwenden möchten. In diesem Tutorial wird der SQLite-Anbieter verwendet.

Das folgende NuGet-Paket ist für alle Projekte in der Xamarin.Forms-Projektmappe erforderlich.

  • Microsoft.EntityFrameworkCore.Sqlite

Modellklassen

Alle Tabellen in der SQLite-Datenbank, auf die über EF Core zugegriffen wird, werden in einer Klasse modelliert. In diesem Beispiel werden zwei Klassen verwendet: Blog und Post, die sich im Ordner Models befinden.

Die Modellklassen bestehen lediglich aus Eigenschaften, die Spalten in der Datenbank modellieren.

  • Blog.cs

    using System;
using System.Collections.Generic;

namespace EFGetStarted
{
    public class Blog
    {
        public int BlogId { get; set; }
        public string Url { get; set; }

        public List<Post> Posts { get; set; } = new List<Post>();
    }
}

  • Die Eigenschaft Posts definiert eine Über-/Unterordnungsbeziehung zwischen Blog und Post.

  • Post.cs

    using System;
namespace EFGetStarted
{
    public class Post
    {
        public int PostId { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }

        public int BlogId { get; set; }
        public Blog Blog { get; set; }
    }
}

  • Die Eigenschaften BlogId und Blog beziehen sich auf das übergeordnete Blog-Objekt für die Post-Instanz.

Datenkontext

Die BloggingContext-Klasse befindet sich im Ordner Services und erbt von der EF Core-Klasse DbContext. Eine DbContext-Klasse wird zum Gruppieren von Datenbankabfragen und -änderungen verwendet.

using System;
using System.IO;
using Microsoft.EntityFrameworkCore;
using Xamarin.Essentials;

namespace EFGetStarted
{
    public class BloggingContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        public BloggingContext()
        {
            SQLitePCL.Batteries_V2.Init();

            this.Database.EnsureCreated();
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            string dbPath = Path.Combine(FileSystem.AppDataDirectory, "blogs.db3");

            optionsBuilder
                .UseSqlite($"Filename={dbPath}");
        }
    }
}
  • Beide Eigenschaften in dieser Klasse vom Typ DbSet werden verwendet, um die zugrunde liegenden Tabellen zu betreiben, die Blogs und Beiträge darstellen.
  • SQLitePCL.Batteries_V2.Init() ist im Konstruktor erforderlich, um SQLite unter iOS zu initiieren.
  • Die OnConfiguring-Funktion richtet den Speicherort der SQLite-Datenbank auf dem physischen Gerät ein.

Erstellen, Lesen, Aktualisieren und Löschen

Im Folgenden werden einige Instanzen in der App aufgeführt, in der EF Core für den Zugriff auf SQLite verwendet wird.

Lesen

  • Zurückgeben aller Datensätze
    • Die OnAppearing-Funktion von BlogsPage.xaml.cs gibt alle Blog-Datensätze zurück und speichert diese in einer List-Variable.
using (var blogContext = new BloggingContext())
{
    var theBlogs = blogContext.Blogs.ToList();
}
  • Zurückgeben spezifischer Datensätze
    • Die OnAppearing-Funktion von PostsPage.xaml.cs gibt Post-Datensätze zurück, die einen spezifischen BlogId-Wert enthalten.
using (var blogContext = new BloggingContext())
{
    var postList = blogContext.Posts
        .Where(p => p.BlogId == BlogId)
        .ToList();
}

Erstellen

  • Einfügen eines neuen Datensatzes
    • Die Save_Clicked-Funktion von AddBlogPage.xaml.cs fügt ein neues Blog-Objekt in die SQLite-Datenbank ein.
var blog = new Blog { Url = blogUrl.Text };

using (var blogContext = new BloggingContext())
{
    blogContext.Add(blog);

    await blogContext.SaveChangesAsync();
}

Aktualisieren

  • Aktualisieren eines vorhandenen Datensatzes
    • Die Save_Clicked-Funktion von AddPostPage.xaml.cs aktualisiert ein vorhandenes Blog-Objekt mit einem neuen Post.
var newPost = new Post
{
    BlogId = BlogId,
    Content = postCell.Text,
    Title = titleCell.Text
};

using (var blogContext = new BloggingContext())
{
    var blog = await blogContext
        .Blogs
        .FirstAsync(b => b.BlogId == BlogId);

    blog.Posts.Add(newPost);

    await blogContext.SaveChangesAsync();
}

Entf

  • Löschen aller Datensätze mit einer Weitergabe an untergeordnete Datensätze
    • Die DeleteAll_Clicked-Funktion von BlogsPage.xaml.cs löscht alle Blog-Datensätze in der SQLite-Datenbank und gibt die Löschvorgänge an alle untergeordneten Post-Datensätze von Blog weiter.
using (var blogContext = new BloggingContext())
{
    blogContext.RemoveRange(blogContext.Blogs);

    await blogContext.SaveChangesAsync();
}

Nächste Schritte

In diesen ersten Schritten haben Sie gelernt, wie Sie eine Xamarin.Forms-Anwendung für den Zugriff auf eine SQLite-Datenbank mithilfe von Entity Framework Core verwenden.

Im Folgenden finden Sie weitere Entity Framework Core-Themen, die für Xamarin-Entwickler interessant sind: