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

ชื่อกล่าวว่า "การพึ่งพาหนังสือเวียน" แต่มันไม่ได้เป็นถ้อยคำที่ถูกต้องเพราะสำหรับฉันการออกแบบดูเหมือนจะแข็ง อย่างไรก็ตามให้พิจารณาสถานการณ์ต่อไปนี้ซึ่งชิ้นส่วนสีน้ำเงินได้รับจากคู่ค้าภายนอกและสีส้มคือการนำไปปฏิบัติของฉันเอง นอกจากนี้สมมติว่ามีมากกว่าหนึ่งConcreteMainแต่ฉันต้องการใช้เฉพาะ (ในความเป็นจริงแต่ละชั้นมีการพึ่งพาอาศัยกันมากกว่านี้ แต่ฉันพยายามทำให้มันง่ายขึ้นที่นี่) ฉันต้องการเริ่มต้นทั้งหมดนี้ด้วย Depency Injection (Unity) แต่เห็นได้ชัดว่าฉันได้รับStackOverflowExceptionรหัสต่อไปนี้เนื่องจาก Runner พยายามยกตัวอย่าง ConcreteMain และ ConcreteMain ต้องการนักวิ่ง IUnityContainer ioc = new UnityContainer(); ioc.RegisterType<IMain, ConcreteMain>() .RegisterType<IMainCallback, Runner>(); var runner = ioc.Resolve<Runner>(); ฉันจะหลีกเลี่ยงสิ่งนี้ได้อย่างไร มีวิธีการสร้างโครงสร้างนี้เพื่อให้ฉันสามารถใช้กับ DI? สถานการณ์ที่ฉันทำอยู่ในขณะนี้คือการตั้งค่าทุกอย่างด้วยตนเอง แต่นั่นทำให้การพึ่งพาอย่างหนักConcreteMainในชั้นเรียนที่ทำให้อินสแตนซ์มัน นี่คือสิ่งที่ฉันพยายามหลีกเลี่ยง (ด้วยการลงทะเบียน Unity ในการกำหนดค่า) รหัสแหล่งที่มาทั้งหมดด้านล่าง (ตัวอย่างง่ายมาก!); public class Program { public static void Main(string[] …

15 architecture  dependency-injection  architectural-patterns 

สมมติว่าเรามีลูกค้า 1001 รายที่สร้างการพึ่งพาโดยตรงแทนที่จะยอมรับการฉีด Refactoring the 1001 ไม่ใช่ตัวเลือกตามที่เจ้านายของเรา จริงๆแล้วเราไม่ได้รับอนุญาตให้เข้าถึงแหล่งข้อมูลของพวกเขาเพียงแค่ไฟล์คลาส สิ่งที่เราควรจะทำคือ "ปรับปรุง" ระบบที่ลูกค้า 1001 เหล่านี้ผ่านให้ได้ เราสามารถ refactor ที่เราชอบ การพึ่งพาเป็นส่วนหนึ่งของระบบนั้น และการพึ่งพาเหล่านั้นบางอย่างเราควรเปลี่ยนไปใช้การติดตั้งใหม่ สิ่งที่เราต้องการจะทำคือมีความสามารถในการกำหนดค่าการใช้งานที่แตกต่างกันของการอ้างอิงเพื่อตอบสนองลูกค้าจำนวนมากนี้ น่าเสียดายที่ DI ไม่ได้ดูตัวเลือกเนื่องจากลูกค้าไม่ยอมรับการฉีดด้วยตัวสร้างหรือผู้ตั้งค่า ตัวเลือก: 1) Refactor การปรับใช้บริการที่ลูกค้าใช้เพื่อให้เป็นไปตามที่ลูกค้าต้องการ ปังเราเสร็จแล้ว ไม่ยืดหยุ่น ไม่ซับซ้อน 2) ปรับโครงสร้างการนำไปใช้ใหม่เพื่อให้ผู้รับมอบสิทธิ์สามารถทำงานให้กับการพึ่งพาอื่นที่ได้มาจากโรงงาน ตอนนี้เราสามารถควบคุมว่าการใช้งานแบบใดที่พวกเขาใช้โดยการปรับโครงสร้างโรงงานอีกครั้ง 3) ปรับโครงสร้างการนำไปใช้ใหม่เพื่อให้ผู้รับมอบสิทธิ์สามารถทำงานได้กับการพึ่งพาอื่นที่ได้รับผ่านตัวระบุบริการ ตอนนี้เราสามารถควบคุมได้ว่าการใช้งานใดที่พวกเขาใช้โดยการกำหนดค่าบริการตัวระบุตำแหน่งซึ่งอาจเป็นhashmapสตริงของวัตถุที่มีการแคสต์เล็กน้อย 4) บางสิ่งที่ฉันยังไม่ได้คิดเลย วัตถุประสงค์: ลดความเสียหายที่เกิดจากการออกแบบโดยการลากรหัสลูกค้าเก่าที่ออกแบบมาไม่ดีในอนาคตโดยไม่เพิ่มความซับซ้อนที่ไม่มีจุดหมาย ลูกค้าไม่ควรจะรู้หรือควบคุมการดำเนินงานของการอ้างอิงของพวกเขา newแต่พวกเขายืนยันในการสร้างพวกเขาด้วย เราไม่สามารถควบคุมได้newแต่เราควบคุมชั้นเรียนที่พวกเขากำลังสร้าง คำถามของฉัน: ฉันไม่ได้พิจารณาอะไร คำถามจาก Doc Brown คุณต้องการความเป็นไปได้ที่จะกำหนดค่าระหว่างการใช้งานที่แตกต่างกันหรือไม่? เพื่อจุดประสงค์อะไร? ความว่องไว …

14 design  refactoring  dependency-injection  factory-method  service-locator 

ฉันเรียนรู้ที่จะพัฒนา Test Driven Development (TDD), Dependency Injection (DI) และ Inversion of Control (IoC) ทั้งหมดในเวลาเดียวกัน เมื่อฉันเขียนรหัสโดยใช้ TDD ฉันมักจะจบลงด้วยการใช้ DI ใน Constructor ของชั้นเรียน ฉันสงสัยว่านี่เป็นเพราะฉันเรียนรู้ที่จะทำ TDD หรือถ้านี่เป็นผลข้างเคียงตามธรรมชาติของ TDD ดังนั้นคำถามของฉันคือ: ทำตามหลักการของ TDD และการทดสอบหน่วยการเขียนที่ไม่ได้ขึ้นอยู่กับบริการภายนอกที่นำไปสู่ ​​DI อย่างหลีกเลี่ยงไม่?

14 tdd  dependency-injection  inversion-of-control 

ในปีที่ผ่านมาฉันสร้างระบบใหม่โดยใช้ Dependency Injection และ IOC container เรื่องนี้สอนฉันมากมายเกี่ยวกับ DI! อย่างไรก็ตามหลังจากเรียนรู้แนวคิดและรูปแบบที่เหมาะสมแล้วฉันคิดว่ามันเป็นความท้าทายในการแยกรหัสและแนะนำคอนเทนเนอร์ IOC ในแอปพลิเคชันรุ่นเก่า แอปพลิเคชันมีขนาดใหญ่พอที่จะนำไปใช้จริง แม้ว่าค่าจะเข้าใจและเวลาที่ได้รับ ใครให้เวลากับอะไรแบบนี้ ?? เป้าหมายของหลักสูตรคือการนำการทดสอบหน่วยมาใช้ในตรรกะทางธุรกิจ! ตรรกะทางธุรกิจที่เกี่ยวพันกับการเรียกการป้องกันฐานข้อมูลการทดสอบ ผมเคยอ่านบทความและผมเข้าใจอันตรายของคนจนพึ่งพาการฉีดตามที่อธิบายไว้ในบทความ Los Techies นี้ ผมเข้าใจว่ามันไม่ได้อย่างแท้จริง decouple อะไร ฉันเข้าใจว่าสามารถมีส่วนร่วมในการปรับโครงสร้างระบบได้มากเนื่องจากการติดตั้งใช้งานต้องอาศัยการพึ่งพาใหม่ ฉันจะไม่พิจารณาใช้กับโปรเจ็กต์ใหม่ที่มีขนาดเท่าใดก็ได้ คำถาม:การใช้ DI ของ Poor Man เพื่อแนะนำการทดสอบกับแอปพลิเคชั่นรุ่นเก่าและเริ่มต้นการหมุนลูกบอลได้หรือไม่? นอกจากนี้การใช้ Poor Man's DI เป็นวิธีรากหญ้าในการฉีด Dependency ที่แท้จริงเป็นวิธีที่มีคุณค่าในการให้ความรู้เกี่ยวกับความต้องการและประโยชน์ของหลักการหรือไม่ คุณสามารถ refactor วิธีการที่มีการอ้างอิงการโทรฐานข้อมูลและนามธรรมที่โทรไปด้านหลังส่วนติดต่อ? เพียงแค่มีสิ่งที่เป็นนามธรรมจะทำให้วิธีการนั้นสามารถทดสอบได้เนื่องจากการใช้งานจำลองอาจถูกส่งผ่านทางตัวสร้างเกินพิกัด เมื่อถึงความพยายามที่ได้รับการสนับสนุนโครงการสามารถปรับปรุงเพื่อใช้คอนเทนเนอร์ IOC และผู้สร้างจะออกไปที่นั่นในนามธรรม

14 architecture  dependency-injection  legacy  inversion-of-control 

ฉันกำลังสร้างแอปพลิเคชัน WPF โดยใช้รูปแบบ MVVM ในตอนนี้ viewmodels ของฉันเรียกเลเยอร์บริการเพื่อเรียกคืนโมเดล (ความเกี่ยวข้องกับ viewmodel) และแปลงเป็น viewmodels ฉันใช้ตัวสร้างการฉีดเพื่อส่งผ่านบริการที่จำเป็นสำหรับโมเดลวิวเวอร์ มันทดสอบได้ง่ายและทำงานได้ดีสำหรับ viewmodels ที่มีการพึ่งพาน้อย แต่ทันทีที่ฉันพยายามสร้าง viewModels สำหรับรุ่นที่ซับซ้อนฉันมี Constructor ที่มีบริการมากมายแทรกอยู่ (หนึ่งเพื่อดึงการอ้างอิงแต่ละรายการและรายการค่าที่มีทั้งหมด เพื่อผูกกับ itemsSource เป็นต้น) ฉันสงสัยว่าจะจัดการกับบริการหลายอย่างเช่นนั้นได้อย่างไรและยังมีวิวเวอร์โมเดลที่ฉันสามารถทดสอบหน่วยได้อย่างง่ายดาย ฉันกำลังคิดถึงวิธีแก้ปัญหาบางอย่าง: การสร้างบริการแบบซิงเกิล (IServices) ที่มีบริการทั้งหมดที่มีอยู่เป็นส่วนต่อประสาน ตัวอย่าง: Services.Current.XXXService.Retrieve (), Services.Current.YYYService.Retrieve () ด้วยวิธีนี้ฉันไม่มีคอนสตรัคเตอร์ขนาดใหญ่ที่มีพารามิเตอร์บริการจำนวนมากในตัวพวกเขา การสร้างส่วนหน้าสำหรับบริการที่ใช้โดย viewModel และส่งผ่านออบเจ็กต์นี้ใน ctor ของ viewmodel ของฉัน แต่แล้วฉันจะต้องสร้างซุ้มสำหรับแต่ละมุมมองเชิงซ้อนของฉันและมันอาจจะค่อนข้างมาก ... คุณคิดว่าเป็นวิธีที่ "ถูกต้อง" ในการใช้งานสถาปัตยกรรมประเภทนี้?

14 architecture  dependency-injection  mvvm 

IContextฉันมีอินเตอร์เฟซที่เรียกว่า สำหรับวัตถุประสงค์นี้ไม่สำคัญว่าจะทำอะไรยกเว้นดังต่อไปนี้: T GetService<T>(); สิ่งที่วิธีนี้ทำคือดูที่ DI คอนเทนเนอร์ปัจจุบันของแอ็พพลิเคชันและพยายามแก้ไขการพึ่งพา ฉันคิดว่าค่อนข้างมาตรฐาน ในแอปพลิเคชัน ASP.NET MVC ของฉันคอนสตรัคของฉันมีลักษณะเช่นนี้ protected MyControllerBase(IContext ctx) { TheContext = ctx; SomeService = ctx.GetService<ISomeService>(); AnotherService = ctx.GetService<IAnotherService>(); } ดังนั้นแทนที่จะเพิ่มหลายพารามิเตอร์ในตัวสร้างสำหรับแต่ละบริการ (เพราะจะทำให้รำคาญและใช้เวลานานสำหรับนักพัฒนาที่ขยายแอปพลิเคชัน) ฉันใช้วิธีนี้เพื่อรับบริการ ตอนนี้ก็รู้สึกผิด แต่วิธีการที่ฉันกำลังเหตุผลมันอยู่ในหัวของฉันนี้ - ฉันจะเยาะเย้ยมัน ฉันสามารถ. IContextการทดสอบตัวควบคุมนั้นคงไม่ยาก ฉันจะต้องต่อไป: public class MyMockContext : IContext { public T GetService<T>() { if (typeof(T) == typeof(ISomeService)) …

13 c#  unit-testing  asp.net-mvc  dependency-injection 

กรอบการฉีดที่พึ่งพาเช่น Google Guice ให้แรงจูงใจต่อการใช้งาน (ที่มา ): ในการสร้างวัตถุคุณต้องสร้างการขึ้นต่อกันก่อน แต่ในการสร้างการพึ่งพาแต่ละครั้งคุณจำเป็นต้องมีการพึ่งพาและอื่น ๆ ดังนั้นเมื่อคุณสร้างวัตถุคุณจำเป็นต้องสร้างกราฟวัตถุ การสร้างกราฟวัตถุด้วยมือนั้นเป็นเรื่องยากสำหรับแรงงาน (... ) และทำให้การทดสอบเป็นเรื่องยาก แต่ฉันไม่ได้ซื้ออาร์กิวเมนต์นี้: แม้จะไม่มีกรอบการฉีดพึ่งพาฉันสามารถเขียนชั้นเรียนซึ่งทั้งง่ายต่อการ instantiate และสะดวกในการทดสอบ เช่นตัวอย่างจากหน้าแรงจูงใจของ Guiceสามารถเขียนใหม่ด้วยวิธีต่อไปนี้: class BillingService { private final CreditCardProcessor processor; private final TransactionLog transactionLog; // constructor for tests, taking all collaborators as parameters BillingService(CreditCardProcessor processor, TransactionLog transactionLog) { this.processor = processor; this.transactionLog = …

13 design-patterns  object-oriented  dependency-injection  ioc-containers 

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

13 frameworks  dependency-injection 

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

13 php  dependency-injection 

ก่อนอื่นฉันเป็นโปรแกรมเมอร์ระดับต้น ในความเป็นจริงฉันกำลังจบระดับ AS ด้วยโปรเจ็กต์สุดท้ายของฤดูร้อน ในงานใหม่ของฉันเมื่อไม่มีโครงการให้ฉันทำ (พวกเขากำลังรอที่จะเติมทีมด้วยการจ้างงานใหม่) ฉันได้รับหนังสือให้อ่านและเรียนรู้จากในขณะที่ฉันรอ - ตำราบางเล่มอื่น ๆ ไม่มาก (เช่น Code Complete) หลังจากอ่านหนังสือเหล่านี้ฉันได้หันไปใช้อินเทอร์เน็ตเพื่อเรียนรู้ให้มากที่สุดและเริ่มเรียนรู้เกี่ยวกับ SOLID และ DI (เราได้พูดถึงหลักการทดแทนของ Liskov แต่ไม่ได้มีแนวคิด SOLID อื่น) เพื่อที่ฉันจะได้เรียนรู้ฉันนั่งลงเพื่อเรียนรู้ให้ดีขึ้นและเริ่มเขียนโค้ดเพื่อใช้ DI ด้วยมือ (ไม่มีกรอบ DI บนคอมพิวเตอร์การพัฒนา) สิ่งที่ฉันทำมันฉันสังเกตเห็นว่ามันรู้สึกคุ้นเคย ... และดูเหมือนว่ามันเป็นเหมือนงานที่ฉันเคยทำในอดีตโดยใช้องค์ประกอบของคลาสนามธรรมโดยใช้ polymorphism ฉันคิดถึงภาพที่ใหญ่กว่านี้หรือไม่? มีบางอย่างเกี่ยวกับ DI (อย่างน้อยด้วยมือ) ที่ไปได้หรือไม่? ฉันเข้าใจถึงความเป็นไปได้ของการกำหนดค่าที่ไม่ได้อยู่ในรหัสของกรอบงาน DI บางอันที่มีประโยชน์มากพอ ๆ กับการเปลี่ยนแปลงสิ่งต่าง ๆ โดยไม่ต้องคอมไพล์ใหม่ แต่เมื่อทำด้วยมือฉันไม่แน่ใจว่ามันแตกต่างจากที่ระบุข้างต้น ... ข้อมูลเชิงลึกเกี่ยวกับเรื่องนี้จะมีประโยชน์มาก!

13 dependency-injection  abstraction  polymorphism  composition 

ฉันกำลังอ่านหนังสือหลักการพึ่งพาวิธีปฏิบัติและรูปแบบการพึ่งพาหนังสือและฉันอ่านเกี่ยวกับแนวคิดของสิ่งที่เป็นนามธรรมซึ่งอธิบายไว้ในหนังสือ วันนี้ฉันกำลังสร้างฐานรหัส C # ขึ้นใหม่โดยใช้การฉีดอ้างอิงเพื่อให้มีการใช้การโทรแบบ async แทนการบล็อก การทำเช่นนี้ฉันกำลังพิจารณาอินเทอร์เฟซบางตัวที่เป็นนามธรรมในรหัสฐานของฉันและต้องได้รับการออกแบบใหม่เพื่อให้สามารถใช้การโทรแบบ async ได้ เป็นตัวอย่างให้พิจารณาอินเตอร์เฟสต่อไปนี้ที่แสดงถึงที่เก็บสำหรับผู้ใช้แอ็พพลิเคชัน: public interface IUserRepository { Task<IEnumerable<User>> GetAllAsync(); } ตามคำนิยามของหนังสือสิ่งที่เป็นนามธรรมคือสิ่งที่เป็นนามธรรมที่ได้รับการออกแบบมาโดยเฉพาะในใจนามธรรมเพื่อให้รายละเอียดของการดำเนินการ "รั่ว" ผ่านสิ่งที่เป็นนามธรรมเอง คำถามของฉันมีดังต่อไปนี้: เราสามารถพิจารณาอินเทอร์เฟซที่ออกแบบโดยคำนึงถึง async เช่น IUserRepository เป็นตัวอย่างของ Leaky Abstraction ได้หรือไม่? แน่นอนว่าการใช้งานที่เป็นไปไม่ได้ทั้งหมดมีบางอย่างที่เกี่ยวข้องกับ asynchrony: มีเพียงการติดตั้งแบบไม่ใช้กระบวนการ (เช่นการใช้ SQL) แต่การเก็บข้อมูลในหน่วยความจำไม่จำเป็นต้องใช้แบบอะซิงโครนัส ยากถ้าอินเทอร์เฟซถูกเปิดเผยเมธอด async ตัวอย่างเช่นคุณอาจต้องส่งคืนสิ่งที่ต้องการเช่น Task.CompletedTask หรือ Task.FromResult (ผู้ใช้) ในการประยุกต์ใช้เมธอด) คุณคิดยังไงเกี่ยวกับที่ ?

13 c#  object-oriented  api-design  interfaces  dependency-injection 

นี่เป็นศัพท์เฉพาะ (การเขียนเชิงเทคนิค) มากกว่าคำถามทางเทคนิคอย่างแท้จริง ฉันกำลังพยายามเขียนข้อเสนอการปรับโครงสร้างใหม่ (และให้สิทธิ์ตัวเอง) โดยมีศูนย์กลางที่การขยายการฉีดที่ต้องพึ่งพาในแอปพลิเคชันของเรา ในขณะที่เราใช้Springในการเรียกถั่วอัตโนมัติยังคงมีกรณีที่ยกตัวอย่างถั่วที่ใช้MyClass obj = new MyClass(...)ซึ่งสามารถฉีดได้ทั้งหมด ฉันต้องการทำให้ข้อเสนอของฉันใช้ระบบการตั้งชื่อที่สง่างามและอ้างอิงถึงรูปแบบการออกแบบตรงข้ามกับ DI ด้วยคำที่เหมาะสม คำว่า "คับคัปปลิ้ง" เป็นคำที่เพียงพอหรือไม่ที่ตรงกันข้ามกับ DI?

12 terminology  refactoring  dependency-injection 

ฉันยังใหม่กับการฉีดแบบพึ่งพาและฉันมีคำถามสองสามข้อเกี่ยวกับสไตล์ที่ฉันควรใช้ในแอปพลิเคชันของฉัน ฉันเพิ่งอ่านInversion of Control Containers และรูปแบบการพึ่งพาการฉีดของ Martin Fowler แต่ฉันไม่สามารถรับความแตกต่างระหว่าง Constructor, Setter และ Interface Injection ได้ สำหรับฉันแล้วเหตุผลที่ใช้อีกอันหนึ่งเป็นเพียงเรื่องของการล้างโค้ดและ / หรือความชัดเจน อะไรคือความแตกต่าง? มีข้อดีหรือข้อเสียที่แข็งแกร่งในการใช้อย่างใดอย่างหนึ่งมากกว่าหรือเป็นเพียงสิ่งที่ฉันได้กล่าวก่อนหน้านี้? ในความคิดของการฉีดคอนสตรัคเป็นที่ใช้งานง่ายที่สุดของทั้งหมดเช่นเดียวกับการฉีดอินเตอร์เฟซเป็นอย่างน้อย ในอีกทางหนึ่งการฉีดเซทเทอร์เป็นระยะกลาง แต่คุณควรจะสามารถเปลี่ยนอินสแตนซ์ของออบเจ็กต์การพึ่งพาที่คุณฉีดตอนแรกได้หรือไม่ รูปแบบการฉีดแบบนี้รับประกันได้ว่าวัตถุที่ต้องการการพึ่งพานั้นจะต้องทำการฉีดหรือไม่? ฉันไม่เชื่อ แต่โปรดแก้ไขให้ถูกต้องถ้าฉันผิด

12 design-patterns  dependency-injection  inversion-of-control 

ขณะนี้ฉันกำลังออกแบบโซลูชัน n-tier ซึ่งใช้ Entity Framework 5 (.net 4) เป็นกลยุทธ์การเข้าถึงข้อมูล แต่ฉันกังวลเกี่ยวกับวิธีรวมการฉีดพึ่งพาเพื่อให้สามารถทดสอบ / ยืดหยุ่นได้ เค้าโครงโซลูชันปัจจุบันของฉันมีดังนี้ (โซลูชันของฉันชื่อ Alcatraz): Alcatraz.WebUI : การ asp.net เว็บฟอร์มโครงการส่วนติดต่อผู้ใช้ปลายด้านหน้าอ้างอิงโครงการAlcatraz.BusinessและAlcatraz.Data.Models Alcatraz.Business : โครงการห้องสมุดระดับมีตรรกะทางธุรกิจโครงการอ้างอิงAlcatraz.Data.Access , Alcatraz.Data.Models Alcatraz.Data.Access : ห้องสมุดชั้นโครงการบ้านAlcatrazModel.edmxและAlcatrazEntitiesDbContext อ้างอิงโครงการAlcatraz.Data.Models Alcatraz.Data.Models : โครงการห้องสมุดคลาสมี POCO สำหรับรุ่น Alcatraz ไม่มีการอ้างอิง วิสัยทัศน์ของฉันสำหรับวิธีการแก้ปัญหานี้จะทำงานเป็น web-UI จะยกตัวอย่างพื้นที่เก็บข้อมูลภายในห้องสมุดธุรกิจที่เก็บนี้จะมีการพึ่งพา (ผ่านตัวสร้าง) ของสตริงการเชื่อมต่อ (ไม่ใช่AlcatrazEntitiesอินสแตนซ์) web-ui จะรู้จักสตริงการเชื่อมต่อฐานข้อมูล แต่ไม่ใช่ว่าเป็นสตริงการเชื่อมต่อของเฟรมเวิร์กเอนทิตี ในโครงการธุรกิจ: public class InmateRepository : …

12 c#  .net  dependency-injection  entity-framework  n-tier 

ฉันชอบจุดที่เพิ่มความสามารถของ MVC ช่วยให้มุมมองแบบจำลองใช้ IValidatableObject และเพิ่มการตรวจสอบความถูกต้องที่กำหนดเอง ฉันพยายามควบคุมให้ตัวควบคุมของฉันคงอยู่เพราะการใช้รหัสนี้เป็นเพียงตรรกะการตรวจสอบเท่านั้น: if (!ModelState.IsValid) return View(loginViewModel); ตัวอย่างเช่นโมเดลมุมมองล็อกอินใช้ IValidatableObject รับวัตถุ ILoginValidator ผ่านการสร้างคอนสตรัค: public interface ILoginValidator { bool UserExists(string email); bool IsLoginValid(string userName, string password); } ดูเหมือนว่า Ninject การฉีดอินสแตนซ์ในมุมมองแบบจำลองไม่ใช่วิธีปฏิบัติทั่วไปจริง ๆ อาจเป็นรูปแบบการต่อต้านหรือไม่ นี่เป็นวิธีที่ดีหรือไม่? มีดีกว่าไหม

12 architecture  asp.net-mvc  dependency-injection  validation  single-responsibility