Introduzione a EF Core e Xamarin

  • Articolo

In questa esercitazione viene creata un'applicazione Xamarin.Forms che esegue l'accesso ai dati su un database SQLite usando Entity Framework Core.

È possibile seguire l'esercitazione usando Visual Studio in Windows o Visual Studio per Mac.

Suggerimento

È possibile visualizzare l'esempio di questo articolo in GitHub.

Prerequisiti

Installare uno dei seguenti elementi:

Questa documentazione fornisce istruzioni dettagliate sull'installazione per ogni piattaforma.

Scaricare ed eseguire il progetto di esempio

Per eseguire ed esplorare questa applicazione di esempio, scaricare il codice in GitHub.

Dopo il download, aprire il file EFGettingStarted.sln della soluzione in Visual Studio o Visual Studio per Mac ed eseguire l'applicazione nella piattaforma preferita.

All'avvio dell'app, popola il database SQLite locale con due voci che rappresentano i blog.

Screenshot of all blogs list page

Fare clic sul pulsante Aggiungi sulla barra degli strumenti.

Verrà visualizzata una nuova pagina che consente di immettere informazioni su un nuovo blog.

Screenshot of new blog edit page

Compilare tutte le informazioni e fare clic su Salva dalla barra degli strumenti. Il nuovo blog verrà salvato nel database SQLite dell'app e verrà visualizzato nell'elenco.

È possibile fare clic su una delle voci di blog nell'elenco e visualizzare eventuali post per tale blog.

Screenshot of blog posts list page

Fare clic su Aggiungi sulla barra degli strumenti.

Viene visualizzata quindi una pagina che consente di compilare informazioni su un nuovo post di blog.

Screenshot of add new post page

Compilare tutte le informazioni e fare clic su Salva sulla barra degli strumenti.

Il nuovo post verrà associato al post di blog su cui si è fatto clic in un passaggio precedente e verrà salvato nel database SQLite dell'app e visualizzato nell'elenco.

Tornare alla pagina dell'elenco di blog. Fare clic su Elimina tutto nella barra degli strumenti. Tutti i blog e i post corrispondenti verranno quindi eliminati dal database SQLite dell'app.

Screenshot of app with all blogs deleted

Esplorare il codice

Le sezioni seguenti illustrano il codice nel progetto di esempio che legge, crea, aggiorna ed elimina i dati da un database SQLite usando EF Core con Xamarin.Forms.

Si presuppone che si abbia familiarità con gli argomenti di Xamarin.Forms relativi alla visualizzazione dei dati e all'esplorazione tra le pagine.

Importante

Entity Framework Core usa la reflection per richiamare le funzioni che il linker Xamarin.iOS può rimuovere durante le configurazioni in modalità rilascio . È possibile evitare questo problema in uno dei due modi seguenti.

  • Il primo consiste nell'aggiungere --linkskip System.Coreagli argomenti Mtouch aggiuntivi nelle opzioni di compilazione iOS .
  • In alternativa, impostare il comportamento del linker Xamarin.iOS su nelle opzioni di compilazione iOS.Don't Link Questo articolo illustra altre informazioni sul linker Xamarin.iOS, tra cui come impostare il comportamento in Xamarin.iOS. Questo approccio non è ideale perché può comportare il rifiuto dall'archivio.

Pacchetti NuGet di Entity Framework Core

Per creare app Xamarin.Forms con EF Core, installare il pacchetto per i provider di database EF Core di destinazione in tutti i progetti nella soluzione Xamarin.Forms. Questa esercitazione usa il provider SQLite.

In ogni progetto della soluzione Xamarin.Forms è necessario il pacchetto NuGet seguente.

  • Microsoft.EntityFrameworkCore.Sqlite

Classi di modello

Ogni tabella nel database SQLite a cui si accede tramite EF Core viene modellata in una classe . In questo esempio vengono usate due classi: Blog e Post disponibili nella Models cartella .

Le classi di modello sono composte solo da proprietà, ovvero le colonne del modello nel database.

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

  • La Posts proprietà definisce una relazione padre-figlio tra Blog e 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; }
    }
}

  • Le BlogId proprietà e Blog sono correlate all'oggetto padre Blog per l'istanza di Post.

Contesto dei dati

La BloggingContext classe si trova nella Services cartella ed eredita dalla classe EF Core DbContext . Un DbContext oggetto viene usato per raggruppare query e modifiche del database.

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}");
        }
    }
}
  • Entrambe le proprietà in questa classe di tipo DbSet vengono utilizzate per operare sulle tabelle sottostanti che rappresentano Blog e Post.
  • È SQLitePCL.Batteries_V2.Init() necessario nel costruttore per avviare SQLite in iOS.
  • La OnConfiguring funzione configura la posizione del database SQLite nel dispositivo fisico.

Creazione, lettura, aggiornamento ed eliminazione

Di seguito sono riportate alcune istanze dell'app in cui EF Core viene usato per accedere a SQLite.

Lettura

  • Restituisce tutti i record.
    • La OnAppearing funzione di BlogsPage.xaml.cs restituisce tutti i Blog record e li archivia in una List variabile.
using (var blogContext = new BloggingContext())
{
    var theBlogs = blogContext.Blogs.ToList();
}
  • Restituisce record specifici.
    • La OnAppearing funzione di PostsPage.xaml.cs restituisce Post record che contengono un oggetto specifico BlogId.
using (var blogContext = new BloggingContext())
{
    var postList = blogContext.Posts
        .Where(p => p.BlogId == BlogId)
        .ToList();
}

Creazione

  • Inserire un nuovo record.
    • La Save_Clicked funzione di AddBlogPage.xaml.cs inserisce un nuovo Blog oggetto nel database SQLite.
var blog = new Blog { Url = blogUrl.Text };

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

    await blogContext.SaveChangesAsync();
}

Update

  • Aggiornare un record esistente.
    • La Save_Clicked funzione di AddPostPage.xaml.cs aggiorna un oggetto esistente Blog con un nuovo Postoggetto .
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();
}

Elimina

  • Eliminare tutti i record con propagazione ai record figlio.
    • La DeleteAll_Clicked funzione di BlogsPage.xaml.cs elimina tutti i Blog record nel database SQLite e propaga le eliminazioni a tutti i Blog record figlio Post .
using (var blogContext = new BloggingContext())
{
    blogContext.RemoveRange(blogContext.Blogs);

    await blogContext.SaveChangesAsync();
}

Passaggi successivi

In questa guida introduttiva si è appreso come usare un'applicazione Xamarin.Forms per accedere a un database SQLite usando Entity Framework Core.

Altri argomenti di Entity Framework Core che interessano gli sviluppatori Xamarin: