Cuarto paso: API con ASP.NET API

Conexión entre ASP.NET Web API y Azure SQL

Fecha: 5 de septiembre
Hora de inicio: 4:00 p.m.
Hora de finalización: 11:30 p.m.

1. Estructuración de carpetas en el proyecto

Estructura aplicada:

Code

/Controllers
/Models
/DTOs
/Repositories
/appsettings.json
/Program.cs

Explicación:

• /Controllers: contiene los endpoints HTTP que exponen la lógica de negocio.

• /Models: define las entidades que representan la estructura de datos.

• /DTOs: objetos de transferencia que encapsulan los datos que se reciben o envían.

• /Repositories: lógica de acceso a datos, incluyendo conexión con Azure SQL y ejecución de SP.

• Program.cs: configuración de servicios, rutas y dependencias.

2. Código final de cada archivo .cs

Empleado.cs (/Models)

namespace aspnet_api.Models
{
    public class Empleado
    {
        public int Id { get; set; }
        public string Nombre { get; set; } = string.Empty;
        public decimal Salario { get; set; }
    }
}

EmpleadoDto.cs (/DTOs)

namespace aspnet_api.DTOs
{
    public class EmpleadoDto
    {
        public string Nombre { get; set; } = string.Empty;
        public decimal Salario { get; set; }
    }
}

EmpleadoRepository.cs (/Repositories)

using Microsoft.Data.SqlClient;
using System.Data;
using aspnet_api.Models;

namespace aspnet_api.Repositories
{
    public class EmpleadoRepository
    {
        private readonly IConfiguration _configuration;

        public EmpleadoRepository(IConfiguration configuration)
        {
            _configuration = configuration;
        }

        public async Task<int> InsertarEmpleadoAsync(string nombre, decimal salario)
        {
            using var connection = new SqlConnection(_configuration.GetConnectionString("DefaultConnection"));
            using var command = new SqlCommand("InsertarEmpleado", connection)
            {
                CommandType = CommandType.StoredProcedure
            };

            command.Parameters.AddWithValue("@Nombre", nombre);
            command.Parameters.AddWithValue("@Salario", salario);

            var resultado = new SqlParameter
            {
                ParameterName = "@Resultado",
                SqlDbType = SqlDbType.Int,
                Direction = ParameterDirection.ReturnValue
            };
            command.Parameters.Add(resultado);

            await connection.OpenAsync();
            await command.ExecuteNonQueryAsync();

            return (int)resultado.Value;
        }

        public async Task<List<Empleado>> ConsultarEmpleadosAsync()
        {
            var empleados = new List<Empleado>();

            using var connection = new SqlConnection(_configuration.GetConnectionString("DefaultConnection"));
            using var command = new SqlCommand("ConsultarEmpleados", connection)
            {
                CommandType = CommandType.StoredProcedure
            };

            await connection.OpenAsync();
            using var reader = await command.ExecuteReaderAsync();

            while (await reader.ReadAsync())
            {
                empleados.Add(new Empleado
                {
                    Id = reader.GetInt32(0),
                    Nombre = reader.GetString(1),
                    Salario = reader.GetDecimal(2)
                });
            }

            return empleados;
        }
    }
}

EmpleadoController.cs (/Controllers)

using Microsoft.AspNetCore.Mvc;
using aspnet_api.Repositories;
using aspnet_api.DTOs;

[ApiController]
[Route("api/[controller]")]
public class EmpleadoController : ControllerBase
{
    private readonly EmpleadoRepository _repo;

    public EmpleadoController(EmpleadoRepository repo)
    {
        _repo = repo;
    }

    [HttpPost("insertar")]
    public async Task<IActionResult> Insertar([FromBody] EmpleadoDto dto)
    {
        var resultado = await _repo.InsertarEmpleadoAsync(dto.Nombre, dto.Salario);
        return Ok(new { Codigo = resultado });
    }

    [HttpGet("consultar")]
    public async Task<IActionResult> Consultar()
    {
        var empleados = await _repo.ConsultarEmpleadosAsync();
        return Ok(empleados);
    }
}

Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddScoped<EmpleadoRepository>();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.MapControllers();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.Run();

3. Prueba de APIs en Postman

•