การจัดการกับน้ำซุปรั้งหยิก

ฉันเขียนโปรแกรมทั้ง C # และ VB.NET มาหลายปีแล้ว แต่ส่วนใหญ่เป็น VB ฉันเปลี่ยนอาชีพไปสู่ ​​C # และโดยรวมแล้วฉันชอบ C # ดีกว่า

แต่ประเด็นหนึ่งที่ฉันมีก็คือซุปรั้งปีกนก ใน VB คำหลักโครงสร้างแต่ละคำมีคีย์เวิร์ดปิดที่ตรงกันตัวอย่างเช่น:

Namespace ...
    Class ...
        Function ...
            For ...
                Using ...
                    If ...
                        ...
                    End If
                    If ...
                        ...
                    End If
                End Using
            Next
        End Function
    End Class
End Namespace

รหัสเดียวกันที่เขียนใน C # จบลงยากมากที่จะอ่าน:

namespace ... {
    class ... {
        function ... {
            for ... {
                using ... {
                    if ... {
                        ...
                    }
                    if ... {
                        ...
                    }
                }
            }
            // wait... what level is this?
        }
    }
}

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

ใส่วงเล็บปีกกาเริ่มต้นของคุณใน "อันดับ" เดียวกับที่สิ้นสุดของคุณเช่นนี้:

namespace ... 
{
    class ... 
    {
        function ... 
        {
            for ... 
            {
                using ... 
                {
                    if ... 
                    {
                        ...
                    }
                    if ... 
                    {
                        ...
                    }
                }
            }
            // It's the `function` level!
        }
    }
}

• ทั้งนี้ขึ้นอยู่กับ IDE ของคุณ: วางเคอร์เซอร์ของคุณที่วงเล็บปีกกาเปิด / ปิดและมันจะเน้นทั้งที่และวงเล็บปีกกาที่สอดคล้องกัน
• ยุบบล็อกและจะแสดงตำแหน่งที่เปิด / ปิด
• เขียนบล็อคโค้ดที่เล็กลง อย่างจริงจัง. ลองดูClean Codeและอย่าพบปัญหานี้อีก (และมีรหัสที่สามารถอ่าน / บำรุงรักษาได้มากกว่า)

One note, ต่อไปนี้เป็นไวยากรณ์ c # ที่ถูกต้องที่อาจช่วยสถานการณ์ของคุณโดยเฉพาะ:

using (var type = new MyDisposable1())
using (var type2 = new MyDisposable2())
{
    /* do what you will with type2 and type2 */
}

หลักการทั่วไปคือการเพิ่มความคิดเห็นหลังวงเล็บปิดเพื่อระบุโครงสร้างที่ปิด:

if {
   ...
} // end if

while (condition) {
   ...
} // end while

ฯลฯ ฉันไม่เคยรู้สึกอบอุ่นกับอนุสัญญานี้ แต่บางคนเห็นว่าเป็นประโยชน์

โดยทั่วไปเมื่อมันยากที่จะจับคู่เครื่องมือจัดฟันในสไตล์ใด ๆ - มันอาจหมายถึงวิธีการที่ยาวเกินไปและควรได้รับการพิจารณาใหม่

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

ตรวจสอบให้แน่ใจว่ามีการเยื้องอย่างเหมาะสมและว่ามีการติดตามการเว้นวรรคบางส่วน (ไม่สำคัญว่า)

ฉันลบการซ้อน 2 ระดับโดยการยุบเนมสเปซและขอบเขตของคลาสในแนวนอน ขอให้สังเกตวิธีการที่จะล้างด้วยขอบด้านซ้ายของหน้าจอ ฉันไม่เห็นจุดในการสูญเสียการเยื้อง 2 ระดับในทุกไฟล์

หลังจากนั้นก็หายากคุณจะต้องทำรังลึกมากกว่า 4 ระดับ

namespace FooNameSpace {
class Foo {

public void bar()
{
    while(true)
    {
        while(true)
        {
            break;
        }
    }
}

public void fooBar()
{
    foreach(var item in FooList)
    {
        foreach(var b in item.Bars)
        {
            if(b.IsReady)
            {
                bar();
            }
            bar();
        }
        bar();
    }
}

}}//end class, namespace

เมื่อเร็ว ๆ นี้ฉันตัดสินใจลองใช้กฎสองข้อเกี่ยวกับโครงสร้างการควบคุมการไหลซึ่งโดยทั่วไปจะเป็นดังนี้:

• คุณไม่ควรมีอะไรนอกจากโครงสร้างโค้ดโฟลว์ที่จำเป็น
• คุณควรทำให้โค้ดโฟลว์สร้างเล็กที่สุดเท่าที่จะทำได้

สำหรับเหตุผลที่คุณได้กล่าวถึงและทราบอย่างชัดเจนว่าฉันคิดว่าสิ่งเหล่านี้เป็นกฎที่ดีในการปฏิบัติตาม มีเทคนิคง่ายๆสองสามอย่างที่คุณสามารถใช้เพื่อทำให้สำเร็จ:

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

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

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

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

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

ใช้ Resharper ซึ่งจะช่วยแนะนำวิธีการลดการซ้อน นอกจากนี้อ่านClean Codeของ Bob Martin ซึ่งเน้นว่าฟังก์ชั่นควรทำสิ่งหนึ่งเท่านั้นดังนั้นแต่ละฟังก์ชันควรมีความยาวครึ่งโหลดังนั้นคุณจะไม่ต้องทำรังหลายระดับ

: มี add-on ที่จะแก้ไขที่อาจช่วยให้คุณที่เป็นC # โครงร่าง

ส่วนเสริมขยายตัวแก้ไข VS20xx สำหรับ C # โดยการเพิ่มคุณสมบัติเพื่อยุบขยายและไฮไลต์บล็อกที่ซ้อนกันของรหัส คุณสมบัติเหล่านี้ช่วยให้การแก้ไขและการอ่านเนื้อหาซ้อนของบล็อคโค้ดง่ายขึ้นเช่น if, while, ฯลฯ

หากคุณเขียนรหัสใน Visual Studio ก็มีปลั๊กอินที่แสดงจุดแนวตั้งระหว่างจุดเริ่มต้นและจุดสิ้นสุดของทุกโครงสร้างที่คุณสร้าง

แต่โดยรวมแล้วฉันคิดว่ามันจะใช้เวลาพอสมควรจนกว่าคุณจะคุ้นเคยกับ "Curly-Braces-Soup" (Btw ฉันชอบการแสดงออกนั้นฟังดูคล้ายกับชื่อตอนของทฤษฎีบิกแบง)

การเยื้องจะบอกคุณว่าคุณอยู่ที่ไหนทั้งในรูปแบบของไวยากรณ์ หากคุณเขียนโปรแกรม VB หรือโปรแกรม C # ในบรรทัดเดียวคุณจะไม่สามารถบอกได้ว่าอยู่ในไวยากรณ์ที่ซ้อนกันคุณอยู่ที่ไหน เครื่องจักรแยกวิเคราะห์วลีที่ลงท้ายด้วยบล็อกหรือเครื่องหมายปีกกา แต่มนุษย์ต้องการการเยื้อง

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

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

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

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

เสียงกระเพื่อมใช้วงเล็บจากจุดเริ่มต้นและอาจไม่บังเอิญแฮกเกอร์ Lisp บุกเบิกการเขียนโปรแกรมเป็นประสบการณ์การโต้ตอบโดยการสร้างระบบที่ยอมรับโปรแกรมในชิ้นเล็ก ๆ (การแสดงออก)

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

หากคุณใช้ IDE เพียงกดCrtl+ k+ Dและ IDE จะทำงานที่เหลือ