Introduzione a Entity Framework Core

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.

Consiglio

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

Prerequisiti

Installare uno dei seguenti elementi:

• Visual Studio 2019 versione 16.3 o successiva con questo carico di lavoro:
  • Lo sviluppo di applicazioni mobili con .NET
• Visual Studio per Mac

Questa documentazione fornisce istruzioni dettagliate passo dopo passo per l'installazione su 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 della soluzione EFGettingStarted.sln 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.

Fare clic sul pulsante Aggiungi sulla barra degli strumenti.

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

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.

Fare clic su Aggiungi sulla barra degli strumenti.

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

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 tutti i sulla barra degli strumenti. Tutti i blog e i post corrispondenti verranno quindi eliminati dal database SQLite dell'app.

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 di visualizzare i dati e spostarsi tra pagine.

Importante

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

• Il primo consiste nell'aggiungere --linkskip System.Core agli argomenti aggiuntivi mtouch nelle opzioni di Build di iOS .
• In alternativa, impostare il comportamento del linker di Xamarin.iOS suDon't Link nelle opzioni di compilazione iOS. 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 un rifiuto dal negozio.

Pacchetti NuGet di Entity Framework Core

Per creare app Xamarin.Forms con EF Core, è necessario installare il pacchetto per i provider di database EF Core di destinazione in tutti i progetti della 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 cartella Models.

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 proprietà Posts 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 proprietà BlogId e Blog sono correlate all'oggetto Blog padre per l'istanza del Post.

Il contesto dei dati

La classe BloggingContext si trova nella cartella Services ed eredita dalla classe DbContext EF Core. Un DbContext viene usato per raggruppare le query e le 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à di questa classe di tipo DbSet vengono utilizzate per operare sulle tabelle sottostanti che rappresentano Blog e Post.
• Il SQLitePCL.Batteries_V2.Init() è necessario nel costruttore per avviare SQLite in iOS.
• La funzione OnConfiguring configura la posizione del database SQLite nel dispositivo fisico.

Creare, Leggere, Aggiornare & Eliminare

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

Leggere

• Restituisce tutti i record.

  • La funzione OnAppearing di BlogsPage.xaml.cs restituisce tutti i record Blog e li archivia in una variabile List.

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

• Restituisce record specifici.

  • La funzione OnAppearing di PostsPage.xaml.cs restituisce record Post che contengono un BlogIdspecifico.

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

Creare

• Inserire un nuovo record.

  • La funzione Save_Clicked di AddBlogPage.xaml.cs inserisce un nuovo oggetto Blog nel database SQLite.

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

Aggiornare

• Aggiornare un record esistente.

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

Cancellare

• Eliminare tutti i record con propagazione ai record figlio.

  • La funzione DeleteAll_Clicked di BlogsPage.xaml.cs elimina tutti i record Blog nel database SQLite e le eliminazioni vengono propagate a tutti i record Post figlio Blog.

    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.