Validar CNPJ em C#

O CNPJ (Cadastro Nacional da Pessoa Jurídica) é um documento fundamental para empresas brasileiras, utilizado para identificá-las em diversas transações. A validação do CNPJ é importante para garantir que o número fornecido esteja correto e siga as regras estabelecidas. Neste post, vamos aprender como validar CNPJ em C#.

Estrutura do CNPJ

O CNPJ é composto por 14 dígitos, formatados na seguinte estrutura: XX.XXX.XXX/0001-XX. Os dois últimos dígitos são verificadores, calculados a partir dos 12 primeiros.

Passos para validar o CNPJ:

1. Verificar o comprimento do CNPJ: O CNPJ deve ter exatamente 14 dígitos.
   
   
2. Remover formatação: Eliminar os pontos, a barra 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 CNPJ em C# com o seguinte código:

using System;
using System.Linq;

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

        if (ValidarCNPJ(cnpj))
        {
            Console.WriteLine("CNPJ válido!");
        }
        else
        {
            Console.WriteLine("CNPJ inválido!");
        }
    }

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

        if (cnpj.Length != 14 || !cnpj.All(char.IsDigit))
            return false;

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

        // Calcular primeiro dígito verificador
        int[] pesos1 = { 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
        int soma1 = 0;
        for (int i = 0; i < 12; i++)
        {
            soma1 += int.Parse(cnpj[i].ToString()) * pesos1[i];
        }
        int primeiroDigitoVerificador = 11 - (soma1 % 11);
        if (primeiroDigitoVerificador >= 10)
            primeiroDigitoVerificador = 0;

        if (primeiroDigitoVerificador != int.Parse(cnpj[12].ToString()))
            return false;

        // Calcular segundo dígito verificador
        int[] pesos2 = { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
        int soma2 = 0;
        for (int i = 0; i < 13; i++)
        {
            soma2 += int.Parse(cnpj[i].ToString()) * pesos2[i];
        }
        int segundoDigitoVerificador = 11 - (soma2 % 11);
        if (segundoDigitoVerificador >= 10)
            segundoDigitoVerificador = 0;

        return segundoDigitoVerificador == int.Parse(cnpj[13].ToString());
    }
}

Explicação do código

1. Entrada do usuário: O código solicita que o usuário insira um número de CNPJ.
   
   
2. Remoção de formatação: Usamos Replace para remover os pontos, a barra e o hífen do CNPJ.
   
   
3. Verificação de comprimento: Checamos se o CNPJ tem 14 dígitos.
   
   
4. Verificação de dígitos iguais: É feita uma checagem para garantir que todos os dígitos não sejam iguais (exemplo: 00.000.000/0000-00).
   
   
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 CNPJ for válido e false caso contrário.

Outro exemplo prático

Validar os dados na aplicação antes de enviá-los ao SGBD é uma prática elementar que evita muitos transtornos e processamento na base de dados.

É uma prática de segurança que visa evitar inconsistências na base de dados e torna os softwares mais seguros e robustos.

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

public bool ValidaCNPJ(string cnpj) {

      int[] multiplicador1 = new int[12] { 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };
      int[] multiplicador2 = new int[13] { 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2 };

      int soma;
      int resto;
      string digito;
      string tempCnpj;

      cnpj = cnpj.Trim();
      cnpj = cnpj.Replace(".", "").Replace("-", "").Replace("/", "");

      if (cnpj.Length != 14)
          return false;

      tempCnpj = cnpj.Substring(0, 12);
      soma = 0;

      for (int i = 0; i < 12; i++)
          soma += int.Parse(tempCnpj[i].ToString()) * multiplicador1[i];
          resto = (soma % 11);

          if (resto < 2)
              resto = 0;
          else
              resto = 11 - resto;
          digito = resto.ToString();
          tempCnpj = tempCnpj + digito;
          soma = 0;

          for (int i = 0; i < 13; i++)
              soma += int.Parse(tempCnpj[i].ToString()) * multiplicador2[i];
              resto = (soma % 11);

          if (resto < 2)
              resto = 0;
          else
              resto = 11 - resto;
          digito = digito + resto.ToString();

          return cnpj.EndsWith(digito);
   }

A validação de CNPJ 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 CNPJ esteja correto é essencial para evitar problemas em registros e transações comerciais. Experimente implementar essa validação em seus projetos!

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

Tags: cnpj c#