Temos que fazer a instalação do nosso EF Core juntamente com o provedor (banco de dados) que queremos utilizar entre outros pacotes que vão deixar nossa aplicação mais robusta e eficiente. Além disso, para funcionar
1. Entity Framework Core
install-package Microsoft.EntityFrameworkCore
2. Entity Framework Core Design
Ferramenta que o Entity Framework utiliza para facilitar a criação e gerenciamento de modelos entre o banco de dados e aplicação, como por exemplo “gerar modelos de dados e o M apeamento Objeto-Relacional (ORM)
install-package *Microsoft.EntityFrameworkCore.Design*
3. Entity Framework Core Tools
Ferramenta que aplica migrações e interações entre a aplicação e o banco de dados.
install-package *Microsoft.EntityFrameworkCore.Tools*
4. Provedor de banco de dados escolhido
Logo após isso temos que efetuar a instalação do nosso provedor que vamos estar fazendo a integração com o Entity, no nosso caso será o SQL Server.
install-package *Microsoft.EntityFrameworkCore.SQLServer*
Finalizando as instalações será necessário configurar o EF Core do nosso sistema e o banco de dados.
Configurando DBContext
A classe dbContext faz parte do Entity Framework e sua instância representa uma sessão do banco de dados. Nessa sessão você pode manipular e salvar instâncias de sua entidade para um banco de dados.
Para usar o dbContext na sua aplicação, você deve criar uma classe que herda de dbContext.
public class EscolaContext: DbContext
{
}
A classe acima está derivando do DbContext e pode ser chamado de “classe de contexto”. Apesar de ter sido apenas declarado esse nosso trecho de código não faz nada ainda.
Quando começamos a trabalhar em um projeto, definimos nossas classes que representam a nossa entidade. São modelos de dados com propriedades correspondentes aos campos do banco de dados. Porém não é suficiente ter apenas os Models precisamos transformá-las em entidades rastreáveis.
Então, em nossa classe de contexto temos que declarar a propriedade DBSet. (DbSet<TEntity>)
Quando declaramos essa propriedade em nossa classe de contexto estamos dizendo ao Entity Framework que queremos que ele rastreie e gerencie as entidades desse tipo no banco de dados.
Agora, vamos imaginar que na nossa aplicação tem dois Models: Estudante e Materia, podemos transformá-las em entidades do Entity Framework adicionando em nossa classe de contexto. Vale ressaltar que você precisa ter os modelos criados em sua aplicação.
public class EscolaContext: DbContext
{
public DbSet<Student> Estudantes { get; set; }
public DbSet<Grade> Materias { get; set; }
}
Após fazer isso, o EF Core será capaz de rastrear as instâncias de Estudante e Materia que estão associadas ao contexto EscolaContext permitindo a interação com o banco de dados.
Configurar Conexão do Banco de Dados
Após especificar o DBContext e DBSets temos que especificar o nome e informações do banco de dados.
Existem várias maneiras de fazer essa implementação, a seguir tratei dois exemplos, sendo a forma 1 mais robusta, enquanto a forma 2 mais simples.
Exemplo Robusto
Acessando nosso arquivo appsettings.json, podemos anexar nossa connection string. Existem vários tipos de strings de acordo com cada banco de dados e tipo de autenticação da aplicação. É uma boa prática pesquisar qual a que adapta a necessidade do seu projeto.
"ConnectionStrings": {
"ServerConnection": "Server=NOME_DO_SERVIDOR;Database=NOME_DO_BANCO_DE_DADOS;User Id=USUARIO;Password=SENHA;"
}
Após isso temos que configurar nosso contexto do banco de dados para usar a string de conexão.
- Usamos a injenção de dependência do contexto do DBContext
- O método
onConfiguringé uma parte essencial da configuração de um DBContext. Ele é usado para configurar o contexto, incluindo a definição dos provedores de bancos de dados, habilitar logging, definir comportamentos de rastreamentos, e muito mais.
public class SeuContexto : DbContext
{
public SeuContexto(DbContextOptions<SeuContexto> options) : base(options)
{
}
// protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
//{
// optionsBuilder.UseSqlServer(configuration.GetConnectionString("ServerConnection"));
// }
// Defina suas DbSet aqui
public DbSet<Materia> Materias { get; set; }
}
e no Program.cs efetuar a nossa conexão:
builder.Services.
AddDbContext<AppDbContext>(options =>
options.UseSqlServer(builder.Configuration.GetConnectionString("ServerConnection")));
Com isso configurado, vamos ser capaz de fazer nossas implementações, criar a nossa tabela e relacionar nossos objetos para modelos relacionais de banco de dados.
Exemplo Simples
Vamos sobrescrever (override) o método OnConfiguring() do DBContext para configurar o nosso banco de dados e outras opções que serão usadas nesse contexto. Esse método é chamado cada vez que a instância do contexto é criada.
public class EscolaContext : DbContext
{
//Entidades
public DbSet<Estudante> Estudantes { get; set; }
public DbSet<Materia> Materias { get; set; }
**protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
base.OnConfiguring(optionsBuilder);
}**
}
Acima base.OnConfiguring(optionsBuilder); chama a implementação base, que não faz nada. Vamos remover e especificar a connection string para o banco de dados.
public class EscolaContext : DbContext
{
//Entidades
public DbSet<Estudante> Estudantes { get; set; }
public DbSet<Materia> Materias { get; set; }
**protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=SchoolDb;Trusted_Connection=True;");
}**
}
Acima, o **optionsBuilder.UseSqlServer() é um método de extensão que é usado para configurar EF para usar SQL Server como o provedor de banco de dados **pela especificação de uma connection string, e é por meio dessa string de conexão que vamos comunicar com o banco de dados. Existe diversas formas de especificar uma connection string.
Configurando com Arquivo de Configuração
Além dos exemplos robustos e simples, podemos fazer uma configuração que modulariza a aplicação para outro arquivo. Essa prática é recomendada para projetos maiores e quando não há previsão de escalabilidade.
Criar um arquivo de configuração
Vamos criar um arquivo chamado DataBaseConfig.cs
using AL.Data.Context;
using Microsoft.EntityFrameworkCore;
namespace AL.WebApi.Configuration;
public static class DataBaseConfig
{
public static void AddDataBaseConfiguration(this IServiceCollection services, IConfiguration configuration)
{
services.
AddDbContext<ALContext>(options =>
options.UseSqlServer(configuration.GetConnectionString("ClConnection")));
}
}
Desse modo, temos a configuração do nossa conexão modularizada. Com isso, é necessário adequar o nosso código na Program.cs. Nesse código chamaremos a classe que criamos e sua função de adicionar a configuração do banco de dados AddDataBaseConfiguration
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
**builder.Services.AddDataBaseConfiguration(builder.Configuration);**
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
Garantir Integridade Estrutural
Nesse exemplo, além de conectarmos nosso banco, vamos garantir a integridade estrutural da base de dados na subida da aplicação com o EF Core. Isso, garante que toda alteração e versão do banco de dados seja subido junto com a aplicação.
Vamos usar a base do exemplo anterior e adicionar mais um método. Ele será chamado de UseDatabaseConfiguration. Ele é um método de extensão que, ao ser chamado durante o ciclo de vida da aplicação, garante que o banco de dados seja configurado corretamente, migrado e se necessário criado.
public static class DataBaseConfig
{
public static void AddDataBaseConfiguration(this IServiceCollection services, IConfiguration configuration)
{
services.
AddDbContext<ALContext>(options =>
options.UseSqlServer(configuration.GetConnectionString("ALConnection")));
}
public static void UseDatabaseConfiguration(this IApplicationBuilder app)
{
using var serviceScope = app.ApplicationServices.GetRequiredService<IServiceScopeFactory>().CreateScope();
using var context = serviceScope.ServiceProvider.GetService<ALContext>();
if (context != null)
context.Database.Migrate(); // Aplica qualquer migração pendente no contexto do banco de dados.
context.Database.EnsureCreated(); // Garantir que a base de dados está criada
}
}
Agora, em nosso arquivo Startup, temos que chamar essas configurações:
using AL.WebApi.Configuration;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
**builder.Services.AddDataBaseConfiguration(builder.Configuration);**
var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
**app.UseDatabaseConfiguration();**
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();
Top comments (0)