C#: Evolução do Sistema de Tipos, Imutabilidade com Records e Pattern Matching

Desde sua concepção inicial no início dos anos 2000, o C# destacou-se por sua tipagem forte, robustez em ambientes corporativos e produtividade de desenvolvimento. No entanto, a linguagem não permaneceu estática: ao longo de mais de duas décadas de lançamentos contínuos, o C# incorporou os melhores conceitos da programação funcional, segurança estrita de ponteiros e otimizações de baixo nível, transformando-se em uma das linguagens mais expressivas e modernas da atualidade.

Essa evolução permitiu que desenvolvedores abandonassem o código redundante (boilerplate) e as antigas armadilhas de ponteiros nulos em favor de estruturas concisas, previsíveis e imutáveis por padrão.

Sistema de Tipos Nulos e Segurança em Tempo de Compilação

Um dos maiores problemas históricos em linguagens corporativas gerenciadas sempre foi a infame exceção de referência nula (NullReferenceException). O C# introduziu os Tipos de Referência Anuláveis (Nullable Reference Types), transformando o compilador em um verificador ativo de fluxo:

// 1. Variável não anulável: o compilador impede a atribuição de null
string nomeObrigatorio = "Murilo";

// 2. Variável explicitamente anulável usando o modificador '?'
string? apelidoOpcional = null;

// 3. Operador de coalescência nula (??) para fornecer valor padrão seguro
string nomeExibicao = apelidoOpcional ?? nomeObrigatorio;

// 4. Operador de navegação segura (?.) evita falhas em cadeia
int tamanho = apelidoOpcional?.Length ?? 0;

Essa disciplina obriga o desenvolvedor a declarar formalmente onde valores nulos são aceitáveis, capturando inconsistências durante a digitação no editor antes que qualquer linha seja executada em produção.

Imutabilidade Elegante com Records e Construtores Primários

Historicamente, criar um objeto imutável exigia dezenas de linhas de código: declarar campos privados somente leitura, escrever construtores repetitivos e sobrescrever manualmente métodos de igualdade (Equals), código hash (GetHashCode) e formatação textual (ToString).

Os Records (registros) simplificam essa criação para uma única declaração declarativa:

// Declaração posicional de um Record imutável com construtor primário
public record Endereco(string Logradouro, string Cidade, string Cep);

public record Cliente(Guid Id, string Nome, Endereco Localizacao);

// Uso prático
var end1 = new Endereco("Av. Paulista, 1000", "São Paulo", "01310-100");
var end2 = new Endereco("Av. Paulista, 1000", "São Paulo", "01310-100");

// A igualdade é estrutural baseada nos valores, e não no ponteiro de memória
bool saoIguais = (end1 == end2); // Retorna true!

// Mutação não-destrutiva com a cláusula 'with'
var end3 = end1 with { Logradouro = "Av. Paulista, 1050" };

A igualdade estrutural automática torna os records a escolha ideal para representar Value Objects em Domain-Driven Design e Data Transfer Objects (DTOs) em APIs, garantindo que os dados permaneçam inalterados durante seu trânsito entre camadas.

Comparativo de Estruturas: Class, Struct e Record

A linguagem oferece diferentes opções para acomodar perfis de memória e necessidades de mutabilidade:

Tipo	Local de Alocação	Semântica de Igualdade	Mutabilidade Típica	Cenário Recomendado
class	Heap (gerenciado por GC)	Referência (ponteiro de memória)	Mutável	Entidades de domínio com identidade e ciclo de vida
record class	Heap (gerenciado por GC)	Estrutural (valores das propriedades)	Imutável (init-only)	DTOs de APIs, eventos e Value Objects complexos
struct	Stack ou inline no container	Valor (cópia membro a membro)	Mutável	Tipos numéricos e primitivos ultraleves
readonly record struct	Stack ou inline no container	Estrutural (sem pressão no GC)	Imutável garantido	Coordenadas, métricas e IDs fortemente tipados

flowchart TD
    Inicio(["Definir nova estrutura de dados"]) --> PrecisaIdentidade{"Requer identidade e ciclo de vida próprio?"}
    PrecisaIdentidade -- "Sim (Entidade)" --> UsarClass["Usar 'class' convencional"]
    PrecisaIdentidade -- "Não (Baseado em Dados)" --> Memoria{"Tamanho pequeno e alta frequência de alocação?"}
    Memoria -- "Sim" --> UsarStruct["Usar 'readonly record struct' (Stack)"]
    Memoria -- "Não" --> UsarRecord["Usar 'record class' (Imutabilidade e igualdade estrutural)"]

Expressividade Máxima com Pattern Matching Avançado

O recurso de Pattern Matching do C# afasta a necessidade de cadeias excessivas de if/else e conversões explícitas de tipo (casts), permitindo inspecionar o formato, os tipos internos e as propriedades de um objeto de maneira concisa:

public abstract record Pagamento;
public record Boleto(decimal Valor, DateTime Vencimento, bool Pago) : Pagamento;
public record CartaoCredito(decimal Valor, int Parcelas, string Bandeira) : Pagamento;
public record Pix(decimal Valor, string Chave) : Pagamento;

// Expressão switch combinando verificação de tipos, propriedades e limites relacionais
public static string AnalisarTransacao(Pagamento pagamento) => pagamento switch
{
    // Padrão relacional combinado com propriedades
    CartaoCredito { Parcelas: > 6, Valor: > 5000m } c => 
        $"Alerta: Pagamento de alto valor com parcelamento longo ({c.Parcelas}x).",

    // Padrão de guarda usando 'when'
    Boleto b when !b.Pago && b.Vencimento < DateTime.UtcNow => 
        "Aviso: Boleto vencido e ainda não compensado.",

    // Padrão posicional direto
    Pix { Valor: <= 1000m } => 
        "Transação Pix de baixo risco aprovada instantaneamente.",

    // Padrão descartável padrão (default)
    _ => "Transação sujeita a análise de crédito manual."
};

Esse estilo declarativo mantém as regras de autorização de transações organizadas em uma única tela, facilitando revisões de código e manutenção evolutiva por especialistas de negócio.

Sintaxe Moderna e Recursos de Produtividade

O C# contemporâneo introduziu uma série de refinamentos para maximizar a legibilidade sem comprometer o rigor da tipagem estática:

• Literais Brutos de String (Raw String Literals): Permitem escrever blocos de texto multilinha (como JSON, SQL ou XML) delimitados por três aspas ("""), eliminando a necessidade de caracteres de escape para aspas internas ou barras invertidas.
• Detecção Segura de Estouro com Checked: Blocos checked garantem que cálculos matemáticos críticos (como transferências financeiras) disparem uma exceção de estouro (OverflowException) em vez de sofrerem truncamento silencioso de bits.
• Membros com Corpo de Expressão (Expression-Bodied Members): Reduzem métodos de linha única a expressões limpas utilizando a seta =>, melhorando a fluidez de leitura em serviços e repositórios.

A maturidade alcançada pelo C# consolida a linguagem como uma ferramenta extremamente versátil: ela oferece a velocidade de prototipação de linguagens dinâmicas com a segurança e a performance bruta de linguagens fortemente tipadas de nível de sistema.