Como validar CPF em tempo real usando .NET e APIs REST

public static class CpfValidator
{
    public static bool ValidarDigitos(string cpf)
    {
    cpf = new string(cpf.Where(char.IsDigit).ToArray());

    if (cpf.Length != 11 || cpf.Distinct().Count() == 1)
    return false;

    int[] multiplicadores1 = { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
    int[] multiplicadores2 = { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };

    string tempCpf = cpf[..9];
    int soma = tempCpf.Select((c, i) => (c - '0') * multiplicadores1[i]).Sum();
    int resto = soma % 11;
    int digito1 = resto < 2 ? 0 : 11 - resto;

    tempCpf += digito1;
    soma = tempCpf.Select((c, i) => (c - '0') * multiplicadores2[i]).Sum();
    resto = soma % 11;
    int digito2 = resto < 2 ? 0 : 11 - resto;

    return cpf.EndsWith($"{digito1}{digito2}");
    }
}

public class ValidacaoCpfResult
{
    public bool FormatoValido { get; set; }
    public bool EncontradoNaBase { get; set; }
    public string? Nome { get; set; }
    public string? DataNascimento { get; set; }
    public string? Mensagem { get; set; }
}

public class CpfValidationService
{
    private readonly HttpClient _httpClient;

    public CpfValidationService(HttpClient httpClient)
    {
    _httpClient = httpClient;
    }

    public async Task<ValidacaoCpfResult> ValidarEmTempoRealAsync(string cpf)
    {
    var result = new ValidacaoCpfResult();

    if (!CpfValidator.ValidarDigitos(cpf))
    {
    result.Mensagem = "CPF com formato inválido";
    return result;
    }

    result.FormatoValido = true;

    try
    {
    var response = await _httpClient.GetAsync($"cpf/{cpf}");
    if (response.IsSuccessStatusCode)
    {
    var dados = await response.Content.ReadFromJsonAsync<CpfResponse>();
    if (dados is { Success: true })
    {
    result.EncontradoNaBase = true;
    result.Nome = dados.Data.Name;
    result.DataNascimento = dados.Data.BirthDate;
    result.Mensagem = "CPF válido e encontrado";
    }
    }
    else
    {
    result.Mensagem = "CPF válido, mas não encontrado na base";
    }
    }
    catch (Exception ex)
    {
    result.Mensagem = $"Erro na consulta: {ex.Message}";
    }

    return result;
    }
}

[ApiController]
[Route("api/[controller]")]
public class ValidacaoController : ControllerBase
{
    private readonly CpfValidationService _validationService;

    public ValidacaoController(CpfValidationService validationService)
    {
    _validationService = validationService;
    }

    [HttpGet("validar/{cpf}")]
    public async Task<IActionResult> Validar(string cpf)
    {
    var resultado = await _validationService.ValidarEmTempoRealAsync(cpf);
    return Ok(resultado);
    }
}

public class CachedCpfValidationService
{
    private readonly CpfValidationService _inner;
    private readonly IMemoryCache _cache;

    public CachedCpfValidationService(
    CpfValidationService inner,
    IMemoryCache cache)
    {
    _inner = inner;
    _cache = cache;
    }

    public async Task<ValidacaoCpfResult> ValidarAsync(string cpf)
    {
    var cacheKey = $"cpf_validacao_{cpf}";

    if (_cache.TryGetValue(cacheKey, out ValidacaoCpfResult? cached))
    return cached!;

    var resultado = await _inner.ValidarEmTempoRealAsync(cpf);

    var options = new MemoryCacheEntryOptions()
    .SetAbsoluteExpiration(TimeSpan.FromMinutes(10));

    _cache.Set(cacheKey, resultado, options);
    return resultado;
    }
}