กรุณาขายตู้คอนเทนเนอร์ IoC ให้ฉันด้วย

ฉันเห็นหลายแนะนำให้ใช้คอนเทนเนอร์ IoC ในรหัส แรงจูงใจนั้นง่าย ใช้รหัสฉีดพึ่งพาต่อไปนี้:

class UnitUnderTest
{
    std::auto_ptr<Dependency> d_;
public:
    UnitUnderTest(
        std::auto_ptr<Dependency> d = std::auto_ptr<Dependency>(new ConcreteDependency)
    ) : d_(d)
    {
    }
};


TEST(UnitUnderTest, Example)
{
    std::auto_ptr<Dependency> dep(new MockDependency);
    UnitUnderTest uut(dep);
    //Test here
}

เป็น:

class UnitUnderTest
{
    std::auto_ptr<Dependency> d_;
public:
    UnitUnderTest()
    {
        d_.reset(static_cast<Dependency *>(IocContainer::Get("Dependency")));
    }
};


TEST(UnitUnderTest, Example)
{
    UnitUnderTest uut;
    //Test here
}

//Config for IOC container normally
<Dependency>ConcreteDependency</Dependency>

//Config for IOC container for testing
<Dependency>MockDependency</Dependency>

(ตัวอย่างข้างต้นเป็นตัวอย่างของซีพลัสพลัสสมมุติฐาน)

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

ดังนั้น .. มีประโยชน์อื่น ๆ อีกไหมในการใช้ภาชนะประเภทนี้หรือฉันแค่ไม่เห็นด้วยกับภาชนะที่แนะนำ?

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

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

มีภาชนะประเภทต่าง ๆ เช่นกัน ไม่ใช่ทั้งหมดที่พิมพ์อย่างเข้มงวดและไม่ใช่ทั้งหมดที่ต้องการไฟล์กำหนดค่า

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

ฉันเชื่อว่า Guice เป็น Java IoC framework ซึ่งในที่สุดก็มีการตั้งค่าที่ถูกต้อง

คำตอบ SOที่ยอดเยี่ยมนี้โดยBen Scheirman ให้รายละเอียดตัวอย่างโค้ดใน C #; ข้อดีของ IoC container (DI)

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