Exercício: Armazene dados localmente com SQLite

  • 15 minutos

Neste exercício, você usa SQLite para armazenar informações localmente com um aplicativo. No cenário de exemplo, você decidiu armazenar em cache dados para o aplicativo de mídia social para melhorar a capacidade de resposta. Este exercício cria e usa um banco de dados SQLite local para armazenar informações sobre pessoas. Salve o arquivo de banco de dados físico no armazenamento local.

Este módulo usa o SDK do .NET 9.0. Certifique-se de ter o .NET 9.0 instalado executando o seguinte comando no seu terminal de comando preferido:

dotnet --list-sdks

Saída semelhante ao exemplo a seguir aparece:

8.0.100 [C:\Program Files\dotnet\sdk]
9.0.100 [C:\Program Files\dotnet\sdk]

Certifique-se de que uma versão que começa com 9 está listada. Se nenhum estiver listado ou o comando não for encontrado, instale o SDK do .NET 9.0 mais recente.

Abra a solução inicial

  1. Clone ou baixe o repositório de exercícios.

    Nota

    É melhor clonar o conteúdo do exercício para um caminho de pasta curta, como C:\dev, para evitar que os arquivos gerados pela compilação excedam o comprimento máximo do caminho.

  2. Use o Visual Studio para abrir a solução People.sln, que você encontra em mslearn-dotnetmaui-store-local-data> ou a pasta inicial no Visual Studio Code.

    Nota

    Não tente executar o aplicativo ainda, o código está incompleto e lançará exceções até que você adicione os elementos ausentes mais tarde neste exercício.

Definir uma entidade SQLite

  1. Abra o arquivo Person.cs na pasta Modelos .

  2. Adicione uma int propriedade chamada Id à Person classe.

  3. Adicione uma string propriedade chamada Name. A classe deve ter esta aparência:

    namespace People.Models;

public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
}

  4. Salve o arquivo Person.cs .

Adicionar a biblioteca SQLite

  1. Clique com o botão direito do mouse no nó do projeto Pessoas no Gerenciador de Soluções no Visual Studio.

  2. No menu de contexto exibido, selecione Gerenciar pacotes NuGet.

  3. Procure e selecione sqlite-net-pcl e, em seguida, selecione Instalar.

    Uma captura de tela mostrando o gerenciador de pacotes NuGet com a biblioteca sqlite-net-pcl selecionada.

Se estiver usando o Visual Studio Code, abra o terminal e esses pacotes com os seguintes comandos:

dotnet add package sqlite-net-pcl

Adicionar atributos SQLite

  1. No arquivo Person.cs, adicione uma using diretiva para o SQLite namespace ao arquivo da Person classe. Esta diretiva permite que você use os atributos SQLite.

    using SQLite;

namespace People.Models;

public class Person
{
    ...
}

  2. Anote a Person classe com o [Table] atributo e especifique o nome da tabela como people.

  3. Especifique a Id propriedade como a chave primária. Anote com os [PrimaryKey] atributos e [AutoIncrement] .

  4. Adicione anotações à Name propriedade. Especifique como MaxLength 250. Especifique que cada valor na coluna deve ser Unique.

    A classe concluída deve ter esta aparência:

    using SQLite;

namespace People.Models;

[Table("people")]
public class Person
{
    [PrimaryKey, AutoIncrement]
    public int Id { get; set; }

    [MaxLength(250), Unique]
    public string Name { get; set; }
}

  5. Salve o arquivo Person.cs .

Ligue-se à base de dados

  1. Abra o arquivo PersonRepository.cs .

  2. Examine a PersonRepository classe. Esta classe contém código esqueleto incompleto com TODO marcadores onde você adiciona a funcionalidade para acessar o banco de dados.

  3. Adicione uma using diretiva para os SQLite namespaces e People.Models ao arquivo da PersonRepository.cs classe.

  4. Adicione um campo privado SQLiteConnection nomeado conn à classe, acima da Init função.

  5. Init Na função, verifique se conn não é igual a null. Em caso afirmativo, devolva imediatamente.

    if (conn != null)
    return;

    Dessa forma, o código de inicialização para o banco de dados SQLite só é executado uma vez.

  6. Inicialize o conn campo para se conectar ao banco de dados usando a _dbPath variável.

  7. Use o conn.CreateTable método para criar uma tabela para armazenar Person dados. A função concluída Init deve ter esta aparência:

    using SQLite;
using People.Models;
...

private SQLiteConnection conn;
...
private void Init()
{
   if (conn != null)
      return;

   conn = new SQLiteConnection(_dbPath);
   conn.CreateTable<Person>();
}

Inserir uma linha no banco de dados

  1. Na PersonRepository classe, encontre o AddNewPerson método.

  2. Para inserir um novo Person objeto, substitua o TODO comentário neste método por código. O código primeiro chama Init para verificar se o banco de dados foi inicializado e, em seguida, usa o SQLiteConnection método do Insert objeto. Defina a result variável para o valor que o Insert método retorna, conforme mostrado no código a seguir:

    public void AddNewPerson(string name)
{
    int result = 0;
    try
    {
        // enter this line
        Init();

        // basic validation to ensure a name was entered
        if (string.IsNullOrEmpty(name))
            throw new Exception("Valid name required");

        // enter this line
        result = conn.Insert(new Person { Name = name });
        ...
    }
    ...
}

Recuperar linhas do banco de dados

  1. Na classe, encontre o PersonRepositoryGetAllPeople método.

  2. Ligue Init para verificar se o banco de dados foi inicializado.

  3. Use o método generic Table\<T> para recuperar todas as linhas na tabela. Especifique Person como o parâmetro type.

  4. Use o ToList() método extension para transformar o resultado em uma List\<Person> coleção e retornar essa coleção.

  5. Adicione tratamento de erros encapsulando seu código em um try-catch bloco. Se houver um erro, defina a StatusMessage propriedade como a propriedade da Message exceção e retorne uma coleção vazia. O método concluído deve ter esta aparência:

    public List<Person> GetAllPeople()
{
   try
   {
      Init();
      return conn.Table<Person>().ToList();
   }
   catch (Exception ex)
   {
      StatusMessage = string.Format("Failed to retrieve data. {0}", ex.Message);
   }

   return new List<Person>();
}

  6. Salve o arquivo PersonRepository.cs .

Integrar o repositório na interface do usuário

  1. Abra o arquivo MauiProgram.cs .

  2. CreateMauiApp Na função, após as instruções que adicionam a MainPage página como um serviço singleton ao aplicativo, adicione código para executar as seguintes tarefas:

    • Crie uma variável de cadeia de caracteres chamada dbPath. Inicialize esta cadeia de caracteres com a expressão FileAccessHelper.GetLocalFilePath("people.db3"). O arquivo de banco de dados que o aplicativo usa é chamado people.db3 e o aplicativo salva esse arquivo no armazenamento local no dispositivo.

    • Use a injeção de dependência para adicionar a PersonRepository classe como um serviço singleton ao aplicativo. A PersonRepository classe expõe um construtor que usa o caminho para o arquivo de banco de dados como um parâmetro de cadeia de caracteres.

    O código concluído para a função deve ter esta CreateMauiApp aparência:

    public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .ConfigureFonts(fonts =>
        {
            fonts.AddFont("OpenSans-Regular.ttf", "OpenSansRegular");
            fonts.AddFont("OpenSans-Semibold.ttf", "OpenSansSemibold");
        });

    // Add this code
    string dbPath = FileAccessHelper.GetLocalFilePath("people.db3");
    builder.Services.AddSingleton<PersonRepository>(s => ActivatorUtilities.CreateInstance<PersonRepository>(s, dbPath));

    return builder.Build();
}

  3. Salve o arquivo MauiProgram.cs .

  4. Expanda App.xaml no Gerenciador de Soluções e abra o arquivo App.xaml.cs.

  5. Adicione uma publicpropriedade , static chamada PersonRepo. Esta propriedade contém um PersonRepository objeto para a App classe.

  6. Inicialize a PersonRepo propriedade no construtor adicionando um PersonRepository parâmetro ao construtor e definindo a propriedade 'PersonRepo' para o valor nesse parâmetro. A classe concluída App deve ter esta aparência:

    public partial class App : Application
{
    public static PersonRepository PersonRepo { get; private set; }

    public App(PersonRepository repo)
    {
        InitializeComponent();
        PersonRepo = repo;
    }
}

Nota

O processo de injeção de dependência preenche automaticamente o repo parâmetro para o construtor.

Testar a aplicação

  1. Crie a solução usando CTRL+Shift+B.

  2. Quando a compilação for concluída, inicie a depuração usando F5. Quando a interface do usuário aparecer, digite seu nome e selecione Adicionar pessoa.

    Uma captura de tela do aplicativo com uma mensagem bem-sucedida informando que um registro foi adicionado.

  3. Selecione Obter Todas as Pessoas e verifique se o seu nome aparece.

    Uma captura de tela do aplicativo com uma lista de todos os registros no banco de dados.

  4. Experimente adicionando mais nomes e recuperando a lista de pessoas armazenadas.

  5. Retorne ao Visual Studio ou Visual Studio Code e pare a depuração usando Shift+F5.

  6. Reinicie o aplicativo e selecione Obter todas as pessoas. Verifique se os nomes armazenados anteriormente ainda estão armazenados no banco de dados. Feche o aplicativo quando terminar.