ฉันควรใช้ int หรือ Int32

352

ใน C # intและInt32เป็นสิ่งเดียวกัน แต่ฉันได้อ่านหลายครั้งที่intต้องการมากกว่าInt32โดยไม่มีเหตุผล มีเหตุผลหรือไม่และฉันควรจะใส่ใจไหม?

c# variable-types

— Graham
แหล่งที่มา

ทวีตโดย Skeet เกี่ยวกับสิ่งนี้ซึ่งเขาชอบ Int32 มากกว่า int เมื่อตั้งโปรแกรม API

— comecme

@JohnBubriski และให้ไม่ลืมว่ามันต้องใช้งบน้อยลงที่จะใช้มัน (หรือคุณต้องการจะพิมพ์System.Int32)

— sehe

ฉันมีคำถาม: เราไม่ได้ใช้ประเภท CLR โดยตรง แต่ทำไมเราต้องการพวกเขา ??

— AminM

@JohnBubriski อัพเดทสถานะ Facebook นั้นง่ายกว่าการพิมพ์รหัส คิดไม่ดีอยู่ที่นั่น! การอ่านและทำความเข้าใจง่ายขึ้นมีความสำคัญมากกว่าพิมพ์ง่ายกว่า When something can be read without effort, great effort has gone into its writing. Easy writing is hard reading

— 7hi4g0

เป็นไปได้ที่ซ้ำกันของความแตกต่างระหว่างสตริงและสตริงใน C # คืออะไร?

— โคลจอห์นสัน

134

ECMA-334 : 2006 C # ภาษาสเปค (p18):

ประเภทที่กำหนดไว้ล่วงหน้าแต่ละประเภทเป็นแบบย่อสำหรับประเภทที่ระบบจัดให้ ยกตัวอย่างเช่นคำที่intหมายถึงการที่ System.Int32struct เป็นเรื่องของสไตล์การใช้คำหลักเป็นที่นิยมมากกว่าการใช้ชื่อประเภทระบบที่สมบูรณ์

— SpaceghostAli
แหล่งที่มา

271

ทั้งสองมีความหมายเหมือนกันแน่นอน; intจะดูคุ้นเคยเล็กน้อยขึ้นInt32ทำให้พยาน 32 คนชัดเจนมากขึ้นสำหรับผู้ที่อ่านรหัสของคุณ ฉันอยากจะใช้intเมื่อฉันต้องการ 'จำนวนเต็ม' Int32ซึ่งขนาดนั้นสำคัญ (รหัสการเข้ารหัสโครงสร้าง) ดังนั้นผู้ดูแลในอนาคตจะรู้ว่ามันปลอดภัยที่จะขยายintหากเหมาะสม แต่ควรดูแลการเปลี่ยนแปลงInt32ในลักษณะเดียวกัน

รหัสผลลัพธ์จะเหมือนกัน: ความแตกต่างเป็นเพียงหนึ่งในการอ่านหรือการปรากฏตัวของรหัส

— user6779
แหล่งที่มา

65

ผู้ที่อ่านรหัสของคุณควรรู้ว่า int เป็นนามแฝงสำหรับ System.Int32 สำหรับความสามารถในการอ่านความมั่นคงมีความสำคัญมากกว่า

— Troels Thomsen

11

สำหรับผู้ที่มี C ++ mindset แบบเก่า IntPtr ได้รับการออกแบบให้เป็น 32 บิตในระบบปฏิบัติการ 32 บิตและ 64 บิตในระบบปฏิบัติการ 64 บิต พฤติกรรมนี้ถูกกล่าวถึงโดยเฉพาะในแท็กสรุป msdn.microsoft.com/en-us/library/system.intptr(VS.71).aspx

— มงกุฎ

87

พวกเขาทั้งสองประกาศจำนวนเต็ม 32 บิตและตามที่ผู้โพสต์อื่นระบุ อย่างไรก็ตามพวกเขาไม่ได้ทำตัวแบบเดียวกันเสมอไป ตัวอย่างเช่นคอมไพเลอร์ C # จะไม่อนุญาตสิ่งนี้:

public enum MyEnum : Int32
{
    member1 = 0
}

แต่มันจะช่วยให้สิ่งนี้:

public enum MyEnum : int
{
    member1 = 0
}

ไปคิด

— ดำขลับ
แหล่งที่มา

9

หากคุณใช้ตัวสะท้อนสัญญาณเพื่อตรวจสอบชนิดของ System.Int32 คุณจะพบว่ามันเป็นโครงสร้างและไม่ใช่คลาส รหัสมีลักษณะดังนี้: [Serializable, StructLayout (LayoutKind.Sequential), ComVisible (จริง)] public struct Int32: IComparable, IFormattable, IConvertible, IComparable <int>, IEquatable <int> const const int MaxValue = 0x7fffffffffff; ... คุณไม่สามารถหาประเภทจากโครงสร้างได้ อย่างน้อยที่สุดคุณจะได้รับข้อผิดพลาดที่แจ้งให้คุณทราบ อย่างไรก็ตามพฤติกรรม enum แตกต่างกันเล็กน้อยซึ่งฉันจะแสดงความคิดเห็นต่อไป

— raddevus

16

การไม่สามารถรับ enum จาก Int32 เป็นพฤติกรรมที่ออกแบบมาซึ่งสามารถมองเห็นได้ด้วยการดูรหัส. NET: [Serializable, ComVisible (จริง)] คลาสนามธรรมสาธารณะสาธารณะ Enum: ValueType, IComparable, IFormattable สังเกตว่า Enum มา จาก ValueType? หากคุณพยายามหาค่า enum จากสิ่งอื่นนอกเหนือจากชนิดข้อมูลภายใน (int, ไบต์ ฯลฯ ) คุณจะได้รับข้อผิดพลาดที่มีลักษณะดังนี้: พิมพ์ไบต์, sbyte, สั้น, ushort, int, uint, long หรือ ulong ที่คาดไว้ .

— raddevus

2

@daylight หมายเหตุว่าการระบุการenumใช้intไม่ใช่ไม่ใช่deriveแต่เป็นการระบุunderlying type; ดูmsdn.microsoft.com/en-us/library/sbbt4032.aspx#code-snippet-2

— Jeroen Wiert Pluimers

2

@JeroenWiertPluimers แต่ก็ยังน่าสนใจว่าทำไมพวกเขาเลือกที่จะตรวจสอบประเภทพื้นฐานและโยนCS1008ตามประเภทพื้นฐานเป็นเพียงประเภทของค่าคงที่ใน enum ดังนั้นจึงไม่สำคัญเมื่อรวบรวม

— IllidanS4 ต้องการโมนิก้ากลับ

5

@ IllidanS4 พร้อมคอมไพเลอร์ใหม่ Roslyn - สิ่งนี้ได้รับการแก้ไขและตัวแปรทั้งสองใช้ได้

— Grundy

49

ฉันมักจะใช้ประเภทระบบ - เช่นแทนInt32 intฉันยอมรับการฝึกนี้หลังจากอ่านการเขียนโปรแกรม. NET Framework - ผู้แต่ง Jeffrey Richter เป็นกรณีที่ดีสำหรับการใช้ชื่อเต็มประเภท นี่คือจุดสองจุดที่ติดอยู่กับฉัน:

ชื่อประเภทอาจแตกต่างกันระหว่างภาษา. NET ตัวอย่างเช่นใน C # longจะจับคู่กับ System.Int64 ในขณะที่อยู่ใน C ++ ที่มีส่วนขยายที่มีการจัดการlongแม็พกับ Int32 เนื่องจากภาษาสามารถผสมและจับคู่ได้ในขณะที่ใช้. NET คุณจึงมั่นใจได้ว่าการใช้ชื่อคลาสที่ชัดเจนจะชัดเจนกว่าเสมอไม่ว่าผู้ใช้จะต้องการภาษาใด

วิธีเฟรมเวิร์กจำนวนมากมีชื่อชนิดเป็นส่วนหนึ่งของชื่อเมธอด:

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

— Remi Despres-Smyth
แหล่งที่มา

ปัญหาเกี่ยวกับสิ่งนี้คือ Visual Studio auto-complete ยังคงใช้ int ดังนั้นถ้าคุณทำList<Tuple<Int32, Boolean>> test = new, Visual Studio List<Tuple<int, bool>>()ตอนนี้จะแทรก คุณรู้วิธีเปลี่ยนการเติมคำอัตโนมัติเหล่านี้หรือไม่?

— MrFox

2

ใช่มันเป็นปัญหา ไม่ฉันไม่ทราบวิธีการเปลี่ยนพวกเขาทันที Point # 2 ไม่ใช่ปัญหาอีกต่อไปสำหรับฉันเนื่องจากฉันมักจะใช้varมากที่สุดเพื่อลดความ wordiness ของรหัส ในบางครั้งที่การเติมข้อความอัตโนมัติเข้ามาและถ่มน้ำลายลงบนพื้นฉันปรับตัวเอง - เป็นเวลาหนึ่งหรือสองวินาที

— Remi Despres-Smyth

20

int เป็นคำหลัก C # และไม่คลุมเครือ

ส่วนใหญ่แล้วมันไม่สำคัญ แต่มีสองสิ่งที่ขัดแย้งกับ Int32:

คุณต้องมี "กำลังใช้ระบบ" คำให้การ. ใช้ "int" ไม่จำเป็นต้องใช้คำสั่ง
เป็นไปได้ที่จะกำหนดคลาสของคุณเองที่เรียกว่า Int32 (ซึ่งจะโง่และสับสน) int มักจะหมายถึง int

— ผี
แหล่งที่มา

นอกจากนี้ยังเป็นไปได้ที่จะสร้างคลาส 'var' ของคุณเอง แต่นั่นไม่ทำให้ผู้คนไม่สามารถใช้งานได้

— Neme

คำหลักทุกคำเป็นคำหลัก C # int ถูกใช้ไปแล้วใน C และ C ++ ดังนั้นจึงไม่มีอะไรพิเศษเกี่ยวกับมัน C #

— MrFox

12

ตามที่ระบุไว้แล้วint= Int32. เพื่อความปลอดภัยให้แน่ใจว่าได้ใช้int.MinValue/ int.MaxValueเมื่อใช้สิ่งที่ใส่ใจเกี่ยวกับขอบเขตชนิดข้อมูลเสมอ สมมติว่า. NET ตัดสินใจว่าintจะเป็นไปได้ในตอนนี้Int64รหัสของคุณจะขึ้นอยู่กับขอบเขตน้อยกว่า

— spoulson
แหล่งที่มา

8

@spoulson: ข้อผิดพลาดความคิดเห็นในบรรทัดที่ 1: การกำหนดห้ามระหว่างประเภทที่เท่ากัน ใช่เป็นเรื่องตลกที่ไม่ดี

— Johann Gerell

22

ถ้า C # ข้อมูลจำเพาะ (มัน C # ไม่ตัดสินใจ .NET) เคยตัดสินใจที่จะเปลี่ยนที่จะทำให้int64 บิตที่จะเป็นเช่นการเปลี่ยนแปลงทำลายที่ผมไม่เชื่อว่ามันเป็นไปได้ (หรือที่เหมาะสมอย่างแน่นอน) รหัส defensively กับ eventualities ดังกล่าว

— Jon Skeet

9

ขนาดไบต์สำหรับประเภทไม่น่าสนใจเกินไปเมื่อคุณต้องจัดการกับภาษาเดียว (และสำหรับรหัสที่คุณไม่ต้องเตือนตัวเองเกี่ยวกับคณิตศาสตร์ล้น) ส่วนที่น่าสนใจคือเมื่อคุณเชื่อมโยงระหว่างภาษาหนึ่งไปยังอีกภาษาหนึ่งวัตถุ C # ถึง COM ฯลฯ หรือคุณกำลังทำการขยับบิตหรือปิดบังและคุณต้องเตือนตัวเอง (และผู้ตรวจทานโค้ดของคุณ) ของขนาดของข้อมูล

ในทางปฏิบัติฉันมักจะใช้ Int32 เพียงเพื่อเตือนตัวเองว่าพวกเขามีขนาดเท่าไหร่เพราะฉันเขียน C ++ ที่ได้รับการจัดการ (เพื่อเชื่อมต่อกับ C #) เช่นเดียวกับ C ++ ที่ไม่มีการจัดการ

ตราบใดที่คุณอาจรู้ว่าใน C # เป็น 64- บิต แต่ใน C ++ พื้นเมืองมันจะจบลงที่ 32- บิตหรือถ่านเป็น Unicode / 16-bits ในขณะที่ใน C ++ มันเป็น 8 บิต แต่เราจะรู้ได้อย่างไร คำตอบคือเพราะเราได้ค้นหาในคู่มือแล้วก็พูดอย่างนั้น

ด้วยเวลาและประสบการณ์คุณจะเริ่มมีความขยันขันแข็งมากขึ้นเมื่อคุณเขียนรหัสเพื่อเชื่อมระหว่างภาษา C # กับภาษาอื่น ๆ (ผู้อ่านบางคนกำลังคิดว่า "ทำไมต้องเป็นคุณ?") แต่ IMHO ฉันเชื่อว่าเป็นวิธีที่ดีกว่าเพราะ ฉันจำไม่ได้ว่าสิ่งที่ฉันเขียนเมื่อสัปดาห์ที่แล้ว (หรือฉันไม่จำเป็นต้องระบุในเอกสาร API ของฉันว่า "พารามิเตอร์นี้เป็นจำนวนเต็ม 32- บิต")

ในF # (แม้ว่าฉันไม่เคยใช้มัน) พวกเขาให้คำจำกัดความint , int32และnativeint nativeintคำถามเดียวกันควรเพิ่มขึ้น "ฉันจะใช้อันไหนดี?" ตามที่คนอื่น ๆ พูดถึงในกรณีส่วนใหญ่มันไม่ควรสำคัญ (ควรมีความโปร่งใส) แต่ฉันจะเลือก int32 และ uint32 เพียงเพื่อลบความคลุมเครือ

ฉันเดาว่ามันจะขึ้นอยู่กับแอปพลิเคชันที่คุณกำลังใช้รหัสใครใช้มันการเข้ารหัสที่คุณและทีมของคุณปฏิบัติตามนั้น ฯลฯ เพื่อพิสูจน์ว่าเมื่อใดควรใช้ Int32

— ฮิเดกิ
แหล่งที่มา

นั่นไม่ได้เป็นการทำให้วัตถุประสงค์ของ. net เป็นโมฆะใช่ไหม F # คืออะไรนะความคิดเกตส์มีที่เดินออกไปพร้อมกับการเกษียณอายุของเขา ...

— นิคเทอร์เนอ

8

ไม่มีความแตกต่างระหว่าง intและInt32แต่เป็นintคำหลักภาษาที่หลายคนชอบมันโวหาร (เช่นเดียวกับstringvs String)

— Simon Steele
แหล่งที่มา

7

จากประสบการณ์ของฉันมันเป็นเรื่องของการประชุม ฉันไม่ทราบถึงเหตุผลทางเทคนิคใด ๆ ที่จะใช้ int เหนือ Int32 แต่เป็น:

พิมพ์เร็วกว่า
คุ้นเคยกับนักพัฒนา C # ทั่วไปมากกว่า
สีที่แตกต่างในการเน้นไวยากรณ์สตูดิโอภาพเริ่มต้น

ฉันชอบที่ล่าสุดโดยเฉพาะอย่างยิ่ง :)

— Greg D
แหล่งที่มา

7

ฉันมักจะใช้ประเภทนามแฝง (int, string ฯลฯ ) เมื่อกำหนดตัวแปรและใช้ชื่อจริงเมื่อเข้าถึงวิธีคงที่:

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

ดูเหมือนว่าน่าเกลียดที่จะเห็นสิ่งที่เหมือน int.TryParse () ไม่มีเหตุผลอื่นที่ฉันทำสิ่งนี้นอกจากสไตล์

— Mark A. Nicolosi
แหล่งที่มา

5

ฉันรู้ว่าแนวทางปฏิบัติที่ดีที่สุดคือการใช้ int และรหัส MSDN ทั้งหมดใช้ int อย่างไรก็ตามไม่มีเหตุผลใดที่นอกเหนือไปจากมาตรฐานและความสม่ำเสมอเท่าที่ฉันรู้

— Raithlin
แหล่งที่มา

5

แม้ว่าจะเหมือนกัน (ส่วนใหญ่) เหมือนกัน (ดูด้านล่างสำหรับความแตกต่าง [ข้อผิดพลาด]) คุณควรใส่ใจอย่างแน่นอนและคุณควรใช้ Int32

ชื่อสำหรับจำนวนเต็ม 16 บิตคือ Int16 สำหรับจำนวนเต็ม 64 บิตเป็น Int64 และสำหรับจำนวนเต็มแบบ 32 บิตตัวเลือกที่ใช้งานง่ายคือ: int หรือ Int32
คำถามเกี่ยวกับขนาดของตัวแปรประเภท Int16, Int32 หรือ Int64 คือการอ้างอิงตนเอง แต่คำถามของขนาดของตัวแปรประเภท int นั้นเป็นคำถามและคำถามที่ถูกต้องสมบูรณ์แบบไม่ว่าจะเป็นเรื่องเล็กน้อยกวนใจ ความสับสนเวลาที่เสียไปขัดขวางการพูดคุย ฯลฯ (ความจริงคำถามนี้มีอยู่พิสูจน์จุด)
การใช้ Int32 ส่งเสริมให้นักพัฒนาตระหนักถึงการเลือกประเภทของพวกเขา int ใหญ่แค่ไหนอีกครั้ง โอ้ใช่แล้ว 32. ความน่าจะเป็นที่ขนาดของประเภทนั้นจะได้รับการพิจารณานั้นยิ่งใหญ่กว่าเมื่อมีการรวมขนาดไว้ในชื่อ การใช้ Int32 ยังส่งเสริมความรู้เกี่ยวกับตัวเลือกอื่น ๆ เมื่อคนไม่ถูกบังคับให้จำอย่างน้อยก็มีทางเลือกมันกลายเป็นเรื่องง่ายเกินไปที่ int จะกลายเป็น "ประเภทจำนวนเต็ม"
คลาสภายในกรอบงานที่ต้องการโต้ตอบกับจำนวนเต็ม 32 บิตมีชื่อว่า Int32 อีกครั้งซึ่งก็คือ: ใช้งานง่ายมากขึ้นสับสนน้อยลงขาดการแปล (ไม่จำเป็น) (ไม่ใช่การแปลในระบบ แต่ในใจของนักพัฒนา) ฯลฯ int lMax = Int32.MaxValueหรือInt32 lMax = Int32.MaxValue?
int ไม่ใช่คำหลักในทุกภาษา. NET
แม้ว่าจะมีข้อโต้แย้งว่าทำไมมันจึงไม่น่าจะเปลี่ยนแปลง แต่ int อาจไม่ใช่ Int32 เสมอไป

ข้อเสียคืออักขระพิเศษสองตัวที่จะพิมพ์และ [ข้อผิดพลาด]

สิ่งนี้จะไม่รวบรวม

public enum MyEnum : Int32
{
    AEnum = 0
}

แต่จะ:

public enum MyEnum : int
{
    AEnum = 0
}

— ไม่ทราบ84% (yahoo)
แหล่งที่มา

คุณพูดว่า "ชื่อสำหรับจำนวนเต็ม 16 บิตคือ Int16 สำหรับจำนวนเต็ม 64 บิตเป็น Int64 และสำหรับจำนวนเต็ม 32 บิตตัวเลือกที่ใช้งานง่ายคือ: int หรือ Int32?" แต่มีคำหลัก C # สำหรับคำเหล่านี้เช่นกัน Int16 = สั้น Int64 = ยาวดังนั้นจุดหนึ่งในคำตอบของคุณขึ้นอยู่กับสมมติฐานที่ไม่ถูกต้อง

— Mel

"ตัวแปรประเภท int เป็นคำถามและคำถามที่ถูกต้องสมบูรณ์แบบไม่ว่าจะเป็นเรื่องเล็กน้อยกวนใจนำไปสู่ความสับสนเสียเวลาขัดขวางการสนทนา ฯลฯ (ความจริงคำถามนี้มีอยู่พิสูจน์ประเด็น)" คุณล้อเล่นกับฉันไหม คุณทำงานในภาษาที่คุณไม่เข้าใจสิ่งที่อยู่เบื้องหลังประทุน หากนักพัฒนาไม่เข้าใจว่าประเภทดั้งเดิมนั้นเท่ากับเขาควรใช้ศิลปะการทำอาหาร เสียงเหมือนนักพัฒนา VB การใช้แบบดั้งเดิมนั้นมีถิ่นกำเนิดในภาษาใด ๆ และควรเป็นที่ต้องการ ไม่เป็นไรถ้าคุณไม่ชอบคนโบราณ แต่ไม่ต้องทำให้เป็นจริง

— Nick Turner

อืมฉันไม่เห็นด้วยกับความคิดเห็นของคุณที่ฉันควรสนใจ ... แต่ฉันไม่รู้ว่า enums สามารถสืบทอดมาจากคำหลักเท่านั้น ความจริงที่ไร้ประโยชน์สวย แต่ยังคงความสนุกสนานที่จะรู้ :)

— Jowen

4

คุณไม่ควรสนใจ คุณควรใช้intเวลาส่วนใหญ่ มันจะช่วยในการย้ายโปรแกรมของคุณไปสู่สถาปัตยกรรมที่กว้างขึ้นในอนาคต (ปัจจุบันintเป็นนามแฝงSystem.Int32แต่อาจเปลี่ยนแปลงได้) เมื่อความกว้างบิตของตัวแปรสำคัญ (ตัวอย่างเช่น: เพื่อควบคุมเค้าโครงในหน่วยความจำของ a struct) คุณควรใช้int32และอื่น ๆ (พร้อมกับ "" ที่เกี่ยวข้องusing System;)

— yhdezalvarez
แหล่งที่มา

1

คุณไม่จริงจัง ... ทำให้การย้ายพอร์ตง่ายขึ้นใช่ไหม ฉันไม่คิดว่าการค้นหาและแทนที่นั้นเป็นเรื่องใหญ่

— Vince Panuccio

2

(ปัจจุบัน int เป็นชื่อแทน System.Int32 แต่อาจเปลี่ยนได้) ? โอ้มาหนึ่ง ... คุณจริงจังไหม

— Oybek

ทำไมคุณถึงเขียนโค้ดเป็นภาษาที่คุณต้องการทิ้งในที่สุด? ดูเหมือนว่าโดยการตัดสินใจของผู้บริหาร ใช้ int หรือ Int32 Int32 ดูเหมือนว่า VB

— Nick Turner

สิ่งที่ฉันหมายถึงคือ MAYBE (และเป็น MAYBE ใหญ่ฉันไม่รู้จริง ๆ ว่าทำไมนักออกแบบทำแบบนั้น) คุณควรมีวิธีที่จะประกาศ int ที่มีความกว้างเท่ากับโค้งที่คุณกำลังวิ่งอยู่ เหมือนงานของ int / long / ... นี่คือกลไก (int ถึง alias int32) ที่ดูเหมือนว่าได้รับการออกแบบมาเพื่อทำสิ่งนี้ และคำนึงถึงด้วยว่า Microsoft แนะนำให้ใช้ "int" กับ "Int32" เสมอ (เช่นเดียวกับที่พวกเขาทำหากนี่เป็นความตั้งใจดั้งเดิมของพวกเขา) ฉันรู้ว่ามันเป็นเรื่องใหญ่ถ้า ... เมื่อฉันเขียนคำตอบนี้ไม่มีกรอบ 64 บิต. NET ดังนั้นฉันจึงไม่รู้ว่าพวกเขาจะทำอะไรในกรณีนี้

— Yanko Hernández Alvarez

3

int คือทางลัดของภาษา C # สำหรับ System.Int32

ในขณะที่นี่หมายความว่า Microsoft สามารถเปลี่ยนการแมปนี้โพสต์ในการสนทนาของ FogCreek ระบุ[แหล่งที่มา]

"ในประเด็น 64 บิต - Microsoft กำลังทำงานกับ. NET Framework รุ่น 64 บิต แต่ฉันค่อนข้างมั่นใจว่า int จะไม่จับคู่กับ 64 บิตในระบบนั้น

เหตุผล:

1. มาตรฐาน C # ECMA ระบุว่า int คือ 32 บิตและยาวคือ 64 บิต

2. Microsoft แนะนำคุณสมบัติและวิธีการเพิ่มเติมใน Framework เวอร์ชัน 1.1 ที่ส่งคืนค่าแบบยาวแทนค่า int เช่น Array.GetLongLength นอกเหนือจาก Array.GetLength

ดังนั้นฉันคิดว่ามันปลอดภัยที่จะบอกว่า C-type ในตัวทั้งหมดจะเก็บการแมปปัจจุบันของพวกเขาไว้ "

— เรย์เฮย์ส
แหล่งที่มา

หากมีการแนะนำรุ่น 64 บิตพวกเขาอาจจะเพิ่ม 'nativeint' ลงใน C # (เนื่องจากมีการใช้งานใน F # ในปัจจุบัน) นี่เป็นการตอกย้ำว่าการแนะนำ 'int' และการกำหนดสิ่งนี้ในฐานะ Int32 เป็นความผิดพลาด! และไม่สอดคล้องกันจาก API (เช่น ReadInt32 ไม่ใช่ ReadInt), สี (สีน้ำเงินเข้มเทียบกับสีฟ้าอ่อน) และความไวของตัวพิมพ์เล็ก (DateTime vs int) นั่นคือสาเหตุที่ประเภทค่า 'DateTime' ไม่มีชื่อแทนเช่น Int32

— คาร์โลบอส

3

int เหมือนกันกับ System.Int32 และเมื่อรวบรวมมันจะกลายเป็นสิ่งเดียวกันค่ะ CIL

เราใช้ int โดยการประชุมใน C # เนื่องจาก C # ต้องการดูเหมือน C และ C ++ (และ Java) และนั่นคือสิ่งที่เราใช้ที่นั่น ...

BTW ฉันจะใช้ System.Int32 เมื่อประกาศการนำเข้าฟังก์ชั่น Windows API ต่างๆ ฉันไม่แน่ใจว่านี่เป็นการประชุมที่กำหนดไว้หรือไม่ แต่มันทำให้ฉันนึกถึงว่าฉันกำลังจะไปยัง DLL ภายนอก ...

— Jack Bolding
แหล่งที่มา

3

กาลครั้งหนึ่งชนิดข้อมูล int ถูกตรึงไว้กับขนาดการลงทะเบียนของเครื่องที่กำหนดเป้าหมายโดยคอมไพเลอร์ ตัวอย่างเช่นคอมไพเลอร์สำหรับระบบ 16 บิตจะใช้จำนวนเต็ม 16 บิต

แต่เราโชคดีที่ไม่ได้เห็นมาก 16 บิตใด ๆ มากขึ้นและเมื่อ 64 บิตเริ่มที่จะรับคนที่นิยมมีความกังวลมากขึ้นด้วยการทำให้มันเข้ากันได้กับซอฟแวร์ที่มีอายุมากกว่าและ 32 บิตได้รับรอบนานมากว่าสำหรับคอมไพเลอร์มากที่สุดintถูกสันนิษฐานว่าเป็น 32 บิต

— Peter Mortensen
แหล่งที่มา

3

ฉันขอแนะนำให้ใช้ไมโครซอฟท์StyleCop

มันเหมือนกับFxCopแต่สำหรับปัญหาที่เกี่ยวข้องกับสไตล์ การกำหนดค่าเริ่มต้นตรงกับคู่มือลักษณะภายในของ Microsoft แต่สามารถปรับแต่งให้เหมาะกับโครงการของคุณ

อาจใช้เวลาสักครู่เพื่อทำความคุ้นเคย แต่แน่นอนว่าทำให้โค้ดของคุณดีกว่า

คุณสามารถรวมไว้ในกระบวนการสร้างของคุณเพื่อตรวจสอบการละเมิดโดยอัตโนมัติ

— devstuff
แหล่งที่มา

ฉันไม่เห็นด้วยกับ StyleCop ในอันนี้ ใช่มันดี แต่ฉันชอบใช้ Int32 ทำไม เพื่อหลีกเลี่ยงคำตอบเช่นคำตอบสองข้อ ผู้คนสับสน Int32 กับการแสดง ints ใน C

— John Demetriou

2

intและInt32เหมือนกัน เป็นนามแฝงสำหรับintInt32

— Jesper Kihlberg
แหล่งที่มา

int ไม่ใช่ชื่อแทนมันเป็นคำหลัก ดูคำตอบอื่น ๆ

— Timores

int เป็นคำหลักที่แน่นอนสำหรับภาษา แต่ก็สามารถเรียกว่านามแฝงของ System.Int32 นอกจากนี้วิธีคิดอีกอย่างคือคุณมี using int = System.Int32; คำสั่งสำหรับไฟล์ซอร์สโค้ดทั้งหมดของคุณ

— uygar donduran

2

คุณไม่ควรสนใจ หากขนาดเป็นเรื่องที่น่ากังวลฉันจะใช้ไบต์สั้น int แล้วยาว เหตุผลเดียวที่คุณจะใช้ int ที่ใหญ่กว่า int32 คือถ้าคุณต้องการตัวเลขที่สูงกว่า 2147483647 หรือต่ำกว่า -2147483648

นอกจากนั้นฉันจะไม่แคร์มีรายการอื่น ๆ อีกมากมายที่ต้องกังวล

— David Basarab
แหล่งที่มา

ฉันจะเพิ่มว่าคุณสามารถใช้คำหลัก "ยาว" แทน System.Int64

— Keith

22

คุณเข้าใจผิดคำถาม OP กำลังถามว่ามีความแตกต่างระหว่างการประกาศ "int i" และ "Int32 i" หรือไม่

— กา

2

มันไม่ได้ทำให้ความแตกต่างในทางปฏิบัติและในเวลาที่คุณจะยอมรับการประชุมของคุณเอง ฉันมักจะใช้คำหลักเมื่อกำหนดประเภทและรุ่นระดับเมื่อใช้วิธีการคงที่และเช่น:

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

— chrisb
แหล่งที่มา

1

intเป็นนามแฝงสำหรับSystem.Int32ตามที่กำหนดไว้ในตารางนี้: ตาราง ชนิดในตัว (การอ้างอิง C #)

— Jim T
แหล่งที่มา

1

ฉันใช้ int ในกรณีที่ Microsoft เปลี่ยนการใช้งานเริ่มต้นสำหรับจำนวนเต็มเป็นรุ่น fangled ใหม่ (ลองเรียกมันว่า Int32b)

Microsoft สามารถเปลี่ยนนามแฝง int เป็น Int32b และฉันไม่จำเป็นต้องเปลี่ยนรหัสใด ๆ ของฉันเพื่อใช้ประโยชน์จากการดำเนินการจำนวนเต็มใหม่ของพวกเขา (และปรับปรุงโดยหวังว่า)

เช่นเดียวกันสำหรับคำหลักประเภทใด ๆ

— anon
แหล่งที่มา

0

คุณไม่ควรสนใจภาษาการเขียนโปรแกรมส่วนใหญ่เว้นแต่คุณจะต้องเขียนฟังก์ชั่นทางคณิตศาสตร์ที่เฉพาะเจาะจงมาก ๆ หรือรหัสที่เหมาะสำหรับสถาปัตยกรรมเฉพาะอย่างใดอย่างหนึ่ง ... ตรวจสอบให้แน่ใจว่าขนาดของประเภทนั้นเพียงพอสำหรับคุณรู้ว่าคุณต้องการตัวอย่างมากกว่า 32 บิต)

— stacker
แหล่งที่มา

0

มันไม่สำคัญ int คือคำหลักภาษาและ Int32 ชนิดของระบบที่แท้จริง

ดูคำตอบของฉันที่นี่สำหรับคำถามที่เกี่ยวข้อง

— Keith
แหล่งที่มา

0

การใช้งาน Int หรือ Int32 นั้นเหมือนกัน Int นั้นเป็นเพียงแค่น้ำตาลเพื่อลดความซับซ้อนของรหัสสำหรับผู้อ่าน

ใช้ชุดตัวแปร Nullable Int หรือไม่ หรือ Int32 เมื่อคุณทำงานกับฐานข้อมูลในเขตข้อมูลที่มีค่า Null ที่จะช่วยให้คุณประหยัดจากปัญหา runtime มากมาย

— bovium
แหล่งที่มา

0

คอมไพเลอร์บางตัวมีขนาดแตกต่างกันสำหรับ int บนแพลตฟอร์มที่แตกต่างกัน (ไม่เฉพาะ C #)

มาตรฐานการเข้ารหัสบางอย่าง (MISRA C) กำหนดให้ทุกประเภทที่ใช้มีการระบุขนาด (เช่น Int32 และไม่ใช่ int)

นอกจากนี้ยังเป็นการดีที่จะระบุคำนำหน้าสำหรับตัวแปรประเภทต่างๆ (เช่น b สำหรับ 8 บิตไบต์, w สำหรับคำ 16 บิตและ l สำหรับคำยาว 32 บิต => Int32 lMyVariable)

คุณควรใส่ใจเพราะมันจะทำให้โค้ดของคุณพกพาได้ง่ายขึ้นและบำรุงรักษาได้มากขึ้น

พกพาอาจไม่สามารถใช้ได้กับ C # หากคุณจะใช้ C # เสมอและข้อกำหนด C # จะไม่เปลี่ยนแปลงในเรื่องนี้

การบำรุงรักษา ihmo จะสามารถใช้งานได้ตลอดเวลาเพราะผู้ที่รักษารหัสของคุณอาจไม่ทราบถึงข้อกำหนด C # นี้โดยเฉพาะและพลาดจุดบกพร่องซึ่งบางครั้ง int จะกลายเป็นมากกว่า 2147483647

ใน for-loop ที่นับตัวอย่างเช่นเดือนของปีคุณจะไม่สนใจ แต่เมื่อคุณใช้ตัวแปรในบริบทที่มันอาจเป็นไปได้ที่ไหลคุณควรดูแล

คุณควรใส่ใจด้วยว่าคุณกำลังจะทำสิ่งที่ชาญฉลาดหรือไม่

— user11211
แหล่งที่มา

มันไม่ได้ทำให้แตกต่างใน. สุทธิ - int อยู่เสมอ Int32 และยาวอยู่เสมอ Int64

— Keith

It is also good to specify prefixes for different type variablesสัญกรณ์ฮังการีจะเลิกในปัจจุบันส่วนใหญ่และรูปแบบการเข้ารหัสส่วนใหญ่กีดกันการใช้งานของมัน อนุสัญญาภายในของ บริษัท ซอฟต์แวร์มักจะห้ามสัญกรณ์นั้น

— phuclv

0

การใช้Int32ชนิดนั้นต้องการการอ้างอิงเนมสเปซSystemหรือหรือมีคุณสมบัติครบถ้วน ( System.Int32) ฉันมักจะไปintเพราะมันไม่จำเป็นต้องมีการนำเข้าเนมสเปซดังนั้นจึงลดโอกาสของการชนกันของเนมสเปซในบางกรณี เมื่อรวบรวมไปยัง IL จะไม่มีความแตกต่างระหว่างทั้งสอง

— Michael Meadows
แหล่งที่มา

0

ตามหน้าต่างค้นหาทันทีใน Visual Studio 2012 Int32 เป็น int นั้น Int64 นั้นยาว นี่คือผลลัพธ์:

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

— Selim
แหล่งที่มา

0

พิจารณา Int16 ด้วย หากคุณต้องการเก็บจำนวนเต็มในหน่วยความจำในแอปพลิเคชันของคุณและคุณกังวลเกี่ยวกับจำนวนหน่วยความจำที่ใช้คุณสามารถไปกับ Int16 ได้เนื่องจากมันใช้หน่วยความจำน้อยกว่าและมีช่วงนาที / แม็กซ์เล็กกว่า Int32 .)

— Chris Pietschmann
แหล่งที่มา

0

ซักพักฉันกำลังทำงานโปรเจ็กต์กับ Microsoft เมื่อเราได้รับการติดต่อจากบางคนในทีมผลิตภัณฑ์ Microsoft .NET CLR บุคคลนี้เขียนตัวอย่างและเมื่อเขากำหนดตัวแปรเขาใช้“ Int32” กับ“ int” และ“ String” กับ“ string”

ฉันจำได้ว่าเคยเห็นสไตล์นี้ในโค้ดตัวอย่างอื่นจาก Microsoft ดังนั้นฉันจึงทำการวิจัยและพบว่าทุกคนบอกว่าไม่มีความแตกต่างระหว่าง "Int32" และ "int" ยกเว้นการระบายสีไวยากรณ์ ที่จริงแล้วฉันพบวัสดุจำนวนมากแนะนำให้คุณใช้“ Int32” เพื่อทำให้โค้ดของคุณอ่านง่ายขึ้น ดังนั้นฉันจึงนำสไตล์

วันก่อนฉันพบความแตกต่าง! คอมไพเลอร์ไม่อนุญาตให้คุณพิมพ์ enum โดยใช้“ Int32” แต่จะทำเมื่อคุณใช้“ int” อย่าถามฉันทำไมเพราะฉันยังไม่รู้

ตัวอย่าง:

public  enum MyEnum : Int32
{
    AEnum = 0
}

วิธีนี้ใช้ได้ผล

public enum MyEnum : int
{
    AEnum = 0
}

นำมาจาก: สัญกรณ์ Int32 กับ int

— Schmuli
แหล่งที่มา