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

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

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

  • Si vous collectez des données d’un utilisateur, vous utiliserez généralement Int32.TryParse() , car il vous permet de mieux contrôler la situation lorsque l’utilisateur saisit une entrée non valide.

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

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

Regardez dans le réflecteur:

int.Parse (“32”):

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

qui est un appel à:

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

Convert.ToInt32 (“32”):

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

Comme le dit le premier commentaire de Dave M.

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

Sauf pour une chose que Convert.ToInt32() renvoie 0 lorsque l’argument est null

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

La différence est la suivante:

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

int.Parse (ssortingng 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 (ssortingng 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(ssortingng[] args) { ssortingng strInt = "24532"; ssortingng strNull = null; ssortingng strWrongFrmt = "5.87"; ssortingng 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(ssortingng 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(ssortingng 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); } } 

TryParse est plus rapide …

La première de ces fonctions, Parse, devrait être familière à tout développeur .Net. Cette fonction prendra une chaîne et tentera d’en extraire un entier puis renverra l’entier. S’il se heurte à quelque chose qu’il ne peut pas parsingr, il lève une exception FormatException ou si le nombre est trop grand, une exception OverflowException. En outre, il peut lancer une exception ArgumentException si vous lui transmettez une valeur nulle.

TryParse est un nouvel ajout au nouveau framework .Net 2.0 qui résout certains problèmes liés à la fonction Parse d’origine. La principale différence est que la gestion des exceptions est très lente, donc si TryParse ne peut pas parsingr la chaîne, elle ne lève pas une exception comme celle de Parse. Au lieu de cela, il retourne un booléen indiquant s’il a pu parsingr un numéro avec succès. Donc, vous devez passer à TryParse à la fois la chaîne à parsingr 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 la chaîne ne peut pas être correctement analysée.

La classe Convert contient une série de fonctions permettant de convertir une classe de base en une autre. Je crois que Convert.ToInt32 (chaîne) vérifie juste une chaîne vide (si la chaîne est nulle, elle renvoie zéro contrairement à l’parsing), 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 exemples

J’espère que cela t’aides.

Int32.parse (ssortingng) —>

La méthode Int32.Parse (ssortingng 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 générera une exception de débordement. Par exemple :

 ssortingng s1 = "1234"; ssortingng s2 = "1234.65"; ssortingng s3 = null; ssortingng s4 = "123456789123456789123456789123456789123456789"; result = Int32.Parse(s1); //1234 result = Int32.Parse(s2); //FormatException result = Int32.Parse(s3); //ArgumentNullException result = Int32.Parse(s4); //OverflowException 

La méthode Convert.ToInt32 (ssortingng) -> Convert.ToInt32 (ssortingng s) convertit la représentation sous forme de chaîne spécifiée d’un équivalent entier signé de 32 bits. Cela appelle la méthode Int32.Parse (). Lorsque s est une référence null, il retournera 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 générera une exception de débordement.

Par exemple:

  result = Convert.ToInt32(s1); // 1234 result = Convert.ToInt32(s2); // FormatException result = Convert.ToInt32(s3); // 0 result = Convert.ToInt32(s4); // OverflowException 
 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:

Object, Boolean, Char, SByte, Octet, Int16, UInt16, Int32, UInt32, Int64, UInt64, Unique, Double, Décimal, Chaîne, Date

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

D’autre part, l’parsing n’a que 4 surcharges ou 4 manières différentes d’appeler la méthode.

 Integer.Parse( s As Ssortingng) Integer.Parse( s As Ssortingng, style As System.Globalization.NumberStyles ) Integer.Parse( s As Ssortingng, provider As System.IFormatProvider ) Integer.Parse( s As Ssortingng, style As System.Globalization.NumberStyles, provider As System.IFormatProvider ) 

Cela dépend du type de paramètre. Par exemple, je viens juste de découvrir qu’il convertira directement un caractère 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 

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 plus de clarté, ouvrez l’application console, copiez simplement le code ci-dessous et collez-le dans static void Main(ssortingng[] args) méthode static void Main(ssortingng[] args) , j’espère que vous pourrez comprendre

 public class Program { static void Main(ssortingng[] args) { int result; bool status; ssortingng s1 = "12345"; Console.WriteLine("input1:12345"); ssortingng s2 = "1234.45"; Console.WriteLine("input2:1234.45"); ssortingng s3 = null; Console.WriteLine("input3:null"); ssortingng s4 = "1234567899012345677890123456789012345667890"; Console.WriteLine("input4:1234567899012345677890123456789012345667890"); ssortingng s5 = ssortingng.Empty; Console.WriteLine("input5:Ssortingng.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(); } } 

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

Si vous avez une chaîne de type ssortingng[] b=['1','2','3','4'] , alors Convert.ToInt32 et int.Parse n’auront aucune différence de sortie. Les deux renvoient le bon entier.