Outros podem não ser tão úteis e são poucos usados, mas podem fazer com que seu código fique mais simples e mais eficiente em cenários específicos.

Usando os operadores condicionais

O operador condicional (?:) ou operador ternário pode ser usado para substituir uma instrução if/else usado para atribuir valores:

Veja outro exemplo:

int x = 20, y = 10;

var resultado = x > y ? "x é maior que y" : "x é menor que ou igual a y";

Console.WriteLine(resultado);

Além disso podemos aninhar o operador em expressões condicionais. Exemplo:

int x = 20, y = 10;

string resultado = x > y ? "x é maior que y" : x < y ? 
                           "x é menor que y" : x == y ? 
                           "x é igual a y " : "Sem resultado";

Este operador é conveniente quando usado com expressões simples. Verificar se um valor é null é outro bom exemplo de seu uso:

nome = nome != null ? nome : "";

Neste  caso especial, o operador de coalescência nula (??) pode ser usado também:

nome = nome ?? "";

O operador de coalescência nula, ?? , retornará o valor do operando esquerdo se não for null; caso contrário, ele avaliará o operando direito e retornará seu resultado.

Ele não avaliará seu operando direito se o operando esquerdo for avaliado como não nulo.

Infelizmente, isso só funciona quando queremos usar diretamente o valor que está sendo verificado para o valor null. Se desejarmos acessar um de seus membros vamos precisar usar o operador condicional:

contador = lista != null ? lista.Count : 0 ;

Para simplificar esses casos, o operador condicional nulo (?.) ou 'operador Elvis' foi introduzido na versão 6.0 da linguagem C#.  Para acessar membros usamos ?. e para acessar elementos usamos ?[].

Exemplo :  a?.x  ou  a?[x]

• Se a for avaliado como nulo, o resultado de a?.x ou a?[x] será null;
   
• Se a for avaliado como não nulo, o resultado de a?.x ou a?[x] será igual ao resultado de a.x ou a [x], respectivamente.

Assim a expressão :

if (x != null)
      x.Executar();

pode ser substituída por x?.Executar()

A seguir temos um exemplo onde combinamos o operador ?. com o operador ?? :

contador = lista?.Count ?? 0; 

Se lista não for null retorna o número de itens da lista, se for null ele retorna o valor zero.

Este operador permite o acesso seguro aos membros. Se o valor do lado esquerdo for não nulo, ele acessa o
membro, caso contrário, ele retornará nulo, evitando a exceção NullReferenceException que seria lançada ao tentar acessar um membro de uma variável com valor nulo.

Seu uso não esta restrito a propriedades ele também trabalha com campos, métodos e até acesso ao índice.

Exemplo:

int? primeiroValor = lista?[0];

Se lista for null o resultado será null, caso contrário, vai retornar o primeiro elemento da lista.

Nota: int? significa um int anulável, ou seja, um int que pode ser um valor null. Sintaxe: Nullable<int>

O operador condicional nulo também é uma ótima opção para invocar os manipuladores de eventos com segurança.

Nas versões anteriores do C#, o manipulador de eventos precisava ser armazenado em uma variável local para ser seguro em cenários multithread (multiencadeados). Caso contrário, seu valor poderia ser alterado por outro segmento depois de ter sido verificado como nulo, mas antes de ser chamado, causando um exceção de Referência Nula.

Abaixo um exemplo de como isso era feito antes:

Este bloco de código agora pode ser substituído com um linha de código usando o operador condicional nulo:

A chamada ainda é segura para threads, ou seja, o código gerado avalia a variável apenas uma vez. isto mantém o resultado em uma variável temporária para que não possa ser alterada posteriormente.