คุณตั้งชื่อตัวแปรส่วนตัวใน C # ได้อย่างไร [ปิด]

แนวปฏิบัติที่ดีที่สุดคืออะไรหลักการจัดการการตั้งชื่อที่ยอมรับกันทั่วไปสำหรับตัวแปรส่วนตัวใน C #

1. private int myInteger;
2. private int MyInteger;
3. private int mMyInteger;
4. private int _myInteger;
5. private int _MyInteger;
6. ตัวเลือกอื่น ๆ ที่ลึกลับ

คุณใช้อันไหนและเพราะอะไร (บริษัท ของฉันค่อนข้างใหม่สำหรับ C # และฉันต้องการเลือกวิธี "ยอมรับในอุตสาหกรรม" มากที่สุดเพื่อลองใช้มาตรฐานการเข้ารหัสของเรา)

แนวทางการออกแบบคลาส MSDN http://msdn.microsoft.com/en-us/library/ta31s3bc.aspxแนะนำตัวเลือกที่ 1 - myInteger

ฉันมักจะใช้สไตล์นี้ ฉันไม่ชอบส่วนตัวสำหรับตัวละคร _

ฉันใช้ตัวเลือก # 4 ด้านบน:

private int _myInteger;

ฉันชอบที่จะมีการบ่งชี้ขอบเขตในชื่อตัวแปรของฉันและขีดเส้นใต้ก็เพียงพอสำหรับวัตถุประสงค์นั้น นอกจากนี้ยังง่ายต่อการอ่าน

ฉันใช้รูปแบบการตั้งชื่อต่อไปนี้:

• 1st (myInteger) สำหรับตัวแปรที่กำหนดขอบเขต
• 2nd (MyInteger) สำหรับคุณสมบัติสาธารณะ
• 4th (_myInteger) สำหรับตัวแปรส่วนตัว

ฉันคิดว่าตัวเลือก 4 เป็นตัวเลือกที่อ่านง่ายที่สุดจริง ๆ ช่วยให้คุณไม่ต้องทำสิ่งนี้:

public Person(string name, int age) 
{
    this.name = name;
    this.age = age;
}

นอกจากนี้ยังทำให้สมาชิกเอกชนทุกคนเห็นได้ชัดเจนขึ้น ในตัวอย่างต่อไปนี้ heck ageมาจากไหน หากไม่มีผู้thisคัดเลือกจึงเป็นการยากที่จะบอก

private void Method()
{
    var x = 2;
    var y = age + x;
}

นี่เป็นวิธีที่เข้าใจง่ายกว่า:

private void Method()
{
    var x = 2;
    var y = _age + x;
}

ก่อนอื่น PascalCasing สงวนไว้สำหรับคุณสมบัติสาธารณะ consts วิธีการและอื่น ๆ ของคลาส ดังนั้นฉันจะข้าม 2 และ 5

ประการที่สองสัญกรณ์ฮังการีไม่ได้รับการสนับสนุนในโลก NET ดังนั้น (เอ่อฉันคิดว่า) 3 ถูกต้องแล้ว สมมติว่าเป็นสิ่งที่เกิดขึ้นกับ 3

ใบนั้นมี camelCasing และ _camelCasing ฉันมักจะใช้ _camelCasing สำหรับตัวแปรคลาสและ camelCasing แบบเก่าธรรมดาสำหรับตัวแปรที่กำหนดขอบเขตให้กับเมธอดหรือแคบกว่า ปลอก Camel เป็นมาตรฐานที่ได้รับการยอมรับที่ใช้สำหรับการโต้แย้งวิธีชื่อตัวแปรป้องกัน / ส่วนตัวและตัวแปรภายในวิธีการหรือขอบเขตที่แคบลง

ฉันยังต้องการเพิ่มขีดล่างด้วยเครื่องหมายขีดล่างเพื่อให้ตัวแปรส่วนตัวของฉันถูกจัดกลุ่มใน Intellisense ของฉัน อย่างไรก็ตามฉันทำสิ่งนี้เฉพาะกับตัวแปรที่กำหนดขอบเขตไว้ที่ประเภทเท่านั้น ตัวแปรที่ประกาศภายในเมธอดหรือขอบเขตที่แคบกว่าฉันปล่อยขีดเส้นใต้ออก ทำให้มันง่ายต่อการแยกพวกมันและทำให้ตัวแปรที่ใช้น้อยอยู่ด้วยกัน

private int integer

หากคุณสับสนระหว่างสมาชิกและตัวแปรในขอบเขตในเมธอดคุณอาจต้องทำการปรับโครงสร้างใหม่

ฉันเชื่อว่าวิธีที่ดีที่สุดที่จะทำ (ใน C # /. net ต่อไป) คือการรวมกันของ 2 และ 6:

private int MyInteger { get; set; }

ในทางทฤษฎีไม่มีตัวแปรเลย แต่มันก็ดูและทำหน้าที่เหมือนตัวแปรอินสแตนซ์ส่วนตัว หากเราต้องการเพิ่มตรรกะทางธุรกิจบางอย่างให้กับค่านั้น (เป็นค่าภายในที่สมบูรณ์ดังนั้นเราจึงสามารถทำทุกอย่างที่เราต้องการได้) จากนั้นมันจะเป็น 'คุณสมบัติ' สำหรับเรา ถ้วยนึ่งแห่งชัยชนะที่ร้อนแรง!

ฉันเลือก # 4 เพราะนั่นคือสิ่งที่ SSCLI ดูเหมือน แต่จริง ๆ แล้วฉันไม่สนใจเรื่องการตั้งชื่อตัวแปรส่วนตัวมากนัก สาธารณะเป็นเรื่องที่แตกต่าง

BTW คุณลืม m_MyInteger

ฉันจะไม่เรียกมันว่า "ฉัน" อะไร!

แต่ฉันจะบอกว่า

class C
{
     int VariableName { get; set; }
}

ค่อนข้างบ่อยครั้งนี้ดีกว่าการมีตัวแปรที่ชัดเจน ถ้าฉันมีตัวแปรส่วนตัวที่ชัดเจนฉันจะเรียกมันว่าint _variableName;

ใน C ++ ฉันมักจะใช้ _ เนื่องจากฉันสลับผู้แก้ไขจำนวนมากซึ่งไม่อนุญาตให้ฉันดูว่าเป็นส่วนตัวหรือไม่

สำหรับ C # ฉันมักจะทิ้ง _ ไปเนื่องจาก Visual Studio อนุญาตให้ฉันดูว่าเป็นส่วนตัวหรือไม่

ฉันมักจะใช้วิธี Camel Case เพื่อทำสิ่งนี้

ฉันใช้ 4 ( private int _myInteger;) เพราะ:

private int myInteger;

นี่คือวิธีที่ฉันตั้งชื่อตัวแปรท้องถิ่นของฉัน

private int MyInteger;

นี่คือวิธีที่ฉันตั้งชื่อค่าคงที่

private int mMyInteger;

นี่ไม่ใช่สไตล์ C #

private int _MyInteger;

มันดูแปลก ๆ

ด้วยเครื่องหมายขีดล่าง

บิลแว็กเนอร์อธิบายว่าทำไมในที่มีประสิทธิภาพ C # แต่ฉันไม่เคยจะตั้งชื่อเป็นจำนวนเต็มของฉันจำนวนเต็ม , สิ่งที่ดีกว่าเช่น _age หรือ _length การรวม TypeName ในชื่ออินสแตนซ์เป็นวิธีปฏิบัติที่น่ากลัว ชื่อควรอธิบายด้วยตนเองและเนื่องจาก C # เป็นประเภทที่ปลอดภัยสามารถพบได้ตลอดเวลา

คุณต้องให้ตัวอย่างที่เฉพาะเจาะจงมากขึ้น แต่:

private int count, private int badFileCount,private static readonly int ReconnectAttemptsLimit

โดยวิธีการที่คุณจะได้รับทั้งหมดนี้ฟรีMSFT Stylecopเมื่อคุณติดตั้งและเริ่มใช้ล่าสุดและยิ่งใหญ่ที่สุด

ฉันไปตามตัวเลือก 5: private int _MyFoo

ฉันไม่เห็นความได้เปรียบในการแข่งขันอย่างแท้จริงใน _myFoo

ใช้ camelCasing สำหรับตัวแปรส่วนตัวเช่น myInteger

พิจารณาก่อนหน้า_ว่าตัวแปรเป็นการสำรองข้อมูลสำหรับคุณสมบัติเพื่อลดความสับสน -
ตัวแปร_myPropertyสำหรับคุณสมบัติMyProperty

ฉันมี ReSharper ชื่อตัวแปรของฉันไม่เพียง แต่ฉัน แต่ทุกคนก็ทำได้เช่นกัน มีโครงการความสอดคล้องจำนวนมาก

IDesign C # Coding ของ Juval Lowyเป็นที่นิยมมาก มาตรฐานนี้แนะนำให้นำหน้าตัวแปรสมาชิกส่วนตัวด้วยคำนำหน้า "m_" (ตัวเลือก 6) นั่นคือสิ่งที่เราทำในทีมของเรา

private int m_myInteger;

ตัวเลือก 4 ( _myInteger) เป็นรูปแบบที่ยอมรับได้ของมาตรฐานนี้

ฉันไม่ชอบคำแนะนำ MSDN ( myInteger) เพราะทำให้ยากที่จะบอกสมาชิกส่วนตัวจากตัวแปรท้องถิ่น แน่นอนคำแนะนำของพวกเขาแก้ปัญหานี้โดยการคัดเลือกสมาชิกส่วนตัวที่มีคุณสมบัติthisซึ่งดูเหมือนจะซ้ำซ้อนกับฉัน