Gerar CPF em C#: Função com Testes xUnit

Para quem desenvolve em .NET, ter um gerador de CPF para testes embutido no código evita dependência de ferramentas externas durante a execução automatizada. A classe C# abaixo aplica o algoritmo de módulo 11 sobre nove dígitos aleatórios, com métodos estáticos para geração e validação.

Código

using System;
using System.Linq;
using System.Text.RegularExpressions;

public static class CPFGenerator
{
    private static readonly Random Rng = new Random();

    public static string Generate()
    {
        int[] digits = new int[11];

        for (int i = 0; i < 9; i++)
        {
            digits[i] = Rng.Next(10);
        }

        // Primeiro dígito verificador
        int sum = 0;
        for (int i = 0; i < 9; i++)
        {
            sum += digits[i] * (10 - i);
        }
        int r = sum % 11;
        digits[9] = r < 2 ? 0 : 11 - r;

        // Segundo dígito verificador
        sum = 0;
        for (int i = 0; i < 10; i++)
        {
            sum += digits[i] * (11 - i);
        }
        r = sum % 11;
        digits[10] = r < 2 ? 0 : 11 - r;

        return string.Join("", digits);
    }

    public static bool Validate(string cpf)
    {
        string cleaned = Regex.Replace(cpf, @"[^\d]", "");

        if (cleaned.Length != 11)
        {
            return false;
        }

        // Rejeita CPFs com todos os dígitos iguais
        if (cleaned.Distinct().Count() == 1)
        {
            return false;
        }

        int[] digits = cleaned.Select(c => c - '0').ToArray();

        // Verifica primeiro dígito
        int sum = 0;
        for (int i = 0; i < 9; i++)
        {
            sum += digits[i] * (10 - i);
        }
        int r = sum % 11;
        int expected = r < 2 ? 0 : 11 - r;
        if (digits[9] != expected)
        {
            return false;
        }

        // Verifica segundo dígito
        sum = 0;
        for (int i = 0; i < 10; i++)
        {
            sum += digits[i] * (11 - i);
        }
        r = sum % 11;
        expected = r < 2 ? 0 : 11 - r;
        return digits[10] == expected;
    }
}

Análise do código

O método Generate() cria um array de 11 inteiros e preenche as nove primeiras posições com dígitos aleatórios via Rng.Next(10). O primeiro dígito verificador é calculado somando cada dígito base multiplicado pelo peso correspondente (10 a 2), aplicando o módulo 11 sobre o total e convertendo o resto conforme a regra: se menor que 2 o verificador é zero, caso contrário é 11 menos o resto. O segundo verificador repete o processo incluindo o primeiro verificador recém-calculado, com pesos de 11 a 2.

O método Validate() faz o caminho inverso. Ele remove qualquer caractere não numérico com Regex.Replace, verifica se a string resultante tem exatamente 11 dígitos e rejeita sequências com todos os dígitos iguais (como 00000000000) usando LINQ Distinct(). Em seguida, converte cada caractere para inteiro e recalcula ambos os verificadores para compará-los com os fornecidos.

A escolha de string.Join("", digits) para montar o resultado aproveita a conversão implícita de int para string do C#, produzindo código conciso. A instância de Random é declarada como campo estático (readonly) para ser reutilizada entre chamadas, evitando a criação de novas instâncias com sementes duplicadas em execuções rápidas.

Uso

string cpf = CPFGenerator.Generate();
Console.WriteLine($"CPF gerado: {cpf}");
Console.WriteLine($"Válido: {CPFGenerator.Validate(cpf)}");

Testes

using Xunit;

public class CPFGeneratorTests
{
    [Fact]
    public void GeradoDeveTer11Digitos()
    {
        string cpf = CPFGenerator.Generate();
        Assert.Equal(11, cpf.Length);
        Assert.Matches(@"^\d{11}$", cpf);
    }

    [Fact]
    public void GeradoDeveSerValido()
    {
        string cpf = CPFGenerator.Generate();
        Assert.True(CPFGenerator.Validate(cpf));
    }

    [Fact]
    public void MultiplosGeradosDevemDiferir()
    {
        string cpf1 = CPFGenerator.Generate();
        string cpf2 = CPFGenerator.Generate();
        string cpf3 = CPFGenerator.Generate();
        Assert.False(cpf1 == cpf2 && cpf2 == cpf3,
            "Três CPFs gerados consecutivamente não devem ser todos iguais");
    }
}

O primeiro teste verifica que o CPF tem exatamente 11 caracteres e que todos são numéricos. O segundo confirma que o CPF gerado passa na validação. O terceiro gera três CPFs e assegura que nem todos são idênticos, detectando falhas na aleatoriedade.

Veja também como validar CPF em C# com exemplos detalhados, ou volte à página inicial para gerar CPFs online.