Question Quelle est la différence principale entre int.Parse () et Convert.ToInt32


  • Quelle est la principale différence entre int.Parse() et Convert.ToInt32()?
  • Lequel doit être préféré

414
2017-10-13 23:48


origine


Réponses:


  • Si vous avez une chaîne et que vous vous attendez à ce qu'elle soit toujours un entier (par exemple, si un service Web vous envoie un entier au format chaîne), vous utiliserez Int32.Parse().

  • Si vous collectez des données d'un utilisateur, vous utiliserez généralement Int32.TryParse(), car il vous permet un contrôle plus précis sur la situation lorsque l'utilisateur entre entrée non valide.

  • Convert.ToInt32() prend un objet comme argument. (Voir la réponse de Chris S sur son fonctionnement)

    Convert.ToInt32() aussi ne jette pas ArgumentNullException quand son argument est nul la façon Int32.Parse() Est-ce que. Cela signifie aussi que Convert.ToInt32() est probablement un peu plus lent que Int32.Parse()Cependant, en pratique, à moins de faire un très grand nombre d'itérations dans une boucle, vous ne le remarquerez jamais.


385
2017-10-13 23:53



Jetez un oeil dans le réflecteur:

int.Parse ("32"):

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

qui est un appel à:

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);
}

Comme le premier commentaire (Dave M) dit.


152
2017-10-14 14:32



Aucune différence en tant que telle.
Convert.ToInt32() appels int.Parse() intérieurement

Sauf pour une chose Convert.ToInt32() résultats 0 quand l'argument est null

Sinon les deux fonctionnent de la même manière


61
2017-10-13 23:52



La différence est la suivante:

Int32.Parse() et Int32.TryParse() ne peut convertir que des chaînes. Convert.ToInt32() peut prendre n'importe quelle classe qui implémente IConvertible. Si vous lui passez une chaîne, elles sont équivalentes, sauf que vous obtenez un surcoût supplémentaire pour les comparaisons de type, etc. Si vous convertissez des chaînes, alors TryParse() est probablement la meilleure option.


20
2017-10-14 00:21



int.Parse (chaîne s)

  • Entier dans RANGE> renvoie une valeur entière
  • Valeur nulle> ArguementNullException
  • Pas au format> FormatException
  • Valeur non comprise dans RANGE> OverflowException

Convert.ToInt32 (chaîne s)

  • Entier dans RANGE> renvoie une valeur entière
  • Valeur nulle> renvoie "0"
  • Pas au format> FormatException
  • Valeur non comprise dans RANGE> OverflowException

bool isParsed = int.TryParse (chaîne s, out res)

  • Entier dans RANGE> renvoie une valeur entière, isParsed = true
  • Valeur nulle> renvoie "0", isParsed = false
  • Pas dans le format> renvoie "0", isParsed = false
  • La valeur n'est pas dans RANGE> renvoie "0", isParsed = false

Essayez ce code ci-dessous .....

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);
        }
    }

19
2018-03-07 07:13



TryParse est plus rapide ...

La première de ces fonctions, Parse, est celle qui devrait être familière à   tout développeur .Net. Cette fonction prendra une chaîne et tentera de   en extraire un entier, puis renvoyer l'entier. Si cela fonctionne   en quelque chose qu'il ne peut pas analyser puis il jette une FormatException ou   si le nombre est trop grand, une exception OverflowException. En outre, il peut jeter un   ArgumentException si vous lui passez une valeur nulle.

TryParse est un nouvel ajout au nouveau framework .Net 2.0 qui résout certains problèmes avec la fonction Parse d'origine. Le principal   différence est que la gestion des exceptions est très lente, donc si TryParse est   incapable d'analyser la chaîne, elle ne lance pas d'exception comme Parse   Est-ce que. Au lieu de cela, il renvoie un booléen indiquant s'il était capable de   analyser avec succès un nombre. Donc, vous devez passer dans TryParse à la fois   la chaîne à analyser et un paramètre de sortie Int32 à remplir.   utiliser le profileur pour examiner la différence de vitesse entre TryParse et   Analyser dans les deux cas où la chaîne peut être correctement analysée et dans   cas où la chaîne ne peut pas être correctement analysée.

La classe Convert contient une série de fonctions pour convertir une classe de base en une autre. je crois que   Convert.ToInt32 (chaîne) vérifie juste une chaîne nulle (si la chaîne   est nul il renvoie zéro contrairement à la Parse) alors juste des appels   Int32.Parse (chaîne). Je vais utiliser le profiler pour le confirmer et voir   si l'utilisation de Convert par opposition à Parse a un effet réel sur   performance.

Source avec des exemples

J'espère que cela t'aides.


8
2017-10-13 23:56



Int32.parse (chaîne) --->

La méthode Int32.Parse (chaîne s) convertit la représentation sous forme de chaîne d'un nombre en son équivalent entier signé 32 bits. Lorsque s est une référence nulle, il lancera ArgumentNullException. Si s est différent de la valeur entière, il lancera FormatException. Lorsque s représente un nombre inférieur à MinValue ou supérieur à MaxValue, il renvoie OverflowException. Par exemple:

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 (chaîne) -> La méthode Convert.ToInt32 (chaîne s) convertit la représentation de chaîne spécifiée de l'équivalent entier signé 32 bits. Cela appelle la méthode Int32.Parse (). Lorsque s est une référence nulle, il renverra 0 plutôt que de lancer ArgumentNullException. Si s est différent de la valeur entière, il lancera FormatException. Lorsque s représente un nombre inférieur à MinValue ou supérieur à MaxValue, il renvoie OverflowException.

Par exemple:

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

5
2018-05-11 10:03



Convert.ToInt32

a 19 surcharges ou 19 façons différentes que vous pouvez appeler. Peut-être plus dans les versions 2010.

Il tentera de convertir à partir des TYPES suivants;

Objet, Booléen, Char, SByte, Octet, Int16, UInt16, Int32, UInt32, Int64, UInt64, Simple, Double, Décimal, Chaîne, Date

et il a également un certain nombre d'autres méthodes; l'un à faire avec une base de nombre et 2 méthodes impliquent un System.IFormatProvider

Parse d'autre part a seulement 4 surcharges ou 4 façons différentes, vous pouvez appeler la méthode.

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 )

3
2018-05-10 05:54



Cela dépend du type de paramètre. Par exemple, je viens de découvrir aujourd'hui qu'il va convertir un caractère directement en int en utilisant sa valeur ASCII. Pas exactement la fonctionnalité que j'avais l'intention de ...

TU ÉTAIS PRÉVENU!

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

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

2
2017-10-21 21:03



Convert.ToInt32 autorise la valeur null, il ne jette aucune erreur Int.parse n'autorise pas la valeur null, il lève une erreur ArgumentNullException.


1
2017-11-14 10:08



pour une application de console ouverte de clarification, copiez juste ci-dessous le code et collez-le dans static void Main(string[] args) méthode, j'espère que vous pouvez comprendre

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
2017-08-03 05:16