สิ่งที่ควรทำก่อนหน้า: YAGNI หรือ Good Design

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

นี่คือตัวอย่างที่เป็นรูปธรรมของสิ่งที่ฉันหมายถึง: ฉันมีชั้นการเข้าถึงข้อมูลห่อชุดของขั้นตอนการจัดเก็บซึ่งใช้รูปแบบ Repository สไตล์พื้นฐานกับฟังก์ชั่น CRUD ขั้นพื้นฐาน IRepositoryเนื่องจากมีกำมือของวิธีการที่ทุกชั้นเรียนที่เก็บของฉันต้องฉันสร้างอินเตอร์เฟซทั่วไปสำหรับเก็บของฉันเรียกว่า อย่างไรก็ตามฉันได้สร้างอินเทอร์เฟซ "ตัวทำเครื่องหมาย" (เช่นอินเทอร์เฟซที่ไม่เพิ่มฟังก์ชันการทำงานใหม่) สำหรับที่เก็บแต่ละประเภท (เช่นICustomerRepository) และคลาสคอนกรีตนำไปใช้ ฉันได้ทำสิ่งเดียวกันกับการใช้ Factory เพื่อสร้างออบเจ็กต์ทางธุรกิจจาก DataReaders / DataSets ที่ส่งคืนโดย Stored Procedure ลายเซ็นของคลาสที่เก็บของฉันมีแนวโน้มที่จะมีลักษณะเช่นนี้:

public class CustomerRepository : ICustomerRepository
{
    ICustomerFactory factory = null;

    public CustomerRepository() : this(new CustomerFactory() { }

    public CustomerRepository(ICustomerFactory factory) {
        this.factory = factory;
    }      

    public Customer Find(int customerID)
    {
        // data access stuff here
        return factory.Build(ds.Tables[0].Rows[0]);
    }
}

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

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

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

YAGNI

ฉันเสียสละการออกแบบที่ดีเล็กน้อย

สมมติฐานที่ผิดพลาด

และอินเทอร์เฟซฐานแล้วคอนกรีตเดี่ยว

นั่นไม่ใช่ "การเสียสละ" นั่นคือการออกแบบที่ดี

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

การออกแบบที่ง่ายที่สุดคือการพัฒนาที่ง่ายที่สุด ไม่มีสิ่งใดที่จะบำรุงรักษาได้อย่างไร้ประโยชน์

YAGNI และ SOLID (หรือวิธีการออกแบบอื่น ๆ ) ไม่ได้เกิดร่วมกัน อย่างไรก็ตามพวกมันอยู่ใกล้กับขั้วตรงกันข้าม คุณไม่ต้องปฏิบัติตาม 100% อย่างใดอย่างหนึ่ง แต่จะมีบางอย่างให้และรับ; ยิ่งคุณมองรูปแบบที่มีความเป็นนามธรรมสูงที่ใช้โดยคลาสเดียวในที่เดียวและพูดว่า YAGNI และทำให้มันง่ายขึ้นยิ่งการออกแบบที่เป็นของแข็งน้อยลง การย้อนกลับอาจเป็นจริงเช่นกัน หลายครั้งในการพัฒนาการออกแบบได้ถูกนำไปใช้อย่างแข็ง "กับศรัทธา"; คุณไม่เห็นว่าคุณจะต้องการมัน แต่คุณมีลางสังหรณ์ สิ่งนี้อาจเป็นจริง (และมีแนวโน้มที่จะเป็นความจริงมากขึ้นเมื่อคุณได้รับประสบการณ์มากขึ้น) แต่มันอาจทำให้คุณมีหนี้สินทางเทคนิคมากพอ ๆ กับวิธีการตบเบา ๆ แทนที่จะเป็น codebase "รหัสสปาเก็ตตี้" DIL คุณอาจท้ายด้วย "รหัสลาซานญ่า" การมีเลเยอร์จำนวนมากที่เพียงแค่เพิ่มวิธีการหรือเขตข้อมูลใหม่กลายเป็นกระบวนการที่ต้องใช้เวลานานหลายวันในการให้บริการผ่านพร็อกซีบริการและการพึ่งพาคู่กันอย่างหลวม ๆ หรือคุณอาจจบลงด้วย "รหัสราวีโอลี่" ซึ่งมีขนาดชิ้นเล็ก ๆ ที่ขยับขึ้นลงซ้ายหรือขวาในสถาปัตยกรรมพาคุณไป 50 วิธีด้วยกัน 3 บรรทัด

ฉันได้พูดไปแล้วในคำตอบอื่น ๆ แต่ที่นี่คือ: ในรอบแรกให้ใช้งานได้ ในรอบที่สองทำให้มันดูดี ในรอบที่สามทำให้เป็นของแข็ง

ทำลายมันลง:

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

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

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

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

แทนที่จะเป็นอย่างใดอย่างหนึ่งฉันชอบ WTSTWCDTUAWCROT

(สิ่งที่ง่ายที่สุดที่เราสามารถทำได้คือมีประโยชน์และเราสามารถวางจำหน่ายในวันพฤหัสบดี?)

ตัวย่อที่เรียบง่ายอยู่ในรายการสิ่งที่ต้องทำของฉัน แต่มันไม่สำคัญ

YAGNI และการออกแบบที่ดีไม่ขัดแย้งกัน YAGNI เกี่ยวกับ (ไม่) สนับสนุนความต้องการในอนาคต การออกแบบที่ดีคือการทำให้เกิดความโปร่งใสว่าซอฟต์แวร์ของคุณทำอะไรอยู่ตอนนี้

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

YAGNI กำลังจะเพิ่มความซับซ้อนเพื่อรองรับฟังก์ชั่นในอนาคต
การออกแบบที่ดีนั้นเกี่ยวกับการขจัดความซับซ้อนในขณะที่ยังรองรับฟังก์ชั่นปัจจุบันทั้งหมด

พวกเขาไม่ได้อยู่ในความขัดแย้งเป้าหมายของคุณผิด

คุณพยายามทำอะไรให้สำเร็จ

คุณต้องการเขียนซอฟต์แวร์ที่มีคุณภาพและเพื่อให้คุณต้องการให้รหัสของคุณมีขนาดเล็กและไม่มีปัญหา

ตอนนี้เราถึงความขัดแย้งเราจะครอบคลุมทุกกรณีได้อย่างไรถ้าเราไม่เขียนกรณีที่เราจะไม่ใช้?

นี่คือปัญหาของคุณ

(ใครก็ตามที่สนใจสิ่งนี้เรียกว่าเมฆระเหย )

ดังนั้นสิ่งที่ขับรถนี้

1. คุณไม่รู้ว่าคุณไม่ต้องการอะไร
2. คุณไม่ต้องการเสียเวลาและขยายโค้ดของคุณ

ข้อใดที่เราสามารถแก้ไขได้ ดูเหมือนว่าไม่ต้องการเสียเวลาและรหัส bloat เป็นเป้าหมายที่ยอดเยี่ยมและสมเหตุสมผล แล้วอันแรกล่ะ เราจะทราบได้อย่างไรว่าจะต้องใช้รหัสหรือไม่

ฉันกำลังทำงานในโครงการในที่ทำงานและต้องการที่จะแนะนำมาตรฐานรหัสที่ดีให้กับเพื่อนร่วมงานของฉันอย่างช้าๆ (ขณะนี้ไม่มีเลยและทุกอย่างก็แค่แฮ็คด้วยกันโดยไม่มีการสัมผัสหรือเหตุผล) [... ] และคิดว่ามันเป็นการละเมิด YAGNI เพราะฉันค่อนข้างรู้ด้วยความมั่นใจว่าเราไม่ต้องการขยายชั้นเรียนเหล่านี้

ขอวลีทั้งหมดนั้นอีกครั้ง

• ไม่มีมาตรฐานรหัส
• ไม่มีการวางแผนโครงการเกิดขึ้น
• เคาบอยทำสิ่งที่ด่าของพวกเขาเอง (และคุณกำลังพยายามเล่นนายอำเภอในป่าทางทิศตะวันตก) เย้อว์

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ดังนั้นหลังจากการพิจารณาทั้งหมดนั้นเราพบว่า YAGNI และ SOLID ให้คำแนะนำที่เป็นของแข็งและเกี่ยวข้องกับชิ้นส่วนที่พบได้ทันที: จริง ๆ แล้วมันอาจไม่จำเป็นต้องสร้างอินเทอร์เฟซที่เก็บข้อมูลทั่วไป

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

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

IMO นั่นคือการออกแบบที่ไม่ดี YAGNI เป็นองค์ประกอบของการออกแบบที่ดีไม่เคยขัดแย้งกับมัน

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

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

• การออกแบบที่เพียงพอ
• การออกแบบที่เพียงพอหมายถึงการออกแบบที่ดี
• เมื่อการออกแบบที่เพียงพอหมายถึงการออกแบบที่ไม่ดี

บางคนโต้แย้งว่าชื่ออินเทอร์เฟซไม่ควรเริ่มต้นด้วย I. โดยเฉพาะอย่างยิ่งเหตุผลหนึ่งคือคุณต้องพึ่งพาการอ้างอิงว่าประเภทที่กำหนดเป็นคลาสหรืออินเทอร์เฟซหรือไม่

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

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

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

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

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

คุณกำลังสร้างการใช้งานที่interfaceคาดการณ์ไว้ในอนาคต คุณอาจมีI<class>คลาสสำหรับ codebase ของคุณทุกคลาสเช่นกัน อย่า

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

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

YAGNI บอกว่าจะไม่เขียนโค้ดก่อนที่จะต้องเขียน

การออกแบบที่ดีบอกว่าจะใช้สิ่งที่เป็นนามธรรม

คุณสามารถมีทั้ง คลาสเป็นสิ่งที่เป็นนามธรรม

ทำไมอินเทอร์เฟซของ marker มันทำให้ฉันรู้สึกว่ามันไม่ได้ทำอะไรมากไปกว่า "การติดแท็ก" ด้วย "แท็ก" ที่แตกต่างกันสำหรับโรงงานทุกประเภทประเด็นคืออะไร?

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

อินเทอร์เฟซสำหรับการจัดการสิ่งต่าง ๆ บนพื้นฐานของ commonalities แต่อินเทอร์เฟซมาร์กเกอร์แบบกำหนดเองก) ไม่เพิ่มการทำงาน และ b) บังคับให้คุณจัดการเอกลักษณ์ของพวกเขา

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

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

ตอนนี้คุณสามารถเขียน ICustomerRepository ที่สมเหตุสมผลได้ไหม? เช่น (ถึงที่นี่จริงๆอาจเป็นตัวอย่างที่ไม่ดี) ในอดีตที่ลูกค้าของคุณเคยใช้ PayPal อยู่เสมอ หรือทุกคนใน บริษัท มีความกังวลเกี่ยวกับการติดต่อกับ Alibaba หรือไม่ ถ้าเป็นเช่นนั้นคุณอาจต้องการใช้การออกแบบที่ซับซ้อนมากขึ้นในตอนนี้และดูเหมือนว่าเจ้านายของคุณจะมองการณ์ไกล :-)

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