taquigrafia - Taquigrafía para anular la comprobación nula C#

taquigrafia pitman dictado

Question

Por lo que sé, no hay una forma significativamente más elegante de escribir lo siguiente ...

string src;
if((ParentContent!= null)
    &&(ParentContent.Image("thumbnail") != null)
    &&(ParentContent.Image("thumbnail").Property("src") != null))
    src = ParentContent.Image("thumbnail").Property("src").Value

¿Crees que debería haber una función de lenguaje C # para hacer esto más corto?
Y si es así, ¿qué aspecto debería tener?
por ejemplo, algo así como extender el ?? operador

string src = ParentContent??.Image("thumbnail")??.Property("src")??.Value;

Disculpas por el ejemplo más bien artificial, y mi solución demasiado simplificada.

Editar ... Muchos años después
Esta es ahora una función de lenguaje planificada llamada " Operador de propagación nula " ?. https://roslyn.codeplex.com/discussions/540883 (Gracias @Brian)

Answer 1

Corríjame, si estoy equivocado, pero esto podría resolverse utilizando el operador condicional nulo de C # 6.0:

string src = ParentContent?.Image("thumbnail")?.Property("src")?.Value;

Si src ya está en uso antes de esta asignación de valor, puede usarlo de la siguiente manera:

string src = ....;

// ...

src = ParentContent?.Image("thumbnail")?.Property("src")?.Value ?? src;

// ...

Answer 2

Ha sido sugerido y aparentemente rechazado por el equipo:

Un poco más de azúcar sintáctica C # para nulos.

La sintaxis propuesta hubiera parecido a.?b.?c() - muy útil e inequívoca.

Realmente me gustaría verlo también, pero no parece que vaya a suceder. ¡Tal vez si suficientes personas lo votan!

Answer 3

Lo consideramos para C # 4 pero no teníamos el presupuesto. Es una buena característica que muchas personas solicitan, así que quizás la incorporemos en una futura versión de lenguaje hipotético. Sin promesas.

Answer 4

No hay una sintaxis incorporada para hacer esto, pero puede definir un método de extensión para hacer esto:

R NotNull<T, R>(this T src, Func<T, R> f) 
    where T : class where R : class {
  return src != null ? f(src) : null;
}

Ahora, puede volver a escribir su ejemplo de la siguiente manera:

src = ParentContent.NotNull(p => p.Image("thumbnail")).
        NotNull(i => i.Property("src")).NotNull(src => src.Value);

No es tan bueno como puede ser con un soporte sintáctico, pero diría que es mucho más legible.

Tenga en cuenta que esto agrega el método NotNull a todos los tipos .NET, lo que puede ser un poco inconveniente. Puede resolverlo definiendo un tipo de envoltura simple WrapNull<T> where T : class contenga solo un valor de tipo T y un método para convertir cualquier tipo de referencia en WrapNull y proporcionar NotNull en el tipo WrapNull . Entonces el código se vería así:

src = WrapNull.Wrap(ParentContent).NotNull(p => p.Image("thumbnail")).
        NotNull(i => i.Property("src")).NotNull(src => src.Value);

(Para no contaminar el IntelliSense de cada tipo con el nuevo método de extensión)

Con un poco más de esfuerzo, también podría definir un operador de consulta LINQ para hacer esto. Esto es un poco excesivo, pero es posible escribirlo (no incluiré las definiciones aquí ya que son un poco más largas, pero es posible en caso de que alguien esté interesado :-)).

src = from p in WrapNull.Wrap(ParentContent)
      from i in p.Image("thumbnail").
      from src in i.Property("src")
      select src.Value;

Answer 5

Todavía deja un poco que desear pero lo escribiría así:

var src = ParentContent == null ? null
    : ParentContent.Image("thumbnail") == null ? null
    : ParentContent.Image("thumbnail").Property("src") == null ? null
    : ParentContent.Image("thumbnail").Property("src").Value;