comment convertir une chaîne en booléen

J'ai un stringqui peut être "0" ou "1", et il est garanti que ce ne sera rien d'autre.

La question est donc: quelle est la meilleure façon, la plus simple et la plus élégante de convertir cela en un bool?

Très simple en effet:

bool b = str == "1";

En ignorant les besoins spécifiques de cette question, et bien que ce ne soit jamais une bonne idée de convertir une chaîne en booléen, une façon serait d'utiliser la méthode ToBoolean () sur la classe Convert:

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

ou une méthode d'extension pour faire tout mappage étrange que vous faites:

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!");
        }
    }
}

Je sais que cela ne répond pas à votre question, mais simplement pour aider d'autres personnes. Si vous essayez de convertir des chaînes "true" ou "false" en booléen:

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

Ou encore mieux, comme suggéré dans un commentaire ci-dessous:

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

J'ai fait quelque chose d'un peu plus extensible, en s'appuyant sur le concept de Mohammad Sepahvand:

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

J'ai utilisé le code ci-dessous pour convertir une chaîne en booléen.

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

Voici ma tentative de conversion de chaîne en booléen la plus indulgente qui soit toujours utile, en ne supprimant que le premier caractère.

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

J'utilise ceci:

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

J'adore les méthodes d'extension et c'est celle que j'utilise ...

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

Ensuite, pour l'utiliser, faites quelque chose comme ...

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

Si vous souhaitez tester si une chaîne est un booléen valide sans aucune exception levée, vous pouvez essayer ceci:

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

sortie is Boolean et la sortie pour stringToBool2 est: 'n'est pas booléen'