Erste Schritte mit Entity Framework Core

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

Sie können dem Lernprogramm folgen, indem Sie Visual Studio unter Windows oder Visual Studio für Mac verwenden.

Trinkgeld

Sie können das Beispiel dieses Artikels auf GitHubanzeigen.

Voraussetzungen

Installieren Sie eine der folgenden Optionen:

• Visual Studio 2019, Version 16.3 oder höher mit dieser Workload:
  • Mobile-Entwicklung mit .NET
• Visual Studio für Mac

Diese Dokumentation enthält detaillierte Schrittweise Installationsanweisungen für jede Plattform.

Herunterladen und Ausführen des Beispielprojekts

Um diese Beispielanwendung auszuführen und zu erkunden, laden Sie den Code auf GitHub herunter.

Öffnen Sie nach dem Herunterladen 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.

Wenn die App zum ersten Mal gestartet wird, füllt sie die lokale SQLite-Datenbank mit zwei Einträgen, die Blogs darstellen.

Klicken Sie auf der Symbolleiste auf die Schaltfläche Hinzufügen.

Eine neue Seite wird angezeigt, mit der Sie Informationen zu einem neuen Blog eingeben können.

Füllen Sie alle Informationen aus, und klicken Sie auf Speichern auf der Symbolleiste. 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 und alle Beiträge für diesen Blog anzeigen.

Klicken Sie in der Symbolleiste auf " hinzufügen".

Daraufhin wird eine Seite angezeigt, auf der Sie Informationen zu einem neuen Blogbeitrag ausfüllen können.

Füllen Sie alle Informationen aus; klicken Sie dann in der Symbolleiste auf Speichern.

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

Wechseln Sie zurück zur Bloglistenseite. Klicken Sie auf der Symbolleiste auf Alle löschen. Alle Blogs und ihre entsprechenden Beiträge werden dann aus der SQLite-Datenbank der App gelöscht.

Erkunden des Codes

In den folgenden Abschnitten werden Sie durch den Code im Beispielprojekt geführt, das Daten aus einer SQLite-Datenbank mit EF Core mit Xamarin.Forms liest, erstellt, aktualisiert und löscht.

Es wird davon ausgegangen, dass Sie mit den Xamarin.Forms-Themen von Anzeigen von Daten und Navigieren zwischen Seitenvertraut sind.

Wichtig

Entity Framework Core verwendet Spiegelung, um Funktionen aufzurufen, die der Xamarin.iOS-Linker in Release- Moduskonfigurationen entfernen kann. Sie können dies auf eine von zwei Arten vermeiden.

• Als Erstes fügen Sie --linkskip System.Core zu den zusätzlichen mtouch-Argumenten in den iOS Build-Optionen hinzu.
• Alternativ können Sie das Xamarin.iOS-Linker-Verhalten in den iOS-Build-Optionen auf Don't Link setzen. In diesem Artikel werden weitere Informationen zum Xamarin.iOS-Linker erläutert, einschließlich der Festlegung des Verhaltens auf Xamarin.iOS. (Dieser Ansatz ist nicht ideal, da er zu Ablehnungen aus dem Laden führen kann).

Entity Framework Core NuGet-Pakete

Zum Erstellen von Xamarin.Forms-Apps mit EF Core installieren Sie das Paket für die EF Core-Datenbankanbieter, auf die Sie in allen Projekten in der Xamarin.Forms-Lösung abzielen möchten. In diesem Lernprogramm wird der SQLite-Anbieter verwendet.

Das folgende NuGet-Paket wird in jedem der Projekte in der Xamarin.Forms-Lösung benötigt.

• Microsoft.EntityFrameworkCore.Sqlite

Modellklassen

Jede Tabelle in der SQLite-Datenbank, auf die über EF Core zugegriffen wird, wird in einer Klasse modelliert. In diesem Beispiel werden zwei Klassen verwendet: Blog und Post, die im Ordner Models zu finden sind.

Die Modellklassen bestehen nur aus Eigenschaften, die Modellspalten in der Datenbank darstellen.

• 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 Eltern-Kind-Beziehung 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 für die Instanz des Postzurück zum übergeordneten Blog-Objekt.

Datenkontext

Die BloggingContext Klasse befindet sich im ordner Services und erbt von der EF Core DbContext Klasse. Ein DbContext wird verwendet, um Datenbankabfragen und -änderungen zu gruppieren.

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 mit den zugrunde liegenden Tabellen zu arbeiten, die Blogs und Beiträge darstellen.
• Der SQLitePCL.Batteries_V2.Init() wird im Konstruktor benötigt, um SQLite unter iOS zu initiieren.
• Die OnConfiguring-Funktion richtet den Speicherort der SQLite-Datenbank auf dem physischen Gerät ein.

Erstellen, Lesen, Aktualisieren & Löschen

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

Lesen

• Gibt alle Datensätze zurück.

  • Die OnAppearing-Funktion von BlogsPage.xaml.cs gibt alle Blog Datensätze zurück und speichert sie in einer List Variablen.

    using (var blogContext = new BloggingContext())
    {
        var theBlogs = blogContext.Blogs.ToList();
    }
    

• Gibt bestimmte Datensätze zurück.

  • Die Funktion OnAppearing von PostsPage.xaml.cs liefert Post Datensätze zurück, die einen bestimmten BlogIdenthalten.

    using (var blogContext = new BloggingContext())
    {
        var postList = blogContext.Posts
            .Where(p => p.BlogId == BlogId)
            .ToList();
    }
    

Erstellen

• Fügen Sie einen neuen Datensatz ein.

  • 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();
    }
    

Löschen

• Lösche alle Datensätze mit Kaskadierung zu untergeordneten Datensätzen.

  • Die DeleteAll_Clicked-Funktion von BlogsPage.xaml.cs löscht alle Blog-Datensätze in der SQLite-Datenbank und leitet die Löschung an alle Blog untergeordneten Post-Datensätze 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.