RESTTemplate

\(\color{lightgreen}\mathbb{Context}\)

O que é Context

Uma classe Context é uma referência à classe DbContext do Entity Framework no .NET.

DbContext é uma classe importante que encapsula as funcionalidades do Entity Framework, incluindo a capacidade de consultar e salvar instâncias de suas entidades.

O que a classe DbContext faz:

Gerenciamento de Conexão: Por padrão, o DbContext gerencia conexões com o banco de dados. Ele abre e fecha conexões conforme necessário. Por exemplo, o DbContext abre a conexão para executar uma consulta e, em seguida, fecha a conexão quando todos os conjuntos de resultados tiverem sido processados.
Representação do Modelo de Dados: A classe DbContext representa uma sessão com o banco de dados, permitindo que você consulte e salve instâncias de suas entidades. É uma ponte entre o seu domínio ou modelo de entidade e o banco de dados.
Rastreamento de Alterações: O DbContext rastreia todas as alterações feitas nas instâncias de suas entidades desde que foram carregadas no DbContext. Isso inclui novas entidades que você adicionou, entidades existentes que você modificou e entidades que você excluiu.
Persistência de Alterações: Quando o método SaveChanges é chamado, o DbContext gera comandos SQL para persistir essas alterações no banco de dados.

O que é Entity Framework Core

O Entity Framework Core (EF Core) é uma versão leve, extensível e de código aberto do Entity Framework, que é uma tecnologia de acesso a dados popular no .NET.

O EF Core é um mapeador objeto-relacional (ORM) que permite aos desenvolvedores .NET trabalhar com bancos de dados usando objetos .NET. Ele elimina a necessidade da maior parte do código de acesso a dados que os desenvolvedores geralmente precisam escrever.

Com o EF Core, você pode realizar as seguintes tarefas:

Modelar um domínio orientado a objetos no .NET e mapeá-lo para um banco de dados relacional.
Consultar e manipular dados diretamente do código de aplicativo usando LINQ.
Realizar o rastreamento de alterações, persistência e manipulação de dados de maneira eficiente.
Migrar seu esquema de banco de dados de maneira segura usando migrações do EF Core.

O EF Core suporta muitos provedores de banco de dados, como SQL Server, SQLite, PostgreSQL, MySQL e muitos outros. Ele também suporta uma variedade de padrões de desenvolvimento de aplicativos, incluindo aplicativos de console, aplicativos de desktop, aplicativos da web ASP.NET Core e muito mais.

Adicionando o EF Core no .NET

Dependências (ou Dependencies) são softwares criados na biblioteca do Nuget para podermos utilizar em projetos .NET, Nuget é o gerenciador de pacotes do .NET que nos ajuda de uma maneira fácil de adicionar, remover e atualizar bibliotecas e ferramentas em projetos .NET. Todas as bibliotecas e ferramentas adicionadas ficam dentro de Dependencies no nosso projeto, para poder adicionar nesse diretório devemos clicar com o botão direito do mouse no nome do diretório Dependencies e escolher a opção Manage Nuget Packages

Ele vai abrir uma página visual do Nuget para pesquisarmos o pacote que queremos instalar no nosso projeto, de forma simples e fácil.

Devemos escolher o tipo de Entity Framework que queremos usar pelo tipo de banco de dados, no nosso caso queremos o Microsoft.EntityFrameworkCore.Sqlite para gerenciar o banco SQLite, para instalar o banco acesse esta documentação e para configurar acesse esta documentação.

Então clique em Install e aceite os requisitos para o pacote e ele vai instalar para você nas dependências do projeto. Assim que tiver baixado ele vai mostrar um check em verde no lado do pacote.

Após instalado podemos verificar se ele foi corretamente adicionado clicando duas vezes no nome da API na área de Solution Explorer

Devemos adicionar também o Pacote Microsoft.EntityFrameworkCore.Tools junto com esse primeiro.

Criando uma classe Context

Agora que instalamos o pacote no projeto, vamos criar sua configuração no nosso projeto, onde iremos criar uma pasta dentro de Model chamada Context onde ficam armazenado as conexões com o banco de dados.

No nosso caso que estamos trabalhando com SQLite, vamos criar uma classe dentro do diretório Context chamado SQLiteContext .

Criação do Folder Context.

Criação da classe SQLiteContext

Nessa nova classe, temos que estender a classe do Entity Framework chamada DbContext em nossa classe de conexão ao banco de dados e depois adicionar o Entity Framework Core em nossa lista de pacotes conectados nessa classe.

// Antes
namespace RESTTemplate.Model.Context
{
    public class SQLiteContext
    {
    }
}

// Depois
using Microsoft.EntityFrameworkCore;

namespace RESTTemplate.Model.Context
{
    public class SQLiteContext : DbContext
    {
    }
}

Agora vamos construir dois construtores para nossa classe, um deles é vazio e o outro recebe por parâmetro opções de acesso.

using Microsoft.EntityFrameworkCore;

namespace RESTTemplate.Model.Context
{
    public class SQLiteContext : DbContext
    {
        public SQLiteContext() 
        { 
            
        }

        public SQLiteContext(DbContextOptions<SQLiteContext> options) : base(options)
        {

        }
    }
}

Qualquer Context deve ter essa estrutura básica, agora vamos construir os métodos dos modelos que queremos em nosso banco de dados.

Criando método de acesso ao Model Person

Agora vamos colocar em nossa classe Context a conexão ao Model de Person, para isso adicionamos o seguinte atributo:

public DbSet<Person> Persons { get; set; }

Atualizando o appsettings.json

Agora que criamos o nosso Context para acessar ao Banco de dados, devemos atualizar o arquivo appsettings.json com os dados de conexão.

No nosso caso passamos uma String com o nome do nosso banco de dados utilizando na string o nome Data Source.

Deve ser colocado todo o caminho até o banco de dados, onde no nosso caso quando criamos localmente nesta documentação ele se encontra no seguinte caminho: C:\sqlite\db\restemplate.db e no appsettings.json sempre que tiver uma barra deve colocar duas, como mostra o exemplo abaixo:

"SQLiteConnection": {
  "SQLiteConnectionString": "Data Source=C:\\sqlite\\db\\restemplate.db"  
}

Podemos colocar essa info antes do Logging no appsettings.json

Conectando o banco de dados no Program.cs

Em .NET 8 é feito essa configuração no Program.cs onde vamos dizer a nossa API qual é a conexão do nosso banco de dados, onde colocamos essas informações depois de AddControllers(). Primeiro criamos uma variável puxando as informações que se encontram no appsetings.json como configuramos:

var connection = builder.Configuration["SQLiteConnection:SQLiteConnectionString"];

Depois criamos um serviço chamado AddDbContext<>() onde iremos conectar o Context que criamos nos passos anteriores e definimos as opções de acesso.

builder.Services.AddDbContext<SQLiteContext>(options => options.UseSqlite(connection));

O código deve ficar mais ou menos assim:

Pronto! com isso temos a nossa conexão com o banco de dados definido em nosso projeto, agora podemos desenvolver os métodos de como se conectar em nosso caso no banco de dados SQLite.

This site is open source. Improve this page.