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 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.
ToInt32méthode a une surcharge pour des charges de types, il n'y a System.Stringpas de temps entre eux pour discerner le type. Le code réel ne fait que renvoyer 0 pour les valeurs nulles et int.Parse(value, CultureInfo.CurrentCulture)pour tout le reste.
Int32.TryParse()dans Convert.ToInt32()car elle est incorrecte. Convert lève une exception si la chaîne n'est pas formatée correctement.
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.
Convert.ToInt32retourne 0si nullpour empêcher int.Parsede lever un ArgumentNullException.
default(int)est évaluée au moment de la compilation, car c'est une valeur intrinsèque - le résultat de l'expression est 0, donc le compilateur insère un littéral 0. Les outils de désassemblage IL ne peuvent pas mieux connaître, ils vous montrent donc simplement un zéro littéral.
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
Convert.ToInt32(string)appelle en int.Parseinterne. Convert.ToInt32(object), cependant, les appels ((IConvertible) value).ToInt32, qui dans le cas d' stringappels Convert.ToInt32(string)... un peu alambiqués ...
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); //OverflowExceptionConvert.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.
J'espère que cela t'aides.
Convert.ToInt32a 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 1charconvertir implicitement stringen C #? Il peut certainement en VB.NET, et donc les programmeurs dans ce langage s'attendraient probablement Convert.ToInt32("1"c)et Convert.ToInt32("1")seraient équivalents, mais je ne pense pas que C # a cette conversion implicite.
charvaleurs comme étant un peu plus numérotées que vb.net. Le danger serait plus grand dans vb.net, où à cause d'une distribution implicite, il y a moins de différence perçue entre Charet String.
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.