คำถามติดแท็ก dependency-injection

ฉันกำลังทำงานเพื่อให้บทเรียนในหน่วยของฉันเป็นแบบทดสอบได้โดยใช้การฉีดแบบพึ่งพา แต่ชั้นเรียนเหล่านี้บางแห่งมีลูกค้าจำนวนมากและฉันยังไม่พร้อมที่จะปรับโครงสร้างพวกเขาทั้งหมดเพื่อเริ่มผ่านการพึ่งพา ดังนั้นฉันพยายามทำมันทีละน้อย; ทำให้การพึ่งพาเริ่มต้นสำหรับตอนนี้ แต่ช่วยให้พวกเขาถูกแทนที่สำหรับการทดสอบ วิธีการหนึ่งที่ฉันกำลังสร้างคือการย้ายการเรียก "ใหม่" ทั้งหมดเป็นวิธีการของตนเองเช่น: public MyObject createMyObject(args) { return new MyObject(args); } จากนั้นในการทดสอบหน่วยของฉันฉันสามารถคลาสย่อยนี้และแทนที่ฟังก์ชันสร้างดังนั้นพวกเขาจึงสร้างวัตถุปลอมแทน นี่เป็นวิธีที่ดีหรือไม่? มีข้อเสียหรือไม่? โดยทั่วไปแล้วจะเป็นการดีไหมหากมีการอ้างอิงแบบกำหนดค่าตายตัวตราบใดที่คุณสามารถแทนที่การทดสอบได้ ฉันรู้ว่าวิธีการที่ต้องการคือการกำหนดไว้อย่างชัดเจนในตัวสร้างและฉันต้องการไปที่นั่นในที่สุด แต่ฉันสงสัยว่านี่เป็นก้าวแรกที่ดีหรือไม่ ข้อเสียอย่างหนึ่งที่เพิ่งเกิดขึ้นกับฉัน: หากคุณมีคลาสย่อยจริงที่คุณต้องการทดสอบคุณไม่สามารถใช้คลาสย่อยทดสอบที่คุณเขียนสำหรับคลาสแม่ได้ คุณจะต้องสร้างคลาสย่อยทดสอบสำหรับแต่ละคลาสย่อยจริงและมันจะต้องแทนที่ฟังก์ชั่นการสร้างเดียวกัน

12 unit-testing  dependency-injection 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันเห็นในหลาย ๆ ที่ที่ใช้คำResolveนี้ใน Dependency Injection (แก้ไขการใช้งานอินเทอร์เฟซ), Package Managers (เช่น: แก้ไขการพึ่งพาแพ็คเกจ), เว็บ (เช่น: แก้ไขชื่อโฮสต์) ดังนั้นสิ่งที่จะทำให้ตรรกะของรหัสพิเศษที่ทำให้คนเลือกคำResolveมากกว่าง่ายConvertหรือTransformหรือแม้กระทั่งGet?

12 programming-practices  naming  dependency-injection  packages 

สมมติว่าฉันมีสิ่งServiceที่ได้รับการอ้างอิงผ่านตัวสร้าง แต่ยังต้องเริ่มต้นด้วยข้อมูลที่กำหนดเอง (บริบท) ก่อนจึงจะสามารถใช้: public interface IService { void Initialize(Context context); void DoSomething(); void DoOtherThing(); } public class Service : IService { private readonly object dependency1; private readonly object dependency2; private readonly object dependency3; public Service( object dependency1, object dependency2, object dependency3) { this.dependency1 = dependency1 ?? throw new ArgumentNullException(nameof(dependency1)); …

11 dependency-injection  coupling 

ฉันแค่เรียนรู้เกี่ยวกับการฉีดพึ่งพาและติดอยู่กับบางสิ่ง การพึ่งพาการฉีดแนะนำให้ส่งคลาสที่ต้องพึ่งพาผ่านตัวสร้าง แต่ฉันสงสัยว่านี่เป็นสิ่งจำเป็นสำหรับวัตถุข้อมูลหรือไม่ เนื่องจาก Unit-Testability เป็นหนึ่งในประโยชน์หลักของ DI จะเป็น data data ที่เก็บข้อมูลเท่านั้นไม่ใช่โพรซีเดอร์ใด ๆ ที่เคยถูกทดสอบโดยหน่วยทำให้ DI เป็นเลเยอร์ที่ซับซ้อนโดยไม่จำเป็นหรือยังช่วยแสดงการพึ่งพา กับวัตถุข้อมูล? Class DO{ DO(){ DataObject2List = new List<DO2>(); } public string Field1; public string Field2; public List<DO2> DataObject2List; } Class DO2{ public DateTime Date; public double Value; }

11 c#  dependency-injection  class-design 

ฉันดู Pycon ของ Raymond Hettinger พูดว่า "Super Considered Super" และเรียนรู้เล็กน้อยเกี่ยวกับ PROON ของ MRO (Method Resolution Order) ซึ่งทำให้ชั้นเรียนเป็น "ผู้ปกครอง" ในลักษณะเชิงเส้น เราสามารถใช้สิ่งนี้เพื่อประโยชน์ของเราเช่นในรหัสด้านล่างเพื่อทำการฉีดพึ่งพา ตอนนี้ตามธรรมชาติฉันต้องการใช้superสำหรับทุกสิ่ง! ในตัวอย่างด้านล่างที่Userระดับประกาศอ้างอิงมันโดยการสืบทอดจากทั้งสองและLoggingService UserServiceนี่ไม่ใช่สิ่งที่พิเศษเป็นพิเศษ ส่วนที่น่าสนใจคือเราสามารถใช้การแก้ไขวิธีสั่งซื้อยังจำลองการอ้างอิงในระหว่างการทดสอบหน่วย โค้ดด้านล่างนี้สร้างสิ่งMockUserServiceที่สืบทอดมาUserServiceและนำเสนอวิธีการที่เราต้องการจำลอง validate_credentialsในตัวอย่างด้านล่างเราให้การดำเนินการของ เพื่อที่จะได้MockUserServiceจัดการกับการโทรใด ๆ ที่validate_credentialsเราจำเป็นต้องวางไว้ก่อนUserServiceใน MRO นี้ทำได้โดยการสร้างชั้นห่อหุ้มรอบUserเรียกว่าMockUserและมีมันสืบทอดมาจากและUserMockUserService ตอนนี้เมื่อเราทำMockUser.authenticateและในทางกลับกันการเรียกใช้มาsuper().validate_credentials() MockUserServiceก่อนUserServiceในการสั่งซื้อวิธีการแก้ปัญหาและเนื่องจากมีการใช้งานที่เป็นรูปธรรมของvalidate_credentialsการดำเนินการนี้จะถูกนำมาใช้ Yay - เราประสบความสำเร็จUserServiceในการทดสอบหน่วยการเรียนรู้ของเรา พิจารณาว่าUserServiceอาจทำการโทรผ่านเครือข่ายหรือฐานข้อมูลราคาแพง - เราเพิ่งลบปัจจัยแฝงของสิ่งนี้ นอกจากนี้ยังไม่มีความเสี่ยงในการUserServiceสัมผัสข้อมูลสด / กระทุ้ง class LoggingService(object): """ Just a contrived logging class …

11 object-oriented  python  dependency-injection  multiple-inheritance 

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

10 java  design-patterns  dependency-injection 

ตัวอย่างเช่น: var duckBehaviors = new Duckbehavior(); duckBehaviors.quackBehavior = new Quack(); duckBehaviors.flyBehavior = new FlyWithWings(); Duck mallardDuck = new Duck(DuckTypes.MallardDuck, duckBehaviors) เนื่องจากคลาส Duck มีพฤติกรรมทั้งหมด (นามธรรม) การสร้างคลาสใหม่MallardDuck(ซึ่งขยายDuck) จึงไม่จำเป็นต้องมี การอ้างอิง: รูปแบบการออกแบบส่วนหัวแรกบทที่ 1

10 design-patterns  dependency-injection  strategy-pattern 

ฉันมีรถยนต์มากมายในแอปพลิเคชัน C ++ ของฉันซึ่งบรรจุอยู่ภายใน RaceTrack รถแต่ละคันประกอบด้วยชิ้นส่วนหลายร้อยชิ้น แต่ละส่วนขึ้นอยู่กับส่วนอื่น ๆ หรือสอง ฉันได้อ่านคำถามมากมายเกี่ยวกับ DI และหนังสือของ Mark Seemann และดูเหมือนว่าฉันไม่ควรกำหนดคลาสรถยนต์เพื่อเก็บชิ้นส่วนรถยนต์เพราะชิ้นส่วนรถยนต์ทั้งหมดจะขึ้นอยู่กับแต่ละชิ้นและชิ้นส่วนซุปนี้เป็นรถยนต์ ฉันถูกไหม? ดังนั้นเมื่อฉันวางรถแข่งทั้งหมดของฉันลงใน RaceTrack จะไม่มีเอนทิตีของรถยนต์ แต่มีชิ้นส่วนรถยนต์มากมายขึ้นอยู่กับการแข่งรถในแต่ละแทร็ค? ฉันถูกไหม? แก้ไข: สำหรับทุกวัยที่ฉันเขียนโปรแกรมคลาสรถยนต์เพราะเห็นได้ชัดว่าฉันต้องการคลาสรถยนต์หากฉันเขียนโปรแกรมตรรกะรถ แต่ด้วย DI มันไม่ชัดเจนสำหรับฉัน ยังสงสัยว่ามันเป็นสำนวนที่ DI จะไม่สร้างคลาสรถถ้าฉันไม่มีบทบาทที่กำหนดไว้หรือไม่? ฉันหมายความว่ามันโอเคที่จะมีพวงมาลัยล้อเลื่อนสำหรับการขับขี่ BoltsAndNuts บนล้อสำหรับลูกเรือหลุมและอินเทอร์เฟซตลกอื่น ๆ ทุกประเภทโดยไม่ต้องมีอินสแตนซ์ที่แสดงถึงรถยนต์โดยรวมหรือไม่?

10 c++  dependency-injection 

ฉันเพิ่งอ่านเกี่ยวกับ@ImplementedByคำอธิบายประกอบที่มีอยู่ในGoogle Guice อนุญาตให้โปรแกรมเมอร์ระบุการเชื่อมโยงระหว่างอินเตอร์เฟสและการนำไปใช้เพื่อใช้ในอนาคตในการฉีดพึ่งพา มันเป็นตัวอย่างของหนึ่งเพียงในเวลาที่มีผลผูกพัน ฉันค่อนข้างคุ้นเคยกับการกำหนดการผูกอย่างชัดเจนในโมดูลของฉันโดยใช้ไวยากรณ์ต่อไปนี้: bind(SomeInterface.class).to(SomeInterfaceImplementation.class); ตามเอกสารนี้เทียบเท่ากับการใช้@ImplementedByคำอธิบายประกอบต่อไปนี้: @ImplementedBy(SomeInterfaceImplementation.class) public interface SomeInterface { //method declarations } กำไรเดียวที่ฉันเห็นที่นี่คือรหัสสั้นลงเล็กน้อย ในเวลาเดียวกันวิธีการนี้มีข้อเสียเปรียบชี้ให้เห็นอย่างถูกต้องโดยเอกสารเดียวกัน: ใช้@ImplementedByอย่างระมัดระวัง มันเพิ่มการพึ่งพาเวลารวบรวมจากอินเทอร์เฟซเพื่อการใช้งาน การพึ่งพาดังกล่าวอาจไม่เป็นปัญหาในหลายกรณี แต่โดยส่วนตัวแล้วฉันเห็นว่ามันเป็นกลิ่นรหัส กรณีการใช้งานใดที่ทำให้การเพิ่มความคิดเห็นมี@ImplementedByค่าควรใช้ วิธีหนึ่งที่เป็นไปได้คือการใช้มันในโค้ดของไลบรารีหรือกรอบงาน ดังที่อธิบายไว้ในเอกสารคำอธิบายประกอบสามารถจัดเตรียมการโยงดีฟอลต์ได้ง่าย ๆ หากประเภทอยู่ในทั้งสองbind()คำสั่ง (เป็นอาร์กิวเมนต์แรก) และมี@ImplementedByคำอธิบายประกอบคำbind()สั่งจะถูกนำมาใช้ คำอธิบายประกอบแนะนำการใช้งานเริ่มต้นที่สามารถแทนที่ด้วยการผูก ด้วยวิธีนี้ในฐานะนักพัฒนาของห้องสมุดฉันสามารถให้ผู้ใช้ของฉันมีส่วนร่วมนอกกรอบที่สามารถปรับแต่งที่ไหนสักแห่งในรหัสลูกค้า นี่เป็นเหตุผลเดียวที่มีคำอธิบายประกอบอยู่หรือไม่ หรือมีบางอย่างที่ฉันขาดหายไป? ฉันจะได้อะไรจากการใช้มันในโค้ดที่เป็นเพียงแอปพลิเคชันที่ดูแลตรรกะทางธุรกิจบางอย่างและไม่สามารถขยายไลบรารี / กรอบงานได้หรือไม่?

10 java  dependency-injection 

สำหรับปีที่ผ่านมาฉันได้ทำงานกับชุดของแอปพลิเคชันทั้งหมดตามกรอบ Zend และเน้นที่ตรรกะทางธุรกิจที่ซับซ้อนซึ่งแอปพลิเคชันทั้งหมดต้องเข้าถึงได้แม้ว่าจะไม่ได้ใช้ทั้งหมด (ง่ายกว่าการมีโฟลเดอร์ไลบรารีหลายโฟลเดอร์สำหรับแต่ละโฟลเดอร์ แอปพลิเคชันที่เชื่อมโยงทั้งหมดกับศูนย์ส่วนกลาง) โดยไม่ต้องลงรายละเอียดมากนักเกี่ยวกับโครงการที่เฉพาะเจาะจงฉันกำลังมองหาข้อมูล (ขณะที่ฉันกำลังทำงานในโครงการเพียงอย่างเดียว) ว่าฉันมี "จัดกลุ่ม" รหัสของฉันอย่างไร ฉันได้พยายามแยกมันออกมาในลักษณะที่จะลบการพึ่งพาได้มากที่สุด ฉันพยายามที่จะเก็บมันไว้อย่างอิสระเท่าที่ฉันจะทำได้อย่างมีเหตุมีผลดังนั้นในเวลา 12 เดือนเมื่อเวลาของฉันเพิ่มขึ้นใครก็ตามที่เข้ามาไม่มีปัญหาในการขยายสิ่งที่ฉันสร้างขึ้น โครงสร้างตัวอย่าง: applicationStorage\ (contains all applications and associated data) applicationStorage\Applications\ (contains the applications themselves) applicationStorage\Applications\external\ (application grouping folder) (contains all external customer access applications) applicationStorage\Applications\external\site\ (main external customer access application) applicationStorage\Applications\external\site\Modules\ applicationStorage\Applications\external\site\Config\ applicationStorage\Applications\external\site\Layouts\ applicationStorage\Applications\external\site\ZendExtended\ (contains extended Zend …

10 php  architecture  dependency-injection  zend-framework 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ฉันได้คิดเล็กน้อยเกี่ยวกับวิธีการฉีดพึ่งพาสามารถบูรณาการโดยตรงในภาษา C # เช่น ฉันคิดวิธีแก้ปัญหาที่เป็นไปได้ฉันอยากฟังความคิดเห็นของคุณ ฉันไม่ได้ใช้กรอบการฉีดพึ่งพาหลายคนดังนั้นอาจมีบางสิ่งที่ฉันมองเห็น อย่างไรก็ตามแนวคิดก็คือสามารถประกาศคุณสมบัติเป็น "ฉีดได้" โดยใช้คำหลัก เมื่อวัตถุถูกยกตัวอย่างและคุณสมบัตินั้นไม่ได้เริ่มต้นผ่านตัวสร้างหรือวัตถุเริ่มต้นมันขอตัวอย่างของคุณสมบัติประเภทนั้นจากบริการระดับโลกบางอย่าง ในทำนองเดียวกันคุณลงทะเบียนเครื่องจัดการสำหรับประเภทที่แตกต่างกับบริการนั้นเพื่อให้คุณสามารถยกตัวอย่างประเภททรัพย์สินที่ฉีด ข้อดีของการใช้สถาปัตยกรรม IMO ประเภทนี้คือความยืดหยุ่นและใช้งานง่าย ข้อเสียคืออาจมีค่าใช้จ่ายในการทำไฮไลต์บางครั้งในแต่ละครั้งที่คุณเริ่มชั้นเรียนที่มีการฉีด จากนั้นอีกครั้งนั่นเป็นเพียงปัญหาสำหรับคลาสที่รับอินสแตนซ์บ่อยในโซลูชันที่มีประสิทธิภาพสูงดังนั้นจึงไม่ควรเป็นปัญหามากนัก บางทีคุณอาจใช้โรงงานบางประเภทในกรณีเหล่านั้น ความคิดปัญหาคำถามความคิดที่ดีกว่า รหัส public class SomeClass { public SomeClass() { //implicit behavior if Animal is not set in constructor or initializer this.Animal = GlobalInjector.Get(this,typeof(Mammal)) } public injectable …

10 programming-languages  dependency-injection  ioc-containers 

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

10 design  dependency-injection  maintenance 

เมื่อครั้งแรกที่ฉันได้เรียนรู้เกี่ยวกับการออกแบบการขับเคลื่อนด้วยโดเมนฉันยังได้รับการแนะนำให้รู้จักกับที่เก็บและรูปแบบการทำงานที่ครั้งหนึ่งดูเหมือนจะเป็นอันดับต้น ๆ สำหรับเด็กสุดเท่ห์ที่ทำให้แบบสอบถาม SQL เช่น cavemans เทียบกับฐานข้อมูล ยิ่งฉันเข้าสู่หัวข้อนั้นมากเท่าไหร่ฉันก็ยิ่งรู้ว่าพวกเขาไม่จำเป็นอีกต่อไปเพราะORMsเช่นEFและNHibernateที่ใช้ทั้งสองหน่วยงานและพื้นที่เก็บข้อมูลไว้ใน API เดียวที่เรียกว่าเซสชันหรือบริบท ตอนนี้ฉันไม่แน่ใจว่าจะทำอย่างไร เพื่อเก็บหรือไม่ไปยังที่เก็บ ผมเข้าใจโต้แย้งว่าแนวคิดดังกล่าวรั่วเพียงสิ่งที่มากกว่าซับซ้อนขณะที่การเพิ่มอะไรอย่างที่อาจลดความซับซ้อนของการเข้าถึงข้อมูล แต่ก็ไม่ได้รู้สึกขวาคู่ทุกด้านที่เป็นไปได้ของการประยุกต์ใช้ของฉันไปเช่นEntity Framework โดยปกติฉันทำตามคำแนะนำง่ายๆ: เลเยอร์โดเมนคือหัวใจของระบบที่มีเอนทิตี, บริการ, ที่เก็บ ... ชั้นโครงสร้างพื้นฐานให้การใช้งานของส่วนต่อประสานโดเมนที่เกี่ยวข้องกับโครงสร้างพื้นฐานเช่นไฟล์ฐานข้อมูลโปรโตคอล ชั้นแอพลิเคชันเป็นเจ้าภาพรากองค์ประกอบที่เชื่อมโยงสิ่งต่างๆและประสานทุกอย่าง โซลูชันของฉันมักจะมีลักษณะเช่นนี้: Domain.Module1 Domain.Module2 IModule2Repo IModule2Service Module2 Infrastructure.Persistence Repositories EntityFrameworkRepositoryBase MyApp Boostrapper -> inject EntityFrameworkRepositoryBase into IRepository etc. ฉันรักษาเลเยอร์โดเมนของฉันให้สะอาดโดยใช้สิ่งIRepository<'T>ที่เป็นข้อกังวลเกี่ยวกับโดเมนไม่ขึ้นอยู่กับสิ่งอื่นใดที่บอกวิธีเข้าถึงข้อมูล เมื่อตอนนี้ฉันจะทำให้การใช้งานที่เป็นรูปธรรมของIModule2Serviceที่ต้องการเข้าถึงข้อมูลฉันจะต้องฉีดDbContextและโดยสิ่งนี้เชื่อมต่อโดยตรงกับชั้นโครงสร้างพื้นฐาน ( มาที่โครงการ Visual Studio สิ่งนี้อาจทำให้ยุ่งยากเพราะการอ้างอิงแบบวงกลม! ) นอกจากนี้สิ่งที่สามารถเป็นทางเลือกให้กับศูนย์รับฝากและงานfucktons ? CQRS? …

10 design-patterns  database  domain-driven-design  dependency-injection  repository 

ฉันมีคลาสแกนกลางจำนวนมากที่ต้องการ ISessionContext ของฐานข้อมูล ILogManager สำหรับบันทึกและ IService ที่ใช้สำหรับสื่อสารกับบริการอื่น ฉันต้องการใช้การฉีดพึ่งพาสำหรับชั้นนี้ใช้โดยชั้นเรียนหลักทั้งหมด ฉันใช้งานได้สองแบบ คลาสหลักที่ยอมรับ IAmbientContext กับคลาสทั้งหมดสามคลาสหรือฉีดสำหรับคลาสทั้งหมดสามคลาส public interface ISessionContext { ... } public class MySessionContext: ISessionContext { ... } public interface ILogManager { } public class MyLogManager: ILogManager { ... } public interface IService { ... } public class MyService: IService { ... } …

9 c#  dependency-injection 

ฉันใช้ Unity ใน C # สำหรับการฉีดพึ่งพา แต่คำถามควรใช้กับภาษาและกรอบงานใด ๆ ที่ใช้การฉีดพึ่งพา ฉันพยายามทำตามหลักการ SOLID ดังนั้นฉันจึงมี abstractions มากมาย แต่ตอนนี้ฉันสงสัยว่ามีวิธีปฏิบัติที่ดีที่สุดในการฉีดหนึ่งชั้นควรจะฉีดเท่าไหร่? ตัวอย่างเช่นฉันมีพื้นที่เก็บข้อมูลที่มีการฉีด 9 ครั้ง สิ่งนี้จะยากที่จะอ่านสำหรับผู้พัฒนารายอื่นหรือไม่? การฉีดมีความรับผิดชอบดังต่อไปนี้: IDbContextFactory - สร้างบริบทสำหรับฐานข้อมูล IMapper - การแมปจากเอนทิตีกับโมเดลโดเมน IClock - บทคัดย่อ DateTime ตอนนี้จะช่วยในการทดสอบหน่วย IPerformanceFactory - วัดเวลาดำเนินการสำหรับวิธีการเฉพาะ ILog - Log4net สำหรับการบันทึก ICollectionWrapperFactory - สร้างคอลเลกชัน (ที่ขยาย IEnumerable) IQueryFilterFactory - สร้างเคียวรีตามอินพุตที่จะเคียวรี db IIdentityHelper - ดึงผู้ใช้ที่เข้าสู่ระบบ …

9 dependency-injection