O que há de novo no C# 13: visão geral das novidades

Com o lançamento do C# 13, várias novidades e melhorias foram introduzidas. Neste artigo, vamos explorar algumas das mais interessantes.

---

Inicialização de Objetos Usando Índice “do Fim”

Um dos recursos mais fáceis de entender no C# 13 é a inicialização de objetos usando o operador de índice “do fim” (^). Antes, os índices podiam ser especificados apenas a partir do início da coleção, mas agora é possível referenciar posições começando do final.

var initialList = Enumerable.Range(1, 10);
var anotherList = new List<int>(initialList)
{
    [^1] = 15
};
Console.WriteLine(string.Join(" ", anotherList));
// Saída: 1 2 3 4 5 6 7 8 9 15

Isso facilita muito o trabalho com índices em coleções grandes, além de ser compatível com classes que sobrecarregam o operador de indexação para Index.

Propriedades e Indexadores Parciais

Agora, além de classes e métodos, o C# 13 permite que propriedades e indexadores sejam declarados parcialmente. Com isso, é possível separar declarações e implementações de maneira modular.

partial class TestCollection<T> : IEnumerable<T>
{
    public partial int Count { get; }
    public partial T this[Index index] { get; set; }
}

partial class TestCollection<T>
{
    public partial int Count => _items.Length;
    public partial T this[Index index]
    {
        get => _items[index];
        set => _items[index] = value;
    }
}

Esse recurso será especialmente útil para desenvolvedores que geram código automaticamente e que desejam organizar grandes classes com mais flexibilidade.

Coleções com o Modificador params

O C# 13 também permite o uso de coleções diretamente com o modificador params, eliminando a necessidade de converter coleções para arrays antes de passá-las como parâmetros.

void Check()
{
    ParamsMethod(1, 2, 3);
}

void ParamsMethod(params IEnumerable<int> values)
{
    // ....
}

Isso reduz a quantidade de código necessário e melhora a legibilidade, especialmente ao trabalhar com listas ou seleções de dados.

Atributo de Prioridade de Sobrecarga

O novo atributo OverloadResolutionPriorityAttribute permite definir uma prioridade entre métodos sobrecarregados, facilitando o controle sobre qual método deve ser chamado em casos de ambiguidade.

[OverloadResolutionPriority(1)]
void ParamsMethod(params Span<int> values) { /* ... */ }

void ParamsMethod(params ReadOnlySpan<int> values) { /* ... */ }

Essa funcionalidade é especialmente útil para desenvolvedores de APIs que querem guiar os usuários para métodos mais otimizados.

Nova Classe de Bloqueio (Lock)

Para melhorar a sincronização de threads, o C# 13 introduz a classe Lock, que substitui o uso de objetos para bloqueio de código e melhora a clareza do código.

class LockExample
{
    Lock _lock = new();

    void Do()
    {
        using (var scope = _lock.EnterScope())
        {
            // Código protegido
        }
    }
}

Além disso, Lock traz métodos como Enter(), TryEnter() e Exit(), assim como a propriedade IsHeldByCurrentThread.

Sequência de Escape

Um novo caractere de escape, \e, foi adicionado para simplificar o uso de escape de sequência, substituindo o antigo \x1b. Esse novo caractere previne erros que podem surgir quando valores hexadecimais são interpretados incorretamente.

Melhorias no Tipo Natural para Grupos de Métodos

O C# 13 aprimora a determinação de tipos aplicáveis em grupos de métodos, permitindo que o compilador descarte métodos incompatíveis mais facilmente. Embora técnico, essa melhoria ajuda a reduzir erros e simplifica o uso de métodos naturais.

ref struct e Herança de Interfaces

No C# 13, ref struct pode implementar interfaces, permitindo que tipos com alocação exclusiva na pilha herdem interfaces sem o risco de “boxing”.

interface IExample
{
    string Text { get; set; }
}

ref struct RefStructExample : IExample
{
    public string Text { get; set; }
}

Essa mudança ajuda a melhorar a segurança e a performance, especialmente em tipos como Span<T> e ReadOnlySpan<T>.

Conclusão

Com novas ferramentas e funcionalidades, o C# 13 oferece tanto melhorias incrementais quanto mudanças importantes. Essa versão é promissora para desenvolvedores que buscam desempenho e clareza em seus códigos. Fique atento a esses novos recursos para aproveitar ao máximo essa linguagem.