C#: CRUD básico con solicitudes HTTP (HttpClient)

/// <summary>
/// Modelo UserModel.
/// </summary>
public class UserModel
{
  public int Id { get; set; }
  public string Name { get; set; }
  public string Email { get; set; }
}

/// <summary>
/// Servicio UserService.
/// </summary>
public class UserService
{
  private readonly HttpClient httpClient;

  public UserService()
  {
    httpClient = new HttpClient();
    httpClient.BaseAddress = new Uri("https://jsonplaceholder.typicode.com/");
  }

  /// <summary>
  /// Método para obtener todos los usuarios.
  /// </summary>
  /// <returns>Listado con todos los usuarios obtenidos.</returns>
  public async Task<List<UserModel>> GetUsers()
  {
    HttpResponseMessage response = await httpClient.GetAsync("users");
    response.EnsureSuccessStatusCode();

    List<UserModel> users = await response.Content.ReadAsAsync<List<UserModel>>();
    return users;
  }

  /// <summary>
  /// Método para obtener un usuario filtrando por su id.
  /// </summary>
  /// <param name="id">Identificador del usuario.</param>
  /// <returns>Usuario obtenido.</returns>
  public async Task<UserModel> GetUser(int id)
  {
    HttpResponseMessage response = await httpClient.GetAsync($"users/{id}");
    response.EnsureSuccessStatusCode();

    UserModel user = await response.Content.ReadAsAsync<UserModel>();
    return user;
  }

  /// <summary>
  /// Método para crear un usuario nuevo.
  /// </summary>
  /// <param name="user">Usuario con los datos informados.</param>
  /// <returns>Usuario creado.</returns>
  public async Task<UserModel> CreateUser(UserModel user)
  {
    HttpResponseMessage response = await httpClient.PostAsJsonAsync("users", user);
    response.EnsureSuccessStatusCode();

    UserModel createdUser = await response.Content.ReadAsAsync<UserModel>();
    return createdUser;
  }

  /// <summary>
  /// Método para modificar un usuario existente.
  /// </summary>
  /// <param name="id">Identificador del usuario.</param>
  /// <param name="user">Usuario con los datos informados.</param>
  /// <returns>Usuario modificado.</returns>
  public async Task<UserModel> UpdateUser(int id, UserModel user)
  {
    HttpResponseMessage response = await httpClient.PutAsJsonAsync($"users/{id}", user);
    response.EnsureSuccessStatusCode();

    UserModel updatedUser = await response.Content.ReadAsAsync<UserModel>();
    return updatedUser;
  }

  /// <summary>
  /// Método para eliminar un usuario.
  /// </summary>
  /// <param name="id">Identificador del usuario.</param>
  /// <returns>Booleano para indicar si el usuari ha sido eliminado (true) o no (false).</returns>
  public async Task<bool> DeleteUser(int id)
  {
    HttpResponseMessage response = await httpClient.DeleteAsync($"users/{id}");
    return response.IsSuccessStatusCode;
  }
}

/// <summary>
/// Clase Program.
/// </summary>
public class Program
{
  /// <summary>
  /// Método Main.
  /// </summary>
  /// <returns></returns>
  public static async Task Main()
  {
    UserService userService = new UserService();

    // Obtener todos los usuarios.
    List<UserModel> users = await userService.GetUsers();
    foreach (UserModel user in users)
    {
      Console.WriteLine($"ID: {user.Id}, Nombre: {user.Name}, Email: {user.Email}");
    }

    // Obtener un usuario por su ID.
    int userId = 1;
    UserModel userById = await userService.GetUser(userId);
    Console.WriteLine($"ID: {userById.Id}, Nombre: {userById.Name}, Email: {userById.Email}");

    // Crear un nuevo usuario.
    UserModel newUser = new UserModel
    {
      Name = "John Doe",         
      Email = "johndoe@example.com"
      };
    UserModel createdUser = await userService.CreateUser(newUser);
    Console.WriteLine($"ID: {createdUser.Id}, Nombre: {createdUser.Name}, Email: {createdUser.Email}");

    // Actualizar un usuario existente.
    UserModel editUser = new UserModel
    {
      Id = 1,
      Name = "John Doe Smith",         
      Email = "johnsmith@example.com"
      };
    UserModel updatedUser = await userService.UpdateUser(1, editUser);
    Console.WriteLine($"ID: {updatedUser.Id}, Nombre: {updatedUser.Name}, Email: {updatedUser.Email}");

    // Eliminar un usuario.
    int userIdToDelete = 1;
    var hasDeleted = await userService.DeleteUser(userIdToDelete);
    if (hasDeleted)
    {
      Console.WriteLine($"El usuario con ID {userIdToDelete} ha sido eliminado");
    }
    else
    {
      Console.WriteLine($"El usuario con ID {userIdToDelete} no ha sido eliminado");
    }

    Console.WriteLine();
    Console.WriteLine("Presione cualquier tecla para salir...");
    Console.ReadKey();
  }
}