आज मैं स्ट्रक्च्योर मैप आईओसी कंटेनर के बारे में बात करना चाहता हूं (और यह पुराने आधिकारिक दस्तावेज का अनुवाद नहीं है), जो मुझे यूनिटी से ज्यादा पसंद आया। हालाँकि, ईमानदार होने के लिए, एकता के साथ मेरा संबंध शुरू से ही कारगर नहीं था, जब मैंने इसके लिए किलोमीटर-लंबी कॉन्फ़िगरेशन फ़ाइलों या कोड में दो सौ महत्वपूर्ण कॉन्फ़िगरेशन लाइनों को देखा। दु: खद बातों पर बात नहीं करते।

स्ट्रक्चरुरैप न केवल मुझे अन्य DI \ IoC कार्यान्वयनों की तुलना में अधिक सुविधाजनक लग रहा था, बस Google में स्ट्रक्चोरपाइप बनाम यूनिटी में टाइप करें और उन लिंक्स का एक गुच्छा प्राप्त करें जहां लोग चर्चा करते हैं और स्पष्ट रूप से प्रदर्शित करते हैं कि स्ट्रक्चरुरैप काम में सबसे सुविधाजनक, लचीला और प्राकृतिक है।

लिंक एक , दो और तीन । इसके अलावा, स्ट्रक्च्योर मैप भी काफी तेज है।
यहाँ http://www.sturmnet.org/blog/2010/03/03/04/poll-results-ioc-containers-for-net की तुलना करने वाले सामग्रियों के कुछ बहुत ही रोचक संग्रह हैं

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

क्या है, मेरी राय में, StructureMap के फायदे:

• डीएसएल सेटअप
• हर चीज का बहुत लचीला अनुकूलन
• अंत उपयोग में आसानी
• आंतरिक संबंधों की जाँच के अवसर
• आउट-ऑफ-द-बॉक्स परीक्षण समर्थन

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

अनुवर्ती सामग्री की एक संक्षिप्त रूपरेखा इस प्रकार है:

• स्थापना
• पंजीकरण (आधार, प्रोफाइल, प्लगइन्स, स्कैनिंग, परिनियोजन)
• कंस्ट्रक्टर्स (सरल प्रकार, डिफॉल्ट कंस्ट्रक्टर, कंपाउंड प्रकार, ज़बरदस्ती, सेटिंग तर्क)
• गुण (साधारण संपत्ति सेटिंग, अंतर्निहित संपत्ति सेटिंग, एक रूपरेखा के साथ गुण सेट करना, मौजूदा कक्षाओं का विस्तार करना)
• जीवन का समय
• इंटरसेप्टर (ऑनक्रिशन, एनरिचविथ)
• सामान्य प्रकार
• विशेषताएँ (DefaultConstructor, मान्यकरण, अन्य सभी)
• परीक्षण

ढांचा स्थापित करें

मैं आपके आवेदन में स्ट्रक्चरुरेशन को स्थापित करने के लिए NuGet का उपयोग करने की सलाह देता हूं। पैकेज मैनेजर कंसोल (इंस्टॉल-पैकेज स्ट्रक्चुरपेज़) में एक कमांड या विज़ार्ड के साथ खोज और इंस्टॉल करना इसे प्राप्त करने के सबसे आसान तरीके हैं। लेकिन अगर आप चाहें, तो आप परियोजना को आधिकारिक पेज http://github.com/structuremap/structuremap/downloads से डाउनलोड कर सकते हैं

पंजीकरण

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

लेखक डीएसएल का व्यापक रूप से उपयोग करने की सलाह देता है और कॉन्फ़िगरेशन फ़ाइल का केवल तभी उपयोग करता है जब आपको कनेक्शन स्ट्रिंग, URL, फ़ाइल पथ और बाकी सब कुछ एक ही नस में अलग से सेट करने की आवश्यकता होती है।

आइए सरलतम से शुरू करें, एक डिफ़ॉल्ट कंस्ट्रक्टर के साथ एक वर्ग का पंजीकरण करें।

मान लीजिए कि हमारे पास कक्षाओं का इतना सरल सेट है:

public interface IClass {} public interface IClass1 : IClass {} public interface IClass2 : IClass {} public class Class1 : IClass1 {} public class Class2 : IClass2 {} 

यह सेट अब तक संभावनाओं को प्रदर्शित करने वाला मुख्य होगा। लेकिन चिंता न करें, आगे की कक्षाएं और कनेक्शन अधिक कठिन होंगे, क्योंकि आप ऐसी कक्षाओं में बहुत अधिक नहीं दिखाएंगे।

आधार

कंटेनर का उपयोग करके स्थैतिक ऑब्जेक्टफैक्टरी वर्ग का उपयोग करके , या रजिस्ट्री वर्ग का उपयोग करके पंजीकरण संभव है। धीरे-धीरे इन सभी वस्तुओं का उपयोग करके पंजीकरण पर विचार करें। पंजीकरण के लिए मुख्य वर्ग रजिस्ट्री है, बाकी कक्षाएं सुविधा के लिए, इसकी कार्यक्षमता को फेंक देती हैं।

स्थिर ObjectFactory वर्ग के साथ रजिस्टर करें।

 public class RegisterByObjectFactory { public RegisterByObjectFactory() { ObjectFactory.Initialize(x => { x.For<IClass1>().Use<Class1>(); x.For<IClass2>().Use<Class2>(); }); } } 

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

वस्तुओं को प्राप्त करना निम्नलिखित तरीके से किया जा सकता है, यह भी सहज है:

 private static string ObjectFactoryExample() { new RegisterByObjectFactory(); var class1Inst = ObjectFactory.GetInstance<IClass1>(); var class2Inst = ObjectFactory.GetInstance<IClass2>(); return ObjectFactory.WhatDoIHave(); } 

इंटरफ़ेस के साथ, इस मामले में GetInstance ऑब्जेक्ट प्राप्त करने का मुख्य तरीका। इसके अलावा हम तैयार वस्तुओं को प्राप्त करने के विभिन्न तरीकों पर विचार करेंगे। आप देख सकते हैं कि विधि एक स्ट्रिंग प्रदान करती है जो हमें विधि से मिलता है बोलने वाले नाम के साथ WhatDoIHave । इस पद्धति का उपयोग करके, आप कंटेनर के इनसाइट्स का निदान कर सकते हैं, देखें कि यह कैसे और कैसे पंजीकृत है।

एक लंबे समय के लिए, फ्रेमवर्क के लेखक अपने वंश के संबंध में कंटेनर शब्द को स्वीकार नहीं कर सकते थे, इसलिए अगली विधि लंबे समय तक छिपी रही और केवल बाद में कार्यान्वयन ने पंजीकरण के प्राकृतिक पाठ्यक्रम को खोल दिया, क्योंकि यह एक स्थिर वर्ग के पीछे, अंदर लागू किया गया था। इस प्रकार,

 public class RegisterByContainer { public IContainer Container; public RegisterByContainer() { Container = new Container(x => { x.For<IClass1>().Use<Class1>(); x.For<IClass2>().Use<Class2>(); }); } } 

पहली नज़र में, सब कुछ समान है, लैम्ब्डा एक ही है, लेकिन अब हम एक वर्ग बना रहे हैं जो हम तब बाहर को देंगे, और जिसके द्वारा हम कंटेनर तक पहुंचेंगे। यानी एक बार फिर, ObjectFactory सिर्फ कंटेनर वर्ग पर एक स्थिर आवरण वर्ग है।

वस्तुओं को प्राप्त करना उसी परिदृश्य का अनुसरण करेगा:

 private static string ContainerExample() { var container = new RegisterByContainer().Container; var class1Inst = container.GetInstance<IClass1>(); var class2Inst = container.GetInstance<IClass2>(); return container.WhatDoIHave(); } 

लाइन में अगली वस्तु रजिस्ट्री है । दरअसल, आपने परोक्ष रूप से इसे पिछले सभी समय में कहा था। एक बदलाव के लिए हम विशिष्ट वर्गों को पंजीकृत करेंगे।

 public class RegisterByRegister { public IContainer Container; public RegisterByRegister() { var registry = new Registry(); registry.ForConcreteType<Class1>(); registry.ForConcreteType<Class2>(); Container = new Container(x => x.AddRegistry(registry)); } } 

इस स्थिति में, ForConcreteType पद्धति का उपयोग किया जाता है , जो इसके लिए एक पर्याय है । < T> () के लिए। < T> () का उपयोग करें । आप यह भी देख सकते हैं कि रजिस्ट्री वर्ग का उपयोग एक उप-निर्माता के रूप में किया जा सकता है, इसे इकट्ठा कर सकता है और फिर इसे एक कंटेनर में विधानसभा में स्थानांतरित कर सकता है। इस मामले में, निर्माण के समय रजिस्ट्री के अलावा को चित्रित किया गया है, लेकिन कुछ भी आपको लिखने से नहीं रोकेगा:

 Container = new Container(); Container.Configure(x => x.AddRegistry(registry)); 

"कंक्रीट" कक्षाएं पढ़ना सामान्य से अलग नहीं है:

 private static string ConcreteClassExample() { var container = new RegisterByRegister().Container; var class1Inst = container.GetInstance<Class1>(); var class2Inst = container.GetInstance<Class2>(); return container.WhatDoIHave(); } 

प्रोफाइल

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

 public class RegisteringProfiles { public IContainer Container; public RegisteringProfiles() { var registry = new Registry(); registry.Profile("p1", x => x.For<IClass>().Use<Class1>()); registry.Profile("p2", x => x.For<IClass>().Use<Class2>()); Container = new Container(x => x.AddRegistry(registry)); } } 

यहां यह ध्यान देने योग्य है कि क्लास 1 और क्लास 2 सामान्य इंटरफ़ेस द्वारा पंजीकृत हैं, लेकिन विभिन्न प्रोफाइल में। आवश्यक वर्ग प्राप्त करने के लिए, आपको सेटडिफ़ॉल्टपॉफ़ाइल विधि का उपयोग करके कंटेनर में प्रोफाइल के बीच स्विच करना होगा जो प्रोफ़ाइल का नाम लेता है।

 private static string ProfilesExample() { var container = new RegisteringProfiles().Container; container.SetDefaultsToProfile("p1"); var class1Inst = container.GetInstance<IClass>(); container.SetDefaultsToProfile("p2"); var class2Inst = container.GetInstance<IClass>(); return container.WhatDoIHave(); } 

प्रोफ़ाइल नाम केवल एक स्ट्रिंग चर हो सकता है, लेकिन यह अब एक बड़ी समस्या नहीं है। मेरा मतलब है, वास्तव में, आपको एक खुली रेखा के साथ उदाहरण में प्रोफ़ाइल नाम नहीं लिखना चाहिए। कर्म के लिए हानिकारक।

सक्रिय प्रोफ़ाइल सेट करने के बाद, आप हमेशा की तरह कंटेनर के साथ काम कर सकते हैं। नतीजतन, एक ही लाइन को निष्पादित करते समय, कंटेनर। गेट इनस्टेंस <IClass> (); हमें अलग-अलग कक्षाएं मिलती हैं।

प्लग-इन

एक सामान्य इंटरफ़ेस का उपयोग करके विशिष्ट वर्ग प्राप्त करने की समस्या को हल करने का एक और तरीका है, यह एक नामित प्लगइन है।

शब्दावली के बारे में थोड़ा। IntelliSense और थोड़ा यहाँ आप सामान्य रूप से शब्द प्लगइन, प्लग इन और प्लग इन टाइप कर सकते हैं , इसका मतलब है कि आप जिस प्रकार को प्राप्त करना चाहते हैं । यानी पिछले सभी उदाहरणों में, IClass को PluginType कहा जा सकता है, और Class1 या Class2 को PluggedType कहा जा सकता है।

 public class RegisterAsPlugin { public IContainer Container; public RegisterAsPlugin() { Container = new Container(x => { x.For<IClass>().Use<Class1>().Named("Class1"); x.For<IClass>().Use<Class2>().Named("Class2"); }); } } 

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

 private static string PluginExample() { var container = new RegisterAsPlugin().Container; var class1Inst = container.GetInstance<IClass>("Class1"); var class2Inst = container.GetInstance<IClass>("Class2"); var instanceDef = container.GetInstance<IClass>(); return container.WhatDoIHave(); } 

उदाहरण दिखाता है कि आप कंटेनर तक कैसे पहुंच सकते हैं और एक सामान्य इंटरफ़ेस पर एक विशिष्ट प्रकार प्राप्त कर सकते हैं। हालांकि, यहां हम एक ही समय में सवाल उठाएंगे, अगर हम प्लगइन नाम को निर्दिष्ट किए बिना एक सामान्य इंटरफ़ेस के साथ GetInstance पद्धति को कॉल करने का प्रयास करते हैं तो क्या होगा?

डिफ़ॉल्ट व्यवहार इस कहावत का अनुसरण करता है "जो अंतिम है, वह पिताजी है", अर्थात्। इस स्थिति में, Class2 वर्ग का एक उदाहरण InstDef चर में मिलेगा। हालाँकि, हम डिफॉल्ट क्लास को स्पष्ट रूप से परिभाषित कर सकते हैं। ऐसा करने के लिए, प्लगइन्स के पंजीकरण के थोड़ा अलग रूप का उपयोग करें।

 public class RegisterAsPluginWithDefault { public IContainer Container; public RegisterAsPluginWithDefault() { Container = new Container(x => x.For<IClass>() .AddInstances(i => { i.Type(typeof (Class1)).Named("Class1"); i.Type(typeof (Class2)).Named("Class2"); }) .Use(new Class1()) ); } } 

और फिर से हम कह सकते हैं कि उदाहरण स्वयं का वर्णन करता है। यदि आप इसे पढ़ते हैं, तो यह शाब्दिक रूप से शाब्दिक होगा: IClass इंटरफ़ेस के लिए Class1 नामक Class1 कार्यान्वयन जोड़ें , Class2 को Class2 नाम दिया गया है , Class1 का उपयोग करें (इस मामले में, एक बहुत ही विशिष्ट वर्ग, लेकिन आप भी लिख सकते हैं। पिछले क्लासेज में <Class1 का उपयोग करें। > ())।

इस मामले में, यह उपयोग विधि है जो बताती है कि डिफ़ॉल्ट इंटरफ़ेस के लिए किस प्रकार का उपयोग किया जाएगा। यदि आप अब निम्नलिखित कोड निष्पादित करते हैं

 var instanceDef = container.GetInstance<IClass>(); 

तब हमें कक्षा 1 का एक उदाहरण मिलता है।

पहले से ही डिफ़ॉल्ट प्रकार का उपयोग करता है।

स्कैन

तार्किक निरंतरता कंटेनर में प्रकारों की खोज और स्वचालित पंजीकरण होगी। कल्पना कीजिए कि हम एक सामान्य इंटरफ़ेस से दो कक्षाएं नहीं लेते हैं, लेकिन 50! इन सभी पंजीकरणों और निर्भरता को अपने हाथों से भरना बहुत दुखद और उबाऊ होगा। ऐसे मामले के लिए, स्ट्रक्च्योरपाइप में एक स्कैन विधि है जो उन असेंबली या फ़ोल्डरों के माध्यम से चलती है जिनमें आप रुचि रखते हैं और उपयुक्त वस्तुओं को पंजीकृत करते हैं। इस प्रकार, आवेदन के लिए प्लगइन्स की संरचना को लागू करना और यहां तक ​​कि किसी तरह से MEF के साथ प्रतिस्पर्धा करना या इसे बदलना संभव है।

स्कैन विधि के लिए प्रकार खोजने और रजिस्टर करने के लिए, कई शर्तों को पूरा करना होगा:

• प्रकार स्पष्ट होना चाहिए; सामान्य प्रकार स्वचालित रूप से पंजीकृत नहीं हैं;
• प्रकार में एक सार्वजनिक निर्माता होना चाहिए;
• एक निर्माता में आदिम प्रकार के तर्क नहीं हो सकते;
• एकाधिक पंजीकरण की अनुमति नहीं है।

स्कैनिंग विधि और व्यवहार को ओवरराइड किया जा सकता है, लेकिन अब इस पर विचार नहीं किया जाएगा।

आप कई तरीकों से स्कैनिंग के लिए असेंबली निर्दिष्ट कर सकते हैं:

• स्पष्ट रूप से विधानसभा का नाम जादू करें या इसे पास करें;
• कॉलिंग असेंबली तक पहुंचें;
• एक विशिष्ट प्रकार से युक्त एक विधानसभा का पता लगाएं;
• एक विशिष्ट पथ पर बनाता है।

जब आपने प्रयोगात्मक विधानसभाओं को इंगित किया, तो आप विभिन्न मापदंडों द्वारा प्रकारों को शामिल / बाहर करने के तरीकों का उपयोग करके आयात प्रक्रिया को अधिक विस्तार से कॉन्फ़िगर कर सकते हैं। अधिक विस्तृत जानकारी के लिए प्रलेखन का संदर्भ देना बेहतर है। यह पुराना है, लेकिन संभावनाओं का एक सामान्य विचार देता है।

तो, चलो एक सरल उदाहरण लेते हैं:

 public class RegisterByScan { public IContainer Container; public RegisterByScan() { Container = new Container(x => x.Scan(s => { s.AddAllTypesOf(typeof (IClass)); s.AssembliesFromPath("."); s.WithDefaultConventions(); s.LookForRegistries(); })); } } 

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

विधि काम करने के बाद, आप देख सकते हैं कि कंटेनर में क्या पाया गया और पंजीकृत था।

 private static string RegisterByScanExample() { var container = new RegisterByScan().Container; var instances = container.GetAllInstances<IClass>(); return container.WhatDoIHave(); } 

ध्यान दें कि गेट ऑल इंस्टैंस विधि अब कहा जा रहा है। यदि आप पंजीकृत लोगों से एक विशिष्ट वर्ग प्राप्त करने के लिए एक विधि कहते हैं, तो एक त्रुटि होगी, क्योंकि स्ट्रक्चर्सपाइप को पता नहीं है कि "डिफ़ॉल्ट रूप से" किस वर्ग को वापस लौटना है।

ईमानदारी से, इस तरह के कार्यान्वयन के साथ स्कैन कमांड के परिणामों का उपयोग करना असंभव है। सब कुछ अच्छा बनने के लिए, और पाया वर्गों को नाम से संदर्भित करना संभव होगा, आपको स्कैन कोड को फिर से लिखना होगा।

 public class RegisterByScanWithNaming { public IContainer Container; public RegisterByScanWithNaming() { Container = new Container(x => x.Scan(s => { s.AddAllTypesOf(typeof (IClass)).NameBy(t => t.Name); s.AssembliesFromPath("."); s.WithDefaultConventions(); s.LookForRegistries(); })); } } 

AddAllTypesOf पद्धति में एक स्पष्ट नियम जोड़ा गया है कि सभी वर्गों को उनके नाम से पंजीकृत होना चाहिए। इस संशोधन के बाद, आप विशिष्ट प्रकारों के साथ काम कर सकते हैं:

 var instance = container.GetInstance<IClass>("Class1"); 

की शुरूआत

कंटेनर के साथ काम करने की प्रक्रिया में, आप डिफ़ॉल्ट रूप से लौटाए गए प्रकार को ओवरराइड कर सकते हैं। यह मुख्य रूप से परीक्षणों में उपयोग किया जाता है। कार्य का प्रदर्शन:

 private static string InjectExample() { var container = new RegisterAsPluginWithDefault().Container; var instance1 = container.GetInstance<IClass>("Class1"); var instance2 = container.GetInstance<IClass>("Class2"); var class1Inst = container.GetInstance<IClass>(); container.Inject(typeof (IClass), new Class2()); var class2Inst = container.GetInstance<IClass>(); return container.WhatDoIHave(); } 

हमने पहले RegisterAsPluginWithDefault क्लास की घोषणा की, जो डिफ़ॉल्ट Class1 क्लास को लौटाता है। इंजेक्ट विधि का उपयोग करके, आप रिटर्न प्रकार को ओवरराइड कर सकते हैं, आपको केवल प्लगइन के प्रकार और नए वर्ग को निर्दिष्ट करने की आवश्यकता है।

ये उदाहरण पंजीकरण के सामान्य सिद्धांतों पर थे, जब कक्षाएं स्वयं सरल होती हैं। अगले विषय में, हम उन वर्गों से निपटने के बारे में विचार करेंगे जिनके पास मापदंडों के साथ निर्माणकर्ता हैं।

जारी रखा जाए।