Parse to Boolean or check String Value

Question

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?

Either method is fine but many developers will prefer Bool.TryParse(). The second method is a string comparison which will be slightly slower, o(n^2) — Gusdor, Aug 20 '13 at 07:15

score 44 · Accepted Answer · answered Aug 20 '13 at 07:17

44

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
}

answered Aug 20 '13 at 07:17

ProgramFOX

6,131
11
45
51

Should the original if/else not be a try/catch ? – TheGeekZn Aug 20 '13 at 07:18
2

@NewAmbition: No, because `TryParse` returns true if the conversion was successful, false if it was unable to parse. – ProgramFOX Aug 20 '13 at 07:19
13

A shorthand alternative would be `bool parsed = Boolean.TryParse(stringToParse, out parsedValue) && parsedValue;` – TheGeekZn Aug 20 '13 at 07:30
2

@NewAmbition: Yes, it would be an alternative. But, if you use your alternative, you wouldn't be able to find out whether the conversion was successful. It would just return false if the conversion would be unsuccessful. If you use my code, you're able to find out whether the conversion was successful. – ProgramFOX Aug 20 '13 at 07:31
1

Well, if the conversion was unsuccessful, it would return false. I'm not trying to argue your point at all, but if a person just wants to get the result, you can do it with that ;) Your version allows the user to do 'whatever' after trying to convert. – TheGeekZn Aug 20 '13 at 07:35

score 7 · Answer 2 · answered Aug 20 '13 at 07:15

7

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.

answered Aug 20 '13 at 07:15

Adriaan Stander

162,879
31
289
284

You should probably use string.Equals() – Sam Leach Aug 20 '13 at 07:17
@SamLeach - I dont think that was the point of the exercise.. Secondly, should you not use TryParse in this case (Judging by the other answers?) – TheGeekZn Aug 20 '13 at 07:24
1

You should definitely use `Boolean.TryParse()` (see my answer) but if you're going to compare strings, you should use `string.Equals()` instead of `==`. That was my point. – Sam Leach Aug 20 '13 at 07:33
1

@SamLeach Since string's `==` operator just calls `string.Equals()`, why do you think you should use that instead? Would the same apply to using `int.Equals()` instead of `==`? – Matthew Watson Aug 20 '13 at 08:04
Jon Skeet says otherwise http://stackoverflow.com/questions/3678792/are-string-equals-and-operator-really-same – Sam Leach Aug 20 '13 at 08:07
1

@SamLeach We are not using an object in this example; we are using a `string` and therefore polymorphic differences do not apply. Thus, when using a `string`, `Equals()` and `==` are precisely the same. – Matthew Watson Aug 20 '13 at 10:00

score 4 · Answer 3 · answered Aug 20 '13 at 07:16

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
}

Tobia Zambon · Answer 4 · 2013-08-20T07:26:54.133

2

For sure use Boolean.TryParse(), you will avoid case-sensitive issues that can pop up.

edited Aug 20 '13 at 07:26

answered Aug 20 '13 at 07:16

Tobia Zambon

7,479
3
37
69

4

Case-sensitivity I can see - but cultural issues? – Jon Skeet Aug 20 '13 at 07:19
1

@JonSkeet you are right, I was confused with my personal extension method that avoids cultural issues parsing boolean. Sometimes values can come up "translated" in the system culture (for example *Vero*-*Falso* in italian) depending on how they was written. I've updated the answer. – Tobia Zambon Aug 20 '13 at 07:26

score 1 · Answer 5 · answered Aug 20 '13 at 07:17

1

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.

answered Aug 20 '13 at 07:17

LunicLynx

939
1
8
16

score 0 · Answer 6 · answered Aug 20 '13 at 07:16

0

If you know the string will be a valid "true" or "false" string your first method is prefered.

Otherwise, you could use Boolean.TryParse

answered Aug 20 '13 at 07:16

Sam Leach

12,746
9
45
73

score 0 · Answer 7 · answered Jun 18 '21 at 21:57

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
}

Anderson Costa · Answer 8 · 2018-05-30T13:50:30.930

-1

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.

edited May 30 '18 at 13:50

answered Feb 09 '18 at 12:56

Anderson Costa

79
1
4

1

This does not answer the question that was asked. Also please post to StackOverflow using English. – LordWilmore Feb 09 '18 at 13:19

Parse to Boolean or check String Value

8 Answers8

Linked