Estava trabalhando em um projeto quando achei um algoritmo de validação de CPF desses que o pessoal pega em qualquer site fundo de quintal na net e claro que não funcionava direito!

Cansado disso hoje eu fiz o meu e ainda por cima deixei algumas horas rodando testes unitários em cima.

Ele valida até números de CPF que os algoritmos padrões não validam (os famosos “000.000.000-00″ até o “999.999.999-99″). Ele também valida números com ou sem a máscara (. e -).

Bom, ai vai ele em C# e VB.NET.

Esse funciona 100%

C#

/// <summary>
/// Algoritimo de Validação de CPF
/// </summary>
/// <param name="sourceCPF">CPF de Origem</param>
/// <returns></returns>
public bool ValidaCPF(string sourceCPF)
{
    // Pré-Verificação do Tamanho da String (Apenas para Performance)
    if (sourceCPF.Length != 14)
    {
        return false;
    }

    // Cria Objetos
    string clearCPF;
    int[] cpfArray;
    int totalDigitoI = 0;
    int totalDigitoII = 0;
    int modI;
    int modII;

    // Limpa o CPF
    clearCPF = sourceCPF.Trim(); // Elimina Espaços em Branco
    clearCPF = clearCPF.Replace("-", ""); // Remove Separador de Dígito Verificador
    clearCPF = clearCPF.Replace(".", ""); // Remove os Separadores das Casas

    // Verifica o Tamanho do Texto de Input
    if (clearCPF.Length != 11)
    {
        return false;
    }

    // Verifica os Patterns mais Comuns para CPF's Inválidos
    if (clearCPF.Equals("00000000000") ||
        clearCPF.Equals("11111111111") ||
        clearCPF.Equals("22222222222") ||
        clearCPF.Equals("33333333333") ||
        clearCPF.Equals("44444444444") ||
        clearCPF.Equals("55555555555") ||
        clearCPF.Equals("66666666666") ||
        clearCPF.Equals("77777777777") ||
        clearCPF.Equals("88888888888") ||
        clearCPF.Equals("99999999999"))
    {
        return false;
    }

    // Verifica se no Array Existe Apenas Números
    foreach (char c in clearCPF)
    {
        if (! char.IsNumber(c))
        {
            return false;
        }
    }

    // Converte o CPF em Array Numérico para Validar
    cpfArray = new int[11];
    for (int i = 0; i < clearCPF.Length; i++)
    {
        cpfArray[i] = int.Parse(clearCPF[i].ToString());
    }

    // Computa os Totais para os 2 Dígitos Verificadores
    for (int position = 0; position < cpfArray.Length - 2; position++)
    {
        totalDigitoI += cpfArray[position] * (10 - position);
        totalDigitoII += cpfArray[position] * (11 - position);
    }

    // Aplica Regras do Dígito 1
    modI = totalDigitoI % 11;
    if (modI < 2) { modI = 0; }
    else { modI = 11 - modI; }

    // Verifica o Digito 1
    if (cpfArray[9] != modI)
    {
        return false;
    }

    // Aplica o Peso para o Digito Verificador 2
    totalDigitoII += modI * 2;

    // Aplica Regras do Dígito Verificador 2
    modII = totalDigitoII % 11;
    if (modII < 2) { modII = 0; }
    else { modII = 11 - modII; }

    // Verifica o Digito 2
    if (cpfArray[10] != modII)
    {
        return false;
    }

    // CPF Válido!
    return true;
}

VB.NET

''' <summary>
''' Algoritimo de Validação de CPF
''' </summary>
''' <param name="sourceCPF">CPF de Origem</param>
''' <returns></returns>
Function ValidaCPF(ByVal sourceCPF As String) As Boolean

    ' Pré-Verificação do Tamanho da String (Apenas para Performance)
    If sourceCPF.Length <> 14 Then
        Return False
    End If

    ' Cria Objetos
    Dim clearCPF As String
    Dim cpfArray() As Integer
    Dim totalDigitoI As Integer = 0
    Dim totalDigitoII As Integer = 0
    Dim modI As Integer
    Dim modII As Integer

    ' Limpa o CPF
    clearCPF = sourceCPF.Trim() ' Elimina Espaços em Branco
    clearCPF = clearCPF.Replace("-", "") ' Remove Separador de Dígito Verificador
    clearCPF = clearCPF.Replace(".", "") ' Remove os Separadores das Casas

    ' Verifica o Tamanho do Texto de Input
    If clearCPF.Length <> 11 Then
        Return False
    End If

    ' Verifica os Patterns mais Comuns para CPF's Inválidos
    If (clearCPF.Equals("00000000000") Or _
        clearCPF.Equals("11111111111") Or _
        clearCPF.Equals("22222222222") Or _
        clearCPF.Equals("33333333333") Or _
        clearCPF.Equals("44444444444") Or _
        clearCPF.Equals("55555555555") Or _
        clearCPF.Equals("66666666666") Or _
        clearCPF.Equals("77777777777") Or _
        clearCPF.Equals("88888888888") Or _
        clearCPF.Equals("99999999999")) Then

        Return False
    End If

    ' Verifica se no Array Existe Apenas Números
    Dim c As Char
    For Each c In clearCPF
        If (Not Char.IsNumber(c)) Then
            Return False
        End If
    Next

    'Converte o CPF em Array Numérico para Validar
    ReDim cpfArray(10)
    For i As Integer = 0 To clearCPF.Length - 1
        cpfArray(i) = Integer.Parse(clearCPF(i).ToString())
    Next

    ' Computa os Totais para os 2 Dígitos Verificadores
    For position As Integer = 0 To cpfArray.Length - 3
        totalDigitoI += cpfArray(position) * (10 - position)
        totalDigitoII += cpfArray(position) * (11 - position)
    Next

    ' Aplica Regras do Dígito 1
    modI = totalDigitoI Mod 11
    If (modI < 2) Then
        modI = 0
    Else
        modI = 11 - modI
    End If

    ' Verifica o Digito 1
    If (cpfArray(9) <> modI) Then
        Return False
    End If

    ' Aplica o Peso para o Digito Verificador 2
    totalDigitoII += modI * 2

    ' Aplica Regras do Dígito Verificador 2
    modII = totalDigitoII Mod 11
    If (modII < 2) Then
        modII = 0
    Else
        modII = 11 - modII
    End If

    ' Verifica o Digito 2
    If (cpfArray(10) <> modII) Then
        Return False
    End If

    ' CPF Válido!
    Return True

End Function

Posts Relacionados:

1. Convertendo Caminhos Absolutos e URL’s Absolutas para Caminhos Relativos e URL’s Relativas
2. Compressão de (Compactar) Dados
3. Calculando CRC de Strings (Texto), Array’s e Arquivos
4. Configurando Data para Transmitir para WebServices
5. Abrindo Arquivos de Texto e Lendo Todo o Conteúdo
6. Ordenação de Listas (Coleções)
7. Converter um Array de Bytes para String e String para Array de Bytes