Best solution for an StringToInt function in C#

I were asked to do an StringToInt / Int.parse function on the white board in an job interview last week and did not perform very good but I came up with some sort of solution. Later when back home I made one in Visual Studion and I wonder if there are any better solution than mine below.

Have not bothred with any more error handling except checking that the string only contains digits.

        private int StrToInt(string tmpString)
    {
        int tmpResult = 0;

        System.Text.Encoding ascii = System.Text.Encoding.ASCII;
        byte[] tmpByte = ascii.GetBytes(tmpString);

        for (int i = 0; i <= tmpString.Length-1; i++)
        {
            // Check whatever the Character is an valid digit
            if (tmpByte[i] > 47 && tmpByte[i] <= 58)
开发者_Go百科                // Here I'm using the lenght-1 of the string to set the power and multiply this to the value
                tmpResult += (tmpByte[i] - 48) * ((int)Math.Pow(10, (tmpString.Length-i)-1));
            else
                throw new Exception("Non valid character in string");

        } 

        return tmpResult;
    }

I'll take a contrarian approach.

public int? ToInt(this string mightBeInt)
{
    int convertedInt;
    if (int.TryParse(mightBeInt, out convertedInt))
    {
        return convertedInt;
    }
    return null;
}

After being told that this wasn't the point of the question, I'd argue that the question tests C coding skills, not C#. I'd further argue that treating strings as arrays of characters is a very bad habit in .NET, because strings are unicode, and in any application that might be globalized, making any assumption at all about character representations will get you in trouble, sooner or later. Further, the framework already provides a conversion method, and it will be more efficient and reliable than anything a developer would toss off in such a hurry. It's always a bad idea to re-invent framework functionality.

Then I would point out that by writing an extension method, I've created a very useful extension to the string class, something that I would actually use in production code.

If that argument loses me the job, I probably wouldn't want to work there anyway.

EDIT: As a couple of people have pointed out, I missed the "out" keyword in TryParse. Fixed.

Converting to a byte array is unnecessary, because a string is already an array of chars. Also, magic numbers such as 48 should be avoided in favor of readable constants such as '0'. Here's how I'd do it:

int result = 0;
for (int i = str.Length - 1, factor = 1; i >= 0; i--, factor *= 10)
    result += (str[i] - '0') * factor;

For each character (starting from the end), add its numeric value times the correct power of 10 to the result. The power of 10 is calculated by multiplying it with 10 repeatedly, instead of unnecessarily using Math.Pow.

I think your solution is reasonably ok, but instead of doing math.pow, I would do:

tmpResult = 10 * tmpResult + (tmpByte[i] - 48);

Also, check the length against the length of tmpByte rather than tmpString. Not that it normally should matter, but it is rather odd to loop over one array while checking the length of another.

And, you could replace the for loop with a foreach statement.

If you want a simple non-framework using implementation, how 'bout this:

"1234".Aggregate(0, (s,c)=>  c-'0'+10*s)

...and a note that you'd better be sure that the string consists solely of decimal digits before using this method.

Alternately, use an int? as the aggregate value to deal with error handling:

"12x34".Aggregate((int?)0, (s,c)=>  c>='0'&&c<='9' ? c-'0'+10*s : null)

...this time with the note that empty strings evaluate to 0, which may not be most appropriate behavior - and no range checking or negative numbers are supported; both of which aren't hard to add but require unpretty looking wordy code :-).

Obviously, in practice you'd just use the built-in parsing methods. I actually use the following extension method and a bunch of nearly identical siblings in real projects:

public static int? ParseAsInt32(this string s, NumberStyles style, IFormatProvider provider) {
    int val;
    if (int.TryParse(s, style, provider, out val)) return val;
    else return null;
}

Though this could be expressed slightly shorter using the ternary ? : operator doing so would mean relying on side-effects within an expression, which isn't a boon to readability in my experience.

Just because i like Linq:

string t = "1234";
var result = t.Select((c, i) => (c - '0') * Math.Pow(10, t.Length - i - 1)).Sum();

I agree with Cyclon Cat, they probably want someone who will utilize existing functionality. But I would write the method a little bit different.

public int? ToInt(this string mightBeInt)
{
    int number = 0;
    if (Int32.TryParse(mightBeInt, out number))
        return number;
    return null;
}

Int32.TryParse does not allow properties to be given as out parameter.

I was asked this question over 9000 times on interviews :) This version is capable of handling negative numbers and handles other conditions very well:

public static int ToInt(string s)
{
    bool isNegative = false, gotAnyDigit = false;
    int result = 0;

    foreach (var ch in s ?? "")
    {
        if(ch == '-' && !(gotAnyDigit || isNegative))
        {
            isNegative = true;
        }
        else if(char.IsDigit(ch))
        {
            result = result*10 + (ch - '0');
            gotAnyDigit = true;
        }
        else
        {
            throw new ArgumentException("Not a number");
        }
    }

    if (!gotAnyDigit)
        throw new ArgumentException("Not a number");

    return isNegative ? -result : result;
}

and a couple of lazy tests:

    [TestFixture]
public class Tests
{
    [Test]
    public void CommonCases()
    {
        foreach (var sample in new[]
            {
                new {e = 123, s = "123"},
                new {e = 110, s = "000110"},
                new {e = -011000, s = "-011000"},
                new {e = 0, s = "0"},
                new {e = 1, s = "1"},
                new {e = -2, s = "-2"},
                new {e = -12223, s = "-12223"},
                new {e = int.MaxValue, s = int.MaxValue.ToString()},
                new {e = int.MinValue, s = int.MinValue.ToString()}
            })
        {
            Assert.AreEqual(sample.e, Impl.ToInt(sample.s));
        }
    }
    [Test]
    public void BadCases()
    {
        var samples = new[] { "1231a", null, "", "a", "-a", "-", "12-23", "--1" };
        var errCount = 0;

        foreach (var sample in samples)
        {
            try
            {
                Impl.ToInt(sample);
            }
            catch(ArgumentException)
            {
                errCount++;
            }
        }

        Assert.AreEqual(samples.Length, errCount);
    }
}