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

Question

• Quelle est la principale différence entre int.Parse() y Convert.ToInt32() ?
• Lequel est à préférer

Answer 1

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

• Si vous recueillez des données auprès d'un utilisateur, vous utiliserez en général Int32.TryParse() Cette option permet de contrôler plus finement la situation lorsque l'utilisateur saisit des donné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 jette pas non plus ArgumentNullException lorsque son argument est nul de la manière Int32.Parse() fait. Cela signifie également que Convert.ToInt32() est probablement un peu plus lent que Int32.Parse() Cependant, en pratique, à moins que vous ne fassiez un très grand nombre d'itérations dans une boucle, vous ne le remarquerez jamais.

Answer 2

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

Answer 3

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

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

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

Answer 4

La différence est la suivante :

Int32.Parse() y Int32.TryParse() ne peut convertir que des chaînes de caractères. Convert.ToInt32() peut prendre n'importe quelle classe qui implémente IConvertible . Si vous lui passez une chaîne de caractères, alors ils sont équivalents, sauf que vous avez des frais supplémentaires pour les comparaisons de types, etc. Si vous convertissez des chaînes de caractères, alors TryParse() est probablement la meilleure option.

Answer 5

TryParse est plus rapide...

La première de ces fonctions, Parse, est une fonction qui devrait être familière à tout développeur .Net. Cette fonction prend une chaîne de caractères et tente d'en d'en extraire un nombre entier et de renvoyer ce nombre. Si elle rencontre quelque chose qu'elle ne peut pas analyser, elle lève une FormatException. si le nombre est trop grand, une OverflowException. Elle peut également lancer une ArgumentException si vous lui passez une valeur nulle.

TryParse est un nouvel ajout au nouveau cadre .Net 2.0 qui résout certains problèmes de la fonction Parse originale. La principale principale différence est que la gestion des exceptions est très lente, donc si TryParse est ne parvient pas à analyser la chaîne de caractères, il ne lève pas d'exception comme le fait le fait. Au lieu de cela, elle renvoie un booléen indiquant si elle a pu d'analyser avec succès un nombre. Vous devez donc passer à TryParse à la fois la chaîne à analyser et un paramètre de sortie Int32 à remplir. Nous allons Nous allons utiliser le profileur pour examiner la différence de vitesse entre TryParse et Parse dans les deux cas où la chaîne de caractères peut être correctement analysée et dans les cas suivants cas où la chaîne de caractères ne peut pas être analysée correctement.

La classe Convert contient une série de fonctions permettant de convertir une classe de base en une autre. Je pense que Convert.ToInt32(string) vérifie simplement si la chaîne de caractères est nulle (si la chaîne est est nulle, elle renvoie zéro, contrairement à Parse), puis appelle simplement Int32.Parse(string). Je vais utiliser le profiler pour confirmer cela et pour voir voir si l'utilisation de Convert plutôt que de Parse a un réel effet sur les performances.

Source avec exemples

J'espère que cela vous aidera.