type - En C#, ¿hay una manera limpia de verificar múltiples niveles de referencias nulas?

validar null en c#

Question

Por ejemplo, si quiero llamar a lo siguiente: person.Head.Nose.Sniff() entonces, si quiero estar seguro, tengo que hacer lo siguiente:

if(person != null)
if(person.Head != null)
if(person.Head.Nose != null)
person.Head.Nose.Sniff();

¿Hay alguna forma más fácil de formular esta expresión?

Answer 1

¿Hay alguna forma más fácil de formular esta expresión?

Con C # 6, puedes usar el operador condicional nulo ? .

Ejemplo de código

Este es su código original empaquetado en un método y suponiendo que Sniff() siempre devuelve true :

 public bool PerformNullCheckVersion1(Person person)
{
if (person != null)
if (person.Head != null)
if (person.Head.Nose != null)
return person.Head.Nose.Sniff();
return false;
}

Este es su código reescrito con el operador condicional nulo C # 6:

 public bool PerformNullCheckVersion2(Person person)
{
return person?.Head?.Nose?.Sniff() ?? false;
}

El ?? es el operador de unión nula y no está relacionado con su pregunta.

Para ver el ejemplo completo, consulte: https://github.com/lernkurve/Stackoverflow-question-3701563

Answer 2

Aquí hay otra implementación a lo largo de las líneas de la también mencionada Validación de Parámetros Fluentes: cheques nulos encadenados y la mónada Tal vez

Answer 3

En realidad no, ademas

 if (person != null && person.Head != null && person.Head.Nose != null) 

Answer 4

La mejor forma es usar el operador && lugar de anidado if declaraciones:

if (person != null && person.Head != null && person.Head.Nose != null)
{
person.Head.Nose.Sniff();
}

Tenga en cuenta que técnicamente podría realizar una comprobación nula similar utilizando un árbol de expresiones . Tu método tendría una firma como esta:

static bool IsNotNull<T>(Expression<Func<T>> expression);

... lo que te permitiría escribir código buscando algo como esto:

if (IsNotNull(() => person.Head.Nose))
{
person.Head.Nose.Sniff();
}

Pero esto implicaría una reflexión y, en general, sería mucho más difícil de seguir de una manera profunda en comparación con el método && .

Answer 5

Me libraría de cualquier uso de null y haría algo como esto:

((Nose)person.BodyParts[BodyPart.Nose]).Sniff();

Esto requeriría algún tipo de class base o interface .

public abstract class BodyPart
{
public bool IsDecapitated { get; private set; }
public BodyPart(bool isDecapitated)
{
IsDecapitated = isDecapitated;
}
}

Answer 6

Podría usar objetos nulos en lugar de valores nulos. Sniff no haría nada si los objetos en la cadena de llamadas son objetos nulos.

Esto no arrojaría una excepción:

person.Head.Nose.Sniff(); 

Sus clases nulas podrían tener este aspecto (también puede usarlas como singletons y tener interfaces para IPerson , IHead e INose ):

class NullPerson : Person {
public override Head Head { get { return new NullHead(); }
}
class NullHead : Head {
public override Nose Nose { get { return new NullNose(); }
}
class NullNose : Nose {
public override void Sniff() { /* no-op */ }
}

Como nota al margen, en Oxygene hay un operator para esto:

person:Head:Nose:Sniff; 

Answer 7

Primero, puede aprovechar el cortocircuito en los operadores lógicos booleanos y hacer algo como:

if (person != null && person.Head != null && person.Head.Nose != null)
{
person.Head.Nose.Sniff();
}

También tenga en cuenta que lo que está haciendo va en contra de una guía de diseño para el desarrollo de software que se conoce como Ley de Demeter .

Answer 8

Puede utilizar la validación de parámetros fluidos