Archiviare i dati in un database SQLite.NET locale

Articolo
03/08/2024

In questo argomento di avvio rapido si apprenderà come:

Archiviare i dati in locale in un database SQLite.NET.

La guida introduttiva illustra come archiviare i dati in un database SQLite.NET locale da un'applicazione Xamarin.Forms Shell. L'applicazione finale è riportata di seguito:

Prerequisiti

È consigliabile completare l'argomento di avvio rapido precedente prima di provare con questo. In alternativa, scaricare l'esempio di avvio rapido precedente e usarlo come punto di partenza per questo avvio rapido.

Aggiornare l'app con Visual Studio

Avviare Visual Studio e aprire la soluzione Notes.
In Esplora soluzioni fare clic con il pulsante destro del mouse sulla soluzione Note e scegliere Gestisci pacchetti NuGet per la soluzione...:
Nel Gestione pacchetti NuGet selezionare la scheda Sfoglia e cercare il pacchetto NuGet sqlite-net-pcl.
Avviso

Esistono molti pacchetti NuGet con nomi simili. Il pacchetto corretto ha questi attributi:
- Autori: SQLite-net
- Collegamento NuGet:sqlite-net-pcl
Nonostante il nome del pacchetto, questo pacchetto NuGet può essere usato anche nei progetti .NET Standard.
Nel Gestione pacchetti NuGet selezionare il pacchetto sqlite-net-pcl corretto, selezionare la casella di controllo Progetto e fare clic sul pulsante Installa per aggiungerlo alla soluzione:

Questo pacchetto verrà usato per incorporare le operazioni di database nell'applicazione e verrà aggiunto a ogni progetto della soluzione.

Importante

SQLite.NET è una libreria di terze parti supportata dal repository praeclarum/sqlite-net.

Chiudere Gestione pacchetti NuGet.
In Esplora soluzioni, nel progetto Notes aprire Note.cs nella cartella Models e sostituire il codice esistente con il codice seguente:
```
using System;
using SQLite;

namespace Notes.Models
{
    public class Note
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Text { get; set; }
        public DateTime Date { get; set; }
    }
}
```
Questa classe definisce un modello Note che archivierà i dati relativi a ogni nota nell'applicazione. La proprietà ID è contrassegnata con gli attributi PrimaryKey e AutoIncrement per garantire che ogni istanza di Note nel database SQLite.NET abbia un ID univoco fornito da SQLite.NET.

Salvare le modifiche apportate a Note.cs premendo CTRL+S.

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.
In Esplora soluzioni aggiungere una nuova cartella denominata Data al progetto Notes.
In Esplora soluzioni, nel progetto Notes aggiungere una nuova classe denominata NoteDatabase alla cartella Data.

In NoteDatabase.cs sostituire il codice esistente con il seguente:

using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
    public class NoteDatabase
    {
        readonly SQLiteAsyncConnection database;

        public NoteDatabase(string dbPath)
        {
            database = new SQLiteAsyncConnection(dbPath);
            database.CreateTableAsync<Note>().Wait();
        }

        public Task<List<Note>> GetNotesAsync()
        {
            //Get all notes.
            return database.Table<Note>().ToListAsync();
        }

        public Task<Note> GetNoteAsync(int id)
        {
            // Get a specific note.
            return database.Table<Note>()
                            .Where(i => i.ID == id)
                            .FirstOrDefaultAsync();
        }

        public Task<int> SaveNoteAsync(Note note)
        {
            if (note.ID != 0)
            {
                // Update an existing note.
                return database.UpdateAsync(note);
            }
            else
            {
                // Save a new note.
                return database.InsertAsync(note);
            }
        }

        public Task<int> DeleteNoteAsync(Note note)
        {
            // Delete a note.
            return database.DeleteAsync(note);
        }
    }
}

Questa classe contiene il codice per creare il database, leggere i dati dal database, scrivere i dati in esso ed eliminarli. Il codice usa API SQLite.NET asincrone che spostano le operazioni sul database in thread in background. Inoltre, il costruttore NoteDatabase accetta il percorso del file di database come argomento. Questo percorso verrà fornito dalla classe App nel passaggio successivo.

Salvare le modifiche apportate a NoteDatabase.cs premendo CTRL+S.

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

In Esplora soluzioni, nel progetto Notes espandere App.xaml e fare doppio clic su App.xaml.cs per aprirlo. quindi sostituire il codice esistente con il seguente:

using System;
using System.IO;
using Notes.Data;
using Xamarin.Forms;

namespace Notes
{
    public partial class App : Application
    {
        static NoteDatabase database;

        // Create the database connection as a singleton.
        public static NoteDatabase Database
        {
            get
            {
                if (database == null)
                {
                    database = new NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Notes.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();
            MainPage = new AppShell();
        }

        protected override void OnStart()
        {
        }

        protected override void OnSleep()
        {
        }

        protected override void OnResume()
        {
        }
    }
}

Questo codice definisce una proprietà Database che crea una nuova istanza di NoteDatabase come singleton, passando il nome file del database come argomento al costruttore NoteDatabase. Il vantaggio dell'esposizione del database come singleton è la creazione di una singola connessione al database che verrà mantenuta aperta durante l'esecuzione dell'applicazione, evitando così l'onere dell'apertura e della chiusura del file di database ogni volta che viene eseguita un'operazione di database.

Salvare le modifiche apportate a App.xaml.cs premendo CTRL+S.

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

Nel progetto Notes Esplora soluzioni espandere NotesPage.xaml nella cartella Views e aprire NotesPage.xaml.cs. quindi sostituire i metodi OnAppearing e OnSelectionChanged con il codice seguente:

protected override async void OnAppearing()
{
    base.OnAppearing();

    // Retrieve all the notes from the database, and set them as the
    // data source for the CollectionView.
    collectionView.ItemsSource = await App.Database.GetNotesAsync();
}

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // Navigate to the NoteEntryPage, passing the ID as a query parameter.
        Note note = (Note)e.CurrentSelection.FirstOrDefault();
        await Shell.Current.GoToAsync($"{nameof(NoteEntryPage)}?{nameof(NoteEntryPage.ItemId)}={note.ID.ToString()}");
    }
}

Il OnAppearing metodo popola con CollectionView tutte le note archiviate nel database. Il OnSelectionChanged metodo passa a NoteEntryPage, passando la ID proprietà dell'oggetto selezionato Note come parametro di query.

Salvare le modifiche apportate a NotesPage.xaml.cs premendo CTRL+S.

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

In Esplora soluzioni espandere NoteEntryPage.xaml nella cartella Visualizzazioni e aprire NoteEntryPage.xaml.cs. Sostituire quindi i LoadNotemetodi , OnSaveButtonClickede OnDeleteButtonClicked con il codice seguente:

async void LoadNote(string itemId)
{
    try
    {
        int id = Convert.ToInt32(itemId);
        // Retrieve the note and set it as the BindingContext of the page.
        Note note = await App.Database.GetNoteAsync(id);
        BindingContext = note;
    }
    catch (Exception)
    {
        Console.WriteLine("Failed to load note.");
    }
}

async void OnSaveButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    note.Date = DateTime.UtcNow;
    if (!string.IsNullOrWhiteSpace(note.Text))
    {
        await App.Database.SaveNoteAsync(note);
    }

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

async void OnDeleteButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    await App.Database.DeleteNoteAsync(note);

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

NoteEntryPage Usa il LoadNote metodo per recuperare la nota dal database, il cui ID è stato passato come parametro di query alla pagina e archiviarlo come Note oggetto nella BindingContext pagina. Quando viene eseguito il gestore dell'evento OnSaveButtonClicked, l'istanza di Note viene salvata nel database e l'applicazione torna alla pagina precedente. Quando viene eseguito il gestore dell'evento OnDeleteButtonClicked, l'istanza di Note viene eliminata dal database e l'applicazione torna alla pagina precedente.

Salvare le modifiche apportate a NoteEntryPage.xaml.cs premendo CTRL+S.

Compilare ed eseguire il progetto in ogni piattaforma. Per altre informazioni, vedere Compilazione dell'avvio rapido.

In NotesPage premere il pulsante Aggiungi per passare a NoteEntryPage e immettere una nota. Dopo aver salvato la nota, l'applicazione tornerà a NotesPage.

Immettere diverse note, di lunghezza variabile, per osservare il comportamento dell'applicazione. Chiudere l'applicazione e avviarla nuovamente per assicurarsi che le note immesse siano state salvate nel database.

Aggiornare l'app con Visual Studio per Mac

Avviare Visual Studio per Mac e aprire la soluzione Notes.
Nel riquadro della soluzione fare clic con il pulsante destro del mouse sulla soluzione Note e scegliere Gestisci pacchetti NuGet...:
Nella finestra di dialogo Gestisci pacchetti NuGet selezionare la scheda Sfoglia e cercare il pacchetto NuGet sqlite-net-pcl.
Avviso

Esistono molti pacchetti NuGet con nomi simili. Il pacchetto corretto ha questi attributi:
- Autori: SQLite-net
- Collegamento NuGet:sqlite-net-pcl
Nonostante il nome del pacchetto, questo pacchetto NuGet può essere usato anche nei progetti .NET Standard.
Nella finestra di dialogo Gestisci pacchetti NuGet selezionare il pacchetto sqlite-net-pcl e fare clic sul pulsante Aggiungi pacchetto per aggiungerlo alla soluzione:

Il pacchetto verrà usato per integrare le operazioni di database nell'applicazione.
Nella finestra di dialogo Seleziona progetti verificare che ogni casella di controllo sia selezionata e premere ok:

Verrà aggiunto il pacchetto NuGet a ogni progetto della soluzione.
Nel riquadro della soluzione, nel progetto Notes aprire Note.cs nella cartella Models e sostituire il codice esistente con il codice seguente:
```
using System;
using SQLite;

namespace Notes.Models
{
    public class Note
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Text { get; set; }
        public DateTime Date { get; set; }
    }
}
```
Questa classe definisce un modello Note che archivierà i dati relativi a ogni nota nell'applicazione. La proprietà ID è contrassegnata con gli attributi PrimaryKey e AutoIncrement per garantire che ogni istanza di Note nel database SQLite.NET abbia un ID univoco fornito da SQLite.NET.

Salvare le modifiche apportate a Note.cs scegliendo Salva file (o premendo ⌘ + S).>

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.
Nel riquadro della soluzione aggiungere una nuova cartella denominata Data al progetto Notes.
Nel riquadro della soluzione, nel progetto Notes aggiungere una nuova classe denominata NoteDatabase alla cartella Data.

In NoteDatabase.cs sostituire il codice esistente con il seguente:

using System.Collections.Generic;
using System.Threading.Tasks;
using SQLite;
using Notes.Models;

namespace Notes.Data
{
    public class NoteDatabase
    {
        readonly SQLiteAsyncConnection database;

        public NoteDatabase(string dbPath)
        {
            database = new SQLiteAsyncConnection(dbPath);
            database.CreateTableAsync<Note>().Wait();
        }

        public Task<List<Note>> GetNotesAsync()
        {
            //Get all notes.
            return database.Table<Note>().ToListAsync();
        }

        public Task<Note> GetNoteAsync(int id)
        {
            // Get a specific note.
            return database.Table<Note>()
                            .Where(i => i.ID == id)
                            .FirstOrDefaultAsync();
        }

        public Task<int> SaveNoteAsync(Note note)
        {
            if (note.ID != 0)
            {
                // Update an existing note.
                return database.UpdateAsync(note);
            }
            else
            {
                // Save a new note.
                return database.InsertAsync(note);
            }
        }

        public Task<int> DeleteNoteAsync(Note note)
        {
            // Delete a note.
            return database.DeleteAsync(note);
        }
    }
}

Salvare le modifiche apportate a NoteDatabase.cs scegliendo Salva file (o premendo ⌘ + S).>

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

Nel riquadro della soluzione espandere App.xaml nel progetto Notes e fare doppio clic su App.xaml.cs per aprirlo. quindi sostituire il codice esistente con il seguente:

using System;
using System.IO;
using Notes.Data;
using Xamarin.Forms;

namespace Notes
{
    public partial class App : Application
    {
        static NoteDatabase database;

        // Create the database connection as a singleton.
        public static NoteDatabase Database
        {
            get
            {
                if (database == null)
                {
                    database = new NoteDatabase(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Notes.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();
            MainPage = new AppShell();
        }

        protected override void OnStart()
        {
        }

        protected override void OnSleep()
        {
        }

        protected override void OnResume()
        {
        }
    }
}

Salvare le modifiche apportate a App.xaml.cs scegliendo Salva file (o premendo ⌘ + S).>

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

Nel riquadro della soluzione espandere NotesPage.xaml nella cartella Visualizzazioni e aprire NotesPage.xaml.cs. quindi sostituire i metodi OnAppearing e OnSelectionChanged con il codice seguente:

protected override async void OnAppearing()
{
    base.OnAppearing();

    // Retrieve all the notes from the database, and set them as the
    // data source for the CollectionView.
    collectionView.ItemsSource = await App.Database.GetNotesAsync();
}

async void OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
    if (e.CurrentSelection != null)
    {
        // Navigate to the NoteEntryPage, passing the ID as a query parameter.
        Note note = (Note)e.CurrentSelection.FirstOrDefault();
        await Shell.Current.GoToAsync($"{nameof(NoteEntryPage)}?{nameof(NoteEntryPage.ItemId)}={note.ID.ToString()}");
    }
}

Salvare le modifiche apportate a NotesPage.xaml.cs scegliendo Salva file > (o premendo ⌘ + S).

Avviso

L'applicazione non verrà attualmente compilata a causa di errori che verranno corretti nei passaggi successivi.

Nel riquadro della soluzione espandere NoteEntryPage.xaml nella cartella Visualizzazioni e aprire NoteEntryPage.xaml.cs. Sostituire quindi i LoadNotemetodi , OnSaveButtonClickede OnDeleteButtonClicked con il codice seguente:

async void LoadNote(string itemId)
{
    try
    {
        int id = Convert.ToInt32(itemId);
        // Retrieve the note and set it as the BindingContext of the page.
        Note note = await App.Database.GetNoteAsync(id);
        BindingContext = note;
    }
    catch (Exception)
    {
        Console.WriteLine("Failed to load note.");
    }
}

async void OnSaveButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    note.Date = DateTime.UtcNow;
    if (!string.IsNullOrWhiteSpace(note.Text))
    {
        await App.Database.SaveNoteAsync(note);
    }

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

async void OnDeleteButtonClicked(object sender, EventArgs e)
{
    var note = (Note)BindingContext;
    await App.Database.DeleteNoteAsync(note);

    // Navigate backwards
    await Shell.Current.GoToAsync("..");
}

Salvare le modifiche apportate a NoteEntryPage.xaml.cs scegliendo Salva file (o premendo ⌘ + S).>

Compilare ed eseguire il progetto in ogni piattaforma. Per altre informazioni, vedere Compilazione dell'avvio rapido.

In NotesPage premere il pulsante Aggiungi per passare a NoteEntryPage e immettere una nota. Dopo aver salvato la nota, l'applicazione tornerà a NotesPage.

Immettere diverse note, di lunghezza variabile, per osservare il comportamento dell'applicazione. Chiudere l'applicazione e avviarla nuovamente per assicurarsi che le note immesse siano state salvate nel database.

Passaggi successivi

In questa guida introduttiva si è appreso come:

Archiviare i dati in locale in un database SQLite.NET.

Passare alla guida introduttiva successiva per applicare uno stile all'applicazione con gli stili XAML.

Avanti

Archiviare i dati in un database SQLite.NET locale

Prerequisiti

Aggiornare l'app con Visual Studio

Aggiornare l'app con Visual Studio per Mac

Passaggi successivi

Collegamenti correlati

Risorse aggiuntive