Considere o seguinte cenário típico:
if(myObject == null) {
myObject = new myClass();
}
Estou imaginando o que é pensado na seguinte substituição usando o operador coalescente-nulo:
myObject = myObject ?? new myClass();
Não tenho certeza se devo usar o segundo formulário. Parece uma taquigrafia legal, mas a myObject = myObject
construção no começo parece que pode ser um pouco de cheiro de código.
Isso é uma coisa razoável a se fazer ou existe uma taquigrafia melhor que estou perdendo? Ou talvez: "São três linhas, supere isso!"?
Edit: Como já foi mencionado, talvez chamar isso de cenário típico seja um exagero. Normalmente, encontro essa situação ao recuperar uma entidade de um banco de dados que possui uma propriedade do tipo de referência filho que ainda pode ou não ser preenchida:
myClass myObject = myClassService.getById(id);
myObject.myChildObject = myObject.myChildObject ?? new myChildClass();
MyClass
deve fornecer umpublic static readonly
membro de umEmpty
valor de seu tipo. VejaString.Empty
no MSDN .??=
operador?Respostas:
Eu uso o operador coalescente nulo o tempo todo. Eu gosto da concisão disso.
Acho que esse operador é de natureza semelhante ao operador ternário (A? B: C). É preciso um pouco de prática antes que a leitura seja uma segunda natureza, mas uma vez que você está acostumado a isso, sinto que a legibilidade melhora em relação às versões longhand.
Além disso, a situação que você descreve é apenas um cenário em que o operador é útil. Também é útil substituir construções como esta:
ou
com
fonte
myObject = myObject2 ?? myObject3
. O que estou pensando especificamente é usar o operador para definir um objeto para si mesmo, a menos que seja nulo.null
como uma comparação.Ele
?? operator
é chamado de operador de coalescência nula e é usado para definir um valor padrão para tipos de valor anulável ou tipos de referência. Retorna o operando esquerdo se o operando não for nulo; caso contrário, ele retornará o operando certo.myObject = myObject ?? new myObject();
-instantiate default value of object
Mais detalhes e amostra de código sobre o operador de coalescência nula - artigo do MSDN .
Se você verificar a
more than nullable
condição, como alternativa, poderá usar o operador ternário.Operador ternário
Você também pode olhar ?: Operator . É chamado de operador ternário ou condicional . O operador condicional (? :) retorna um dos dois valores, dependendo do valor de uma expressão booleana.
Um exemplo de código do MSDN -?: Operator (Referência de C #) :
fonte
myObject = (myObject == null) ? new myClass() : myObject
. Portanto, a menos que eu esteja perdendo um uso melhor do operador condicional, ele parece ter o mesmo "problema" de definir um objeto para si mesmo (se não for nulo) que o operador de coalescência nula - e é menos conciso.Não acho que esse cenário seja (ou pelo menos deveria ser) típico.
Se você deseja que o valor padrão de algum campo não seja
null
, defina-o no inicializador de campos:Ou, se a inicialização for mais complicada, defina-a no construtor.
Se você deseja criar
myClass
apenas quando realmente precisa (por exemplo, porque a criação demora muito), você pode usarLazy<T>
:(Isso chama o construtor padrão. Se a inicialização for mais complicada, passe o lambda que é criado
myClass
para oLazy<T>
construtor.)Para acessar o valor, use
myObject.Value
, que chamará a inicialização se esta for a primeira vez que você está acessandomyObject.Value
.fonte
Eu gosto especialmente de usar
??
em conjunto com parâmetros de método opcionais. Limito a necessidade de sobrecargas e garanto que a coisa tenha um valor.fonte