wie man einen String in einen Bool konvertiert

Ich habe eine string, die entweder "0" oder "1" sein kann, und es ist garantiert, dass es nichts anderes sein wird.

Die Frage ist also: Was ist die beste, einfachste und eleganteste Art, dies in eine umzuwandeln bool?

Ganz einfach:

bool b = str == "1";

Wenn Sie die spezifischen Anforderungen dieser Frage ignorieren und es nie eine gute Idee ist, einen String in einen Bool umzuwandeln , besteht eine Möglichkeit darin, die ToBoolean () -Methode für die Convert-Klasse zu verwenden:

bool val = Convert.ToBoolean("true");

oder eine Erweiterungsmethode, um das seltsame Mapping durchzuführen, das Sie ausführen:

public static class StringExtensions
{
    public static bool ToBoolean(this string value)
    {
        switch (value.ToLower())
        {
            case  "true":
                return true;
            case "t":
                return true;
            case "1":
                return true;
            case "0":
                return false;
            case "false":
                return false;
            case "f":
                return false;
            default:
                throw new InvalidCastException("You can't cast that value to a bool!");
        }
    }
}

Ich weiß, dass dies Ihre Frage nicht beantwortet, sondern nur anderen Menschen hilft. Wenn Sie versuchen, "wahre" oder "falsche" Zeichenfolgen in Boolesche Werte umzuwandeln:

Versuchen Sie Boolean.Parse

bool val = Boolean.Parse("true"); ==> true
bool val = Boolean.Parse("True"); ==> true
bool val = Boolean.Parse("TRUE"); ==> true
bool val = Boolean.Parse("False"); ==> false
bool val = Boolean.Parse("1"); ==> Exception!
bool val = Boolean.Parse("diffstring"); ==> Exception!

bool b = str.Equals("1")? true : false;

Oder noch besser, wie in einem Kommentar unten vorgeschlagen:

bool b = str.Equals("1");

Ich habe etwas etwas erweiterbarer gemacht, indem ich Mohammad Sepahvands Konzept huckepack genommen habe:

    public static bool ToBoolean(this string s)
    {
        string[] trueStrings = { "1", "y" , "yes" , "true" };
        string[] falseStrings = { "0", "n", "no", "false" };


        if (trueStrings.Contains(s, StringComparer.OrdinalIgnoreCase))
            return true;
        if (falseStrings.Contains(s, StringComparer.OrdinalIgnoreCase))
            return false;

        throw new InvalidCastException("only the following are supported for converting strings to boolean: " 
            + string.Join(",", trueStrings)
            + " and "
            + string.Join(",", falseStrings));
    }

Ich habe den folgenden Code verwendet, um einen String in einen Booleschen Wert zu konvertieren.

Convert.ToBoolean(Convert.ToInt32(myString));

Hier ist mein Versuch, die verzeihendste Konvertierung von Zeichenfolgen in Bools vorzunehmen, die immer noch nützlich ist, und im Grunde nur das erste Zeichen abzutasten.

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

    private static readonly ICollection<string> PositiveList = new Collection<string> { "Y", "Yes", "T", "True", "1", "OK" };

public static bool ToBoolean(this string input)
{
                return input != null && PositiveList.Any(λ => λ.Equals(input, StringComparison.OrdinalIgnoreCase));
}

Ich benutze das:

public static bool ToBoolean(this string input)
        {
            //Account for a string that does not need to be processed
            if (string.IsNullOrEmpty(input))
                return false;

            return (input.Trim().ToLower() == "true") || (input.Trim() == "1");
        }

Ich liebe Erweiterungsmethoden und diese verwende ich ...

static class StringHelpers
{
    public static bool ToBoolean(this String input, out bool output)
    {
        //Set the default return value
        output = false;

        //Account for a string that does not need to be processed
        if (input == null || input.Length < 1)
            return false;

        if ((input.Trim().ToLower() == "true") || (input.Trim() == "1"))
            output = true;
        else if ((input.Trim().ToLower() == "false") || (input.Trim() == "0"))
            output = false;
        else
            return false;

        //Return success
        return true;
    }
}

Um es dann zu benutzen, mache einfach so etwas wie ...

bool b;
bool myValue;
data = "1";
if (!data.ToBoolean(out b))
  throw new InvalidCastException("Could not cast to bool value from data '" + data + "'.");
else
  myValue = b;  //myValue is True

Wenn Sie testen möchten, ob eine Zeichenfolge ohne ausgelöste Ausnahmen ein gültiger Boolescher Wert ist, können Sie Folgendes versuchen:

    string stringToBool1 = "true";
    string stringToBool2 = "1";
    bool value1;
    if(bool.TryParse(stringToBool1, out value1))
    {
        MessageBox.Show(stringToBool1 + " is Boolean");
    }
    else
    {
        MessageBox.Show(stringToBool1 + " is not Boolean");
    }

Ausgabe is Boolean und die Ausgabe für stringToBool2 lautet: 'ist nicht boolesch'