Better use int.Parse or Convert.ToInt32

Question

Possible Duplicate:
Whats the main difference between int.Parse() and Convert.ToInt32

I would like to know what are PRO and CONS of using Convert.ToInt32 VS int.Parse.

Here an example of syntax I am using:

            int myPageSize = Convert.ToInt32(uxPageSizeUsersSelector.SelectedValue);

            int myPageSize = int.Parse(uxPageSizeUsersSelector.SelectedValue);

I also found out these articles, maybe they can help for a discussion:

Neither method isfaster than a custom int parse code, because in parse has to deal with spaces, - hyphones, new lines, etc. — bandybabboon, Aug 25 '14 at 10:07

score 28 · Accepted Answer · edited Feb 28 '15 at 11:35

Convert.ToInt32 is for dealing with any object that implements IConvertible and can be converted to an int. Also, Convert.ToInt32 returns 0 for null, while int.Parse throws a ArgumentNullException.

int.Parse is specifically for dealing with strings.

As it turns out, the string type's IConvertible implementation merely uses int.Parse in its ToInt32 method.

So effectively, if you call Convert.ToIn32 on a string, you are calling int.Parse, just with slightly more overhead (a couple more method calls).

This is true for any conversion from string to some primitive type (they all call Parse). So if you're dealing with strongly-typed string objects (e.g., you're parsing a text file), I'd recommend Parse, simply because it's more direct.

Converting arbitrary objects (returned to you by some external library, for instance) is the scenario where I'd opt for using the Convert class.

score 17 · Answer 2 · answered Oct 18 '10 at 15:11

There's not much difference. Here's a quote found on msdn.

Basically the Convert class makes it easier to convert between all the base types.

The Convert.ToInt32(String, IFormatProvider) underneath calls the Int32.Parse. So the only difference is that if a null string is passed to Convert it returns 0, whereas Int32.Parse throws an ArgumentNullException. MSDN

score 3 · Answer 3 · answered Oct 18 '10 at 15:10

3

I cannot answer based on performance, but my preferred method is always int.tryparse(mystring, out myint) as that gives a clean failure that you can test for in the program flow (rather than doing a try/catch).

answered Oct 18 '10 at 15:10

This really depends on what you want to do. If you really need the parsing to succeed, or you know that it is a valid representation of a number, it's totally valid to use int.Parse. What would you do when the TryParse fails in such a case? You would just throw another exception. – Pieter van Ginkel Oct 18 '10 at 16:25
2

In my use, *one* exception would be thrown, and that would be a meaningful exception to my application - in your usage, two or more exceptions would be thrown, the one or more thrown by the int.Parse and caught by you and the one you throw to add context to the errors passed back up. – Oct 19 '10 at 08:34

score 2 · Answer 4 · answered Oct 18 '10 at 15:09

The Convert interface is a more general purpose one. The net result should be the same though.

Internally, it just calls int.Parse:

public static int ToInt32(String value) {
    if (value == null)
        return 0;
    return Int32.Parse(value, CultureInfo.CurrentCulture);
}

Above code is from the reference source.

Better use int.Parse or Convert.ToInt32

4 Answers4