ToString anulável ()

Vejo em todos os lugares construções como:

int? myVar = null;
string test = myVar.HasValue ? myVar.Value.ToString() : string.Empty;

Por que não usar simplesmente:

string test = myVar.ToString();

Isso não é exatamente o mesmo? Pelo menos Reflector diz que:

public override string ToString()
{
  if (!this.HasValue)
  {
    return "";
  }
  return this.value.ToString();
}

Então, isso está correto (a versão mais curta) ou estou faltando alguma coisa?

Você está bem correto. Também nesta pergunta , a solução anterior é sugerida enquanto ninguém percebe que ToString()já dá a resposta correta.

Talvez o argumento para uma solução mais detalhada seja a legibilidade: quando você invoca ToString()algo que deveria ser null, geralmente espera um NullReferenceException, embora aqui não seja lançado.

Eu acho que muitas pessoas têm tais verificações, porque não é um comportamento natural de um objeto que pode conter valor nulo.

Não, você está correto, a versão mais curta é a mesma que outras pessoas fizeram a esse respeito. A outra construção que costumo usar muito, em vez do ternário com valores nulos, é o operador coalescente nulo. que também protege você de nulos. Para ToString () não é necessário (como você apontou), mas para valores int padrão (por exemplo) funciona bem, por exemplo:

int page = currentPage ?? 1;

que permite executar todas as operações inteiras na página sem a primeira verificação explícita nula e a chamada do valor em currentPage (onde currentPage é um int? talvez passado como um parâmetro)

Eu sei, muito depois que foi relevante, mas ... suspeito que seja porque para tipos anuláveis ​​como int? o método .ToString () não permite que você use seqüências de caracteres de formato. Consulte Como posso formatar um DateTime anulável com ToString ()? . Talvez no código original houvesse uma string de formato em .ToString () ou talvez o codificador tivesse esquecido que .ToString () sem a string de formato ainda estava disponível em tipos anuláveis.

pode ser que é apenas seguir o padrão? ou eles não conhecem o back-end. você está certo o código é exatamente o mesmo. você pode até fazer:

int? i = null;
i.ToString(); //No NullReferenceException

int?é o açúcar da sintaxe que simplifica a declaração da variável anulável. É o mesmo que Nullable<int>.

Portanto, se você der uma olhada na implementação do ToString()método para Nullable<T> (veja abaixo) , poderá notar que ele retorna uma string vazia, caso não tenha valor.

public struct Nullable<T> where T : struct
{
    public override string ToString()
    {
      if (!this.hasValue)
        return "";
      return this.value.ToString();
    }
}

O que o MSDN diz:

Método Nullable.ToString

Retorna a representação de texto do valor do objeto Nullable atual se a propriedade HasValue for verdadeira ou uma sequência vazia ("") se a propriedade HasValue for falsa.

Portanto, o código a seguir imprimirá uma string vazia no console, em vez de lançar uma ArgumentNullExceptionexceção.

static void Main(string[] args)
{
    int? a = null;
    Console.WriteLine(a.ToString()); // Prints empty string to console.
}