Archiviare i dati in un database locale di SQLite.NET

Scaricare l'esempio Scaricare l'esempio

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, da Xamarin.Forms un'applicazione shell. L'applicazione finale è riportata di seguito:

Pagina diimmissione nota della pagina Delle note

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

  1. Avviare Visual Studio e aprire la soluzione Notes.

  2. In Esplora soluzionifare clic con il pulsante destro del mouse sulla soluzione Notes e scegliere Gestisci NuGet pacchetti per la soluzione...:

    Gestire NuGet pacchetti

  3. Nella NuGet Gestione pacchettiselezionare la scheda Sfoglia e cercare il pacchetto di NuGet sqlite-net-pcl.

    Avviso

    Esistono molti pacchetti NuGet con nomi simili. Il pacchetto corretto ha questi attributi:

    Nonostante il nome del pacchetto, questo pacchetto NuGet può essere usato anche nei progetti .NET Standard.

    Nella NuGet Gestione pacchettiselezionare il pacchetto sqlite-net-pcl corretto, selezionare la casella di controllo Project e fare clic sul pulsante Installa per aggiungerlo alla soluzione:

    Selezionare sqlite-net-pcl

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

    Chiudere il NuGet Gestione pacchetti.

  4. 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 risolti nei passaggi successivi.

  5. In Esplora soluzioni aggiungere una nuova cartella denominata Data al progetto Notes.

  6. In Esplora soluzioni, nel progetto Notes aggiungere una nuova classe denominata NoteDatabase alla cartella Data.

  7. 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 risolti nei passaggi successivi.

  8. 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 ad App.xaml.cs premendo CTRL+S.

    Avviso

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

  9. Nel Esplora soluzioniNotes 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 all'oggetto NoteEntryPage , passando la proprietà ID dell'oggetto Note selezionato 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 risolti nei passaggi successivi.

  10. In Esplora soluzioniespandere NoteEntryPage.xaml nella cartella Views e aprire NoteEntryPage.xaml.cs. Sostituire quindi i LoadNote metodi , e con il codice OnSaveButtonClickedOnDeleteButtonClicked 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("..");
    }
    

    usa il metodo per recuperare la nota dal database il cui ID è stato passato come parametro di query alla pagina e archiviarla come oggetto nel Xamarin_Forms NoteEntryPageLoadNoteNoteNoteEntryPage _BindableObject_BindingContext" data-linktype="absolute-path">BindingContext della 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.

  11. 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 di nuovo per assicurarsi che le note immesse siano state salvate nel database.

Aggiornare l'app con Visual Studio per Mac

  1. Avviare Visual Studio per Mac e aprire la soluzione Note.

  2. Nella finestra riquadro della soluzionefare clic con il pulsante destro del mouse sulla soluzione Notes e scegliere Gestisci NuGet pacchetti...:

    Gestire NuGet pacchetti

  3. Nella finestra di dialogo NuGet pacchetti di distribuzione selezionare la scheda Sfoglia e cercare il pacchetto di NuGet sqlite-net-pcl.

    Avviso

    Esistono molti pacchetti NuGet con nomi simili. Il pacchetto corretto ha questi attributi:

    Nonostante il nome del pacchetto, questo pacchetto NuGet può essere usato anche nei progetti .NET Standard.

    Nella finestra di dialogo NuGet pacchetti di distribuzione selezionare il pacchetto sqlite-net-pcl e fare clic sul pulsante Aggiungi pacchetto per aggiungerlo alla soluzione:

    Selezionare sqlite-net-pcl

    Il pacchetto verrà usato per integrare le operazioni di database nell'applicazione.

  4. Nella finestra di dialogo Seleziona progetti verificare che tutte le caselle di controllo siano selezionate e fare clic sul pulsante OK:

    Aggiungi pacchetto a tutti i progetti

    Il pacchetto NuGet verrà aggiunto a ogni progetto nella soluzione.

  5. 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 risolti nei passaggi successivi.

  6. Nel riquadro della soluzione aggiungere una nuova cartella denominata Data al progetto Notes.

  7. Nel riquadro della soluzione, nel progetto Notes aggiungere una nuova classe denominata NoteDatabase alla cartella Data.

  8. 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 scegliendo Salva file (o premendo ⌘ + S).

    Avviso

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

  9. Nel riquadro della soluzione, 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 in App.xaml.cs scegliendo Salva file (o premendo ⌘ + S).

    Avviso

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

  10. Nel riquadro della soluzione, nel progetto Notes, 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 l'oggetto CollectionView con eventuali note archiviate nel database. Il OnSelectionChanged metodo passa a , passando la proprietà NoteEntryPageID dell'oggetto Note selezionato come parametro di query.

    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 risolti nei passaggi successivi.

  11. Nel riquadro della soluzioneespandere NoteEntryPage.xaml nella cartella Views e aprire NoteEntryPage.xaml.cs. Sostituire quindi i LoadNote metodi , e con il codice OnSaveButtonClickedOnDeleteButtonClicked 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("..");
    }
    

    Usa il metodo per recuperare la nota dal database, il cui ID è stato passato come parametro di query alla pagina e archiviarla come oggetto nel NoteEntryPageLoadNote Xamarin_Forms NoteNoteEntryPage _BindableObject_BindingContext" data-linktype="absolute-path">BindingContext della 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 scegliendo Salva file (o premendo ⌘ + S).

  12. 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 di nuovo per assicurarsi che le note immesse siano state salvate nel database.

Passaggi successivi

In questo argomento di avvio rapido 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 stili XAML.