Após especificar o DBContext, DBSet e onModelCreating 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.

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

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

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

Migrações