C# · CodeProject · Dotnet

String to Integer conversion Internals

Dear Reader,

Today i was thinking about ways to convert strings to integer (32 bit)  in C#. Yes of course you might think its a pretty well-known to every one right? Of course i agree. But most developers i see around do not known the hidden facts about these things and also do not know how to use them effectively.

Let me list out 3 of them here:

  1. Convert.ToInt32
  2. Int32.Parse
  3. Int32.TryParse

But i started to ask myself few questions:

  • When to choose each of those?
  • Why there are 3 ways?
  • Are there any difference between them?
  • Any performance gains?

Let me start off answering one by one above questions and the findings i could spot out.

  1. When to choose each of those?
    There is actually no explicit scenarios as when to choose each of them. Infact, as you already know you can choose TryParse method if you need a safe conversion i.e No exceptions being thrown. But other wise if you know the string value is just a number i.e string str = “1” then you can use any of 3 conversion methods. Although such scenarios are rarely to occur in real world problems. So the standard guidelines always suggests to use Tryparse method.
  2. Why there are 3 ways?
    Based on different requirements Microsoft created these 3 APIs for us to use. One of the requirement as already said above is safe conversion without needing to use Try-Catch-Finally at client side. And as per the name sake, Convert class is like a helper class which supports conversion for different types i.e Int, char, bool, double, etc. Where as Int structure is specific to Int only and it can’t be a helper type here. If in case your code is only dealing with string to integer conversions, then you don’t have to use Convert helper class, because at this point its a waste of memory for this static class,  but this design is very much hypothetical.
  3. Are there any difference between them?
    Yes there are few difference between them in their working actually. Looking at the IL for each of these APIs, i came to know few interesting things

    • Convert.Int32() first checks input value for null, if it is null then it returns 0
    • Convert.Int32() internally calls Int32.Parse() method
    • Int32.Parse() internally calls Number.ParseInt32() method.
    • Int32.Parse() does not check for null, since it directly calls Number.ParseInt32(), this method checks internally for null and throws ArgumentNullException.
    • Int32.TryParse() also does not directly check for null input, but instead it calls Number.TryParse() API which internally checks for null input and returns false if it is.
  4. Any performance gains?
    I have used the below code to do performance analysis:

    And the performance results i got is:

    As you can see, i have taken 5 output samples. It looks like Convert.ToInt32() method is performing much better here. But hold on, first this performance analysis is not accurate. The reason is that, 1) Convert.ToInt32 uses Int32.Parse method internally. 2) Due to extra checks for type safe conversions, TryParse() method is for sure known to be comparatively slow. 3) Since Convert.ToInt32 first checks for null input and then calls Int32.Parse method, so there is negligible delay in the performance figures.
    Hence considering all the above, points one need not really worry for performance factors in this case and rather focus on the benefits of each of these API as i already explained above.

So that’s all dear reader, i do hope you liked it.

Thanks 🙂

P.S: Your comments/votes are much appreciated.


Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s