Xamarin.Forms Esercitazione sul database locale

Prima di provare questa esercitazione è necessario avere completato correttamente:

Creare la prima Xamarin.Forms guida introduttiva all'app .
Esercitazione su StackLayout.
Esercitazione su Button.
Esercitazione su Entry.
Esercitazione su CollectionView.

In questa esercitazione apprenderai a:

Usare il Gestione pacchetti NuGet per aggiungere SQLite.NET a un Xamarin.Forms progetto.
Creare classi di accesso ai dati.
Usare le classi di accesso ai dati.

Si userà Visual Studio 2019 o Visual Studio per Mac per creare un'applicazione semplice che dimostri come archiviare i dati in un database SQLite.NET locale. Gli screenshot seguenti illustrano l'applicazione finale:

Aggiungere SQLite.NET

11 minuti rimanenti

Visual Studio
Visual Studio per Mac

Per completare questa esercitazione è necessario Visual Studio 2019 (la versione più recente) con installato il carico di lavoro Sviluppo di applicazioni per dispositivi mobili con .NET. È inoltre necessario un Mac associato per compilare l'applicazione dell'esercitazione per iOS. Per informazioni sull'installazione della piattaforma Xamarin, vedere Installazione di Xamarin. Per informazioni sulla connessione di Visual Studio 2019 a un host di compilazione Mac, vedere Associa a Mac per lo sviluppo di Xamarin.iOS.

Avviare Visual Studio e creare una nuova app vuota Xamarin.Forms denominata LocalDatabaseTutorial.

Importante

I frammenti di codice C# e XAML di questa esercitazione richiedono che la soluzione sia denominata LocalDatabaseTutorial. Se si usa un nome diverso, si verificheranno errori di compilazione quando si copia il codice da questa esercitazione alla soluzione.

Per altre informazioni sulla libreria .NET Standard che viene creata, vedere Anatomia di un'applicazione Xamarin.Forms nell'approfondimento della Xamarin.Forms guida introduttiva.
In Esplora soluzioni selezionare il progetto LocalDatabaseTutorial, fare clic con il pulsante destro del mouse e selezionare Gestisci pacchetti NuGet...:
In Gestione pacchetti NuGet selezionare la scheda Sfoglia, cercare il pacchetto NuGet sqlite-net-pcl, selezionarlo e fare clic sul pulsante Installa per aggiungerlo al progetto:
Nota

Esistono molti pacchetti NuGet con nomi simili. Il pacchetto corretto ha questi attributi:
- Autori: SQLite-net
- Collegamento a NuGet: sqlite-net-pcl
Nonostante il nome del pacchetto, questo pacchetto NuGet può essere usato anche nei progetti .NET Standard.
Il pacchetto verrà usato per integrare le operazioni di database nell'applicazione.

Importante

SQLite.NET è una libreria di terze parti supportata dal repository praeclarum/sqlite-net.
Compilare la soluzione per assicurarsi che non siano presenti errori.

Creare classi di accesso ai dati

8 minuti rimanenti

In questo esercizio verranno aggiunte classi di accesso ai dati al progetto LocalDatabaseTutorial, che verrà usato per rendere persistenti i dati relativi alle persone nel database.

Visual Studio
Visual Studio per Mac

In Esplora soluzioni aggiungere una nuova classe denominata Person al progetto LocalDatabaseTutorial. In Person.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:
```
using SQLite;

namespace LocalDatabaseTutorial
{
    public class Person
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
}
```
Questo codice definisce una classe Person che archivierà i dati relativi a ogni persona nell'applicazione. La proprietà ID è contrassegnata con gli attributi PrimaryKey e AutoIncrement per garantire che ogni istanza di Person nel database abbia un ID univoco fornito da SQLite.NET.

In Esplora soluzioni aggiungere una nuova classe denominata Database al progetto LocalDatabaseTutorial. In Database.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:

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

namespace LocalDatabaseTutorial
{
    public class Database
    {
        readonly SQLiteAsyncConnection _database;

        public Database(string dbPath)
        {
            _database = new SQLiteAsyncConnection(dbPath);
            _database.CreateTableAsync<Person>().Wait();
        }

        public Task<List<Person>> GetPeopleAsync()
        {
            return _database.Table<Person>().ToListAsync();
        }

        public Task<int> SavePersonAsync(Person person)
        {
            return _database.InsertAsync(person);
        }
    }
}

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

In Esplora soluzioni espandere App.xaml nel progetto LocalDatabaseTutorial e fare doppio clic su App.xaml.cs per aprirlo. In App.xaml.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:

using System;
using System.IO;
using Xamarin.Forms;

namespace LocalDatabaseTutorial
{
    public partial class App : Application
    {
        static Database database;

        public static Database Database
        {
            get
            {
                if (database == null)
                {
                    database = new Database(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "people.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }

        protected override void OnStart()
        {
            // Handle when your app starts
        }

        protected override void OnSleep()
        {
            // Handle when your app sleeps
        }

        protected override void OnResume()
        {
            // Handle when your app resumes
        }
    }
}

Questo codice definisce una proprietà Database che crea una nuova istanza di Database come singleton. Un percorso di file locale e un nome di file, che rappresentano la posizione in cui archiviare il database, vengono passati come argomento per il costruttore della classe Database.

Importante

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.

Compilare la soluzione per assicurarsi che non siano presenti errori.

Nel riquadro della soluzione aggiungere una nuova classe denominata Person al progetto LocalDatabaseTutorial. In Person.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:
```
using SQLite;

namespace LocalDatabaseTutorial
{
    public class Person
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
    }
}
```
Questo codice definisce una classe Person che archivierà i dati relativi a ogni persona nell'applicazione. La proprietà ID è contrassegnata con gli attributi PrimaryKey e AutoIncrement per garantire che ogni istanza di Person nel database abbia un ID univoco fornito da SQLite.NET.

Nel riquadro della soluzione aggiungere una nuova classe denominata Database al progetto LocalDatabaseTutorial. In Database.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:

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

namespace LocalDatabaseTutorial
{
    public class Database
    {
        readonly SQLiteAsyncConnection _database;

        public Database(string dbPath)
        {
            _database = new SQLiteAsyncConnection(dbPath);
            _database.CreateTableAsync<Person>().Wait();
        }

        public Task<List<Person>> GetPeopleAsync()
        {
            return _database.Table<Person>().ToListAsync();
        }

        public Task<int> SavePersonAsync(Person person)
        {
            return _database.InsertAsync(person);
        }
    }
}

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

Nel riquadro della soluzione espandere App.xaml nel progetto LocalDatabaseTutorial e fare doppio clic su App.xaml.cs per aprirlo. In App.xaml.cs rimuovere quindi tutto il codice del modello e sostituirlo con il codice seguente:

using System;
using System.IO;
using Xamarin.Forms;

namespace LocalDatabaseTutorial
{
    public partial class App : Application
    {
        static Database database;

        public static Database Database
        {
            get
            {
                if (database == null)
                {
                    database = new Database(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "people.db3"));
                }
                return database;
            }
        }

        public App()
        {
            InitializeComponent();

            MainPage = new MainPage();
        }

        protected override void OnStart()
        {
            // Handle when your app starts
        }

        protected override void OnSleep()
        {
            // Handle when your app sleeps
        }

        protected override void OnResume()
        {
            // Handle when your app resumes
        }
    }
}

Questo codice definisce una proprietà Database che crea una nuova istanza di Database come singleton. Un percorso di file locale e un nome di file, che rappresentano la posizione in cui archiviare il database, vengono passati come argomento per il costruttore della classe Database.

Importante

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.

Compilare la soluzione per assicurarsi che non siano presenti errori.

Usare le classi di accesso ai dati

3 minuti rimanenti

In questo esercizio si creerà un'interfaccia utente per l'utilizzo delle classi di accesso ai dati create in precedenza.

Visual Studio
Visual Studio per Mac

Fare doppio clic su MainPage.xaml nel progetto LocalDatabaseTutorial in Esplora soluzioni per aprire il file. In MainPage.xaml rimuovere tutto il codice del modello e sostituirlo con il codice seguente:

<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="LocalDatabaseTutorial.MainPage">
    <StackLayout Margin="20,35,20,20">
        <Entry x:Name="nameEntry"
               Placeholder="Enter name" />
        <Entry x:Name="ageEntry"
               Placeholder="Enter age" />
        <Button Text="Add to Database"
                Clicked="OnButtonClicked" />
        <CollectionView x:Name="collectionView">
            <CollectionView.ItemTemplate>
                <DataTemplate>
                    <StackLayout>
                        <Label Text="{Binding Name}"
                               FontSize="Medium" />
                        <Label Text="{Binding Age}"
                               TextColor="Silver"
                               FontSize="Small" />
                    </StackLayout>
                </DataTemplate>
            </CollectionView.ItemTemplate>
        </CollectionView>
    </StackLayout>
</ContentPage>

Questo codice definisce in modo dichiarativo l'interfaccia utente per la pagina costituita da due istanze Entry, un Button e un CollectionView in un StackLayout. Ogni Entry ha la propria proprietà Placeholder impostata, che specifica il testo segnaposto che viene visualizzato prima dell'input dell'utente. Button imposta il relativo evento Clicked su un gestore eventi denominato OnButtonClicked, che verrà creato nel passaggio successivo. CollectionView imposta la proprietà ItemTemplate su DataTemplate che usa un oggetto StackLayout e due oggetti Label per definire l'aspetto di ciascuna riga in CollectionView. Gli oggetti Label associano le proprie proprietà Text rispettivamente alle proprietà Name e Age di ogni oggetto Person.

Inoltre, le istanze Entry e CollectionView hanno nomi specificati con l'attributo x:Name. Ciò consente al file code-behind di accedere a questi oggetti usando i nomi assegnati.

In Esplora soluzioni espandere MainPage.xaml nel progetto LocalDatabaseTutorial e fare doppio clic su MainPage.xaml.cs per aprirlo. In MainPage.xaml.cs aggiungere quindi l'override OnAppearing e il gestore eventi OnButtonClicked alla classe:
```
protected override async void OnAppearing()
{
    base.OnAppearing();
    collectionView.ItemsSource = await App.Database.GetPeopleAsync();
}

async void OnButtonClicked(object sender, EventArgs e)
{
    if (!string.IsNullOrWhiteSpace(nameEntry.Text) && !string.IsNullOrWhiteSpace(ageEntry.Text))
    {
        await App.Database.SavePersonAsync(new Person
        {
            Name = nameEntry.Text,
            Age = int.Parse(ageEntry.Text)
        });

        nameEntry.Text = ageEntry.Text = string.Empty;
        collectionView.ItemsSource = await App.Database.GetPeopleAsync();
    }
}
```
Il metodo OnAppearing popola CollectionView con tutti i dati archiviati nel database. Il metodo OnButtonClicked, che viene eseguito quando viene toccato Button, salva i dati immessi nel database prima della cancellazione di entrambe le istanze Entry e l'aggiornamento dei dati in CollectionView.

Nota

L'override del metodo OnAppearing viene eseguito dopo che è stato eseguito il layout dell'elemento ContentPage, ma subito prima che diventi visibile. Pertanto, questo è un buon posto per impostare il contenuto delle Xamarin.Forms visualizzazioni.
Nella barra degli strumenti di Visual Studio premere il pulsante Avvia, ovvero il pulsante a forma di triangolo simile a un pulsante di riproduzione, per avviare l'applicazione all'interno del simulatore iOS remoto o dell'emulatore Android prescelto.

Immettere diversi elementi di dati, se si tocca Button per ogni elemento di dati. Ciò salverà i dati nel database e ripopolerà CollectionView con tutti i dati dei database:

In Visual Studio arrestare l'applicazione.

Per altre informazioni sui database locali in Xamarin.Forms, vedere Xamarin.Forms Database locali (guida)

Fare doppio clic su MainPage.xaml nel progetto LocalDatabaseTutorial in Riquadro della soluzione per aprire il file. In MainPage.xaml rimuovere tutto il codice del modello e sostituirlo con il codice seguente:

<?xml version="1.0" encoding="utf-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="LocalDatabaseTutorial.MainPage">
    <StackLayout Margin="20,35,20,20">
        <Entry x:Name="nameEntry"
               Placeholder="Enter name" />
        <Entry x:Name="ageEntry"
               Placeholder="Enter age" />
        <Button Text="Add to Database"
                Clicked="OnButtonClicked" />
        <CollectionView x:Name="collectionView">
            <CollectionView.ItemTemplate>
                <DataTemplate>
                    <StackLayout>
                        <Label Text="{Binding Name}"
                               FontSize="Medium" />
                        <Label Text="{Binding Age}"
                               TextColor="Silver"
                               FontSize="Small" />
                    </StackLayout>
                </DataTemplate>
            </CollectionView.ItemTemplate>
        </CollectionView>
    </StackLayout>
</ContentPage>

Questo codice definisce in modo dichiarativo l'interfaccia utente per la pagina costituita da due istanze Entry, un Button e un CollectionView in un StackLayout. Ogni Entry ha la propria proprietà Placeholder impostata, che specifica il testo segnaposto che viene visualizzato prima dell'input dell'utente. Button imposta il relativo evento Clicked su un gestore eventi denominato OnButtonClicked, che verrà creato nel passaggio successivo. CollectionView imposta la proprietà ItemTemplate su DataTemplate che usa un oggetto StackLayout e due oggetti Label per definire l'aspetto di ciascuna riga in CollectionView. Gli oggetti Label associano le proprie proprietà Text rispettivamente alle proprietà Name e Age di ogni oggetto Person.

Inoltre, le istanze Entry e ListView hanno nomi specificati con l'attributo x:Name. Ciò consente al file code-behind di accedere a questi oggetti usando i nomi assegnati.

In Riquadro della soluzione espandere MainPage.xaml nel progetto LocalDatabaseTutorial e fare doppio clic su MainPage.xaml.cs per aprirlo. In MainPage.xaml.cs aggiungere quindi l'override OnAppearing e il gestore eventi OnButtonClicked alla classe:
```
protected override async void OnAppearing()
{
    base.OnAppearing();
    collectionView.ItemsSource = await App.Database.GetPeopleAsync();
}

async void OnButtonClicked(object sender, EventArgs e)
{
    if (!string.IsNullOrWhiteSpace(nameEntry.Text) && !string.IsNullOrWhiteSpace(ageEntry.Text))
    {
        await App.Database.SavePersonAsync(new Person
        {
            Name = nameEntry.Text,
            Age = int.Parse(ageEntry.Text)
        });

        nameEntry.Text = ageEntry.Text = string.Empty;
        collectionView.ItemsSource = await App.Database.GetPeopleAsync();
    }
}
```
Il metodo OnAppearing popola CollectionView con tutti i dati archiviati nel database. Il metodo OnButtonClicked, che viene eseguito quando viene toccato Button, salva i dati immessi nel database prima della cancellazione di entrambe le istanze Entry e l'aggiornamento dei dati in CollectionView.

Nota

L'override del metodo OnAppearing viene eseguito dopo che è stato eseguito il layout dell'elemento ContentPage, ma subito prima che diventi visibile. Pertanto, questo è un buon posto per impostare il contenuto delle Xamarin.Forms visualizzazioni.
Nella barra degli strumenti di Visual Studio per Mac premere il pulsante Avvia, ovvero il pulsante a forma di triangolo simile a un pulsante di riproduzione, per avviare l'applicazione all'interno del simulatore iOS o dell'emulatore Android prescelto.

Immettere diversi elementi di dati, se si tocca Button per ogni elemento di dati. Ciò salverà i dati nel database e ripopolerà CollectionView con tutti i dati dei database:

In Visual Studio per Mac arrestare l'applicazione.

Per altre informazioni sui database locali in Xamarin.Forms, vedere Xamarin.Forms Database locali (guida)

Congratulazioni!

Completata al 100%!

L'esercitazione è stata completata. Si è appreso come:

Usare il Gestione pacchetti NuGet per aggiungere SQLite.NET a un Xamarin.Forms progetto.
Creare classi di accesso ai dati.
Usare le classi di accesso ai dati.

Passaggi successivi

Per altre informazioni sulle nozioni di base sulla creazione di applicazioni per dispositivi mobili con Xamarin.Forms, passare all'esercitazione sui servizi Web.

Esercitazione sui servizi Web

Condividi tramite

Aggiungere SQLite.NET

Creare classi di accesso ai dati

Usare le classi di accesso ai dati

Congratulazioni!

Passaggi successivi

Collegamenti correlati