Delen via

Aan de slag met Entity Framework Core

In deze zelfstudie maakt u een Xamarin.Forms toepassing die gegevenstoegang uitvoert voor een SQLite-database met behulp van Entity Framework Core.

U kunt de handleiding volgen met behulp van Visual Studio op Windows of Visual Studio voor Mac.

Fooi

U kunt het voorbeeld van dit artikel bekijken op GitHub.

Voorwaarden

Installeer een van de onderstaande opties:

Deze documentatie bevat gedetailleerde stapsgewijze installatie-instructies voor elk platform.

Het voorbeeldproject downloaden en uitvoeren

Als u deze voorbeeldtoepassing wilt uitvoeren en verkennen, downloadt u de code op GitHub.

Nadat u het bestand hebt gedownload, opent u het oplossingsbestand EFGettingStarted.sln in Visual Studio of Visual Studio voor Mac en voert u de toepassing uit op het platform van uw keuze.

Wanneer de app voor het eerst wordt gestart, wordt de lokale SQLite-database gevuld met twee vermeldingen die blogs vertegenwoordigen.

Schermopname van de lijstpagina met blogs

Klik op de knop Toevoegen op de werkbalk.

Er wordt een nieuwe pagina weergegeven waarmee u informatie over een nieuw blog kunt invoeren.

Schermopname van de nieuwe pagina voor het bewerken van een blog

Vul alle gegevens in en klik op Opslaan op de werkbalk. De nieuwe blog wordt opgeslagen in de SQLite-database van de app en wordt weergegeven in de lijst.

U kunt op een van de blogberichten in de lijst klikken en alle berichten voor die blog bekijken.

Schermopname van de lijstpagina met blogberichten

Klik op toevoegen op de werkbalk.

Er wordt vervolgens een pagina weergegeven waarmee u informatie over een nieuw blogbericht kunt invullen.

Schermopname van het toevoegen van een nieuwe postpagina

Vul alle gegevens in en klik op Opslaan op de werkbalk.

Het nieuwe bericht wordt gekoppeld aan het blogbericht waarop u in een vorige stap hebt geklikt en slaat deze op in de SQLite-database van de app en wordt weergegeven in de lijst.

Ga terug naar de pagina met de bloglijst. Klik op Alle op de werkbalk verwijderen. Alle blogs en de bijbehorende berichten worden vervolgens verwijderd uit de SQLite-database van de app.

Schermopname van de app met alle blogs verwijderd

De code verkennen

In de volgende secties wordt u begeleid bij de code in het voorbeeldproject dat gegevens leest, maakt, bijwerkt en verwijdert uit een SQLite-database met behulp van EF Core met Xamarin.Forms.

Men gaat ervan uit dat u bekend bent met de onderwerpen van Xamarin.Forms: het weergeven van gegevens en het navigeren tussen de pagina's.

Belangrijk

Entity Framework Core maakt gebruik van reflectie om functies aan te roepen die de Xamarin.iOS-linker in de release modus configuraties kan verwijderen. U kunt dat op twee manieren voorkomen.

  • De eerste is het toevoegen van --linkskip System.Core aan de Extra mtouch-argumenten in de iOS-build opties.
  • U kunt ook het gedrag van Xamarin.iOS Linker instellen op Don't Link in de -opties voor iOS-build. In dit artikel wordt meer uitgelegd over de Xamarin.iOS-linker inclusief het instellen van het gedrag op Xamarin.iOS. (Deze benadering is niet ideaal omdat het kan leiden tot afwijzing van de winkel).

Entity Framework Core NuGet-pakketten

Als u Xamarin.Forms-apps wilt maken met EF Core, installeert u het pakket voor de EF Core-databaseprovider(s) die u wilt toepassen op alle projecten in de Xamarin.Forms-oplossing. In deze zelfstudie wordt gebruikgemaakt van de SQLite-provider.

Het volgende NuGet-pakket is nodig in elk van de projecten in de Xamarin.Forms-oplossing.

  • Microsoft.EntityFrameworkCore.Sqlite

Modelklassen

Elke tabel in de SQLite-database die toegankelijk is via EF Core, wordt gemodelleerd in een klasse. In dit voorbeeld worden twee klassen gebruikt: Blog en Post die te vinden zijn in de map Models.

De modelklassen bestaan alleen uit eigenschappen, die kolommen in de database modelleren.

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

  • De eigenschap Posts definieert een ouder-kind relatie tussen Blog en 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; }
    }
}

  • De eigenschappen BlogId en Blog verwijzen naar het bovenliggende Blog-object voor de instantie van de Post.

Gegevenscontext

De BloggingContext-klasse bevindt zich in de map Services en neemt de klasse EF Core DbContext over. Een DbContext wordt gebruikt om databasequery's en wijzigingen samen te groeperen.

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 eigenschappen in deze klasse van het type DbSet worden gebruikt om te werken op de onderliggende tabellen die Blogs en Posts vertegenwoordigen.
  • De SQLitePCL.Batteries_V2.Init() is nodig in de constructor om SQLite op iOS te initiëren.
  • Met de functie OnConfiguring wordt de locatie van de SQLite-database op het fysieke apparaat ingesteld.

Maken, lezen, bijwerken & verwijderen

Hier volgen enkele exemplaren in de app waarin EF Core wordt gebruikt voor toegang tot SQLite.

Lezen

  • Retourneer alle gegevens.

    • De OnAppearing functie van BlogsPage.xaml.cs retourneert alle Blog records en slaat deze op in een List variabele.

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

  • Geef specifieke records terug.

    • De OnAppearing functie van PostsPage.xaml.cs retourneert Post records die een specifieke BlogIdbevatten.

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

Creëer

  • Een nieuwe record invoegen.

    • De Save_Clicked functie van AddBlogPage.xaml.cs voegt een nieuw Blog-object in de SQLite-database in.

      var blog = new Blog { Url = blogUrl.Text };

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

    await blogContext.SaveChangesAsync();
}

Bijwerken

  • Een bestaande record bijwerken.

    • De Save_Clicked functie van AddPostPage.xaml.cs werkt een bestaand Blog-object bij met een nieuwe 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();
}

Verwijderen

  • Verwijder alle records met trapsgewijs naar onderliggende records.

    • De DeleteAll_Clicked-functie van BlogsPage.xaml.cs verwijdert alle Blog records in de SQLite-database en voert de verwijderingen trapsgewijs uit naar alle Blog onderliggende Post records.

      using (var blogContext = new BloggingContext())
{
    blogContext.RemoveRange(blogContext.Blogs);

    await blogContext.SaveChangesAsync();
}

Volgende stappen

In deze aan de slag hebt u geleerd hoe u een Xamarin.Forms-toepassing gebruikt om toegang te krijgen tot een SQLite-database met behulp van Entity Framework Core.

  • Last updated on