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

ฉันมีการสนทนาที่น่าสนใจในวันนี้กับผู้พัฒนารายอื่นเกี่ยวกับวิธีการเข้าเรียนด้วยวิธีการที่ยอมรับสตริงและเอาต์พุตสตริง ลองนึกภาพบางสิ่งเช่นสิ่งต่อไปนี้ซึ่งสร้างขึ้นโดยสมบูรณ์เพื่อเป็นตัวอย่าง public string GetStringPart(string input) { //Some input validation which is removed for clarity if(input.Length > 5) return input.Substring(0,1); if(input.Substring(0,1) == "B") return input.Substring(0,3); return string.empty; } ฟังก์ชั่นที่มีตรรกะบางอย่างตามการป้อนสตริงของมันจะถูกเพิ่มเข้าไปในโครงการโดยใช้ DI และมี DI Container ในสถานที่ คุณจะเพิ่มคลาสใหม่นี้ด้วยอินเทอร์เฟซและฉีดเมื่อจำเป็นหรือคุณจะทำให้คลาสคงที่หรือไม่ ข้อดีและข้อเสียของแต่ละข้อคืออะไร? ทำไมคุณ (หรือไม่) ต้องการที่จะทำให้สิ่งนี้ใช้กับการฉีดคอนสตรัคเตอร์แทนที่จะเข้าถึงเมื่อต้องการได้ทุกที่

21 dependency-injection  static-methods 

มีเหตุผลมากมายว่าทำไมคนรอบข้างจึงชั่วร้ายใน OOP หากจำนวนหรือขนาดของวัตถุที่ต้องการแบ่งปันมีขนาดใหญ่เกินไปที่จะส่งผ่านอย่างมีประสิทธิภาพในพารามิเตอร์ฟังก์ชั่นมักจะทุกคนแนะนำพึ่งพาการฉีดแทนวัตถุทั่วโลก อย่างไรก็ตามในกรณีที่เกือบทุกคนจำเป็นต้องรู้เกี่ยวกับโครงสร้างข้อมูลบางอย่างทำไมการพึ่งพาการฉีดจึงดีกว่าวัตถุระดับโลก ตัวอย่าง (ตัวย่อที่เรียบง่ายเพื่อแสดงจุดโดยทั่วไปโดยไม่ต้องเจาะลึกในแอปพลิเคชันเฉพาะ) มีรถยนต์เสมือนจำนวนมากที่มีคุณสมบัติและสถานะจำนวนมากตั้งแต่ประเภทชื่อสีไปจนถึงความเร็วตำแหน่ง ฯลฯ ผู้ใช้จำนวนมากสามารถควบคุมจากระยะไกลและเหตุการณ์จำนวนมาก (ทั้งผู้ใช้ - เริ่มต้นและอัตโนมัติ) สามารถเปลี่ยนสถานะหรือคุณสมบัติได้มากมาย วิธีการแก้ปัญหาที่ไร้เดียงสาคือการสร้างภาชนะใส่ของโลกเช่น vector<Vehicle> vehicles; ซึ่งสามารถเข้าถึงได้จากทุกที่ วิธีแก้ปัญหาที่เป็นมิตรกับ OOP ก็คือให้มีคอนเทนเนอร์เป็นสมาชิกของคลาสที่จัดการห่วงเหตุการณ์หลักและถูกสร้างอินสแตนซ์ในตัวสร้าง ทุกคลาสที่ต้องการมันและเป็นสมาชิกของเธรดหลักจะได้รับการเข้าถึงคอนเทนเนอร์ผ่านตัวชี้ในตัวสร้างของพวกเขา ตัวอย่างเช่นหากข้อความภายนอกเข้ามาผ่านการเชื่อมต่อเครือข่ายคลาส (หนึ่งสำหรับแต่ละการเชื่อมต่อ) การจัดการการแยกจะใช้เวลามากกว่าและ parser จะเข้าถึงคอนเทนเนอร์ผ่านตัวชี้หรือการอ้างอิง ตอนนี้ถ้าข้อความที่วิเคราะห์คำส่งผลให้เกิดการเปลี่ยนแปลงในองค์ประกอบของคอนเทนเนอร์หรือต้องการข้อมูลบางส่วนเพื่อดำเนินการก็สามารถจัดการได้โดยไม่จำเป็นต้องสลับตัวแปรหลายพันตัวผ่านสัญญาณและช่องเสียบ (หรือแย่กว่านั้น เก็บไว้ใน parser ที่จะเรียกคืนในภายหลังโดยผู้ที่เรียกว่า parser) แน่นอนว่าคลาสทั้งหมดที่ได้รับการเข้าถึงคอนเทนเนอร์ผ่านการฉีดเป็นส่วนหนึ่งของเธรดเดียวกัน เธรดที่แตกต่างกันจะไม่สามารถเข้าถึงได้โดยตรง แต่ทำงานของพวกเขาแล้วส่งสัญญาณไปยังเธรดหลักและสล็อตในเธรดหลักจะอัพเดตคอนเทนเนอร์ อย่างไรก็ตามถ้าส่วนใหญ่ของคลาสจะเข้าถึงคอนเทนเนอร์สิ่งที่ทำให้แตกต่างจากส่วนกลาง หากคลาสจำนวนมากต้องการข้อมูลในคอนเทนเนอร์ไม่ใช่ "วิธีการฉีดพึ่งพา" เป็นเพียงระบบปลอมทั่วโลกใช่หรือไม่ คำตอบหนึ่งก็คือความปลอดภัยของเธรด: แม้ว่าฉันจะระวังไม่ให้ใช้ภาชนะที่ไม่เหมาะสมกับผู้ใช้ทั่วโลกบางทีผู้พัฒนารายอื่นในอนาคตภายใต้แรงกดดันของเส้นตายที่ใกล้จะถึงกระนั้นก็ตาม กรณีการปะทะกัน อย่างไรก็ตามแม้ในกรณีของการฉีดพึ่งพาใครสามารถชี้ให้คนที่ทำงานในหัวข้ออื่นที่นำไปสู่ปัญหาเดียวกัน

20 design-patterns  object-oriented  dependency-injection 

ฉันกำลังอ่าน "การพึ่งพาการฉีดใน. NET" โดย Mark Seemann (มันยอดเยี่ยมและต้องมี) และผู้เขียนมักใช้คำว่า "ตะเข็บ" แต่ฉันไม่เข้าใจความหมาย นี่คือตัวอย่างของการใช้คำนี้: บทที่ 7 อธิบายวิธีการเขียนวัตถุในเฟรมเวิร์กที่หลากหลายเช่น ASP.NET MVC, WPF, WCF และอื่น ๆ ไม่ใช่ทุกเฟรมเวิร์คที่สนับสนุน DI อย่างเท่าเทียมกันและแม้แต่ในบรรดาที่ทำวิธีที่พวกเขาทำแตกต่างกันมาก สำหรับแต่ละเฟรมเวิร์กอาจเป็นการยากที่จะระบุ SEAM ที่เปิดใช้ DI ในเฟรมเวิร์กนั้น อย่างไรก็ตามเมื่อพบว่า SEAM คุณมีทางออกสำหรับแอปพลิเคชันทั้งหมดที่ใช้กรอบงานนี้โดยเฉพาะ ในบทที่ 7 ฉันได้ทำงานนี้สำหรับกรอบงานแอพพลิเคชัน NET ที่ใช้กันทั่วไปมากที่สุดแล้ว คิดว่ามันเป็นแคตตาล็อกของกรอบ SEAMS ฉันจะขอบคุณมากที่ช่วยฉันทำความเข้าใจกับคำนี้

20 terminology  dependency-injection 

รูปแบบโดเมนโรคโลหิตจางจะอธิบายว่าการต่อต้านรูปแบบในการออกแบบโดเมนขับเคลื่อนโดยมาร์ตินฟาวเลอร์ เพื่อให้มีตรรกะทางธุรกิจในรูปแบบโดเมนมักจะใช้บริการโดเมน แต่การฉีดบริการโดเมนลงในแบบจำลองโดเมนนั้นถือว่าเป็นอันตรายโดย Vaughn Vernon (ดู "การใช้การออกแบบที่ขับเคลื่อนด้วยโดเมน, หน้า 387) ในความคิดของฉันความคิดเห็นเหล่านั้นขัดแย้งกันจริงหรือไม่? จะพิจารณาทั้งสองประเด็นได้อย่างไร มันเป็นรูปแบบโดเมนที่สมบูรณ์จริง ๆกับบริการโดเมนฉีดกับแบบจำลองโดเมน anemic และบริการโดเมนปกติหรือไม่

19 domain-driven-design  dependency-injection  services 

ผู้พัฒนาที่ดีที่ฉันทำงานด้วยบอกกับฉันเมื่อเร็ว ๆ นี้เกี่ยวกับความยากลำบากบางอย่างที่เขามีในการใช้คุณสมบัติในโค้ดบางตัวที่เราได้รับมา เขากล่าวว่าปัญหาคือรหัสนั้นยากที่จะปฏิบัติตาม จากนั้นฉันมองลึกเข้าไปในผลิตภัณฑ์และรู้ว่ามันยากแค่ไหนที่จะเห็นเส้นทางของโค้ด มันใช้อินเทอร์เฟซและเลเยอร์นามธรรมมากมายที่พยายามเข้าใจว่าสิ่งที่เริ่มต้นและสิ้นสุดนั้นค่อนข้างยาก มันทำให้ฉันคิดถึงเวลาที่ฉันได้ดูโครงการที่ผ่านมา (ก่อนที่ฉันจะทราบถึงหลักการของโค้ดที่สะอาด) และพบว่ามันยากมากที่จะได้รับในโครงการส่วนใหญ่เป็นเพราะเครื่องมือนำทางรหัสของฉัน จะต้องใช้ความพยายามเป็นพิเศษในการค้นหาการใช้งานที่เป็นรูปธรรมหรือสิ่งที่มีสายในสถาปัตยกรรมประเภทปลั๊กอินบางอย่าง ฉันรู้ว่านักพัฒนาบางคนหันมาใช้ถังบรรจุแบบพึ่งพาอย่างเคร่งครัดด้วยเหตุผลนี้ มันทำให้เส้นทางของซอฟต์แวร์สับสนจนความยากในการนำทางรหัสเพิ่มขึ้นแบบทวีคูณ คำถามของฉันคือ: เมื่อกรอบงานหรือรูปแบบนำเสนอค่าใช้จ่ายมากเช่นนี้มันจะคุ้มหรือไม่ มันเป็นอาการของรูปแบบการใช้งานที่ไม่ดีหรือไม่? ฉันเดาว่าผู้พัฒนาควรดูภาพรวมของสิ่งที่นามธรรมนำมาสู่โครงการเพื่อช่วยให้พวกเขาผ่านพ้นความยุ่งยาก โดยปกติแล้วมันยากที่จะทำให้พวกเขาเห็นภาพรวมขนาดใหญ่ ฉันรู้ว่าฉันไม่สามารถขายความต้องการของ IOC และ DI ด้วย TDD สำหรับนักพัฒนาเหล่านั้นการใช้เครื่องมือเหล่านั้นทำให้การอ่านโค้ดเป็นเรื่องลำบากมากเกินไป

19 testing  code-quality  tdd  code-smell  dependency-injection 

ฉันใช้คอนเทนเนอร์ IoC (Castle.Windsor, Autofac, MEF และอื่น ๆ ) สำหรับ. Net ในหลายโครงการ ฉันพบว่าพวกเขามักจะถูกทารุณกรรมบ่อยครั้งและส่งเสริมการปฏิบัติที่ไม่ดี มีแนวทางปฏิบัติที่กำหนดไว้สำหรับการใช้คอนเทนเนอร์ IoC โดยเฉพาะอย่างยิ่งเมื่อมีการจัดทำแพลตฟอร์ม / กรอบงาน เป้าหมายของฉันในฐานะนักเขียนเฟรมเวิร์กคือการทำโค้ดให้ง่ายและใช้งานง่ายที่สุดเท่าที่จะทำได้ ฉันควรเขียนโค้ดหนึ่งบรรทัดเพื่อสร้างออบเจ็กต์มากกว่าสิบหรือแม้แต่แค่สอง ตัวอย่างเช่นโค้ดสองสามกลิ่นที่ฉันสังเกตเห็นและไม่มีคำแนะนำที่ดีในการ: พารามิเตอร์จำนวนมาก (> 5) สำหรับตัวสร้าง การสร้างบริการมีความซับซ้อน การพึ่งพาทั้งหมดจะถูกฉีดผ่านทางคอนสตรัคเตอร์ - แม้ว่าจะมีความจริงที่ว่าส่วนประกอบนั้นเป็นทางเลือกที่หาได้ยาก (ยกเว้นในการทดสอบ) การขาดคลาสส่วนตัวและภายใน อันนี้อาจเป็นข้อ จำกัด เฉพาะของการใช้ C # และ Silverlight แต่ฉันสนใจที่จะแก้ไขมันอย่างไร เป็นการยากที่จะบอกว่าอินเตอร์เฟสเฟรมเวิร์กคืออะไรถ้าคลาสทั้งหมดเป็นแบบสาธารณะ มันช่วยให้ฉันเข้าถึงชิ้นส่วนส่วนตัวที่ฉันไม่ควรแตะ เชื่อมวงจรชีวิตของวัตถุกับคอนเทนเนอร์ IoC มันมักจะยากที่จะสร้างการอ้างอิงที่จำเป็นในการสร้างวัตถุ วงจรชีวิตของวัตถุได้รับการจัดการบ่อยเกินไปโดยกรอบงาน IoC ฉันเห็นโปรเจ็กต์ที่ชั้นเรียนส่วนใหญ่ลงทะเบียนเป็นซิงเกิลตัน คุณขาดการควบคุมอย่างชัดเจนและถูกบังคับให้จัดการ internals (มันเกี่ยวข้องกับประเด็นข้างต้นทุกชั้นเป็นสาธารณะและคุณต้องฉีดมัน) ตัวอย่างเช่น. …

18 .net  silverlight  dependency-injection  ioc-containers  inversion-of-control 

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

18 design-patterns  dependency-injection  inversion-of-control  ioc-containers  evidence-based 

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

17 design-patterns  dependency-injection 

ฉันสงสัยว่าฉันทำผิดพลาดกับเด็กนักเรียนที่นี่และกำลังมองหาการชี้แจง เรียนจำนวนมากในโซลูชันของฉัน (C #) - ฉันกล้าพูดส่วนใหญ่ - ฉันสิ้นสุดการเขียนอินเทอร์เฟซที่สอดคล้องกันสำหรับ เช่นอินเทอร์เฟซ "ICalculator" และคลาส "เครื่องคิดเลข" ที่ใช้งานแม้ว่าฉันจะไม่เคยเปลี่ยนเครื่องคิดเลขนั้นด้วยการใช้งานที่แตกต่างกัน นอกจากนี้คลาสเหล่านี้ส่วนใหญ่อาศัยอยู่ในโครงการเดียวกันกับการพึ่งพาของพวกเขา - พวกเขาเพียง แต่จะต้องเป็นinternalจริง แต่ได้กลายpublicเป็นผลข้างเคียงของการใช้อินเทอร์เฟซที่เกี่ยวข้องของพวกเขา ฉันคิดว่าวิธีนี้ในการสร้างส่วนต่อประสานสำหรับทุกสิ่งที่เกิดขึ้นจากความผิดพลาดเล็กน้อย: - 1) ตอนแรกฉันคิดว่าอินเตอร์เฟสจำเป็นต้องสร้างหน่วยทดสอบ mocks (ฉันใช้ Moq) แต่ตั้งแต่ฉันค้นพบว่าคลาสสามารถเยาะเย้ยถ้าสมาชิกเป็นสมาชิกvirtualและมีคอนสตรัคเตอร์แบบไม่ใช้พารามิเตอร์ (แก้ไขฉันถ้า ฉันผิด). 2) ตอนแรกฉันคิดว่าจำเป็นต้องใช้อินเทอร์เฟซในการลงทะเบียนชั้นเรียนด้วยกรอบ IoC (Castle Windsor) เช่น Container.Register(Component.For<ICalculator>().ImplementedBy<Calculator>()... เมื่อในความเป็นจริงฉันสามารถลงทะเบียนประเภทคอนกรีตกับตัวเอง: Container.Register(Component.For<Calculator>().ImplementedBy<Calculator>()... 3) การใช้อินเตอร์เฟสเช่นพารามิเตอร์คอนสตรัคเตอร์สำหรับการฉีดแบบพึ่งพาผลลัพธ์ใน "การเชื่อมต่อแบบหลวม" ดังนั้นฉันจึงโกรธกับอินเทอร์เฟซ! ฉันตระหนักถึงสถานการณ์ที่คุณจะ "ปกติ" ใช้อินเทอร์เฟซเช่นเปิดเผย API สาธารณะหรือสิ่งต่าง ๆ เช่นฟังก์ชัน "เสียบได้" โซลูชันของฉันมีคลาสจำนวนเล็กน้อยที่เหมาะสมกับกรณีการใช้งานดังกล่าว …

17 object-oriented  interfaces  dependency-injection 

ฉันสะดุดกับคำพูดของเกร็กยัง7 เหตุผลที่โครงการ DDD ล้มเหลวซึ่งเขาพูดถึงบางสิ่งที่เขาเรียกว่า DDD-Lite เวลา 7:20 โดยสรุปเขากล่าวโดยทั่วไปว่าบางคนใช้ DDD เป็นภาษารูปแบบ (เอนทิตี, ที่เก็บ, อ็อบเจ็กต์ค่า, การบริการและอื่น ๆ ) โดยไม่ต้องทำสิ่งอื่นใดที่เกี่ยวข้องกับ DDD เขาอ้างถึงโดเมนแบบจำลอง 60% ขึ้นไปใน. Net คือ DDD-Lite เขาคิดว่า DDD-Lite นั้นกำลังสร้างภาษาเกี่ยวกับการฉีดพึ่งพาซึ่งเป็นสิ่งที่คุณไม่จำเป็นต้องทำ เขาบอกว่าทำ DDD ทั้งหมดหรือทำสิ่งที่ง่ายกว่า ไม่อย่างนั้นเขาก็อ้างว่าคน ๆ หนึ่งกำลังนำผลงานทั้งหมดนี้มาสร้างนามธรรมที่ดี แต่ไม่มีผลประโยชน์ที่แท้จริง ฉันต้องยอมรับว่าฉันไม่รู้จัก DDD มากเท่าที่ฉันต้องการและยังไม่ได้ลองใช้ ฉันยังไม่ได้อ่านหนังสือของ Eric Evan เช่นกัน ฉันกำลังมากขึ้นที่สนใจในการพึ่งพาการฉีดและหลายหนังสือหลายเล่มและบล็อกในแง่นี้การใช้งานภายใต้แนวความคิดและการอ้างอิงจากเอริคอีแวนส์หนังสือ DDD นี่คือที่ฉันได้สัมผัสกับแนวคิด DDD หนังสือที่ฉันอ่านมาเล่มนี้ประกอบด้วย: การพึ่งพาการฉีดใน. NET Microsoft .Net: …

17 .net  dependency-injection  domain-driven-design  abstraction 

ฉันเห็นหลายแนะนำให้ใช้คอนเทนเนอร์ 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) { …

17 dependency-injection  inversion-of-control  ioc-containers 

บอกว่าผมได้เรียนFoobarที่ใช้ (ขึ้นอยู่กับ) Widgetระดับ ในวันเฒ่าที่ดีWidgetwolud จะถูกประกาศให้เป็นสนามในFoobarหรืออาจจะเป็นตัวชี้ที่ฉลาดถ้าต้องการพฤติกรรม polymorphic และมันจะเริ่มต้นได้ใน constructor: class Foobar { Widget widget; public: Foobar() : widget(blah blah blah) {} // or std::unique_ptr<Widget> widget; public: Foobar() : widget(std::make_unique<Widget>(blah blah blah)) {} (…) }; และเราจะพร้อมทุกอย่างให้เรียบร้อย น่าเสียดายที่วันนี้เด็ก ๆ จาวาจะหัวเราะเยาะเราเมื่อพวกเขาเห็นมันและอย่างถูกต้องตามที่คู่รักFoobarและWidgetร่วมกัน วิธีแก้ปัญหานั้นง่ายมาก: ใช้การฉีดพึ่งพาเพื่อสร้างการพึ่งพาจากFoobarชั้นเรียน แต่แล้ว C ++ ก็บังคับให้เราคิดถึงการเป็นเจ้าของการพึ่งพา การแก้ปัญหาทั้งสามอยู่ในใจ: ตัวชี้ที่ไม่ซ้ำ class Foobar { std::unique_ptr<Widget> widget; …

16 c++  dependency-injection  smart-pointer 

พิจารณา: public class CtorInjectionExample { public CtorInjectionExample(ISomeRepository SomeRepositoryIn, IOtherRepository OtherRepositoryIn) { this._someRepository = SomeRepositoryIn; this._otherRepository = OtherRepositoryIn; } public void SomeMethod() { //use this._someRepository } public void OtherMethod() { //use this._otherRepository } } ต่อต้าน: public class MethodInjectionExample { public MethodInjectionExample() { } public void SomeMethod(ISomeRepository SomeRepositoryIn) { //use SomeRepositoryIn } …

16 design-patterns  programming-practices  dependency-injection  patterns-and-practices 

ฉันขอโทษถ้าสิ่งนี้ดูเหมือนจะเป็นคำถามที่เกิดขึ้นซ้ำแล้วซ้ำอีก แต่ทุกครั้งที่ฉันพบบทความเกี่ยวกับหัวข้อนั้นส่วนใหญ่จะพูดถึงว่า DI คืออะไร ดังนั้นฉันได้รับ DI แต่ฉันพยายามที่จะเข้าใจความต้องการภาชนะ IoC ซึ่งทุกคนดูเหมือนว่าจะเข้ามา จุดประสงค์ของคอนเทนเนอร์ IoC จริง ๆ แล้วเป็นเพียง "การแก้ไขอัตโนมัติ" การใช้งานที่เป็นรูปธรรมของการพึ่งพาหรือไม่ บางทีชั้นเรียนของฉันมีแนวโน้มที่จะไม่ได้ขึ้นต่อกันหลายครั้งและนั่นอาจเป็นเหตุผลว่าทำไมฉันไม่เห็นเรื่องใหญ่ แต่ฉันต้องการให้แน่ใจว่าฉันเข้าใจถึงประโยชน์ของภาชนะอย่างถูกต้อง โดยทั่วไปแล้วฉันแบ่งตรรกะทางธุรกิจของฉันออกเป็นคลาสที่อาจมีลักษณะเช่นนี้: public class SomeBusinessOperation { private readonly IDataRepository _repository; public SomeBusinessOperation(IDataRespository repository = null) { _repository = repository ?? new ConcreteRepository(); } public SomeType Run(SomeRequestType request) { // do work... var results …

15 c#  dependency-injection  inversion-of-control  ioc-containers 

นี่คือโซลูชันและโครงการของฉัน: ร้านหนังสือ (โซลูชัน) BookStore.Coupler (โครงการ) Bootstrapper.cs BookStore.Domain (โครงการ) CreateBookCommandValidator.cs CompositeValidator.cs IValidate.cs IValidator.cs ICommandHandler.cs BookStore.Infrastructure (โครงการ) CreateBookCommandHandler.cs ValidationCommandHandlerDecorator.cs BookStore.Web (โครงการ) Global.asax BookStore.BatchProcesses (โครงการ) Program.cs Bootstrapper.cs : public static class Bootstrapper.cs { // I'm using SimpleInjector as my DI Container public static void Initialize(Container container) { container.RegisterManyForOpenGeneric(typeof(ICommandHandler<>), typeof(CreateBookCommandHandler).Assembly); container.RegisterDecorator(typeof(ICommandHandler<>), typeof(ValidationCommandHandlerDecorator<>)); container.RegisterManyForOpenGeneric(typeof(IValidate<>), AccessibilityOption.PublicTypesOnly, …

15 c#  dependency-injection  encapsulation