it-swarm.com.de

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

  • Was ist der Hauptunterschied zwischen int.Parse() und Convert.ToInt32()?
  • Welches ist zu bevorzugen
455
jbcedge
  • Wenn Sie eine Zeichenfolge haben und davon ausgehen, dass es sich immer um eine Ganzzahl handelt (z. B. wenn Ihnen ein Webdienst eine Ganzzahl im Zeichenfolgenformat übergibt), verwenden Sie Int32.Parse() .

  • Wenn Sie Eingaben von einem Benutzer sammeln, verwenden Sie im Allgemeinen Int32.TryParse() , da Sie so eine genauere Kontrolle über die Situation, in der der Benutzer eine ungültige Eingabe eingibt.

  • Convert.ToInt32() nimmt ein Objekt als Argument. (Siehe Chris S's Antwort für wie es funktioniert)

    Convert.ToInt32() wirft auch nicht ArgumentNullException, wenn sein Argument null ist, wie es Int32.Parse() tut. Das bedeutet auch, dass Convert.ToInt32() wahrscheinlich etwas langsamer ist als Int32.Parse(), aber in der Praxis werden Sie es nie bemerken, wenn Sie nicht sehr viele Iterationen in einer Schleife ausführen es.

420
Dave Markle

Schauen Sie in den Reflektor:

int.Parse ("32"):

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

das ist ein Aufruf an:

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 (Dave M's) Kommentar sagt.

178
Chris S

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

Mit einer Ausnahme gibt Convert.ToInt32()0 zurück, wenn das Argument null ist.

Ansonsten arbeiten beide gleich

74
shahkalpesh

int.Parse (String s)

  • Integer in RANGE> gibt einen Integer-Wert zurück
  • Nullwert> ArguementNullException
  • Nicht im Format> FormatException
  • Wert nicht in RANGE> OverflowException

Convert.ToInt32 (Zeichenfolge s)

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

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

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

Versuchen Sie diesen Code unten .....

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);
        }
    }
29
NITHIN RAJ T

Der Unterschied ist folgender:

Int32.Parse() und Int32.TryParse() können nur Zeichenfolgen konvertieren. Convert.ToInt32() kann jede Klasse annehmen, die IConvertible implementiert. Wenn Sie eine Zeichenfolge übergeben, sind sie gleichwertig, mit der Ausnahme, dass Sie zusätzlichen Aufwand für Typvergleiche usw. haben. Wenn Sie Zeichenfolgen konvertieren, ist TryParse() wahrscheinlich die bessere Option.

21

TryParse ist schneller ...

Die erste dieser Funktionen, Parse, sollte jedem .NET-Entwickler geläufig sein. Diese Funktion nimmt eine Zeichenfolge und versucht, eine Ganzzahl daraus zu extrahieren und dann die Ganzzahl zurückzugeben. Wenn es auf etwas stößt, das nicht analysiert werden kann, wird eine FormatException ausgelöst, oder wenn die Zahl zu groß ist, wird eine OverflowException ausgelöst. Außerdem kann eine ArgumentException ausgelöst werden, wenn Sie einen Nullwert übergeben.

TryParse ist eine neue Erweiterung des neuen .NET 2.0-Frameworks, das einige Probleme mit der ursprünglichen Parse-Funktion behebt. Der Hauptunterschied besteht darin, dass die Ausnahmebehandlung sehr langsam ist. Wenn TryParse die Zeichenfolge nicht analysieren kann, wird keine Ausnahme wie bei Parse ausgelöst. Stattdessen wird ein Boolescher Wert zurückgegeben, der angibt, ob eine Zahl erfolgreich analysiert werden konnte. Sie müssen also in TryParse sowohl den zu analysierenden String als auch einen Int32-Out-Parameter übergeben, um ihn auszufüllen. In beiden Fällen, in denen der String korrekt analysiert werden kann, und in den Fällen, in denen der Profiler den Geschwindigkeitsunterschied zwischen TryParse und Parse untersucht Die Zeichenfolge kann nicht korrekt analysiert werden.

Die Convert-Klasse enthält eine Reihe von Funktionen zum Konvertieren einer Basisklasse in eine andere. Ich glaube, dass Convert.ToInt32 (string) nur nach einer Nullzeichenfolge sucht (wenn die Zeichenfolge null ist, gibt sie im Gegensatz zum Parse null zurück) und dann nur Int32.Parse (string) aufruft. Ich verwende den Profiler, um dies zu bestätigen und um festzustellen, ob die Verwendung von "Konvertieren" im Gegensatz zu "Analysieren" echte Auswirkungen auf die Leistung hat.

Quelle mit Beispielen

Hoffe das hilft.

8
BoltBait

Int32.parse (string) --->

Die Methode Int32.Parse (string s) konvertiert die Zeichenfolgendarstellung einer Zahl in ihre 32-Bit-Ganzzahl mit Vorzeichen. Wenn s eine Nullreferenz ist, wird ArgumentNullException ausgelöst. Wenn s kein ganzzahliger Wert ist, wird FormatException ausgelöst. Wenn s eine Zahl darstellt, die kleiner als MinValue oder größer als MaxValue ist, wird OverflowException ausgelöst. Zum Beispiel :

string s1 = "1234"; 
string s2 = "1234.65"; 
string s3 = null; 
string s4 = "123456789123456789123456789123456789123456789"; 

result = Int32.Parse(s1);    //1234
result = Int32.Parse(s2);    //FormatException
result = Int32.Parse(s3);    //ArgumentNullException 
result = Int32.Parse(s4);    //OverflowException

Convert.ToInt32 (string) -> Die Methode Convert.ToInt32 (string s) konvertiert die angegebene Zeichenfolgendarstellung eines 32-Bit-Ganzzahläquivalents mit Vorzeichen. Dies ruft wiederum die Int32.Parse () -Methode auf. Wenn s eine Nullreferenz ist, wird 0 zurückgegeben, anstatt ArgumentNullException auszulösen. Wenn s kein ganzzahliger Wert ist, wird FormatException ausgelöst. Wenn s eine Zahl darstellt, die kleiner als MinValue oder größer als MaxValue ist, wird OverflowException ausgelöst.

Zum Beispiel:

 result = Convert.ToInt32(s1);    // 1234 
 result = Convert.ToInt32(s2);    // FormatException
 result = Convert.ToInt32(s3);    // 0
 result = Convert.ToInt32(s4);    // OverflowException 
7
Sonu Rajpoot
Convert.ToInt32

hat 19 Überladungen oder 19 verschiedene Arten, wie Sie es aufrufen können. Vielleicht mehr in 2010er Versionen.

Es wird versucht, die folgenden TYPEN zu konvertieren.

Objekt, Boolescher Wert, Zeichen, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Einfach, Doppel, Dezimal, Zeichenfolge, Datum

und es hat auch eine Reihe anderer Methoden; eine mit einer Zahlenbasis zu tun und 2 Methoden beinhalten ein System.IFormatProvider

Parse hingegen hat nur 4 Überladungen oder 4 verschiedene Möglichkeiten, die Methode aufzurufen.

Integer.Parse( s As String)

Integer.Parse( s As String,  style As System.Globalization.NumberStyles )

Integer.Parse( s As String, provider As System.IFormatProvider )

Integer.Parse( s As String,  style As System.Globalization.NumberStyles, provider As System.IFormatProvider )
4
shashi shekhar

Dies hängt vom Parametertyp ab. Ich habe zum Beispiel gerade festgestellt, dass ein Zeichen mit seinem Wert ASCII) direkt in int konvertiert wird. Nicht genau die Funktionalität, die ich beabsichtigt habe ...

DU WURDEST GEWARNT!

public static int ToInt32(char value)
{
    return (int)value;
} 

Convert.ToInt32('1'); // Returns 49
int.Parse('1'); // Returns 1
2
Dale K

Hier ist ein Detail für int.Parse Und Convert.ToInt32: Angenommen, Sie haben ein Zeichen-Array char[] a=['1','2','3','4'] Und möchten jedes Element in eine Ganzzahl konvertieren. Die Convert.ToInt32(a[0]) gibt Ihnen eine Zahl von 49. Sie behandelt sie als ASCII code Die int.Parse(a[0]) gibt Ihnen die richtige Ausgabe, die 1 ist

Wenn Sie ein String-Array string[] b=['1','2','3','4'] Haben, haben Convert.ToInt32 Und int.Parse Keinen Unterschied in der Ausgabe. Beide geben die rechte Ganzzahl zurück.

2

zur Verdeutlichung öffnen Sie die Konsolenanwendung, kopieren Sie einfach den folgenden Code und fügen Sie ihn in die static void Main(string[] args) -Methode ein. Ich hoffe, Sie können das verstehen

public  class Program
    {
        static void Main(string[] args)
        { 
            int result;
            bool status;
            string s1 = "12345";
            Console.WriteLine("input1:12345");
            string s2 = "1234.45";
            Console.WriteLine("input2:1234.45");
            string s3 = null;
            Console.WriteLine("input3:null");
            string s4 = "1234567899012345677890123456789012345667890";
            Console.WriteLine("input4:1234567899012345677890123456789012345667890");
            string s5 = string.Empty;
            Console.WriteLine("input5:String.Empty");
            Console.WriteLine();
            Console.WriteLine("--------Int.Parse Methods Outputs-------------");
            try
            {
               result = int.Parse(s1);

               Console.WriteLine("OutPut1:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut1:"+ee.Message);
            }
            try
            {
              result = int.Parse(s2);

              Console.WriteLine("OutPut2:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut2:" + ee.Message);
            }
            try
            {
               result = int.Parse(s3);

               Console.WriteLine("OutPut3:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut3:" + ee.Message);
            }
            try
            {
                result = int.Parse(s4);

                Console.WriteLine("OutPut4:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut4:" + ee.Message);
            }

            try
            {
                 result = int.Parse(s5);

                 Console.WriteLine("OutPut5:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut5:" + ee.Message);
            }
            Console.WriteLine();
            Console.WriteLine("--------Convert.To.Int32 Method Outputs-------------");
            try
            {

                result=  Convert.ToInt32(s1);

                Console.WriteLine("OutPut1:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut1:" + ee.Message);
            }
            try
            {

                result = Convert.ToInt32(s2);

                Console.WriteLine("OutPut2:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut2:" + ee.Message);
            }
            try
            {

         result = Convert.ToInt32(s3);

         Console.WriteLine("OutPut3:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut3:" + ee.Message);
            }
            try
            {

                  result = Convert.ToInt32(s4);

                  Console.WriteLine("OutPut4:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut4:" + ee.Message);
            }

            try
            {

                 result = Convert.ToInt32(s5);

                 Console.WriteLine("OutPut5:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut5:" + ee.Message);
            }

            Console.WriteLine();
            Console.WriteLine("--------TryParse Methods Outputs-------------");
            try
            {

                status = int.TryParse(s1, out result);
                Console.WriteLine("OutPut1:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut1:" + ee.Message);
            }
            try
            {

                status = int.TryParse(s2, out result);
                Console.WriteLine("OutPut2:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut2:" + ee.Message);
            }
            try
            {

                status = int.TryParse(s3, out result);
                Console.WriteLine("OutPut3:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut3:" + ee.Message);
            }
            try
            {

                status = int.TryParse(s4, out result);
                Console.WriteLine("OutPut4:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut4:" + ee.Message);
            }

            try
            {

                status = int.TryParse(s5, out result);
                Console.WriteLine("OutPut5:" + result);
            }
            catch (Exception ee)
            {
                Console.WriteLine("OutPut5:" + ee.Message);
            }


            Console.Read();
        }
    }
1
Pradeep Kumar

Convert.ToInt32 erlaubt einen Nullwert, es werden keine Fehler ausgegeben. Int.parse erlaubt keinen Nullwert, es wird ein ArgumentNullException-Fehler ausgegeben.

1
shraddha dhuri

Parse () -Methoden stellen die Zahlenstile bereit, die für Convert () nicht verwendet werden können. Zum Beispiel:

int i;
bool b = int.TryParse( "123-",
           System.Globalization.NumberStyles.AllowTrailingSign,
           System.Globalization.CultureInfo.InvariantCulture,
           out i);

würde die Zahlen mit einem nachgestellten Vorzeichen analysieren, so dass i == -123
Das nachgestellte Zeichen ist in ERP Systemen beliebt.