WPF प्रिज्म क्यों रजिस्टर टाइप? (कंटेनर के साथ)

Question

मेरी समझ से, प्रिज्म की एकता कंटेनर प्रकार की घटना को हल कर सकती है अगर वे पंजीकृत नहीं हैं, तो क्या यह _container बनाता है। रजिस्ट्रार टाइप थोड़े बेकार?

धन्यवाद!

Answer 1

मैं आपके सवाल का सही ढंग से, आप क्या देख रहे हैं कि एकता सीधे (करने की कोशिश) कर सकते हैं वर्गों के उदाहरण बनाने के है, जो प्रकार का समाधान करने से अलग है समझ रहा है। "यूनिवर्सिटी ऑफ कंट्रोल" का लाभ उठाने के लिए यूनिटी से "सीधे" कक्षा बनाने के लिए पूरी तरह से उचित है, आप आमतौर पर एक इंटरफ़ेस को हल करने के लिए एक कंटेनर से पूछेंगे, जहां आपने RegisterType के माध्यम से कक्षा में एक इंटरफ़ेस मैप किया है। इस तरह आप अपने कोड को बदलने के बिना कक्षाओं के इंटरफेस के विभिन्न कार्यान्वयन को मानचित्र बना सकते हैं, जो "नियंत्रण में उलटा" और "इंटरफेस-आधारित प्रोग्रामिंग" काम पर है।

इस प्रक्रिया में आप एक इंटरफ़ेस को हल करने के लिए कह रहे हैं, इसके बाद प्रिज्म इंटरफ़ेस यानी संकल्प के लिए बाध्य है, और फिर आपके लिए एक उदाहरण बनाते हैं यानी फैक्ट्री क्षमताओं। एकता की फैक्ट्री क्षमताओं यह सुनिश्चित करेगी कि किसी अन्य निर्भरता को हल किया गया है जिसे हल किए गए वर्ग का उदाहरण बनाने की आवश्यकता है। वर्ग कन्स्ट्रक्टर पैरामीटर पर निर्भरता इंजेक्शन का उपयोग करना। जब तक सभी निर्भरताओं का समाधान नहीं हो जाता है तब तक यह पूरी प्रक्रिया पुनरावर्ती होती है।

उदाहरण लिए

आप एक IFoo के लिए पूछने के लिए और यह Foo बाध्य है, तो एकता कोशिश करते हैं और Foo का एक उदाहरण कर देगा। यदि Foo में एक निर्माता है जो IBar लेता है, तो यूनिटी IBar को आजमाकर हल करेगी और IFoo के लिए कन्स्ट्रक्टर में उपयोग करने के लिए इसका एक उदाहरण बनाएंगी।

निम्नलिखित कोड में

तो:

हम IFoo जैसा कि ऊपर वर्णित हल कर सकते हैं।

हम सीधे वर्ग Bar का एक उदाहरण बना सकते हैं, के रूप में यह कोई निर्भरता है।

हम Foo कक्षा का उदाहरण सीधे बना सकते हैं, क्योंकि इसकी IFoo पर निर्भरता है, लेकिन हमने इसे पंजीकृत किया है।

हम का उदाहरण नहीं दे सकते क्योंकि IYay के लिए कोई पंजीकरण नहीं है।

//Types 
public interface IBar{} 
public class Bar : IBar {} 

public interface IFoo{} 
public class Foo : IFoo{ public Foo(IBar bar) {} } 

public interface IYay{} 
public class Woo { Woo(IYay yay){} } 

//Registrations 
container.RegisterType<IFoo, Foo>(); 
container.RegisterType<IBar, Bar>(); 

//Resolve IFoo 
IFoo foo = container.Resolve<IFoo>(); 

//Create Bar directly 
Bar bar = container.Resolve<Bar>(); 

//Create Foo directly 
Foo foo = container.Resolve<Foo>(); 

//Create Woo directly - won't work as IYay is not registered! 
Yay yay = container.Reolve<Yay>(); 

RegisterType ऊपर के उदाहरण में एक इंटरफेस करने के लिए एक ठोस कार्यान्वयन मैप करने के लिए प्रयोग किया जाता है। यह इस बिंदु पर है कि हम किसी भी कार्यान्वयन को हम मानचित्र बना सकते हैं और यह हमारे कार्यक्रम में तब तक उछल जाएगा जब तक कंटेनर हमेशा प्रकारों को हल करने के लिए उपयोग किया जाता है।

उदाहरण के लिए, यदि हम IBar को बदलते हैं तो बदलते हैं, तो किसी भी समय IFoo हल हो जाता है, यह IBar के विभिन्न कार्यान्वयन के साथ बनाया जाएगा। यह हमें कोड की एक पंक्ति यानी RegisterType बदलकर किसी प्रोग्राम के व्यवहार को बदलने का एक बड़ा तरीका प्रदान करता है।