O que faz ponto de interrogação e ponto operador? significa em C # 6.0?

Com o C # 6.0 na visualização do VS2015, temos um novo operador ?. , que pode ser usado assim:

 public class A { string PropertyOfA { get; set; } } ... var a = new A(); var foo = "bar"; if(a?.PropertyOfA != foo) { //somecode } 

o que exatamente isto faz?

É o operador condicional nulo . Basicamente significa:

“Avaliar o primeiro operando; caso seja nulo, pare, com resultado nulo. Caso contrário, avalie o segundo operando (como access de membro do primeiro operando).”

No seu exemplo, o ponto é que, se a é null , então a?.PropertyOfA será avaliado como null vez de lançar uma exceção – ele irá comparar essa referência null com foo (usando a sobrecarga == da cadeia), igual e execução irá para o corpo da instrução if .

Em outras palavras, é assim:

 string bar = (a == null ? null : a.PropertyOfA); if (bar != foo) { ... } 

… exceto que a só é avaliado uma vez.

Observe que isso também pode alterar o tipo da expressão. Por exemplo, considere FileInfo.Length . Isso é uma propriedade do tipo long , mas se você usá-lo com o operador condicional nulo, você acaba com uma expressão do tipo long? :

 FileInfo fi = ...; // fi could be null long? length = fi?.Length; // If fi is null, length will be null 

Pode ser muito útil ao nivelar uma hierarquia e / ou mapear objects. Ao invés de:

 if (Model.Model2 == null || Model.Model2.Model3 == null || Model.Model2.Model3.Model4 == null || Model.Model2.Model3.Model4.Name == null) { mapped.Name = "N/A" } else { mapped.Name = Model.Model2.Model3.Model4.Name; } 

Pode ser escrito como (mesma lógica acima)

 mapped.Name = Model.Model2?.Model3?.Model4?.Name ?? "N/A"; 

Exemplo de Trabalho DotNetFiddle.Net .

(o operador de coalescência nulo ou nulo é diferente do operador condicional nulo ou nulo ).

Também pode ser usado fora dos operadores de atribuição com Ação. Ao invés de

 Action myAction = null; if (myAction != null) { myAction(TValue); } 

Pode ser simplificado para:

 myAction?.Invoke(TValue); 

Exemplo de DotNetFiddle :

usando o sistema;

 public class Program { public static void Main() { Action consoleWrite = null; consoleWrite?.Invoke("Test 1"); consoleWrite = (s) => Console.WriteLine(s); consoleWrite?.Invoke("Test 2"); } } 

Resultado:

Teste 2

Isso é relativamente novo no C #, o que facilita a chamada das funções com relação aos valores nulos ou não nulos no encadeamento do método.

maneira antiga de conseguir a mesma coisa era:

 var functionCaller = this.member; if (functionCaller!= null) functionCaller.someFunction(var someParam); 

e agora ficou muito mais fácil com apenas:

 member?.someFunction(var someParam); 

Eu recomendo fortemente que você leia aqui:

https://docs.microsoft.com/pt-br/dotnet/csharp/language-reference/operators/null-conditional-operators