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

int.parse c#

Question

Este ejemplo está en C #, pero creo que podría aplicarse a otros con la misma facilidad.

Recientemente encontré que lo siguiente parece funcionar bien:

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

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

Answer 1

Recientemente encontré que lo siguiente parece funcionar bien

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

Funciona, pero no está 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 de tu problema es que quieres -1 como tu predeterminado. Int32.TryParse define explícitamente 0 como el valor de salida cuando falla la conversión.

Todavía lo dividiría en 2 líneas por motivos de legibilidad.

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

Y cuando lo necesite mucho, escriba un método auxiliar (estático pero no de extensión):

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

Answer 2

Recuerda que no hay 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 de C #:

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

Que está perfectamente bien.

Answer 3

int i declara la variable, y su uso en el parámetro out inicializa. Como el predicado debe evaluarse antes que el consecuente, i se declara y se inicializa antes de su uso. (Los parámetros de out deben asignarse antes de regresar, por lo que definitivamente se inicializa en cualquier caso).

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

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

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
        }
    }
}