long - unsigned short c#

Convert.ToBoolean falla con el valor "0"

Question

Estoy tratando de convertir el valor "0" ( System.String ) a su representación Boolean , como:

var myValue = Convert.ToBoolean("0"); // throwing an exception here

Miré la página de MSDN y en el bloque de muestra de código, encontré estas líneas:

ConvertToBoolean("0");
// ...
Unable to convert ''0'' to a Boolean.

En mi código, estoy convirtiendo de System.String a Boolean esta manera:

// will be OK, but ugly code
var myValue = Convert.ToBoolean(Convert.ToInt32("0"));

• ¿Hay alguna otra forma de convertir al tipo Boolean con un código tan desagradable?
• ¿Por qué ocurre una excepción? Debido a la conversión del tipo de referencia System.String al valor, escriba System.Boolean , pero System.Int32 también es un tipo de valor, ¿no es así?

Answer 1

Dado que en realidad se trata de seguir haciendo esas conversiones y demás, ¿qué tal un método de extensión?

public static class Extensions {
    public static bool ToBool(this string s) {
        return s == "0" ? false : true;
    }
}

y entonces lo usarías así:

"0".ToBool();

y ahora podría extender fácilmente este método para manejar aún más casos si quisiera.

Answer 2

Esto está sucediendo porque Convert.ToBoolean espera uno de los siguientes:

• "True" (String) = true
• "False" (String) = false
• 0 (tipo numérico; int, doble, flotante, etc.) = false
• Cualquier no- 0 (tipo numérico; ...) = true
• null = false

Cualquier otro valor no es válido para Boolean .

Ya tienes un enfoque limpio :

var myValue = Convert.ToBoolean(Convert.ToInt32("0"));

Editar: puede crear un método de extensión que manejará algunos de estos casos por usted, mientras oculta la fealdad de manejar la conversión.

Esta extensión proporciona una interpretación muy libre de Boolean :

• "True" (String) = true
• "False" (String) = false
• "0" (String) = false
• Cualquier otra cadena = true

Código:

public static class Extensions
{
    public static Boolean ToBoolean(this string str)
    {
        String cleanValue = (str ?? "").Trim();
        if (String.Equals(cleanValue, "False", StringComparison.OrdinalIgnoreCase))
            return false;
        return
            (String.Equals(cleanValue, "True", StringComparison.OrdinalIgnoreCase)) ||
            (cleanValue != "0");
    }
}

Alternativamente, si desea un enfoque más estricto, que sigue lo que el .NET Framework espera; entonces simplemente use declaraciones try/catch :

public static class Extensions
{
    public static Boolean ToBoolean(this string str)
    {
        try
        {
            return Convert.ToBoolean(str);
        }
        catch { }
        try
        {
            return Convert.ToBoolean(Convert.ToInt32(str));
        }
        catch { }
        return false;
    }
}

Aunque no es un enfoque limpio o bonito , pero garantiza más posibilidades de obtener el valor correcto. Y, la clase Extensions está escondida de su código de datos / negocio.

Al final, su código de conversión es relativamente simple de usar:

String myString = "1";
Boolean myBoolean = myString.ToBoolean();

Answer 3

Para que se produzca una conversión exitosa, el parámetro de valor debe ser Boolean.TrueString , una constante cuyo valor sea True , Boolean.FalseString , una constante cuyo valor sea False , o debe ser nulo. Al comparar el valor con Boolean.TrueString y Boolean.FalseString, el método ignora el caso así como el espacio en blanco inicial y final.

de MSDN

porque Convert.ToBoolean espera un valor verdadero si el valor no es cero; de lo contrario, falso. valor numérico y valor de String True o False .

Answer 4

Si sabes que sería un int, entonces puedes convertirlo a int y luego a bool. A continuación, intentará la conversión a bool intentando la cadena y luego intentando con el número.

public bool ToBoolean(string value)
{
  var boolValue = false;
  if (bool.TryParse(value, out boolValue ))
  {
    return boolValue;
  }

  var number = 0;
  int.TryParse(value, out number))
  return Convert.ToBoolean(number);
}

Answer 5

public static class BooleanParser
{
    public static bool SafeParse(string value)
    {
        var s = (value ?? "").Trim().ToLower();
        return s == "true" || s == "1";
    }
}

Answer 6

Aquí hay un analizador sintáctico que perdona al primer personaje:

public static class StringHelpers
{
    /// <summary>
    /// Convert string to boolean, in a forgiving way.
    /// </summary>
    /// <param name="stringVal">String that should either be "True", "False", "Yes", "No", "T", "F", "Y", "N", "1", "0"</param>
    /// <returns>If the trimmed string is any of the legal values that can be construed as "true", it returns true; False otherwise;</returns>
    public static bool ToBoolFuzzy(this string stringVal)
    {
        string normalizedString = (stringVal?.Trim() ?? "false").ToLowerInvariant();
        bool result = (normalizedString.StartsWith("y") 
            || normalizedString.StartsWith("t")
            || normalizedString.StartsWith("1"));
        return result;
    }
}

Answer 7

Lo suficientemente rápido y simple:

public static class Extensions
{
        static private List<string> trueSet = new List<string> { "true","1","yes","y" };

        public static Boolean ToBoolean(this string str)
        {
            try
            { return trueSet.Contains(str.ToLower()); }
            catch { return false; }
        }
}