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 = myObjectconstruçã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();

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:

if (value != null)
{
    return value;
}
else
{ 
    return otherValue;
}

ou

return value != null ? value : otherValue;

com

return value ?? otherValue;

O que estou querendo saber especificamente é usar o operador para definir um objeto para si mesmo, a menos que seja nulo.

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 nullablecondiçã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 tipo anulável pode conter um valor ou pode ser indefinido. O ?? O operador define o valor padrão a ser retornado quando um tipo anulável é atribuído a um tipo não anulável. Se você tentar atribuir um tipo de valor anulável a um tipo de valor não anulável sem usar o ?? operador, você gerará um erro em tempo de compilação. Se você usar uma conversão e o tipo de valor anulável não estiver definido no momento, uma exceção InvalidOperationException será lançada.

Um exemplo de código do MSDN -?: Operator (Referência de C #) :

int? input = Convert.ToInt32(Console.ReadLine());
string classify;

// ?: conditional operator.
classify = (input.HasValue) ? ((input < 0) ? "negative" : "positive") : "undefined";

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:

myClass myObject = new myClass();

Ou, se a inicialização for mais complicada, defina-a no construtor.

Se você deseja criar myClassapenas quando realmente precisa (por exemplo, porque a criação demora muito), você pode usar Lazy<T>:

Lazy<myClass> myObject = new Lazy<myClass>();

(Isso chama o construtor padrão. Se a inicialização for mais complicada, passe o lambda que é criado myClasspara o Lazy<T>construtor.)

Para acessar o valor, use myObject.Value, que chamará a inicialização se esta for a primeira vez que você está acessando myObject.Value.

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.

public void DoSomething (MyClass thing1 = null) {
    thing1 = thing1 ?? new MyClass();
}