การฉีดพึ่งพาผู้รับเหมาก่อสร้างหรือผู้ตั้งค่าทรัพย์สิน?

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

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

มันขึ้นอยู่กับ :-)

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

ถ้าคลาสสามารถทำงานได้โดยไม่ต้องพึ่งพาเซ็ตเทอร์ก็ไม่เป็นไร

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

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

public class ClassExample
{
    public ClassExample(IDependencyOne dependencyOne, IDependencyTwo dependencyTwo)
        : this (dependnecyOne, dependencyTwo, new DependnecyThreeConcreteImpl())
    { }

    public ClassExample(IDependencyOne dependencyOne, IDependencyTwo dependencyTwo, IDependencyThree dependencyThree)
    {
        // Set the properties here.
    }
}

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

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

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

หากคุณมีการพึ่งพาตัวเลือกเป็นจำนวนมาก (ซึ่งมีกลิ่นอยู่แล้ว) การฉีดเซทเทอร์อาจเป็นวิธีที่คุณควรทำ คอนสตรัคเตอร์การฉีดดีขึ้นเปิดเผยการอ้างอิงของคุณว่า

วิธีที่ต้องการโดยทั่วไปคือการใช้การสร้างคอนสตรัคเตอร์

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

พยายามสร้างเพียงคอนสตรัคเตอร์เดียวมันทำให้การออกแบบง่ายและหลีกเลี่ยงความกำกวม (ถ้าไม่ใช่สำหรับมนุษย์สำหรับ DI container)

คุณสามารถใช้การฉีดคุณสมบัติเมื่อคุณมีสิ่งที่ Mark Seemann เรียกใช้ค่าเริ่มต้นในเครื่องในหนังสือ "Dependency Injection in .NET" ในหนังสือของเขา: การพึ่งพานั้นเป็นทางเลือกเนื่องจากคุณสามารถให้การใช้งานที่ดี แต่ต้องการอนุญาตให้ผู้โทรระบุคนอื่น จำเป็น

(คำตอบเดิมด้านล่าง)

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

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

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

ตราบใดที่อินเทอร์เฟซคลาส (API) มีความชัดเจนในสิ่งที่จำเป็นในการทำงานคุณก็ยังดี

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

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

ฉันยังคงใช้ตัวตั้งค่าการฉีดเป็นครั้งคราวเมื่อวัตถุที่ถูกฉีดอาจต้องทำงานหลายอย่างเช่นการเริ่มต้น

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

ฉันยังใช้การฉีดคุณสมบัติสำหรับการตั้งค่าสิ่งต่าง ๆ ที่คอนเทนเนอร์ไม่มีการอ้างอิงถึงเช่นมุมมอง ASP.NET บนผู้นำเสนอที่สร้างขึ้นโดยใช้คอนเทนเนอร์

ฉันไม่คิดว่ามันจะห่อหุ้ม การทำงานภายในควรจะยังคงอยู่ภายในและการอ้างอิงที่เกี่ยวข้องกับความกังวลที่แตกต่างกัน

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

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

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

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

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

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

นี่คือโพสต์เก่า แต่หากมีความจำเป็นในอนาคตอาจจะเป็นการใช้งานใด ๆ :

https://github.com/omegamit6zeichen/prinject

ฉันมีความคิดที่คล้ายกันและเกิดขึ้นกับกรอบนี้ มันอาจยังไม่สมบูรณ์ แต่เป็นแนวคิดของกรอบที่มุ่งเน้นไปที่การฉีดคุณสมบัติ

ขึ้นอยู่กับว่าคุณต้องการนำไปใช้อย่างไร ฉันชอบคอนสตรัคเตอร์แบบฉีดทุกที่ที่รู้สึกว่าค่าที่นำไปสู่การนำไปปฏิบัตินั้นไม่เปลี่ยนแปลงบ่อยนัก เช่น: หากกลยุทธ์ของ compnay เป็นไปกับเซิร์ฟเวอร์ oracle ฉันจะกำหนดค่า datsource ของฉันสำหรับการเชื่อมต่อ bean achiveing ​​ผ่านการสร้างคอนสตรัค มิฉะนั้นถ้าแอพของฉันเป็นผลิตภัณฑ์และโอกาสที่มันจะสามารถเชื่อมต่อกับฐานข้อมูลของลูกค้าใด ๆ ฉันจะใช้การกำหนดค่าฐานข้อมูลดังกล่าวและการใช้งานหลายแบรนด์ผ่านการตั้งค่าการตั้งค่า ฉันเพิ่งได้รับตัวอย่าง แต่มีวิธีที่ดีกว่าในการใช้สถานการณ์ที่ฉันกล่าวถึงข้างต้น

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

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