Exercício: Armazene dados localmente com SQLite

{númeroDeMinutos} 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 utiliza o SDK .NET 10.0. Certifique-se de que tem o .NET 10.0 instalado executando o seguinte comando no terminal de comandos preferido:

dotnet --list-sdks

Saída semelhante ao exemplo a seguir aparece:

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

Certifique-se de que uma versão que começa com 10 está listada. Se não aparecer nenhum ou se o comando não for encontrado, instale o SDK .NET 10.0 mais recente.

Abra a solução inicial

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.
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

Abra o arquivo Person.cs na pasta Modelos .
Adicione uma int propriedade chamada Id à Person classe.

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; }
}

Salve o arquivo Person.cs .

Adicionar a biblioteca SQLite

Clique com o botão direito do mouse no nó do projeto Pessoas no Gerenciador de Soluções no Visual Studio.
No menu de contexto exibido, selecione Gerenciar pacotes NuGet.
Procure e selecione sqlite-net-pcl e, em seguida, selecione Instalar.

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

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
{
    ...
}
```
Anote a Person classe com o [Table] atributo e especifique o nome da tabela como people.
Especifique a Id propriedade como a chave primária. Anote com os [PrimaryKey] atributos e [AutoIncrement] .

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; }
}

Salve o arquivo Person.cs .

Ligue-se à base de dados

Abra o arquivo PersonRepository.cs .
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.
Adicione uma using diretiva para os SQLite namespaces e People.Models ao arquivo da PersonRepository.cs classe.
Adicione um campo privado SQLiteConnection nomeado conn à classe, acima da Init função.
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.
Inicialize o conn campo para se conectar ao banco de dados usando a _dbPath variável.

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

Na PersonRepository classe, encontre o AddNewPerson método.

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

Na classe, encontre o PersonRepositoryGetAllPeople método.
Ligue Init para verificar se o banco de dados foi inicializado.
Use o método generic Table\<T> para recuperar todas as linhas na tabela. Especifique Person como o parâmetro type.
Use o ToList() método extension para transformar o resultado em uma List\<Person> coleção e retornar essa coleção.

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>();
}

Salve o arquivo PersonRepository.cs .

Integrar o repositório na interface do usuário

Abra o arquivo MauiProgram.cs .
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();
}
```
Salve o arquivo MauiProgram.cs .
Expanda App.xaml no Gerenciador de Soluções e abra o arquivo App.xaml.cs.
Adicione uma publicpropriedade , static chamada PersonRepo. Esta propriedade contém um PersonRepository objeto para a App classe.

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

Crie a solução usando CTRL+Shift+B.
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.
Selecione Obter Todas as Pessoas e verifique se o seu nome aparece.
Experimente adicionando mais nomes e recuperando a lista de pessoas armazenadas.
Retorne ao Visual Studio ou Visual Studio Code e pare a depuração usando Shift+F5.
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.

Feedback

Esta página foi útil?