¿Algún problema al declarar una variable y usar TryParse para inicializarla en la misma línea?

Question

Este ejemplo está en C# pero espero que pueda aplicarse a otros con la misma facilidad.

Recientemente he descubierto que la siguiente parece funcionar muy bien:

int i = Int32.TryParse(SomeString, out i) ? i : -1; 

De alguna manera, parece como si la variable i no debería ser técnicamente accesibles en el punto que aparece en TryParse. ¿O sería correcto suponer que int i declara efectivamente la variable, a pesar de que todavía no hay un final de declaración?

Answer 1

int i declara la variable, y usándola en el parámetro out la inicializa. Dado que el predicado debe evaluarse antes que el consecuente, i es tanto declarado como inicializado antes de su uso. (out parámetros deben ser asignados antes de regresar, por lo que definitivamente se inicializa en cualquier caso.)

Dicho esto, hay colegas míos que se verían afectados al ver algo así por motivos de estilo. :-)

EDIT: Después de estudiar cómo se ha agotado esto, propondré un par de posibles métodos alternativos de ayuda. La denominación de la clase estática actúa aquí como documentación de intención para los métodos auxiliares.

internal static class TryConvert 
{ 
    /// <summary> 
    /// Returns the integer result of parsing a string, or null. 
    /// </summary> 
    internal static int? ToNullableInt32(string toParse) 
    { 
     int result; 
     if (Int32.TryParse(toParse, out result)) return result; 
     return null; 
    } 

    /// <summary> 
    /// Returns the integer result of parsing a string, 
    /// or the supplied failure value if the parse fails. 
    /// </summary> 
    internal static int ToInt32(string toParse, int toReturnOnFailure) 
    { 
     // The nullable-result method sets up for a coalesce operator. 
     return ToNullableInt32(toParse) ?? toReturnOnFailure; 
    } 
} 

internal static class CallingCode 
{ 
    internal static void Example(string someString) 
    { 
     // Name your poison. :-) 
     int i = TryConvert.ToInt32(someString, -1); 
     int j = TryConvert.ToNullableInt32(someString) ?? -1; 

     // This avoids the issue of a sentinel value. 
     int? k = TryConvert.ToNullableInt32(someString); 
     if (k.HasValue) 
     { 
      // do something 
     } 
    } 
} 

Answer 2

Recientemente he descubierto que la siguiente parece funcionar muy bien

int i = Int32.TryParse(SomeString, out i) ? i : -1; 

Funciona, pero no está muy bien.

¿Algún problema al declarar una variable y usar TryParse para inicializarla en la misma línea?

Sí, legibilidad. Creo que esto se ve horrible, y está haciendo un doble trabajo.

---

Parte del problema es que desea -1 como predeterminado. Int32.TryParse define explícitamente 0 como el valor de salida cuando falla la conversión.

Aún así lo dividiría en 2 líneas por motivos de legibilidad.

int i; 
if (! int.TryParse(SomeString, out i)) i = -1; 

Y cuando se necesita mucho esto, escribir un método de ayuda (extensión estática pero no):

int i = Utils.ParseInt(SomeString, -1); 

Answer 3

Recuerde que no hay ningún operador ternario en CIL.

int i = Int32.TryParse(SomeString, out i) ? i : -1; 

Su código se transforma en CIL que representa el siguiente código C#:

int i; 
if (Int32.TryParse(SomeString, out i)) 
    i = i; 
else 
    i = -1; 

que está perfectamente bien.