¿Qué significa el signo de interrogación y el operador de puntos? significa en C#6.0?

operators c#-6.0

Question

Con C # 6.0 en la vista previa de VS2015 tenemos un nuevo operador, ?. , que se puede usar así:

public class A {
   string PropertyOfA { get; set; }
}

...

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

¿Qué hace exactamente?

Answer 1

Es el operador condicional nulo . Básicamente significa:

"Evalúe el primer operando; si es nulo, deténgase, con un resultado de nulo. De lo contrario, evalúe el segundo operando (como acceso de miembro del primer operando)".

En su ejemplo, el punto es que si a es null , entonces a?.PropertyOfA evaluará a null lugar de lanzar una excepción; luego comparará esa referencia null con foo (usando la cadena == sobrecarga), encontrará que no igual y la ejecución irá al cuerpo de la declaración if .

En otras palabras, es así:

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

... excepto que a solo se evalúa una vez.

Tenga en cuenta que esto también puede cambiar el tipo de expresión. Por ejemplo, considere FileInfo.Length . Esa es una propiedad de tipo long , pero si la usa con el operador condicional nulo, ¿termina con una expresión de tipo long? :

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

Answer 2

Esto es relativamente nuevo en C #, lo que nos facilita llamar las funciones con respecto a los valores nulos o no nulos en el encadenamiento de métodos.

La vieja forma de lograr lo mismo era:

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

y ahora se ha hecho mucho más fácil con solo:

member?.someFunction(var someParam);

Le recomiendo que lo lea aquí:

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/null-conditional-operators

Answer 3

Puede ser muy útil al acoplar una jerarquía y / o asignar objetos. En lugar 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;
}

Se puede escribir como (la misma lógica que la anterior)

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

DotNetFiddle.Net Ejemplo de trabajo .

(el operador ?? o nulo-coalescente es diferente al operador condicional? o nulo ).

También se puede usar fuera de los operadores de asignación con Action. En lugar de

Action<TValue> myAction = null;

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

Se puede simplificar para:

myAction?.Invoke(TValue);

Ejemplo de DotNetFiddle :

utilizando el sistema;

public class Program
{
  public static void Main()
  {
    Action<string> consoleWrite = null;

    consoleWrite?.Invoke("Test 1");

    consoleWrite = (s) => Console.WriteLine(s);

    consoleWrite?.Invoke("Test 2");
  }
}

Resultado:

Prueba 2