• Quelle est la principale différence entre int.Parse()et Convert.ToInt32()?
• Lequel est à privilégier

• 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 remet un entier au format chaîne), vous l'utiliseriez Int32.Parse().

• Si vous collectez des entrées d'un utilisateur, vous les utiliseriez généralement Int32.TryParse(), car cela vous permet un contrôle plus précis de la situation lorsque l'utilisateur entre des entrées non valides.

• Convert.ToInt32()prend un objet comme argument. (Voir la réponse de Chris S pour savoir comment cela fonctionne)

  Convert.ToInt32()ne lance pas non plus ArgumentNullExceptionlorsque son argument est nul comme le Int32.Parse()fait. Cela signifie également que Convert.ToInt32()c'est probablement un peu plus lent que Int32.Parse(), bien qu'en pratique, à moins que vous ne fassiez un très grand nombre d'itérations dans une boucle, vous ne le remarquerez jamais.

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 (de Dave M) le dit.

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

Sauf pour une chose qui Convert.ToInt32()revient 0quand l'argument estnull

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

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

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, ils sont équivalents, sauf que vous obtenez des frais supplémentaires pour les comparaisons de types, etc. Si vous convertissez des chaînes, TryParse()c'est probablement la meilleure option.

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

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

Par exemple:

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

TryParse est plus rapide ...

La première de ces fonctions, Parse, doit être familière à tout développeur .Net. Cette fonction prendra une chaîne et tentera d'en extraire un entier puis de retourner l'entier. S'il rencontre quelque chose qu'il ne peut pas analyser, il lève une FormatException ou si le nombre est trop grand une OverflowException. En outre, il peut lever une 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. La principale différence est que la gestion des exceptions est très lente, donc si TryParse n'est pas en mesure d'analyser la chaîne, il ne lève pas d'exception comme Parse. Au lieu de cela, il renvoie un booléen indiquant s'il a réussi à analyser un nombre. Vous devez donc passer dans TryParse à la fois la chaîne à analyser et un paramètre de sortie Int32 à remplir. Nous utiliserons le profileur pour examiner la différence de vitesse entre TryParse et Parse dans les deux cas où la chaîne peut être correctement analysée et dans les 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 simplement une chaîne nulle (si la chaîne est nulle, elle renvoie zéro contrairement à l'analyse) puis appelle simplement Int32.Parse (chaîne). Je vais utiliser le profileur pour confirmer cela et voir si l'utilisation de Convert par opposition à Parse a un effet réel sur les performances.

Source avec des exemples

J'espère que cela t'aides.

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, caractère, 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; un à voir avec une base numérique et 2 méthodes impliquent unSystem.IFormatProvider

Parse, d'autre part, n'a que 4 surcharges ou 4 façons différentes d'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 )

Cela dépend du type de paramètre. Par exemple, je viens de découvrir aujourd'hui qu'il convertira un char directement en int en utilisant sa valeur ASCII. Pas exactement la fonctionnalité que je voulais ...

TU ÉTAIS PRÉVENU!

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

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

Voici un détail pour int.Parseet Convert.ToInt32: Disons que vous avez un tableau de caractères char[] a=['1','2','3','4']et que vous voulez convertir chaque élément en entier. Le Convert.ToInt32(a[0])vous donnera un nombre de 49. Il le traite comme du code ASCII Le int.Parse(a[0])vous donnera la bonne sortie qui est 1

Si vous avez un tableau de chaînes string[] b=['1','2','3','4'], alors Convert.ToInt32et int.Parsen'aura aucune différence de sortie. Les deux renvoient le bon entier.

Convert.ToInt32 autorise la valeur null, il ne génère aucune erreur. Int.parse n'autorise pas la valeur null, il génère une erreur ArgumentNullException.

pour clarifier l'application console ouverte, copiez simplement le code ci-dessous et collez-le dans la 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();
        }
    }

Les méthodes Parse () fournissent les styles de nombres qui ne peuvent pas être utilisés pour Convert (). Par exemple:

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

analyserait les nombres avec un signe de fin pour que i == -123
Le signe de fin soit populaire dans les systèmes ERP.