• Arasındaki temel fark nedir int.Parse()ve Convert.ToInt32()?
• Hangisi tercih edilecek

• Bir dizeniz varsa ve bunun her zaman bir tamsayı olmasını bekliyorsanız (örneğin, bazı web hizmetleri size dize biçiminde bir tamsayı veriyorsa) kullanırsınız Int32.Parse().

• Bir kullanıcıdan girdi topluyorsanız, genellikle Int32.TryParse()geçersiz girdiler girdiği durum üzerinde daha ayrıntılı bir denetime izin verdiğiniz için genellikle kullanırsınız .

• Convert.ToInt32()bir nesneyi argüman olarak alır. (Chris S'nin nasıl çalıştığı ile ilgili cevaba bakınız)

  Convert.ToInt32()Ayrıca atmaz ArgumentNullExceptiononun argümanı yolu boş olduğunda Int32.Parse()yapar. Bu Convert.ToInt32(), muhtemelen bir çemberde Int32.Parse()çok sayıda yineleme yapmadığınız sürece, bunu asla fark etmeyeceğinizden , muhtemelen daha yavaş olduğu anlamına gelir .

Reflektöre bir göz atın:

int.Parse ( "32"):

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

Bu bir çağrıdır:

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

İlk söylediği gibi (Dave M'in) yorumu.

Böyle bir fark yok. dahili
Convert.ToInt32()aramalarint.Parse()

Bir şey hariç Convert.ToInt32()getiri 0argüman olduğundanull

Aksi takdirde her ikisi de aynı şekilde çalışır

int.Parse (dize)

• RANGE> içindeki tamsayı tamsayı değerini döndürür
• Boş değer> ArguementNullException
• Biçimde değil> FormatException
• Değer RANGE> OverflowException içinde değil

Convert.ToInt32 (dize)

• RANGE> içindeki tamsayı tamsayı değerini döndürür
• Boş değer> "0" değerini döndürür
• Biçimde değil> FormatException
• Değer RANGE> OverflowException içinde değil

bool isParsed = int.TryParse (dize s, çıkış res)

• RANGE> içindeki tamsayı tamsayı değerini döndürür, isParsed = true
• Boş değer> "0" değerini döndürür, isParsed = false
• Biçimde değil> "0" döndürür, isParsed = false
• RANGE> içinde olmayan değer "0" değerini döndürür, isParsed = false

Aşağıdaki kodu deneyin .....

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

Fark şudur:

Int32.Parse()ve Int32.TryParse()yalnızca dizeleri dönüştürebilir. Convert.ToInt32()uygulayan herhangi bir sınıfı alabilir IConvertible. Bir dize geçirirseniz, tür karşılaştırmaları vb. İçin ek yükü almanız dışında eşdeğerdirler. Dizeleri dönüştürüyorsanız TryParse(), muhtemelen daha iyi bir seçenektir.

Int32.Parse (dize) --->

Int32.Parse (string s) yöntemi, bir sayının dize olarak temsil edilmesini 32-bit işaretli tam sayı eşdeğerine dönüştürür. S bir boş başvuru olduğunda, ArgumentNullException özel durumunu atar. S tam sayı değerinden farklıysa, FormatException özel durumunu atar. S, MinValue değerinden küçük veya MaxValue değerinden büyük bir sayıyı temsil ettiğinde OverflowException özel durumunu atar. Örneğin :

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) -> Convert.ToInt32 (string s) yöntemi, 32 bit işaretli tam sayı eşdeğerinin belirtilen dize temsilini dönüştürür. Bu sırayla Int32.Parse () yöntemini çağırır. S null bir başvuru olduğunda, ArgumentNullException öğesini atmak yerine 0 değerini döndürür. S tam sayı değerinden farklıysa, FormatException özel durumunu atar. S, MinValue değerinden küçük veya MaxValue değerinden büyük bir sayıyı temsil ettiğinde OverflowException özel durumunu atar.

Örneğin:

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

TryParse daha hızlı ...

Bu işlevlerden ilki, Parse, herhangi bir .Net geliştiricisine aşina olması gereken işlevdir. Bu işlev bir dize alır ve bir tam sayı çıkarır ve sonra tamsayıyı döndürür. Ayrıştılamadığı bir şeyle çalışırsa, bir FormatException kurar veya sayı çok büyükse bir OverflowException oluşturur. Ayrıca, bir boş değer iletirseniz bir ArgumentException özel durumu atabilir.

TryParse, özgün Ayrıştırma işleviyle ilgili bazı sorunları gideren yeni .Net 2.0 çerçevesine yeni bir ektir. Temel fark, istisna işlemenin çok yavaş olmasıdır, bu nedenle TryParse dizeyi ayrıştıramıyorsa, Parse gibi bir istisna atmaz. Bunun yerine, bir sayıyı başarıyla ayrıştırabildiğini belirten bir Boolean döndürür. Bu nedenle, hem ayrıştırılacak dizeyi hem de doldurmak için bir Int32 çıkış parametresini geçmek zorundasınız. Profil oluşturucuyu, dizenin doğru ayrıştırılabildiği her iki durumda ve dize doğru şekilde ayrıştırılamıyor.

Convert sınıfı, bir temel sınıfı diğerine dönüştürmek için bir dizi işlev içerir. Convert.ToInt32 (dize) sadece boş bir dize (dize null ise, Ayrıştırma'nın aksine sıfır döndürür) denetler sonra Int32.Parse (dize) çağırır inanıyorum. Bunu onaylamak ve Parse yerine Convert'i kullanmanın performans üzerinde gerçek bir etkisi olup olmadığını görmek için profili kullanacağım.

Örneklerle kaynak

Bu yardımcı olur umarım.

Convert.ToInt32

19 aşırı yükleme veya 19 farklı şekilde adlandırabilirsiniz. Belki 2010 sürümlerinde daha fazla.

Aşağıdaki TÜRLERDEN dönüştürmeye çalışacaktır;

Nesne, Boolean, Char, SByte, Bayt, Int16, UInt16, Int32, UInt32, Int64, UInt64, Tek, Çift, Ondalık, Dize, Tarih

ve ayrıca bir takım başka yöntemleri de vardır; biri sayı tabanı ile ilgilidir ve 2 yöntem birSystem.IFormatProvider

Öte yandan ayrıştırma yöntemi sadece 4 aşırı yükleme veya yöntemi çağırabileceğiniz 4 farklı yol vardır.

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 )

Parametre tipine bağlıdır. Örneğin, bugün bir char'ı ASCII değerini kullanarak doğrudan int'ye dönüştüreceğini keşfettim. Tam olarak istediğim işlevsellik değil ...

UYARILDIN!

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

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

İşte bir ayrıntıdır int.Parseve Convert.ToInt32: Söylesenize, karakter dizisi olan char[] a=['1','2','3','4']ve bir tamsayı, her eleman dönüştürmek istiyorum. Convert.ToInt32(a[0])Size Bu ASCII kodu gibi davranır 49'a bir dizi verecektir int.Parse(a[0])size 1 sağ çıktı verecektir

Bir dize diziniz string[] b=['1','2','3','4']varsa Convert.ToInt32ve int.Parseçıkışta hiçbir fark olmayacaktır. Her ikisi de sağ tamsayıyı döndürür.

Convert.ToInt32 null değere izin verir, herhangi bir hata atmaz Int.parse null değere izin vermez, bir ArgumentNullException hatası atar.

Açıklama için açık konsol uygulaması, sadece aşağıdaki kodu kopyalayın ve static void Main(string[] args)yönteme yapıştırın , umarım anlayabilirsiniz

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

Parse () yöntemleri, Convert () için kullanılamayan sayı stillerini sağlar. Örneğin:

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

i == -123
Sondaki işareti ERP sistemlerinde popüler olacak şekilde, sondaki işareti içeren sayıları ayrıştırır .