การป้องกันสำหรับสำเร็จรูป?

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

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

(ฉันหมายถึงสิ่งที่ฉันคิดว่ามีความหมายโดยทั่วไปโดยสำเร็จรูป แต่ตัวอย่างที่ดีคือ getters และ setters ใน Java.)

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

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

สิ่งที่อาจดูน่าเบื่อและซ้ำ ๆ ในขณะที่คุณกำลังเขียนมันอาจเป็นบริบทที่มีคุณค่าสำหรับคนอื่นที่เข้ามาในปี (หรือห้า) ในภายหลังและต้องรักษารหัสของคุณ

โดยเฉพาะอย่างยิ่ง WRT ตัวอย่าง Java ฉันจะยอมรับว่าเป็นตัวอย่างที่ดีของสำเร็จรูป boilerplate เนื่องจากมันสามารถถูกแทนที่ด้วยบางสิ่งที่ทั้งสั้นและง่ายต่อการอ่านและมีความยืดหยุ่นมากขึ้น: คุณสมบัติ แต่นั่นไม่ได้หมายความว่าองค์ประกอบทางวากยสัมพันธ์สำเร็จรูปทั้งหมดจากทุกภาษานั้นสิ้นเปลืองเช่นเดียวกับตัวรับและ setters จาก Java และ C ++

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

สมมติว่าคุณมีรหัสที่บอกว่า

public ForTheBar(Foo foo)
{
    Bar bar = foo.bar();
    return bar.BeFooed();
}

ใช้ในสถานที่ประมาณ 2 แห่งในรหัสของคุณ

อยู่มาวันหนึ่งมีคนมาและพูดว่า "โอเคในเส้นทางนี้เท่านั้นเราต้องการให้คุณ Grommit บาร์ก่อนที่จะตบมัน"

และคุณคิดว่า "นี่มันง่ายมาก"

public ForTheBar(Foo foo, bool shouldIGrommit)
{
    Bar bar = foo.bar();

    if (shouldIGrommit)
    {
        bar.BeGrommitted();
    }

    return bar.BeFooed();
}

จากนั้นผู้ใช้ของคุณจะเพิ่มฟังก์ชั่นใหม่และคุณคิดว่ามันเข้ากันได้ดีกับ FooTheBar และคุณถามพวกเขาตามหน้าที่ถ้าคุณควรจะ Grommit แถบนั้นก่อนที่คุณจะฟูและพวกเขาก็พูดว่า "ไม่ไม่ใช่เวลานี้"

ดังนั้นคุณเพียงแค่เรียกวิธีการข้างต้น

แต่จากนั้นผู้ใช้ของคุณบอกว่า "โอเครอในกรณีที่สามเราต้องการให้คุณ Doodle the Bar ก่อนโทรหา BeFooed"

ไม่มีปัญหาคุณคิดว่าฉันสามารถทำได้

public ForTheBar(Foo foo, bool shouldIGrommit, bool shouldIDoodle)
{
    Bar bar = foo.bar();

    if (shouldIGrommit)
    {
        bar.BeGrommitted();
    }

    if (shouldIDoodle)
    {
        bar.BeDoodled();
    }

    return bar.BeFooed();
}

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

ทั้งหมดนี้กล่าวว่าฉันจะตอบโต้ด้วย "นี่ไม่ใช่กรณีทั่วไปและเมื่อมันเกิดขึ้นคุณสามารถ refactor"

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

ฉันเคยเห็นผู้คนโต้แย้งสิ่งที่คล้ายกันเกี่ยวกับคอนเทนเนอร์ IoC

ไม่พูดว่าฉันเห็นด้วยกับพวกเขา แต่มันก็เป็นข้อโต้แย้งที่ยุติธรรมอย่างไรก็ตาม

วิวัฒนาการของประสิทธิภาพ

คุณเริ่มต้นด้วยสิ่งนี้:

<p>
    <label for="field">My field</label>
    <input type="text" id="field">
</p>

ถ้าอย่างนั้นคุณก็กำจัดส่วนที่น่ารำคาญและใส่เข้าไปในฟังก์ชัน:

1. createFieldHtml( id, label )

   นี้เป็นสิ่งที่ดีฉันบันทึกตัวเองหลายบรรทัด!

2. createFieldHtml( id, label, defaultValue )

   ใช่ฉันต้องการค่าเริ่มต้นด้วยเช่นกันซึ่งง่ายต่อการเพิ่ม

3. createFieldHtml( id, label, defaultValue, type )

   เยี่ยมยอดฉันสามารถใช้เป็นช่องทำเครื่องหมายได้เช่นกัน

4. createFieldHtml( id, label, defaultValue, type, labelFirst )

   นักออกแบบ UX กล่าวว่าป้ายกำกับต้องอยู่หลังกล่องกาเครื่องหมาย

5. createFieldHtml( id, label, defaultValue, type, labelFirst, isDate )

   ตอนนี้จะแสดงตัวใช้เลือกวันที่เมื่อจำเป็น อืม .. params กำลังจะหลุดมือไปหน่อย

6. createFieldHtml( id, label, defaultValue, type, labelFirst, isDate, containerCssClasses )

   มีกรณีนี้ที่ฉันต้องเพิ่มคลาส CSS

7. createFieldHtml( id, label, defaultValue, type, labelFirst, isDate, containerCssClasses, fieldCssClasses, disabled, clearAfter, helpText, uploadPath )

   aaaaaaaaaaaaaaaaaaaaa

ในการป้องกันของสำเร็จรูป

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

1. สำหรับฉันดูเหมือนว่ามีความกลัวว่าจะมีเส้นที่ซ้ำกันที่ยื่นออกไปเล็กน้อย หากเป็นเพียงไม่กี่บรรทัดก็อาจจะไม่มีปัญหาเลย บางสิ่งมีอยู่โดยเนื้อแท้ "เกือบซ้ำ" (เช่นตัวอย่างด้านบน) ฉันเห็นโอกาสเล็กน้อยในการปรับให้เหมาะสมในระยะยาว
2. ผู้คนชอบที่จะแค็ปซูลฟังก์ชั่นบางแห่ง; ถ้าคุณมองอย่างเป็นกลางและดูเหมือนว่ามันเป็นเพียง "ซ่อนความยุ่งเหยิง" - ต้องสงสัย! อาจเป็นเวลาสำหรับต้นแบบเก่าบางอย่างที่ดี
3. เมื่อคุณมีฟังก์ชั่นที่มีพลังมากขึ้น ที่ใช้เส้นทางการดำเนินการที่แตกต่างกันมากขึ้นอยู่กับอินพุตและท้ายที่สุดก็น้อยมาก - มันอาจเป็นเวลาสำเร็จรูป!
4. เมื่อคุณเพิ่มเลเยอร์ของ abstraction ที่อยู่บนเลเยอร์ของ abstraction อื่น แต่เพียงเพื่อทำให้โค้ดของคุณสั้นลง (เลเยอร์พื้นฐานไม่ได้หมายถึงการเปลี่ยนแปลง) - เวลาสำเร็จรูป!
5. เมื่อคุณมีฟังก์ชั่นที่ใช้พารามิเตอร์มากมายที่คุณจำเป็นต้องมีการตั้งชื่อพารามิเตอร์ - อาจถึงเวลาสำเร็จรูป

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

สิ่งนี้ตรงกันข้ามกับการรับรู้ทั่วไปมากว่าสำเร็จรูปเป็นรหัสคัดลอกและวาง สำหรับฉัน boilerplate เป็นเรื่องเกี่ยวกับการคัดลอกและวาง แต่ต้องมีการปรับแต่งเล็กน้อย

อัปเดต : ฉันเพิ่งเจอบทความที่ยกตัวอย่างชื่อของฉันขึ้นด้านบน: "เกินไป DRY anti-pattern"

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

มันเป็นการอ่านที่สั้นและน่าสนใจคุณสามารถค้นหาบทความได้ที่นี่: Too Anti Anti Pattern

ฉันดูหมิ่นรหัสสำเร็จรูป แต่การลบรหัสสำเร็จรูปไม่ได้หมายความว่าเป็นวิธีที่ดีที่สุด

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

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

เฟรมเวิร์ก WPF มีเอกสารที่ดี มันบันทึกวิธีการเขียนโค้ดสำเร็จรูปอย่างถูกต้อง ความพยายามที่จะลบรหัสสำเร็จรูปนี้เป็นแบบฝึกหัดที่ดีและสิ่งที่ควรค่าแก่การสำรวจ แต่การได้รับ 'โปแลนด์' ในระดับเดียวกับที่ข้อเสนอ msdn ใช้เวลานานซึ่งเราไม่ได้มีอยู่เสมอ

ปัญหาเกี่ยวกับสำเร็จรูปก็คือการละเมิด DRY ในสาระสำคัญเมื่อคุณเขียนสำเร็จรูปคุณกำลังทำซ้ำรหัสเดียวกัน (หรือรหัสที่คล้ายกันมาก) ในจำนวนชั้นเรียน เมื่อรหัสนั้นจำเป็นต้องได้รับการเปลี่ยนแปลงมันไม่ได้เป็นที่แน่นอนว่านักพัฒนาจะจำสถานที่ทั้งหมดที่รหัสซ้ำ สิ่งนี้นำไปสู่ข้อผิดพลาดที่ API เก่าหรือวิธีการเก่าจะใช้

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

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

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

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

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

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