Como validar CPF em C#

O CPF (Cadastro de Pessoa Física) é um documento essencial para cidadãos brasileiros, utilizado para identificar pessoas em diversas transações. A validação do CPF é importante para garantir que o número fornecido esteja correto e siga as regras estabelecidas. Neste post, vamos aprender como validar CPF em C#.

Estrutura do CPF

O CPF é composto por 11 dígitos, formatados na seguinte estrutura: XXX.XXX.XXX-XX. Os dois últimos dígitos são verificadores, calculados a partir dos 9 primeiros.

Passos para validar o CPF

1. Verificar o comprimento do CPF: O CPF deve ter exatamente 11 dígitos.
   
   
2. Remover formatação: Eliminar os pontos e o hífen para trabalhar apenas com os dígitos.
   
   
3. Calcular os dígitos verificadores: Usar um algoritmo específico para validar os dois últimos dígitos.

Implementação em C#

Vamos implementar a validação de CPF em C# com o seguinte código:

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        Console.Write("Digite o CPF: ");
        string cpf = Console.ReadLine();

        if (ValidarCPF(cpf))
        {
            Console.WriteLine("CPF válido!");
        }
        else
        {
            Console.WriteLine("CPF inválido!");
        }
    }

    static bool ValidarCPF(string cpf)
    {
        // Remover formatação e verificar comprimento
        cpf = cpf.Replace(".", "").Replace("-", "");

        if (cpf.Length != 11 || !cpf.All(char.IsDigit))
            return false;

        // Verificar se todos os dígitos são iguais
        if (new string(cpf[0], 11) == cpf)
            return false;

        // Calcular primeiro dígito verificador
        int soma = 0;
        for (int i = 0; i < 9; i++)
        {
            soma += int.Parse(cpf[i].ToString()) * (10 - i);
        }
        int primeiroDigitoVerificador = (soma * 10) % 11;
        if (primeiroDigitoVerificador == 10)
            primeiroDigitoVerificador = 0;

        if (primeiroDigitoVerificador != int.Parse(cpf[9].ToString()))
            return false;

        // Calcular segundo dígito verificador
        soma = 0;
        for (int i = 0; i < 10; i++)
        {
            soma += int.Parse(cpf[i].ToString()) * (11 - i);
        }
        int segundoDigitoVerificador = (soma * 10) % 11;
        if (segundoDigitoVerificador == 10)
            segundoDigitoVerificador = 0;

        return segundoDigitoVerificador == int.Parse(cpf[10].ToString());
    }
}

Explicação do código

1. Entrada do usuário: O código solicita que o usuário insira um número de CPF.
   
   
2. Remoção de formatação: Usamos Replace para remover os pontos e o hífen do CPF.
   
   
3. Verificação de comprimento: Checamos se o CPF tem 11 dígitos.
   
   
4. Verificação de dígitos iguais: É feita uma checagem para garantir que todos os dígitos não sejam iguais (exemplo: 111.111.111-11).
   
   
5. Cálculo dos dígitos verificadores: O algoritmo calcula os dois dígitos verificadores e os compara com os fornecidos.
   
   
6. Validação: Retorna true se o CPF for válido e false caso contrário.

Outro exemplo prático

O código abaixo é um outro método que valida o CPF digitado. Veja:

public bool validaCPF(string cpf) {

      int[] multiplicador1 = new int[9] { 10, 9, 8, 7, 6, 5, 4, 3, 2 };
      int[] multiplicador2 = new int[10] { 11, 10, 9, 8, 7, 6, 5, 4, 3, 2 };
      string tempCpf;
      string digito;
      int soma;
      int resto;

      cpf = cpf.Trim();
      cpf = cpf.Replace(".", "").Replace("-", "");
 
      if (cpf.Length != 11)
          return false;

     tempCpf = cpf.Substring(0, 9);
     soma = 0;

     for (int i = 0; i < 9; i++)
          soma += int.Parse(tempCpf[i].ToString()) * multiplicador1[i];

          resto = soma % 11;

          if (resto < 2)
              resto = 0;
          else
              resto = 11 - resto;

          digito = resto.ToString();

          tempCpf = tempCpf + digito;

          soma = 0;

          for (int i = 0; i < 10; i++)
                soma += int.Parse(tempCpf[i].ToString()) * multiplicador2[i];

          resto = soma % 11;
  
          if (resto < 2)
                resto = 0;
          else
                resto = 11 - resto;

          digito = digito + resto.ToString();

          return cpf.EndsWith(digito);
    }

A validação de CPF em C# é uma tarefa simples que pode ser feita com algumas verificações básicas e cálculos de dígitos verificadores.

Garantir que o CPF esteja correto é essencial para evitar problemas em registros e transações financeiras. Experimente implementar essa validação em seus projetos!

Dúvidas ou sugestões sobre como validar CPF em C#? Deixem nos comentários! Para mais dicas, acesse o nosso canal no YouTube:
 https://youtube.com/criandobits

Tags: cpf c#