ASP.NET API com Conexão ao SQL Server: Criando APIs com Banco de Dados

1. Configurando o Projeto

Para começar, precisamos configurar um novo projeto ASP.NET Core e instalar o Entity Framework Core, que será usado para gerenciar a conexão e as operações no banco de dados SQL Server. Execute o seguinte comando para criar um novo projeto:

// Criando o projeto ASP.NET Core
dotnet new webapi -n MinhaApiSqlServer

// Instalando os pacotes do Entity Framework Core e SQL Server
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools

Esses pacotes são necessários para configurar o Entity Framework e para conectar a aplicação ao SQL Server.

2. Configurando o Entity Framework e o SQL Server

Após instalar os pacotes, precisamos configurar a conexão ao banco de dados. A primeira etapa é definir a string de conexão no arquivo appsettings.json:

// Exemplo de configuração do SQL Server em appsettings.json
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MinhaApiDb;Trusted_Connection=True;"
  }
}

Essa string de conexão será usada pelo Entity Framework para se conectar ao banco de dados SQL Server. Em seguida, criamos o contexto do banco de dados, que serve como intermediário entre o banco de dados e a aplicação:

// Exemplo de contexto do banco de dados
using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext {
    public DbSet<Produto> Produtos { get; set; }

    public AppDbContext(DbContextOptions<AppDbContext> options)
        : base(options) {
    }
}

// Registrando o contexto no Startup.cs (ou Program.cs, dependendo da versão do ASP.NET Core)
public void ConfigureServices(IServiceCollection services) {
    services.AddDbContext<AppDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
}

No código acima, estamos registrando o contexto AppDbContext e mapeando-o para a string de conexão definida em appsettings.json. O DbSet<Produto> define uma tabela Produtos que será usada pelo Entity Framework.

3. Criando o Modelo de Dados

Agora, precisamos criar o modelo de dados que representará nossa tabela Produtos no banco de dados. O modelo será uma classe simples que mapeia os campos da tabela:

// Exemplo de modelo Produto
public class Produto {
    public int Id { get; set; }
    public string Nome { get; set; }
    public decimal Preco { get; set; }
}

O Entity Framework usará essa classe para mapear os dados entre a aplicação e a tabela no SQL Server.

4. Criando o Banco de Dados com Migrations

Uma das grandes vantagens do Entity Framework Core é a capacidade de criar e atualizar o banco de dados usando Migrations. Para gerar a migration inicial e criar a tabela Produtos, use os seguintes comandos:

// Gerando a migration inicial
dotnet ef migrations add InitialCreate

// Aplicando a migration e criando o banco de dados
dotnet ef database update

Isso criará o banco de dados e as tabelas necessárias com base nos modelos definidos.

5. Criando um Controlador para a API

Agora, vamos criar um controlador que permitirá realizar operações CRUD na tabela Produtos através da API. O controlador irá interagir com o banco de dados usando o AppDbContext:

// Exemplo de controlador de API para Produtos
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

[ApiController]
[Route("api/[controller]")]
public class ProdutosController : ControllerBase {
    private readonly AppDbContext _context;

    public ProdutosController(AppDbContext context) {
        _context = context;
    }

    [HttpGet]
    public async Task<ActionResult<IEnumerable<Produto>>> GetProdutos() {
        return await _context.Produtos.ToListAsync();
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<Produto>> GetProduto(int id) {
        var produto = await _context.Produtos.FindAsync(id);
        if (produto == null) {
            return NotFound();
        }
        return produto;
    }

    [HttpPost]
    public async Task<ActionResult<Produto>> PostProduto(Produto produto) {
        _context.Produtos.Add(produto);
        await _context.SaveChangesAsync();
        return CreatedAtAction(nameof(GetProduto), new { id = produto.Id }, produto);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> PutProduto(int id, Produto produto) {
        if (id != produto.Id) {
            return BadRequest();
        }
        _context.Entry(produto).State = EntityState.Modified;
        await _context.SaveChangesAsync();
        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteProduto(int id) {
        var produto = await _context.Produtos.FindAsync(id);
        if (produto == null) {
            return NotFound();
        }
        _context.Produtos.Remove(produto);
        await _context.SaveChangesAsync();
        return NoContent();
    }
}

Esse controlador fornece endpoints para realizar as operações CRUD: listar, adicionar, atualizar e excluir produtos no banco de dados SQL Server. Cada ação interage com o AppDbContext para acessar e manipular os dados.

Conclusão

Integrar uma API ASP.NET Core com um banco de dados SQL Server é uma maneira poderosa de criar aplicações com persistência de dados robusta. Com a ajuda do Entity Framework Core, é possível realizar operações complexas no banco de dados de forma simplificada, utilizando modelos e contextos. Além disso, o uso de migrations facilita a criação e manutenção do banco de dados. Seguir essas práticas garantirá que sua API seja eficiente, escalável e fácil de manter.