Erste Schritte mit EF Core und XamarinGetting Started with EF Core and Xamarin

In diesem Tutorial erstellen Sie eine Xamarin.Forms-Anwendung, die den Datenzugriff auf eine SQLite-Datenbank mithilfe von Entity Framework Core durchführt.In this tutorial, you create a Xamarin.Forms application that performs data access against a SQLite database using Entity Framework Core.

Sie können dieses Tutorial mit Visual Studio unter Windows oder Visual Studio für Mac abschließen.You can follow the tutorial by using Visual Studio on Windows or Visual Studio for Mac.

Tipp

Das in diesem Artikel verwendete Beispiel finden Sie auf GitHub.You can view this article's sample on GitHub.

VoraussetzungenPrerequisites

Installieren Sie eines der folgenden Tools:Install one of the below:

In dieser Dokumentation finden Sie ausführliche Installationsanweisungen für jede Plattform.This documentation provides detailed step-by-step installation instructions for each platform.

Herunterladen und Ausführen des BeispielprojektsDownload and run the sample project

Laden Sie den Code von GitHub herunter, um diese Beispielanwendung auszuführen und zu untersuchen.To run and explore this sample application, download the code on GitHub.

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.Once downloaded, open the solution file EFGettingStarted.sln in Visual Studio or Visual Studio for Mac and run the application on the platform of your choice.

Beim ersten Start der App wird die lokale SQLite-Datenbank mit zwei Einträgen aufgefüllt, die Blogs darstellen.When the app first starts, it will populate the local SQLite database with two entries representing blogs.

Screenshot: Seite mit der Liste aller Blogs

Klicken Sie in der Symbolleiste auf Hinzufügen.Click the Add button in the toolbar.

Daraufhin wird eine neue Seite angezeigt, auf der Sie Informationen über einen neuen Blog eingeben können.A new page will appear that allows you to enter information about a new blog.

Screenshot: Seite für neuen Blogeintrag

Geben Sie alle Informationen ein, und klicken Sie in der Symbolleiste auf Speichern.Fill out all the info and click Save from the toolbar. Der neue Blog wird in der SQLite-Datenbank der App gespeichert und in der Liste angezeigt.The new blog will save to the app's SQLite database and will show in the list.

Sie können auf einen der Blogeinträge in der Liste klicken, um alle Beiträge für diesen Blog anzuzeigen.You can click on one of the blog entries in the list and see any posts for that blog.

Screenshot: Seite mit der Liste der Blogbeiträge

Klicken Sie auf der Symbolleiste auf Hinzufügen.Click Add in the toolbar.

Dann wird eine Seite angezeigt, auf der Sie Informationen über einen neuen Blogbeitrag eingeben können.A page then appears that allows you to fill out information about a new blog post.

Screenshot: Seite zum Hinzufügen eines neuen Blogbeitrags

Geben Sie alle Informationen ein, und klicken Sie in der Symbolleiste auf Speichern.Fill out all the information and click Save in the toolbar.

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.The new post will be associated to the blog post you clicked on in a previous step and will save to the app's SQLite database and show in the list.

Wechseln Sie zurück zur Seite mit der Liste der Blogs.Go back to the blog list page. Klicken Sie dann auf der Symbolleiste auf Alle löschen.And click Delete All in the toolbar. Daraufhin werden alle Blogs und ihre zugehörigen Beiträge aus der SQLite-Datenbank der App gelöscht.All blogs and their corresponding posts will then be deleted from the app's SQLite database.

Screenshot der App mit allen Blogs gelöscht

Untersuchen des CodesExplore the code

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.The following sections will walk you through the code in the sample project that reads, creates, updates, and deletes data from a SQLite database using EF Core with Xamarin.Forms.

Dabei wird davon ausgegangen, dass Sie mit den Xamarin.Forms-Themen zum Anzeigen von Daten und zum Navigieren zwischen Seiten vertraut sind.It is assumed that you are familiar with the Xamarin.Forms topics of displaying data and navigating between pages.

Wichtig

Entity Framework Core verwendet Reflektion, um Funktionen aufzurufen, die der Xamarin.iOS-Linker in Release -Moduskonfigurationen möglicherweise entfernen könnte.Entity Framework Core uses reflection to invoke functions which the Xamarin.iOS linker may strip out while in Release mode configurations. Sie können eine von zwei Möglichkeiten auswählen, dies zu vermeiden.You can avoid that in one of two ways.

  • Die erste ist, --linkskip System.Core zu Weitere mtouch-Argumente in den iOS-Build -Optionen hinzuzufügen.The first is to add --linkskip System.Core to the Additional mtouch arguments in the iOS Build options.
  • Alternativ können Sie das Xamarin.iOS- Linkerverhalten in den iOS-Build -Optionen auf Don't Link festlegen.Alternatively set the Xamarin.iOS Linker behavior to Don't Link in the iOS Build options. Dieser Artikel enthält weitere Informationen zum Xamarin.iOS-Linker, unter anderem zum Festlegen des Verhaltens in Xamarin.iOS.This article explains more about the Xamarin.iOS linker including how to set the behavior on Xamarin.iOS.

NuGet-Pakete für Entity Framework CoreEntity Framework Core NuGet packages

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.To create Xamarin.Forms apps with EF Core, you install the package for the EF Core database provider(s) you want to target into all of the projects in the Xamarin.Forms solution. In diesem Tutorial wird der SQLite-Anbieter verwendet.This tutorial uses the SQLite provider.

Das folgende NuGet-Paket ist für alle Projekte in der Xamarin.Forms-Projektmappe erforderlich.The following NuGet package is needed in each of the projects in the Xamarin.Forms solution.

  • Microsoft.EntityFrameworkCore.Sqlite

ModellklassenModel classes

Alle Tabellen in der SQLite-Datenbank, auf die über EF Core zugegriffen wird, werden in einer Klasse modelliert.Each table in the SQLite database accessed through EF Core is modeled in a class. In diesem Beispiel werden zwei Klassen verwendet: Blog und Post, die sich im Ordner Models befinden.In this sample, two classes are used: Blog and Post which can be found in the Models folder.

Die Modellklassen bestehen lediglich aus Eigenschaften, die Spalten in der Datenbank modellieren.The model classes are composed only of properties, which model columns in the database.

  • Blog.csBlog.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.The Posts property defines a parent-child relationship between Blog and Post.

  • Post.csPost.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.The BlogId and Blog properties relate back to the parent Blog object for the instance of the Post.

DatenkontextData context

Die BloggingContext-Klasse befindet sich im Ordner Services und erbt von der EF Core-Klasse DbContext.The BloggingContext class is located in the Services folder and inherits from the EF Core DbContext class. Eine DbContext-Klasse wird zum Gruppieren von Datenbankabfragen und -änderungen verwendet.A DbContext is used to group together database queries and changes.

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.Both properties in this class of type DbSet are used to operate on the underlying tables representing Blogs and Posts.
  • SQLitePCL.Batteries_V2.Init() ist im Konstruktor erforderlich, um SQLite unter iOS zu initiieren.The SQLitePCL.Batteries_V2.Init() is needed in the constructor to initiate SQLite on iOS.
  • Die OnConfiguring-Funktion richtet den Speicherort der SQLite-Datenbank auf dem physischen Gerät ein.The OnConfiguring function sets up the location of the SQLite database on the physical device.

Erstellen, Lesen, Aktualisieren und LöschenCreate, read, update & delete

Im Folgenden werden einige Instanzen in der App aufgeführt, in der EF Core für den Zugriff auf SQLite verwendet wird.The following are some instances in the app where EF Core is used to access SQLite.

LesenRead

  • Zurückgeben aller DatensätzeReturn all records.
    • Die OnAppearing-Funktion von BlogsPage.xaml.cs gibt alle Blog-Datensätze zurück und speichert diese in einer List-Variable.The OnAppearing function of BlogsPage.xaml.cs returns all Blog records and stores them into a List variable.
using (var blogContext = new BloggingContext())
{
    var theBlogs = blogContext.Blogs.ToList();
}
  • Zurückgeben spezifischer DatensätzeReturn specific records.
    • Die OnAppearing-Funktion von PostsPage.xaml.cs gibt Post-Datensätze zurück, die einen spezifischen BlogId-Wert enthalten.The OnAppearing function of PostsPage.xaml.cs returns Post records that contain a specific BlogId.
using (var blogContext = new BloggingContext())
{
    var postList = blogContext.Posts
        .Where(p => p.BlogId == BlogId)
        .ToList();
}

ErstellenCreate

  • Einfügen eines neuen DatensatzesInsert a new record.
    • Die Save_Clicked-Funktion von AddBlogPage.xaml.cs fügt ein neues Blog-Objekt in die SQLite-Datenbank ein.The Save_Clicked function of AddBlogPage.xaml.cs inserts a new Blog object into the SQLite database.
var blog = new Blog { Url = blogUrl.Text };

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

    await blogContext.SaveChangesAsync();
}

UpdateUpdate

  • Aktualisieren eines vorhandenen DatensatzesUpdate an existing record.
    • Die Save_Clicked-Funktion von AddPostPage.xaml.cs aktualisiert ein vorhandenes Blog-Objekt mit einem neuen Post.The Save_Clicked function of AddPostPage.xaml.cs updates an existing Blog object with a new 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();
}

LöschenDelete

  • Löschen aller Datensätze mit einer Weitergabe an untergeordnete DatensätzeDelete all records with cascade to child records.
    • 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.The DeleteAll_Clicked function of BlogsPage.xaml.cs deletes all the Blog records in the SQLite database and cascades the deletes to all of the Blog child Post records.
using (var blogContext = new BloggingContext())
{
    blogContext.RemoveRange(blogContext.Blogs);

    await blogContext.SaveChangesAsync();
}

Nächste SchritteNext steps

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.In this getting started you have learned how to use a Xamarin.Forms application to access a SQLite database using Entity Framework Core.

Im Folgenden finden Sie weitere Entity Framework Core-Themen, die für Xamarin-Entwickler interessant sind:Other Entity Framework Core topics of interest to Xamarin developers: