C# Academy · Aula

Tipos de referência anuláveis (conscientização) e anotações (padrões do C# 6)

Tipos de referência anuláveis (conscientização) e anotações (padrões do C# 6) é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 3 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.

NRT e alternativa

Ideia: os tipos de referência anuláveis (por exemplo, string?) adicionam verificações do compilador nas versões mais recentes do C#.

O C# 6 não oferece suporte a string?
Use validações, documentação clara e auxiliares simples
Retorne valores não nulos por padrão

Proteção contra valores nulos

Adicione validações com ArgumentNullException para parâmetros de tipos de referência; depois, trate os valores como não nulos.

using System;

public static class Greeter
{
  // Contract: name must not be null (C# 6 has no string? to enforce)
  public static string Hello(string name)
  {
    if (name == null) throw new ArgumentNullException("name"); // guard
    return "Hello " + name.ToUpper(); // safe after guard
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Greeter.Hello("Ada"));
    try
    {
      Console.WriteLine(Greeter.Hello(null)); // will throw (by design)
    }
    catch (Exception ex)
    {
      Console.WriteLine("Caught: " + ex.GetType().Name);
    }
  }
}

Auxiliar Require.NotNull

Crie um pequeno auxiliar Require.NotNull para reduzir o código repetitivo e tornar a intenção evidente.

using System;

public static class Require
{
  // Works for reference types; returns the validated value
  public static T NotNull<T>(T value, string name) where T : class
  {
    if (value == null) throw new ArgumentNullException(name);
    return value;
  }
}

public sealed class Email
{
  public string Address { get; private set; }

  public Email(string address)
  {
    Address = Require.NotNull(address, "address").Trim();
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Email e = new Email("user@mail.com");
    Console.WriteLine(e.Address);
  }
}

Nullable<T> versus referências

Nullable<T> (por exemplo, int?) é usado para tipos de valor. Os tipos de referência já podem ser nulos; no C# 6, usamos validações.

using System;

public class Program
{
  public static void Main(string[] args)
  {
    int x = 5;              // value type (non-nullable)
    int? maybe = null;      // Nullable<T> works for value types
    Console.WriteLine("x=" + x);
    Console.WriteLine("maybe has value? " + maybe.HasValue);
    Console.WriteLine("maybe or default: " + (maybe ?? -1));
  }
}

Documentação dos contratos de nulidade

Declare a nulidade na documentação XML e seja consistente: os valores devem ser sempre não nulos ou a possibilidade de nulo deve ser documentada com clareza.

using System;

/// <summary>
/// Parses "key=value" and returns the value part.
/// Returns null if the format is invalid.
/// </summary>
public static class Parser
{
  // Explicitly document when null can be returned.
  public static string TryGetValue(string line)
  {
    if (line == null) throw new ArgumentNullException("line");
    int idx = line.IndexOf("=");
    if (idx < 0 || idx == line.Length - 1) return null; // documented nullable return
    return line.Substring(idx + 1);
  }
}

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Parser.TryGetValue("a=1"));
    Console.WriteLine(Parser.TryGetValue("oops")); // prints nothing (null)
  }
}

Lista de verificação de segurança contra nulos (C# 6)

Lista de verificação:

Valide as entradas com ArgumentNullException.
Retorne valores não nulos por padrão; documente todos os retornos que possam ser nulos.
Use pequenos auxiliares (Require.NotNull) para manter o código organizado.
Quando fizer sentido, prefira sobrecargas que evitem valores nulos (por exemplo, uma string vazia em vez de nulo).

Segurança contra nulos no C# 6

Verificação rápida: no C# 6 (sem tipos de referência anuláveis), qual é uma boa prática para reduzir erros relacionados a nulos em APIs públicas?

Recapitulação

Recapitulação: os NRTs são um recurso mais recente. No C# 6, mantenha a segurança usando validações, documentação clara, métodos auxiliares e contratos previsíveis de retorno não nulo.

Perguntas Frequentes

A aula “Tipos de referência anuláveis (conscientização) e anotações (padrões do C# 6)” é grátis?

Sim — o texto completo de “Tipos de referência anuláveis (conscientização) e anotações (padrões do 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 “Tipos de referência anuláveis (conscientização) e anotações (padrões do C# 6)”?

O C# 6 não possui tipos de referência anuláveis (string?). Aprenda a tratar nulos com segurança: verificações de entrada, documentação clara, o auxiliar Require.NotNull e a comparação com Nullable pa… 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 3.

Quanto tempo leva a aula “Tipos de referência anuláveis (conscientização) e anotações (padrões do 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

Métodos/tipos genéricos e restrições
Variância (in/out) com interfaces e delegados
Tipos de referência anuláveis (conscientização) e anotações (padrões do C# 6)

← Voltar para C# Academy