Convert.ToBoolean and Boolean.Parse don't accept 0 and 1

0 and (not-zero) are not equal to "false" and "true", they're just the representation chosen by C. Other languages use 0 for true and -1 for false, or other schemes entirely. A boolean is not a 0 or a 1, it's a true or a false.

Should it also handle "yes" and "no", "off" and "on", and all of the myriad other things that are analogous to booleans? Where would you draw the line?

What makes booleans special? They are essentially 0 as false, and non-zero as true in my experience...

That is an implementation detail, and isn't at all relevant.

true is a boolean value. false is a boolean value. Anything else is not.

If you want to parse something such that the string "0" evaluates false while anything else evaluates true, you can use:

!mystr.Equals("0");

Unfortunately, this happens a lot in .NET. For example, I can't remember if it's XML Serializer or XmlConvert but one of them fails if the casing of True/False are not correct.

You can round trip through integer to get what you want.

string s = "2";
int i = Convert.ToInt32(s);
bool b = Convert.ToBoolean(i);

In the above case, anything non-zero will evaluate to true.

For this reason, I created a class I use all over called ConversionStrategy which takes into account the source type and destination type and chooses the most ideal (and flexible) conversion strategy for making the conversion.

You want Convert.ToBoolean(int value) not sure what's up with the Parse methods :-)

Code for no useful purpose:

        int falseInt = 0;
        int trueInt = 1;

        bool falseBool;
        bool trueBool;

        if (bool.TryParse(falseInt.ToString(), out falseBool))
        {
            if (!falseBool)
            {
                MessageBox.Show("TryParse: False");
            }
        }

        if (bool.TryParse(trueInt.ToString(), out trueBool))
        {
            if (!trueBool)
            {
                MessageBox.Show("TryParse: True");
            }
        }

        falseBool = Convert.ToBoolean(falseInt);
        trueBool = Convert.ToBoolean(trueInt);

        if (!falseBool)
        {
            MessageBox.Show("Convert: False");
        }

        if (trueBool)
        {
            MessageBox.Show("Convert: True");
        }

To answer the question would be hard. Maybe because the narrow minded developers at Microsoft had their own reasons? No disrespect intended to them. Just saying they did not think about what it would need to be used for or how it would be used. I can't think of a reason why my extension below would not work for anyone. I mean a Boolean value is either on or off, true or false. In my mind it's basically binary. Parse methods for Int, Double, Char, Long, Byte, etc are more forgiving with their Parse methods.

However, consider this; You are looking to see if a value exists in an object. The same might be said for the following...

string myvar = "empty"; //Or maybe = "NULL"
if (String.IsNullOrEmpty(myvar))
{
    //Should this be true?
}

Anyway, let's just make this simple. Here is my solution using an extension method to create a ToBoolean() method for a string.

using System.Linq;
public static bool ToBoolean(this string input)
{
    //Define the false keywords
    String[] bFalse = { "false", "0", "off", "no" };

    //Return false for any of the false keywords or an empty/null value
    if (String.IsNullOrEmpty(input) || bFalse.Contains(input.ToLower()))
        return false;

    //Return true for anything not false
    return true;
}