Haruskah saya menggunakan int atau Int32

Dalam C #, intdan Int32merupakan hal yang sama, tetapi saya telah membaca beberapa kali yang intlebih disukai Int32tanpa alasan yang diberikan. Apakah ada alasan, dan apakah saya harus peduli?

ECMA-334 : 2006 C # Spesifikasi Bahasa (hal18):

Setiap tipe yang telah ditentukan adalah singkatan untuk tipe yang disediakan sistem. Misalnya, kata kunci intmerujuk pada struct System.Int32. Sebagai soal gaya, penggunaan kata kunci lebih disukai daripada penggunaan nama jenis sistem yang lengkap.

Keduanya memang identik; intakan menjadi sedikit lebih familiar, Int32membuat 32-bitness lebih eksplisit bagi mereka yang membaca kode Anda. Saya akan cenderung menggunakan di intmana saya hanya perlu 'bilangan bulat', di Int32mana ukurannya penting (kode kriptografi, struktur) sehingga pengelola di masa depan akan tahu lebih aman untuk memperbesar intjika perlu, tetapi harus berhati-hati mengubahInt32 s dengan cara yang sama.

Kode yang dihasilkan akan sama: perbedaannya adalah murni dari keterbacaan atau penampilan kode.

Keduanya mendeklarasikan bilangan bulat 32 bit, dan seperti yang dinyatakan poster lainnya, yang mana yang Anda gunakan sebagian besar merupakan masalah gaya sintaksis. Namun mereka tidak selalu berperilaku dengan cara yang sama. Sebagai contoh, kompiler C # tidak akan mengizinkan ini:

public enum MyEnum : Int32
{
    member1 = 0
}

tetapi itu akan memungkinkan ini:

public enum MyEnum : int
{
    member1 = 0
}

Sosok pergi.

Saya selalu menggunakan tipe sistem - misalnya, Int32bukan int. Saya mengadopsi praktik ini setelah membaca Pemrograman .NET Framework Programming - penulis Jeffrey Richter membuat kasus yang baik untuk menggunakan nama tipe lengkap. Inilah dua poin yang melekat pada saya:

1. Ketik nama dapat bervariasi di antara bahasa .NET. Misalnya, dalam C #, longmemetakan ke System.Int64 sementara di C ++ dengan ekstensi yang dikelola, longpeta ke Int32. Karena bahasa dapat dicampur-dan-cocokkan saat menggunakan .NET, Anda dapat yakin bahwa menggunakan nama kelas eksplisit akan selalu lebih jelas, tidak peduli bahasa yang disukai pembaca.

2. Banyak metode framework memiliki nama ketik sebagai bagian dari nama metode mereka:

   BinaryReader br = new BinaryReader( /* ... */ );
   float val = br.ReadSingle();     // OK, but it looks a little odd...
   Single val = br.ReadSingle();    // OK, and is easier to read

int adalah kata kunci C # dan tidak ambigu.

Sebagian besar waktu itu tidak masalah tetapi dua hal yang bertentangan dengan Int32:

• Anda harus memiliki "menggunakan Sistem;" pernyataan. menggunakan "int" tidak memerlukan pernyataan menggunakan.
• Dimungkinkan untuk mendefinisikan kelas Anda sendiri yang disebut Int32 (yang akan konyol dan membingungkan). int selalu berarti int.

Seperti yang sudah dinyatakan, int= Int32. Agar aman, pastikan untuk selalu menggunakan int.MinValue/ int.MaxValueketika menerapkan apa pun yang peduli tentang batasan tipe data. Misalkan .NET memutuskan bahwa intsekarang akan menjadi Int64, kode Anda akan kurang bergantung pada batas.

Ukuran byte untuk tipe tidak terlalu menarik ketika Anda hanya perlu berurusan dengan satu bahasa (dan untuk kode yang Anda tidak perlu mengingatkan diri sendiri tentang kelebihan matematika). Bagian yang menjadi menarik adalah ketika Anda menjembatani antara satu bahasa ke bahasa lain, C # ke objek COM, dll., Atau Anda melakukan sedikit perubahan atau penyembunyian dan Anda perlu mengingatkan diri sendiri (dan co-wokers review-kode Anda) dari ukuran data.

Dalam prakteknya, saya biasanya menggunakan Int32 hanya untuk mengingatkan diri saya sendiri berapa ukurannya karena saya menulis managed C ++ (untuk menjembatani ke C # misalnya) serta tidak dikelola / asli C ++.

Selama Anda mungkin tahu, dalam C # adalah 64-bit, tetapi dalam bahasa asli C ++, berakhir sebagai 32-bit, atau char adalah unicode / 16-bit sedangkan di C ++ itu adalah 8-bit. Tapi bagaimana kita tahu ini? Jawabannya adalah, karena kami telah mencarinya di manual dan dikatakan demikian.

Dengan waktu dan pengalaman, Anda akan mulai menjadi lebih tipe-teliti ketika Anda menulis kode untuk menjembatani antara C # dan bahasa lain (beberapa pembaca di sini berpikir "mengapa Anda mau?"), Tapi IMHO saya percaya itu adalah praktik yang lebih baik karena Saya tidak ingat apa yang saya kodekan minggu lalu (atau saya tidak harus menentukan dalam dokumen API saya bahwa "parameter ini adalah integer 32-bit").

Dalam F # (walaupun saya belum pernah menggunakannya), mereka mendefinisikan int , int32 , dan nativeint . Pertanyaan yang sama harus muncul, "yang mana yang saya gunakan?". Seperti yang disebutkan orang lain, dalam banyak kasus, itu tidak masalah (harus transparan). Tetapi saya untuk satu akan memilih int32 dan uint32 hanya untuk menghapus ambiguitas.

Saya kira itu hanya akan tergantung pada aplikasi apa yang Anda koding, siapa yang menggunakannya, apa praktik pengkodean yang Anda dan tim Anda ikuti, dll. Untuk membenarkan kapan harus menggunakan Int32.

Tidak ada perbedaan antara intdan Int32, tetapi seperti intkata kunci bahasa banyak orang lebih suka gaya (seperti dengan stringvs String).

Menurut pengalaman saya, itu adalah hal yang biasa. Saya tidak mengetahui alasan teknis untuk menggunakan int lebih dari Int32, tapi itu:

1. Lebih cepat mengetik.
2. Lebih akrab dengan pengembang C # biasa.
3. Warna berbeda dalam penyorotan sintaksis visual studio standar.

Saya terutama menyukai yang terakhir. :)

Saya selalu menggunakan tipe alias (int, string, dll.) Ketika mendefinisikan variabel dan menggunakan nama asli ketika mengakses metode statis:

int x, y;
...
String.Format ("{0}x{1}", x, y);

Sepertinya jelek untuk melihat sesuatu seperti int.TryParse (). Tidak ada alasan lain mengapa saya melakukan ini selain gaya.

Saya tahu bahwa praktik terbaik adalah menggunakan int, dan semua kode MSDN menggunakan int. Namun, tidak ada alasan di luar standardisasi dan konsistensi sejauh yang saya tahu.

Meskipun mereka (kebanyakan) identik (lihat di bawah untuk satu perbedaan [bug]), Anda pasti harus peduli dan Anda harus menggunakan Int32.

• Nama untuk bilangan bulat 16-bit adalah Int16. Untuk integer 64 bit, itu Int64, dan untuk integer 32-bit, pilihan intuitifnya adalah: int atau Int32?

• Pertanyaan tentang ukuran variabel tipe Int16, Int32, atau Int64 adalah referensi-sendiri, tetapi pertanyaan tentang ukuran variabel tipe int adalah pertanyaan dan pertanyaan yang benar-benar valid, tidak peduli seberapa sepele, mengganggu, memimpin untuk kebingungan, buang waktu, menghalangi diskusi, dll (fakta pertanyaan ini ada membuktikan intinya).

• Menggunakan Int32 mempromosikan bahwa pengembang sadar akan pilihan tipe mereka. Seberapa besar int lagi? Oh ya, 32. Kemungkinan bahwa ukuran jenis akan benar-benar dipertimbangkan lebih besar ketika ukuran termasuk dalam nama. Menggunakan Int32 juga mempromosikan pengetahuan tentang pilihan lain. Ketika orang tidak dipaksa untuk mengenali setidaknya ada alternatif itu menjadi terlalu mudah bagi int untuk menjadi "THE integer type".

• Kelas dalam kerangka yang dimaksudkan untuk berinteraksi dengan bilangan bulat 32-bit bernama Int32. Sekali lagi, yaitu: lebih intuitif, kurang membingungkan, tidak memiliki terjemahan (tidak perlu) (bukan terjemahan dalam sistem, tetapi dalam pikiran pengembang), dll. int lMax = Int32.MaxValueAtau Int32 lMax = Int32.MaxValue?

• int bukan kata kunci dalam semua bahasa .NET.

• Meskipun ada argumen mengapa itu tidak mungkin berubah, int mungkin tidak selalu menjadi Int32.

Kekurangannya adalah dua karakter tambahan untuk diketik dan [bug].

Ini tidak akan dikompilasi

public enum MyEnum : Int32
{
    AEnum = 0
}

Tetapi ini akan:

public enum MyEnum : int
{
    AEnum = 0
}

Anda seharusnya tidak peduli. Anda harus menggunakan intsebagian besar waktu. Ini akan membantu porting program Anda ke arsitektur yang lebih luas di masa depan (saat ini intadalah alias untuk System.Int32tetapi itu bisa berubah). Hanya ketika lebar bit dari variabel yang penting (misalnya: untuk mengontrol tata letak dalam memori a struct) Anda harus menggunakan int32dan yang lainnya (dengan " using System;" yang terkait ).

int adalah pintasan bahasa C # untuk System.Int32

Meskipun ini berarti bahwa Microsoft dapat mengubah pemetaan ini, sebuah posting pada diskusi FogCreek menyatakan [sumber]

"Pada masalah 64 bit - Microsoft memang bekerja pada versi 64-bit dari .NET Framework tapi saya cukup yakin int TIDAK akan memetakan ke 64 bit pada sistem itu.

Alasan:

1. Standar C # ECMA secara khusus mengatakan bahwa int 32 bit dan panjang 64 bit.

2. Microsoft memperkenalkan properti & metode tambahan dalam Framework versi 1.1 yang mengembalikan nilai panjang alih-alih nilai int, seperti Array.GetLongLength di samping Array.GetLength.

Jadi saya pikir aman untuk mengatakan bahwa semua tipe C # bawaan akan menjaga pemetaan mereka saat ini. "

int sama dengan System.Int32 dan ketika dikompilasi akan berubah menjadi hal yang sama di CIL .

Kami menggunakan int dengan konvensi dalam C # karena C # ingin terlihat seperti C dan C ++ (dan Java) dan itulah yang kami gunakan di sana ...

BTW, saya akhirnya menggunakan System.Int32 ketika mendeklarasikan impor berbagai fungsi Windows API. Saya tidak yakin apakah ini adalah konvensi yang ditentukan atau tidak, tetapi mengingatkan saya bahwa saya akan ke DLL eksternal ...

Sekali waktu, tipe data int dipatok ke ukuran register mesin yang ditargetkan oleh kompiler. Jadi, misalnya, kompiler untuk sistem 16-bit akan menggunakan integer 16-bit.

Namun, kami untungnya tidak melihat banyak 16-bit lagi, dan ketika 64-bit mulai mendapatkan orang-orang populer yang lebih peduli dengan membuatnya kompatibel dengan perangkat lunak yang lebih tua dan 32-bit telah ada begitu lama bahwa untuk sebagian besar kompiler sebuah int hanya diasumsikan 32 bit.

Saya akan merekomendasikan menggunakan Microsoft StyleCop .

Ini seperti FxCop , tetapi untuk masalah yang berhubungan dengan gaya. Konfigurasi default cocok dengan panduan gaya internal Microsoft, tetapi dapat disesuaikan untuk proyek Anda.

Dibutuhkan sedikit waktu untuk membiasakan diri, tetapi itu pasti membuat kode Anda lebih baik.

Anda dapat memasukkannya dalam proses pembuatan untuk memeriksa pelanggaran secara otomatis.

intdan Int32sama. intadalah alias untuk Int32.

Anda seharusnya tidak peduli. Jika ukuran menjadi perhatian saya akan menggunakan byte, pendek, int, lalu panjang. Satu-satunya alasan Anda akan menggunakan int lebih besar dari int32 adalah jika Anda memerlukan angka lebih tinggi dari 2147483647 atau lebih rendah dari -2147483648.

Selain itu saya tidak peduli, ada banyak item lain yang perlu diperhatikan.

Tidak ada bedanya dalam praktik dan dalam waktu Anda akan mengadopsi konvensi Anda sendiri. Saya cenderung menggunakan kata kunci saat menetapkan jenis, dan versi kelas saat menggunakan metode statis dan semacamnya:

int total = Int32.Parse("1009");

intadalah alias untuk System.Int32, sebagaimana didefinisikan dalam tabel ini: Tabel Jenis Bawaan (Referensi C #)

Saya menggunakan int jika Microsoft mengubah implementasi default untuk integer ke beberapa versi ketinggalan jaman baru (sebut saja Int32b).

Microsoft kemudian dapat mengubah alias int ke Int32b, dan saya tidak perlu mengubah kode saya untuk mengambil keuntungan dari implementasi integer baru mereka (dan semoga ditingkatkan).

Hal yang sama berlaku untuk semua jenis kata kunci.

Anda seharusnya tidak peduli pada sebagian besar bahasa pemrograman, kecuali jika Anda perlu menulis fungsi matematika yang sangat spesifik, atau kode yang dioptimalkan untuk satu arsitektur spesifik ... Pastikan ukuran jenisnya cukup untuk Anda (gunakan sesuatu yang lebih besar dari Int jika Anda tahu Anda akan membutuhkan lebih dari 32-bit misalnya)

Itu tidak masalah. int adalah kata kunci bahasa dan Int32 jenis sistem yang sebenarnya.

Lihat juga jawaban saya di sini untuk pertanyaan terkait.

Penggunaan Int atau Int32 adalah Int yang sama hanya gula untuk menyederhanakan kode untuk pembaca.

Gunakan varian Nullable Int? atau Int32? ketika Anda bekerja dengan database di bidang yang berisi nol. Itu akan menyelamatkan Anda dari banyak masalah runtime.

Beberapa kompiler memiliki ukuran yang berbeda untuk int pada platform yang berbeda (tidak spesifik C #)

Beberapa standar pengkodean (MISRA C) mensyaratkan bahwa semua jenis yang digunakan adalah ukuran yang ditentukan (yaitu Int32 dan bukan int).

Juga baik untuk menentukan awalan untuk variabel tipe yang berbeda (misalnya b untuk byte 8 bit, w untuk kata 16 bit, dan l untuk kata panjang 32 bit => Int32 lMyVariable)

Anda harus peduli karena itu membuat kode Anda lebih portabel dan lebih dapat dipelihara.

Portable mungkin tidak berlaku untuk C # jika Anda akan selalu menggunakan C # dan spesifikasi C # tidak akan pernah berubah dalam hal ini.

Ihmo yang dapat dipertahankan akan selalu berlaku, karena orang yang menjaga kode Anda mungkin tidak mengetahui spesifikasi C # ini, dan kehilangan bug jika sesekali menjadi lebih dari 2147483647.

Dalam for-loop sederhana yang dihitung sebagai contoh bulan dalam setahun, Anda tidak akan peduli, tetapi ketika Anda menggunakan variabel dalam konteks di mana ia bisa mengalir, Anda harus peduli.

Anda juga harus peduli jika Anda akan melakukan operasi bit-bijaksana di atasnya.

Menggunakan Int32tipe ini membutuhkan referensi namespace System, atau kualifikasi penuh ( System.Int32). Saya cenderung ke arah itu int, karena tidak memerlukan impor namespace, karena itu mengurangi kemungkinan tabrakan namespace dalam beberapa kasus. Saat dikompilasi ke IL, tidak ada perbedaan di antara keduanya.

Menurut Jendela Segera di Visual Studio 2012 Int32 adalah int, Int64 panjang. Berikut hasilnya:

sizeof(int)
4
sizeof(Int32)
4
sizeof(Int64)
8
Int32
int
    base {System.ValueType}: System.ValueType
    MaxValue: 2147483647
    MinValue: -2147483648
Int64
long
    base {System.ValueType}: System.ValueType
    MaxValue: 9223372036854775807
    MinValue: -9223372036854775808
int
int
    base {System.ValueType}: System.ValueType
    MaxValue: 2147483647
    MinValue: -2147483648

Juga pertimbangkan Int16. Jika Anda perlu menyimpan Integer dalam memori di aplikasi Anda dan Anda khawatir tentang jumlah memori yang digunakan, maka Anda bisa menggunakan Int16 karena menggunakan memeory lebih sedikit dan memiliki rentang min / max lebih kecil dari Int32 (yang int .)

Beberapa waktu yang lalu saya mengerjakan proyek dengan Microsoft ketika kami mendapat kunjungan dari seseorang di tim produk Microsoft .NET CLR. Orang ini mengkodekan contoh dan ketika dia mendefinisikan variabelnya dia menggunakan "Int32" vs "int" dan "String" vs "string".

Saya ingat melihat gaya ini dalam kode contoh lain dari Microsoft. Jadi, saya melakukan riset dan menemukan bahwa semua orang mengatakan bahwa tidak ada perbedaan antara "Int32" dan "int" kecuali untuk pewarnaan sintaks. Bahkan, saya menemukan banyak bahan yang menyarankan Anda menggunakan "Int32" untuk membuat kode Anda lebih mudah dibaca. Jadi, saya mengadopsi gayanya.

Suatu hari saya menemukan perbedaan! Kompiler tidak memungkinkan Anda mengetik enum menggunakan "Int32", tetapi ia melakukannya saat Anda menggunakan "int". Jangan tanya kenapa karena saya belum tahu.

Contoh:

public  enum MyEnum : Int32
{
    AEnum = 0
}

Ini bekerja.

public enum MyEnum : int
{
    AEnum = 0
}

Diambil dari: Int32 notation vs int