Komma igång med Entity Framework Core

I den här självstudien skapar du ett Xamarin.Forms--program som utför dataåtkomst mot en SQLite-databas med Entity Framework Core.

Du kan följa självstudien med hjälp av Visual Studio i Windows eller Visual Studio för Mac.

Dricks

Du kan visa den här artikelns exempel på GitHub.

Förutsättningar

Installera något av följande:

• Visual Studio 2019 version 16.3 eller senare med den här arbetsbelastningen:
  • Mobilutveckling med .NET
• Visual Studio för Mac

Den här dokumentationen innehåller detaljerade stegvisa installationsanvisningar för varje plattform.

Ladda ned och kör exempelprojektet

Om du vill köra och utforska det här exempelprogrammet laddar du ned koden på GitHub.

När du har laddat ned öppnar du lösningsfilen EFGettingStarted.sln i Visual Studio eller Visual Studio för Mac och kör programmet på valfri plattform.

När appen startar först fylls den i den lokala SQLite-databasen med två poster som representerar bloggar.

Klicka på knappen Lägg till i verktygsfältet.

En ny sida visas där du kan ange information om en ny blogg.

Fyll i all information och klicka på Spara i verktygsfältet. Den nya bloggen sparas i appens SQLite-databas och visas i listan.

Du kan klicka på någon av blogginläggen i listan och se eventuella inlägg för den bloggen.

Klicka på Lägg till i verktygsfältet.

En sida visas sedan som gör att du kan fylla i information om ett nytt blogginlägg.

Fyll i all information och klicka på Spara i verktygsfältet.

Det nya inlägget associeras med blogginlägget som du klickade på i ett tidigare steg och sparas i appens SQLite-databas och visas i listan.

Gå tillbaka till blogglistesidan. Klicka på Ta bort alla i verktygsfältet. Alla bloggar och deras motsvarande inlägg tas sedan bort från appens SQLite-databas.

Utforska koden

Följande avsnitt beskriver koden i exempelprojektet som läser, skapar, uppdaterar och tar bort data från en SQLite-databas med hjälp av EF Core med Xamarin.Forms.

Det förutsätts att du är bekant med avsnitten Xamarin.Forms i att visa data och navigera mellan sidor.

Viktig

Entity Framework Core använder reflektion för att anropa funktioner som Xamarin.iOS-länkaren kan ta bort i Versionskonfigurationer läge. Du kan undvika det på ett av två sätt.

• Det första är att lägga till --linkskip System.Core i Ytterligare mtouch-argument i alternativen iOS Build.
• Du kan också ange beteendet för Xamarin.iOS--linkern till Don't Link i iOS-bygginställningarna . Den här artikeln förklarar mer om Xamarin.iOS-länkaren inklusive hur du anger beteendet på Xamarin.iOS. (Den här metoden är inte idealisk eftersom den kan leda till avslag från butiken).

Entity Framework Core NuGet-paket

Om du vill skapa Xamarin.Forms-appar med EF Core installerar du paketet för EF Core-databasprovidern som du vill rikta in dig på i alla projekt i Xamarin.Forms-lösningen. I den här självstudien används SQLite-leverantören.

Följande NuGet-paket behövs i vart och ett av projekten i Xamarin.Forms-lösningen.

• Microsoft.EntityFrameworkCore.Sqlite

Modellklasser

Varje tabell i SQLite-databasen som nås via EF Core modelleras i en klass. I det här exemplet används två klasser: Blog och Post som finns i mappen Models.

Modellklasserna består endast av egenskaper, som modellerar kolumnerna i databasen.

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

• Egenskapen Posts definierar en överordnad-underordnad relation mellan Blog och 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; }
      }
  }
  

• Egenskaperna BlogId och Blog relaterar tillbaka till det överordnade Blog objektet för instansen av Post.

Datakontext

Klassen BloggingContext finns i mappen Services och ärver från klassen EF Core DbContext. En DbContext används för att gruppera databasfrågor och ändringar.

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}");
        }
    }
}

• Båda egenskaperna i den här klassen av typen DbSet används för att fungera på de underliggande tabeller som representerar bloggar och inlägg.
• SQLitePCL.Batteries_V2.Init() krävs i konstruktorn för att initiera SQLite på iOS.
• Funktionen OnConfiguring konfigurerar platsen för SQLite-databasen på den fysiska enheten.

Skapa, läsa, uppdatera & ta bort

Följande är några instanser i appen där EF Core används för att komma åt SQLite.

Läsa

• Returnera alla poster.

  • Funktionen OnAppearing för BlogsPage.xaml.cs returnerar alla Blog poster och lagrar dem i en List variabel.

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

• Returnera specifika uppgifter.

  • Funktionen OnAppearing för PostsPage.xaml.cs returnerar Post poster som innehåller en specifik BlogId.

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

Skapa

• Infoga en ny post.

  • Funktionen Save_Clicked för AddBlogPage.xaml.cs infogar ett nytt Blog objekt i SQLite-databasen.

    var blog = new Blog { Url = blogUrl.Text };
    
    using (var blogContext = new BloggingContext())
    {
        blogContext.Add(blog);
    
        await blogContext.SaveChangesAsync();
    }
    

Uppdatera

• Uppdatera en befintlig post.

  • Funktionen Save_Clicked för AddPostPage.xaml.cs uppdaterar ett befintligt Blog-objekt med en ny 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();
    }
    

Ta bort

• Ta bort alla poster med kaskad till underordnade poster.

  • Funktionen DeleteAll_Clicked för BlogsPage.xaml.cs tar bort alla Blog poster i SQLite-databasen och kaskaderar borttagningarna till alla Blog underordnade Post poster.

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

Nästa steg

I den här kom igång har du lärt dig hur du använder ett Xamarin.Forms-program för att komma åt en SQLite-databas med Entity Framework Core.