unmanaged, notnull, new() (emulação no C# 6)
O C# 6 oferece restrições class/struct/new(); emule notnull/unmanaged mais recentes por meio de verificações, do formato da API e de convenções.
unmanaged, notnull, new() (emulação no C# 6) é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.
Panorama das restrições
Objetivo: usar efetivamente as restrições genéricas do C# 6.
- classe versus estrutura
- criação sem parâmetros para criar sem um ativador
- simular não nulo/não gerenciado com guardas e projeto de API
classe versus estrutura
classe restringe T a tipos de referência; estrutura restringe T a tipos de valor. O uso incorreto falha em tempo de compilação.
using System;
// Works only for reference types
public static class RefBox
{
public static string Show<T>(T value) where T : class
{
return value == null ? "null ref" : "ref: " + value.ToString();
}
}
// Works only for value types
public static class ValBox
{
public static string Show<T>(T value) where T : struct
{
return "value: " + value.ToString();
}
}
public class Program
{
public static void Main(string[] args)
{
string s = "hello";
int n = 42;
Console.WriteLine(RefBox.Show<string>(s)); // OK
Console.WriteLine(ValBox.Show<int>(n)); // OK
// Console.WriteLine(RefBox.Show<int>(n)); // compile-time error (int is struct)
// Console.WriteLine(ValBox.Show<string>(s)); // compile-time error (string is class)
}
}
Criação sem parâmetros na prática
A restrição de criação garante um construtor público sem parâmetros, para que o código genérico possa instanciar T diretamente.
using System;
// Requires public parameterless ctor on T
public static class Factory
{
public static T Create<T>() where T : new()
{
return new T(); // safe in C# 6 with new()
}
}
public sealed class Sample
{
public string Name { get; set; }
public Sample() { Name = "default"; }
}
public class Program
{
public static void Main(string[] args)
{
Sample x = Factory.Create<Sample>();
Console.WriteLine("Created: " + x.Name);
}
}
Simulação de não nulo
Não existe não nulo no C# 6. Faça uma aproximação usando uma restrição que exija que T seja uma classe, além de guardas explícitas contra nulo dentro da API.
using System;
// C# 6 has no notnull constraint. Use where T : class and guard at runtime.
public static class NotNullApi
{
public static int LengthOf<T>(T x) where T : class
{
if (x == null) throw new ArgumentNullException("x");
return x.ToString().Length; // placeholder usage
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NotNullApi.LengthOf<string>("hi")); // 2
try
{
Console.WriteLine(NotNullApi.LengthOf<string>(null)); // throws
}
catch (Exception ex)
{
Console.WriteLine("Guard fired: " + ex.GetType().Name);
}
}
}
Simulação da intenção de não gerenciado
Não existe não gerenciado no C# 6. Pode usar estruturas e interfaces, por exemplo, IComparable, para direcionar o uso a tipos de valor semelhantes a tipos numéricos.
using System;
// No unmanaged constraint in C# 6.
// Use struct for value types and restrict API usage (document numeric-only intent).
public static class NumericOps
{
public static T Max<T>(T a, T b) where T : struct, IComparable
{
// Works for numeric primitives because they implement IComparable
return (a.CompareTo(b) >= 0) ? a : b;
}
}
public class Program
{
public static void Main(string[] args)
{
Console.WriteLine(NumericOps.Max<int>(3, 9)); // 9
Console.WriteLine(NumericOps.Max<double>(2.5, 2)); // 2.5
}
}
Dicas práticas
Dicas:
- Escolha classe/estrutura para restringir T desde cedo.
- Use a criação sem parâmetros se precisar criar T.
- Simule não nulo com guardas em tempo de execução.
- Simule não gerenciado por meio de estrutura e uso documentado, geralmente com tipos primitivos numéricos.
Restrição de construtor
Recapitulação
Recapitulação: use classe/estrutura/criação sem parâmetros no C# 6. Simule não nulo com verificações de nulo e a intenção de não gerenciado com limites de estrutura e interface.
Perguntas Frequentes
A aula “unmanaged, notnull, new() (emulação no C# 6)” é grátis?
Sim — o texto completo de “unmanaged, notnull, new() (emulação no C# 6)” é 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 3 aulas no total.
O que vou aprender em “unmanaged, notnull, new() (emulação no C# 6)”?
O C# 6 oferece restrições class/struct/new(); emule notnull/unmanaged mais recentes por meio de verificações, do formato da API e de convenções. 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 1 de 3.
Quanto tempo leva a aula “unmanaged, notnull, new() (emulação no C# 6)”?
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
- unmanaged, notnull, new() (emulação no C# 6)
- Matemática genérica (visão geral), atributos genéricos (quando relevante)
- Utilitários genéricos reutilizáveis