If I have a variable that pulls a string of true or false from the DB,
which would be the preferred way of checking its value?
string value = "false";
if(Boolean.Parse(value)){
DoStuff();
}
I know there are different ways of parsing to bool - this is an example
or
string value = "false";
if(value == "true"){
DoStuff();
}
I am pulling a lot of true/false values from the DB in string format, and want to know if these methods make any performance difference at all?
Use Boolean.TryParse:
string value = "false";
Boolean parsedValue;
if (Boolean.TryParse(value, out parsedValue))
{
if (parsedValue)
{
// do stuff
}
else
{
// do other stuff
}
}
else
{
// unable to parse
}
TryParse returns true if the conversion was successful, false if it was unable to parse.bool parsed = Boolean.TryParse(stringToParse, out parsedValue) && parsedValue;The only issue I can see here is that C# does case sensitive comparisons, so if the database value was "True"
(value == "true")
would return false.
But looking at the example Boolean.Parse Method
string[] values = { null, String.Empty, "True", "False",
"true", "false", " true ", "0",
"1", "-1", "string" };
foreach (var value in values) {
try {
bool flag = Boolean.Parse(value);
Console.WriteLine("'{0}' --> {1}", value, flag);
}
catch (ArgumentException) {
Console.WriteLine("Cannot parse a null string.");
}
catch (FormatException) {
Console.WriteLine("Cannot parse '{0}'.", value);
}
}
// The example displays the following output:
// Cannot parse a null string.
// Cannot parse ''.
// 'True' --> True
// 'False' --> False
// 'true' --> True
// 'false' --> False
// ' true ' --> True
// Cannot parse '0'.
// Cannot parse '1'.
// Cannot parse '-1'.
// Cannot parse 'string'.
Bool.Parse seems a little bit more robust.
Boolean.TryParse() (see my answer) but if you're going to compare strings, you should use string.Equals() instead of ==. That was my point.
== operator just calls string.Equals(), why do you think you should use that instead? Would the same apply to using int.Equals() instead of ==?string and therefore polymorphic differences do not apply. Thus, when using a string, Equals() and == are precisely the same.I would always parse it - your application should be robust against invalid values (even if you "know" your database will always be valid):
bool myVal;
if (!Boolean.TryParse(value, out myVal))
{
throw new InvalidCastException(...); // Or do something else
}
For sure use Boolean.TryParse(), you will avoid case-sensitive issues that can pop up.
In C# 7.0+ you can use inline variable declaration.
string value = "false";
if (bool.TryParse(value, out bool parsedValue))
{
if (parsedValue)
{
// do stuff
}
else
{
// do other stuff
}
}
else
{
// unable to parse
}
When asking for performance the version without parsing will probably be the faster one. But as others already suggested i also would prefer the parsing solution.
If you know the string will be a valid "true" or "false" string your first method is prefered.
Otherwise, you could use Boolean.TryParse
string value = "your text"
bool outresult = false;
bool resultado = false;
resultado = bool.TryParse(value, out outresult);
The try parse function will try to convert the value of the string to boolean, if it can not return the value of the variable outresult.
