¿Qué es una API?

por
Tiempo de lectura: 2 minutos

API es el acrónimo de Application Programing Interface (en español, Interfaz de Programación de Aplicaciones), y con éste término nos referimos a un conjunto de reglas y protocolos que permiten que diferentes componentes de software se comuniquen entre sí.

Las APIs son utilizadas para permitir la integración y la interacción entre diferentes aplicaciones y servicios. En lugar de tener que construir todo un software desde cero, los desarrolladores pueden utilizar APIs para aprovechar la funcionalidad ya existente en otras aplicaciones o servicios. Esto acelera el desarrollo, reduce la complejidad y permite la creación de sistemas más modulares y flexibles.

Las APIs pueden ser utilizadas para una variedad de propósitos, como acceder a bases de datos, enviar y recibir datos a través de internet, controlar hardware, integrar servicios externos (como pagos en línea o redes sociales), y mucho más. Los servicios web modernos, como las API RESTful, son comunes en la creación de aplicaciones web y móviles, permitiendo que los clientes (como navegadores o aplicaciones móviles) se comuniquen con los servidores para obtener o enviar información de manera estructurada.

Ejemplo básico de API para ofrecer las operaciones CRUD para una entidad "User" en .Net Core (C#):

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace UserApi.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class UserController : ControllerBase
    {
        private readonly AppDbContext _context;

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

        /// <summary>
        /// Obtiene todos los usuarios.
        /// </summary>
        [HttpGet]
        public async Task<ActionResult<IEnumerable<User>>> GetUsers()
        {
            return await _context.Users.ToListAsync();
        }

        /// <summary>
        /// Obtiene un usuario por su ID.
        /// </summary>
        /// <param name="id">ID del usuario.</param>
        [HttpGet("{id}")]
        public async Task<ActionResult<User>> GetUserById(int id)
        {
            var user = await _context.Users.FindAsync(id);

            if (user == null)
            {
                return NotFound();
            }

            return user;
        }

        /// <summary>
        /// Crea un nuevo usuario.
        /// </summary>
        /// <param name="user">Datos del usuario a crear.</param>
        [HttpPost]
        public async Task<ActionResult<User>> CreateUser(User user)
        {
            _context.Users.Add(user);
            await _context.SaveChangesAsync();

            return CreatedAtAction(nameof(GetUserById), new { id = user.Id }, user);
        }

        /// <summary>
        /// Actualiza los datos de un usuario existente.
        /// </summary>
        /// <param name="id">ID del usuario a actualizar.</param>
        /// <param name="updatedUser">Datos actualizados del usuario.</param>
        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateUser(int id, User updatedUser)
        {
            if (id != updatedUser.Id)
            {
                return BadRequest();
            }

            _context.Entry(updatedUser).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!UserExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return NoContent();
        }

        /// <summary>
        /// Elimina un usuario por su ID.
        /// </summary>
        /// <param name="id">ID del usuario a eliminar.</param>
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteUser(int id)
        {
            var user = await _context.Users.FindAsync(id);
            if (user == null)
            {
                return NotFound();
            }

            _context.Users.Remove(user);
            await _context.SaveChangesAsync();

            return NoContent();
        }

        private bool UserExists(int id)
        {
            return _context.Users.Any(e => e.Id == id);
        }
    }

    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }

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

        public DbSet<User> Users { get; set; }
    }
}





Deja un comentario