Construindo uma API RESTful com C# e ASP.NET Core: Um Guia Prático para Iniciantes Usando Swagger e Entity Framework

Introdução

Neste tutorial, iremos apresentar um guia passo a passo para a construção de uma API RESTful utilizando C# e o framework ASP.NET Core. O objetivo é fornecer aos iniciantes as ferramentas e conhecimentos necessários para desenvolver uma aplicação completa, usando o Entity Framework para gerenciar dados e o Swagger para a documentação automática da API. A construção de APIs é uma habilidade essencial no desenvolvimento moderno de software, permitindo que diferentes sistemas se comuniquem de forma eficaz. Por meio deste tutorial, você aprenderá a configurar seu ambiente de desenvolvimento, criar um projeto ASP.NET Core, implementar métodos CRUD (Create, Read, Update, Delete) em sua API e a testar a aplicação de maneira eficiente. Após concluir este guia, você estará apto a criar suas próprias APIs RESTful robustas.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de que o .NET SDK e o Visual Studio estejam instalados em sua máquina. O .NET SDK é a ferramenta que permite criar aplicações em C#, enquanto o Visual Studio é o ambiente de desenvolvimento integrado (IDE) recomendado. Verifique a instalação executando os comandos ‘dotnet –version’ no terminal. Caso não os tenha, você pode baixá-los do site oficial da Microsoft.
commands
```
# Verificar versão do .NET SDK
dotnet --version
```
Criação do Projeto ASP.NET Core
Utilize o comando dotnet CLI para criar um novo projeto ASP.NET Core. Isso gerará a estrutura básica do projeto. Acesse o diretório onde deseja criar o projeto e execute o seguinte comando:
commands
```
dotnet new webapi -n ApiRestfulExemplo
```
Adicionar o Entity Framework Core
Adicione as dependências do Entity Framework Core e do banco de dados que você deseja usar. Neste exemplo utilizaremos o SQL Server. Execute os seguintes comandos no terminal dentro da pasta do seu projeto:
commands
```
dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.EntityFrameworkCore.Tools
```

Configuração da String de Conexão

Abra o arquivo ‘appsettings.json’ e adicione a string de conexão para o seu banco de dados SQL Server. Use o seguinte exemplo, substituindo os valores conforme necessário:

appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=ApiRestfulExemplo;Trusted_Connection=True;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Criação da Entidade `Produto`

Crie uma nova classe chamada `Produto` dentro da pasta Models. Esta classe representará a entidade que será armazenada no banco de dados. Utilize as anotações do Entity Framework para mapear a classe à tabela do banco de dados.

Produto.cs

using System.ComponentModel.DataAnnotations;

namespace ApiRestfulExemplo.Models
{
    public class Produto
    {
        [Key]
        public int Id { get; set; }
        [Required]
        public string Nome { get; set; }
        [Required]
        public decimal Preco { get; set; }
    }
}

Criação do Contexto do Banco de Dados

Adicione uma nova classe chamada `ApiDbContext` na pasta Data. Essa classe herda de `DbContext` e irá representar a sessão com o banco de dados. Além disso, será necessário configurar o DbSet para a entidade `Produto`.

ApiDbContext.cs

using Microsoft.EntityFrameworkCore;
using ApiRestfulExemplo.Models;

namespace ApiRestfulExemplo.Data
{
    public class ApiDbContext : DbContext
    {
        public ApiDbContext(DbContextOptions<ApiDbContext> options) : base(options) {}

        public DbSet<Produto> Produtos { get; set; }
    }
}

Configuração do Câmara de Dependência

No arquivo `Startup.cs`, configure a injeção de dependência para o `ApiDbContext` no método `ConfigureServices`.

Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<ApiDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
    services.AddControllers();
    services.AddSwaggerGen(c =>
    {
        c.SwaggerDoc("v1", new OpenApiInfo { Title = "API Restful Exemplo", Version = "v1" });
    });
}

Criação do Controlador `ProdutoController`

Adicione um novo controlador para a entidade `Produto` na pasta Controllers. Este controlador receberá as requisições HTTP e utilizará o contexto do banco de dados para manipular os produtos.

ProdutoController.cs

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using ApiRestfulExemplo.Data;
using ApiRestfulExemplo.Models;

namespace ApiRestfulExemplo.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProdutoController : ControllerBase
    {
        private readonly ApiDbContext _context;

        public ProdutoController(ApiDbContext context)
        {
            _context = context;
        }

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

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

        // Métodos PUT e DELETE podem ser adicionados aqui
    }
}

Configuração do Swagger

No método `Configure` do arquivo `Startup.cs`, habilite o Swagger para que você possa acessar a documentação da API. Você poderá visualizar a UI do Swagger acessando `/swagger` em sua aplicação após a execução.

Startup.cs

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
    }

    app.UseRouting();
    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });

    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "API Restful Exemplo V1");
    });
}

Executando a Aplicação e Testes
Use o seguinte comando para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman ou Swagger UI para testar os endpoints da API.
commands
```
# Compilar e executar a aplicação
dotnet run
# Acesse a UI do Swagger em
http://localhost:5000/swagger
```

Conclusão

Neste tutorial, você aprendeu a construir uma API RESTful usando C# e ASP.NET Core, incluindo a configuração do ambiente, a implementação das entidades e controladores, e a utilização do Swagger para documentação e testes. Com isso, você ganhou conhecimentos práticos que podem ser aplicados para criar aplicações mais robustas e escaláveis. A prática e a exploração contínua de outros recursos do ASP.NET Core e do Entity Framework também são recomendadas para aprimorar suas habilidades em desenvolvimento de software e APIs.

Hashtags

#CSharp #ASPNetCore #APIs #EntityFramework #Swagger #DesenvolvimentoDeSoftware

copycoda.com.br