• Apa perbedaan utama antara int.Parse()danConvert.ToInt32() ?
• Yang mana yang lebih disukai

• Jika Anda memiliki string, dan Anda mengharapkannya selalu berupa integer (katakanlah, jika beberapa layanan web memberi Anda integer dalam format string), Anda akan menggunakannya Int32.Parse().

• Jika Anda mengumpulkan input dari pengguna, Anda biasanya akan menggunakan Int32.TryParse(), karena hal itu memungkinkan Anda mengontrol lebih baik situasi ketika pengguna memasukkan input yang tidak valid.

• Convert.ToInt32()mengambil objek sebagai argumennya. (Lihat jawaban Chris S untuk cara kerjanya)

  Convert.ToInt32()juga tidak membuang ArgumentNullExceptionketika argumennya nol seperti yang Int32.Parse()dilakukannya. Itu juga berarti bahwa Convert.ToInt32()mungkin sedikit lebih lambat daripada Int32.Parse(), meskipun dalam praktiknya, kecuali jika Anda melakukan iterasi yang sangat besar dalam satu lingkaran, Anda tidak akan pernah melihatnya.

Lihatlah reflektor:

int.Parse ("32"):

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

yang merupakan panggilan ke:

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

Seperti komentar pertama (Dave M).

Tidak ada perbedaan seperti itu.
Convert.ToInt32()panggilan int.Parse()internal

Kecuali untuk satu hal Convert.ToInt32()kembali 0ketika argumennyanull

Kalau tidak, keduanya bekerja dengan cara yang sama

int.Parse (string s)

• Integer di RANGE> mengembalikan nilai integer
• Nilai kosong> ArguementNullException
• Tidak dalam format> FormatException
• Nilai tidak di RANGE> OverflowException

Convert.ToInt32 (string s)

• Integer di RANGE> mengembalikan nilai integer
• Nilai kosong> mengembalikan "0"
• Tidak dalam format> FormatException
• Nilai tidak di RANGE> OverflowException

bool isParsed = int.TryParse (string s, out res)

• Integer di RANGE> mengembalikan nilai integer, isParsed = true
• Nilai kosong> mengembalikan "0", isParsed = false
• Tidak dalam format> mengembalikan "0", isParsed = false
• Nilai tidak dalam RANGE> mengembalikan "0", isParsed = false

Coba kode ini di bawah ini .....

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

Perbedaannya adalah ini:

Int32.Parse()dan Int32.TryParse()hanya dapat mengonversi string. Convert.ToInt32()dapat mengambil kelas apa pun yang mengimplementasikan IConvertible. Jika Anda meneruskannya string, maka mereka setara, kecuali bahwa Anda mendapatkan overhead tambahan untuk perbandingan tipe, dll. Jika Anda mengonversi string, maka TryParse()mungkin merupakan opsi yang lebih baik.

Int32.parse (string) --->

Metode Int32.Parse (string s) mengubah representasi string dari angka menjadi setara integer bertanda 32-bit. Ketika s adalah referensi nol, itu akan membuang ArgumentNullException. Jika s selain nilai integer, ia akan membuang FormatException. Ketika s mewakili angka kurang dari MinValue atau lebih besar dari MaxValue, ia akan melempar OverflowException. Sebagai contoh :

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

Metode Convert.ToInt32 (string) -> Convert.ToInt32 (string s) mengubah representasi string yang ditentukan dari setara integer bertanda 32-bit. Ini panggilan pada gilirannya metode Int32.Parse (). Ketika s adalah referensi nol, itu akan mengembalikan 0 daripada membuang ArgumentNullException. Jika s selain nilai integer, ia akan membuang FormatException. Ketika s mewakili angka kurang dari MinValue atau lebih besar dari MaxValue, ia akan melempar OverflowException.

Sebagai contoh:

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

TryParse lebih cepat ...

Yang pertama dari fungsi-fungsi ini, Parse, adalah yang harus dikenal oleh pengembang .Net. Fungsi ini akan mengambil string dan mencoba untuk mengekstrak integer darinya dan kemudian mengembalikan integer. Jika mengalami sesuatu yang tidak dapat diurai maka ia melempar FormatException atau jika jumlahnya terlalu besar sebuah OverflowException. Juga, itu bisa melempar ArgumentException jika Anda memberikan nilai nol.

TryParse adalah tambahan baru pada framework .Net 2.0 baru yang membahas beberapa masalah dengan fungsi Parse asli. Perbedaan utama adalah bahwa penanganan eksepsi sangat lambat, jadi jika TryParse tidak dapat mengurai string, maka tidak membuang eksepsi seperti halnya Parse. Alih-alih, ia mengembalikan Boolean yang menunjukkan apakah ia berhasil mengurai angka. Jadi Anda harus melewatkan TryParse baik string yang akan diuraikan dan parameter Int32 out untuk diisi. Kami akan menggunakan profiler untuk memeriksa perbedaan kecepatan antara TryParse dan Parse dalam kedua kasus di mana string dapat diurai dengan benar dan dalam kasus di mana string tidak dapat diuraikan dengan benar.

Kelas Konversi berisi serangkaian fungsi untuk mengubah satu kelas dasar menjadi yang lain. Saya percaya bahwa Convert.ToInt32 (string) hanya memeriksa string null (jika string adalah null mengembalikan nol tidak seperti Parse) maka panggil saja Int32.Parse (string). Saya akan menggunakan profiler untuk mengonfirmasi ini dan untuk melihat apakah menggunakan Konversi sebagai lawan Parse memiliki efek nyata pada kinerja.

Sumber dengan contoh-contoh

Semoga ini membantu.

Convert.ToInt32

memiliki 19 kelebihan atau 19 cara berbeda yang bisa Anda sebut itu. Mungkin lebih banyak di versi 2010.

Ini akan berusaha untuk mengkonversi dari JENIS-JENIS berikut;

Objek, Boolean, Char, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Ganda, Desimal, String, Tanggal

dan ia juga memiliki sejumlah metode lain; satu hubungannya dengan basis angka dan 2 metode melibatkan aSystem.IFormatProvider

Parse di sisi lain hanya memiliki 4 kelebihan atau 4 cara Anda dapat memanggil metode.

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 )

Itu tergantung pada tipe parameter. Sebagai contoh, saya baru menemukan hari ini bahwa itu akan mengkonversi char langsung ke int menggunakan nilai ASCII-nya. Tidak persis fungsionalitas yang saya maksudkan ...

ANDA TELAH DIPERINGATKAN!

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

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

Berikut adalah detail untuk int.Parsedan Convert.ToInt32: Katakanlah, Anda memiliki array char, char[] a=['1','2','3','4']dan ingin mengkonversi setiap elemen menjadi integer. Ini Convert.ToInt32(a[0])akan memberi Anda jumlah 49. Ini memperlakukannya sebagai kode ASCII. Ini int.Parse(a[0])akan memberi Anda output yang tepat yaitu 1

Jika Anda memiliki larik string string[] b=['1','2','3','4'], maka Convert.ToInt32dan tidak int.Parseakan ada perbedaan dalam output. Keduanya mengembalikan integer yang tepat.

Convert.ToInt32 memungkinkan nilai nol, itu tidak menimbulkan kesalahan Int.parse tidak mengizinkan nilai nol, itu melempar kesalahan ArgumentNullException.

untuk klarifikasi aplikasi konsol terbuka, cukup salin kode di bawah ini dan rekatkan dalam static void Main(string[] args)metode, saya harap Anda bisa mengerti

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

Metode Parse () memberikan gaya angka yang tidak dapat digunakan untuk Konversi (). Sebagai contoh:

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

akan mem-parsing angka dengan tanda trailing sehingga saya == -123
Tanda trailing populer di sistem ERP.