C# Academy · Aula

Restrições where

Restrinja parâmetros de tipo.

Restrições where é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

Por que existem restrições

Por padrão, um parâmetro de tipo T é tratado quase como object, portanto o compilador permite pouquíssimas operações com ele. As restrições, escritas com where, informam mais ao compilador sobre T.

Com esse conhecimento, você pode chamar métodos, criar instâncias ou comparar valores com segurança.

void Show<T>(T value) where T : IFormattable
{
    // now ToString(format, provider) is available
}

Restrições de interface

Uma restrição de interface exige que T implemente determinada interface. O corpo pode então chamar os membros dessa interface.

A seguir, where T : IComparable<T> garante a existência de um método CompareTo.

T Max<T>(T a, T b) where T : IComparable<T>
    => a.CompareTo(b) >= 0 ? a : b;

Restrições de classe base

Você pode exigir que T derive de uma classe base específica. Assim, os membros desse tipo base podem ser usados dentro do código genérico.

Isso é comum em estruturas de software nas quais todas as entidades compartilham um tipo base.

class Animal { public string Name = ""; }

string NameOf<T>(T a) where T : Animal => a.Name;

A restrição de classe

where T : class exige que T seja um tipo por referência. Isso permite atribuir null e verificar a igualdade entre referências.

Ela é comum em repositórios, memórias cache e qualquer estrutura que armazene referências anuláveis.

T? FindOrNull<T>(bool found, T value) where T : class
    => found ? value : null;

A restrição de estrutura

where T : struct exige que T seja um tipo de valor não anulável. Isso permite tratar T como um tipo de valor e usar T? como um tipo de valor anulável.

Ela é usada por auxiliares que funcionam apenas com números, enumerações ou estruturas pequenas.

T? AsNullable<T>(T value) where T : struct
    => value;

A restrição de construtor padrão

A restrição new() exige que T tenha um construtor público sem parâmetros. O corpo pode então escrever new T().

As fábricas e os pools de objetos dependem disso para criar instâncias de forma genérica.

using System;

class Program
{
    static T Make<T>() where T : new() => new T();

    static void Main()
    {
        var list = Make<System.Collections.Generic.List<int>>();
        Console.WriteLine(list.Count);
    }
}

Combinando restrições

Você pode aplicar várias restrições a um parâmetro. As regras de ordenação exigem class ou struct primeiro, depois a classe base, as interfaces e, por último, new().

As restrições são listadas após uma única cláusula where, separadas por vírgulas.

T Build<T>() where T : class, IComparable<T>, new()
    => new T();

Várias cláusulas where

Quando um método ou uma classe tem vários parâmetros de tipo, cada um recebe sua própria cláusula where. Elas são escritas uma após a outra.

Isso mantém claramente separadas as restrições de cada parâmetro.

TResult Convert<TInput, TResult>(TInput x)
    where TInput : class
    where TResult : new()
    => new TResult();

Um exemplo funcional de restrição

Este programa completo usa uma restrição IComparable<T> para encontrar o maior de dois valores, funcionando tanto com inteiros quanto com cadeias de caracteres.

A restrição é o que torna CompareTo permitido dentro do método.

using System;

class Program
{
    static T Max<T>(T a, T b) where T : IComparable<T>
        => a.CompareTo(b) >= 0 ? a : b;

    static void Main()
    {
        Console.WriteLine(Max(3, 9));
        Console.WriteLine(Max("apple", "pear"));
    }
}

As restrições de não anulável e não gerenciado

O C# mais recente adiciona outras restrições. where T : notnull proíbe tipos anuláveis, o que é útil para chaves de dicionários. where T : unmanaged limita T a tipos de valor cuja representação pode ser copiada diretamente, para uso em código de baixo nível.

Essas restrições reforçam a segurança em cenários especializados.

void Use<T>(T key) where T : notnull { }

unsafe void Raw<T>(T v) where T : unmanaged { }

As restrições habilitam recursos, não os limitam

Embora pareçam limitações, as restrições na verdade liberam recursos. Sem uma restrição, você mal consegue acessar T; com uma, obtém acesso aos seus membros.

Escolha a restrição mínima que permita o funcionamento do seu algoritmo, mantendo o parâmetro de tipo o mais flexível possível.

// No constraint: only object members available
string Name<T>(T x) => x.ToString();

Verificação rápida

Teste sua compreensão das restrições where.

Recapitulação

A cláusula where restringe os parâmetros de tipo: interface, classe base, class, struct, new(), notnull e unmanaged. Cada restrição libera operações específicas em T.

Ordene-as corretamente, use uma cláusula por parâmetro e escolha a restrição mínima de que seu algoritmo precisa.

Perguntas Frequentes

A aula “Restrições where” é grátis?

Sim — o texto completo de “Restrições where” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “Restrições where”?

Restrinja parâmetros de tipo. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Restrições where”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy