Was ist der Hauptunterschied zwischen int.Parse() und Convert.ToInt32

Question

• Was ist der Hauptunterschied zwischen int.Parse() y Convert.ToInt32() ?
• Welches ist zu bevorzugen?

Answer 1

• Wenn Sie eine Zeichenkette haben und erwarten, dass sie immer eine Ganzzahl ist (z. B. wenn ein Webdienst Ihnen eine Ganzzahl im Zeichenkettenformat übergibt), verwenden Sie Int32.Parse() .

• Wenn Sie Eingaben von einem Benutzer sammeln, verwenden Sie normalerweise Int32.TryParse() da es Ihnen eine feinere Kontrolle über die Situation ermöglicht, wenn der Benutzer ungültige Eingaben macht.

• Convert.ToInt32() nimmt ein Objekt als Argument. (Siehe die Antwort von Chris S., wie es funktioniert)

  Convert.ToInt32() wirft auch nicht ArgumentNullException wenn sein Argument null ist, so wie Int32.Parse() tut. Das bedeutet auch, dass Convert.ToInt32() ist wahrscheinlich ein bisschen langsamer als Int32.Parse() In der Praxis werden Sie dies jedoch nie bemerken, es sei denn, Sie führen eine sehr große Anzahl von Iterationen in einer Schleife durch.

Answer 2

Schauen Sie im Reflektor nach:

int.Parse("32"):

public static int Parse(string s)
{
    return System.Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}

was ein Aufruf zu ist:

internal static unsafe int ParseInt32(string s, NumberStyles style, NumberFormatInfo info)
{
    byte* stackBuffer = stackalloc byte[1 * 0x72];
    NumberBuffer number = new NumberBuffer(stackBuffer);
    int num = 0;
    StringToNumber(s, style, ref number, info, false);
    if ((style & NumberStyles.AllowHexSpecifier) != NumberStyles.None)
    {
        if (!HexNumberToInt32(ref number, ref num))
        {
            throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
        }
        return num;
    }
    if (!NumberToInt32(ref number, ref num))
    {
        throw new OverflowException(Environment.GetResourceString("Overflow_Int32"));
    }
    return num;
}

Convert.ToInt32("32"):

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

Wie der erste Kommentar (von Dave M.) sagt.

Answer 3

Kein Unterschied als solcher.
Convert.ToInt32() ruft auf. int.Parse() intern

Außer einer Sache Convert.ToInt32() gibt zurück. 0 wenn das Argument null

Ansonsten funktionieren beide auf die gleiche Weise

Answer 4

Int.Parse(string s)

• Integer in RANGE > liefert einen ganzzahligen Wert
• Nullwert > ArguementNullException
• Nicht im Format > FormatException
• Wert nicht im BEREICH > OverflowException

Convert.ToInt32(Zeichenkette s)

• Integer in RANGE > liefert einen ganzzahligen Wert
• Nullwert > gibt "0" zurück
• Nicht im Format > FormatException
• Wert nicht im BEREICH > OverflowException

bool isParsed = int.TryParse(string s,out res)

• Integer in RANGE > liefert Ganzzahlwert, isParsed = true
• Nullwert > ergibt "0", isParsed = false
• Nicht im Format > gibt "0" zurück, isParsed = false
• Wert nicht in RANGE > gibt "0" zurück, isParsed = false

Probieren Sie den folgenden Code aus.....

class Program
{
    static void Main(string[] args)
    {
        string strInt = "24532";
        string strNull = null;
        string strWrongFrmt = "5.87";
        string strAboveRange = "98765432123456";
        int res;
        try
        {
            // int.Parse() - TEST
            res = int.Parse(strInt); // res = 24532
            res = int.Parse(strNull); // System.ArgumentNullException
            res = int.Parse(strWrongFrmt); // System.FormatException
            res = int.Parse(strAboveRange); // System.OverflowException

            // Convert.ToInt32(string s) - TEST
            res = Convert.ToInt32(strInt); // res = 24532
            res = Convert.ToInt32(strNull); // res = 0
            res = Convert.ToInt32(strWrongFrmt); // System.FormatException
            res = Convert.ToInt32(strAboveRange); //System.OverflowException

            // int.TryParse(string s, out res) - Test
            bool isParsed;
            isParsed = int.TryParse(strInt, out res); // isParsed = true, res = 24532
            isParsed = int.TryParse(strNull, out res); // isParsed = false, res = 0
            isParsed = int.TryParse(strWrongFrmt, out res); // isParsed = false, res = 0
            isParsed = int.TryParse(strAboveRange, out res); // isParsed = false, res = 0 
        }
        catch(Exception e)
        {
            Console.WriteLine("Check this.\n" + e.Message);
        }
    }

Answer 5

Der Unterschied ist der folgende:

Int32.Parse() y Int32.TryParse() kann nur Zeichenketten konvertieren. Convert.ToInt32() kann jede Klasse annehmen, die IConvertible . Wenn Sie eine Zeichenkette übergeben, sind sie äquivalent, mit der Ausnahme, dass Sie zusätzlichen Overhead für Typvergleiche usw. erhalten. Wenn Sie Zeichenketten konvertieren, dann TryParse() ist wahrscheinlich die bessere Option.