โดยปกติคุณจะจัดวางพื้นที่ของคลาสอย่างไร

ฉันสงสัยว่ามีมาตรฐานในการกำหนดพื้นที่ของชั้นเรียนหรือไม่

ฉันใช้อยู่

Fields
Constructor
Properties
Public Methods
Private Methods

Fieldsเป็นทรัพย์สินส่วนตัวและPropertiesเป็นทรัพย์สินสาธารณะ ปกติแล้วฉันจะใช้ subregions ภายในถ้าจำเป็นหรือจะเพิ่มภูมิภาคอื่น ๆ ด้านล่าง (เช่นสมาชิกอินเทอร์เฟซหรือ baseClass) เป็นครั้งคราว

คลาสที่เกี่ยวข้องกับ Enums หรือคลาส structs / pure-data เป็นครั้งคราว (เหนือข้อกำหนดคลาสจริง)

--- คำจำกัดความของคลาส ---

สมาชิกส่วนตัว

CTORs / DTORs หากภาษานั้นมี DTORs

สมบัติสาธารณะ

วิธีการยูทิลิตี้ (วิธีส่วนตัวหรือการป้องกันที่มีขอบเขตขนาดเล็ก)

ฟังก์ชั่นการเรียน (อาจแบ่งออกเป็นหลายภูมิภาคขึ้นอยู่กับขอบเขตของคลาส)

ภูมิภาคย่อย? ชั้นเรียนของคุณมีความรับผิดชอบเดี่ยวหรือไม่? (โดยนัยก็คือ ... คำตอบของฉันคือ "แทบทุกภูมิภาคยกเว้นกลุ่มคุณสมบัติคอนสตรัคเตอร์และเมธอด" ... แต่ถึงอย่างนั้นฉันก็ไม่ได้ใช้มันมากนัก)

ฉันแค่ต้องการยืนยันว่าคุณหมายถึง "#regions" ไม่ใช่เลย์เอาต์ของชั้นเรียนโดยทั่วไป

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

ฉันหลีกเลี่ยงภูมิภาค ฉันชอบที่จะเห็นรหัสที่ฉันทำงานด้วย หากคุณพบว่ามันยากที่จะค้นหาสิ่งที่คุณกำลังมองหาให้ใช้การพับโค้ดและสร้างคลาสที่คล้ายกันรวมกัน

ทำไมฉันถึงเกลียดภูมิภาค CTRL+M,LและCTRL+M,Oจะสลับการพับรหัส อย่างไรก็ตามเมื่อการยุบมันจะซ่อนทั่วทั้งภูมิภาค ฉันต้องการเพียงยุบวิธี / คุณสมบัติ / ความคิดเห็น

หากมีหลายภูมิภาคมากเกินไปอาจมีกลิ่นรหัสและชั้นเรียนของคุณทำงานมากเกินไป Jeff Atwood ให้โพสต์ที่ดีในภูมิภาคที่มีค่าอ่าน

คำพูดที่ฉันชอบใน #regions:

ไม่ฉันจะไม่ใช้ #regions และไม่ฉันไม่ได้เจรจากับผู้ก่อการร้าย หุบปาก.

- Jeff Atwood

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

มันแตกต่างจากภาษาเป็นภาษา เนื่องจากฉันเป็นรหัสเดลฟายฉันมักจะทำตามแบบแผนมาตรฐานของเดลฟี่ซึ่งมีลักษณะดังนี้:

type
  TMyClass = class(TBaseClass)
  private
    private fields
    private methods
  protected
    protected fields
    protected methods
    protected properties
  public
    constructor(s)
    destructor
    public methods
    public properties
  end;

ฉันพบว่าเป็นวิธีที่ดีในการจัดระเบียบข้อมูลที่อ่านและเข้าใจได้ง่าย

ฉันมักจะจัดวางพวกเขาด้วยวิธีต่อไปนี้:

Public fields (usually static constants)
Constructors
Public methods
Private methods
Private fields

ยังไม่ได้ใช้ภาษาที่ใช้Propertiesดังนั้นนั่นเป็นสาเหตุที่พวกเขาไม่ได้วาง ฉันใส่วิธีการและฟิลด์ส่วนตัวไว้ที่ด้านล่างเพราะถ้ามีคนอื่นกำลังใช้ไฟล์นี้ในรหัสของพวกเขาพวกเขาควรจะต้องเกี่ยวข้องกับ API ซึ่งเป็นเรื่องสาธารณะ และเครื่องมือแก้ไขข้อความทั้งหมดที่ฉันรู้จักและแม้แต่ IDEs ก็วางเคอร์เซอร์ไว้ที่ด้านบนเมื่อเปิดไฟล์

มันเป็นการตัดสินใจที่เรียกร้องให้ฉัน ฉันใช้พื้นที่เมื่อจำเป็นสำหรับการอ่าน

ฉันยังใช้สีที่แตกต่างในชุดรูปแบบสี Visual Studio ของฉัน (ปัจจุบันเป็นสีแดงเข้ม) เพื่อให้โดดเด่นจากส่วนที่เหลือของรหัส

ตัวอย่างตำแหน่งที่ฉันอาจใช้ #region: หากฉันเขียนวิธีทดสอบสำหรับการทดสอบหน่วยที่ต้องการตัวอย่างข้อมูลหลายบรรทัดของ XML สตริง XML จะแบ่งการเยื้องตามปกติ (เนื่องจากเริ่มต้นตามขอบซ้ายของ หน้าต่างรหัสในการซ่อนความอัปลักษณ์ฉันจะใส่มันไว้ใน #region เพื่อที่ฉันจะได้ยุบมัน

บ็อบมาร์ติน หนังสือClean Codeอุทิศทั้งบทที่ 5 ในการจัดรูปแบบ มีประเด็นสำคัญสองสามข้อที่ฉันรู้สึกสรุปได้เป็นอย่างดี

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

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

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

ฉันกำลังเค้าโครงชั้นเรียนเช่นนี้:

class types
constructors
destructor
accessors
methods
properties (where properties are present in the language)
member variables

จากนั้นนำหน้าระดับการเข้าถึงไปยังการประกาศแต่ละรายการ (บางครั้งจัดกลุ่มตามการเข้าถึง) ฉันเคยทำการจัดกลุ่มระดับบนสุดด้วยการเข้าถึง แต่ในบางจุดฉันไม่รู้ว่าเมื่อใดมันไม่ได้ผลเหมือนข้างต้น ตัวอย่างเช่นใน C ++ / CLI (ซึ่งฉันถูกบังคับให้ใช้ในขณะนี้ :-() คุณสามารถทำสิ่งนี้ได้ซึ่งทำให้การจัดกลุ่มโดยการเข้าถึงยุ่งเหยิง:

public: property int SomeProperty
{
private: void set (int value) { ... }
public: int get () { ... }
}

คำตอบคนบ้า: ฉันไม่อย่างน้อยเมื่อมันมาถึง C # ระหว่าง Visual Studio และ R # ฉันสามารถนำทางไปยังสมาชิกหรือการนำไปใช้งานได้อย่างน่าอัศจรรย์ดังนั้นจึงไม่มีประเด็นใดที่จะครอบงำสิ่งนี้ เพียงเริ่มพิมพ์ที่เคอร์เซอร์อยู่

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

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

• การใช้งานอินเทอร์เฟซในตัวบางอย่าง (IDisposable, IConvertible, IEnumerable หรือ IComparable บางครั้งเนื่องจากต้องการการใช้งานทั่วไปและไม่ใช่ทั่วไป)
• P / เรียกใช้ externs ภายนอกและโครงสร้างที่เกี่ยวข้อง
• Finalizers / destructors (มักจะไปกับ IDisposable)
• เชื่อมต่อกับหน่วยความจำ / ตัวชี้ / รหัส "ไม่ปลอดภัย"