अब यह समय है:

• इंटरसेप्टर (ऑनक्रिशन, एनरिचविथ)
• सामान्य प्रकार
• विशेषताएँ (DefaultConstructor, मान्यकरण, अन्य सभी)
• परीक्षणों के बारे में थोड़ा सा

इंटरसेप्टर

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

प्रसंस्करण के बाद के दो तरीके हैं:

• ऑनक्रिटियन - एक्शन को एक पैरामीटर के रूप में लेता है, जिससे आप ऑब्जेक्ट के अपने (कस्टम) इनिशियलाइज़ेशन को अंजाम दे सकते हैं। SturctureMap संदर्भ तक पहुंच है।
• EnrichWith - एक पैरामीटर के रूप में फ़ंक्शन लेता है। अनुरोध के साथ संगत किसी भी प्रकार की वापसी कर सकते हैं।
• खुद के इंटरसेप्टर हैं

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

OnCreation

प्रदर्शन के लिए, आप निम्नलिखित सरल वर्ग का उपयोग कर सकते हैं:

public class ClassS : IClassS { public int Counter { get; private set; } public void Init() { Counter = -100; } public void Init(IClass1 class1) { Counter = -50; } public void Increase() { Counter++; } } 

अब, आप ऑनक्रेशन विधि के उपयोग को प्रदर्शित कर सकते हैं।

 public class InterceptionsSimple { public IContainer Container; public InterceptionsSimple() { Container = new Container(x => x.For<IClassS>() .Use<ClassS>() .OnCreation(c => c.Init())); } } 

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

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

 public class InterceptionWithContext { public IContainer Container; public InterceptionWithContext() { Container = new Container(x => { x.For<IClass1>().Use<Class1>(); x.For<IClassS>().Use<ClassS>() .OnCreation((context, cls) => { var class1 = context.GetInstance<IClass1>(); cls.Init(class1); }); }); } } 

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

EnrichWith

यह विधि आपको निर्मित वर्ग को दूसरे में लपेटने की अनुमति देती है, यदि प्रकार रूपांतरण संभव है। उदाहरण के लिए, एक वर्ग हो

 public class ClassSs : ClassS { private readonly ClassS s; public int Abs { get { return Math.Abs(s.Counter); } } public ClassSs(ClassS s) { this.s = s; } } 

फिर निम्नलिखित कोड का उपयोग करके इसे स्ट्रक्चरचरप से प्राप्त करना संभव होगा:

 public class InterceptionWithContext2 { public IContainer Container; public InterceptionWithContext2() { Container = new Container(x => { x.For<IClass1>().Use<Class1>(); x.For<IClassS>().Use<ClassS>() .EnrichWith(cls => { cls.Init(); return new ClassSs(cls); }); }); } } 

नतीजतन, जब हम एक श्रेणी का उदाहरण प्राप्त करने का प्रयास करते हैं जो IClassS इंटरफ़ेस को लागू करता है, तो हम क्लासस क्लास प्राप्त करेंगे।

सामान्य प्रकार

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

तो, मान लें कि हमारे पास एक टेम्पलेट एडॉप्टर है।

 public interface IAdapter { string SomeMethod(); } public interface IAdapter<T> : IAdapter {} public class Adapter<T> : IAdapter<T> { public string SomeMethod() { return typeof (T).ToString(); } } 

विशिष्ट प्रकारों के साथ उनके कई उत्तराधिकारी भी हैं।

 public class StringAdapter : Adapter<string> {} public class IntAdapter : Adapter<int> {} 

एडॉप्टर में टी के प्रकारों पर कोई प्रतिबंध नहीं है।

टेम्पलेट प्रकारों के साथ काम करने के कई तरीके हैं। सबसे आसान तरीका है कि विशिष्ट प्रकार के स्ट्रिंगर एडैप्टर को पंजीकृत करना और कॉल करना।

 public class GenericTypes { public IContainer Container; public GenericTypes() { Container = new Container(x => { x.For(typeof (IAdapter<>)).Use(typeof (StringAdapter)); x.For<IAdapter<int>>().Use<IntAdapter>(); }); } } 

टेम्पलेट वर्ग को पंजीकृत करने के लिए उदाहरण दो समान तरीकों को दर्शाता है।

आप उन्हें कई तरीकों से बुला सकते हैं।

विधि एक: आप एक विशिष्ट प्रकार के लिए हमें एक एडाप्टर देने के लिए कंटेनर से पूछ सकते हैं।

 private static string GenericTypesExample() { var container = new GenericTypes().Container; var stringAdapter = container.GetInstance<StringAdapter>(); var intAdapter = container.GetInstance<IntAdapter>(); return stringAdapter.SomeMethod() + " " + intAdapter.SomeMethod(); } 

दूसरी विधि अधिक सामान्य है और, मेरी राय में, अभ्यास में अधिक लागू है। दूसरी विधि का उपयोग करके, आप कुंजी (टी) के प्रकार को पास कर सकते हैं जिसके द्वारा स्ट्रॉन्चपेज़ आवश्यक वर्ग को वापस कर सकता है।

कंटेनर की संरचना समान रहती है, तैयारी की विधि बदल जाती है।

 private static string GenericTypesExample() { var container = new GenericTypes().Container; var instance = container .ForGenericType(typeof (IAdapter<>)) .WithParameters(typeof(string)) .GetInstanceAs<IAdapter>(); return  instance.SomeMethod(); } 

यानी हम कंटेनर को सूचित करते हैं कि हमें इस प्रकार के लिए एक टेम्पलेट प्रकार की आवश्यकता होगी, और उदाहरण के लिए IAdapter प्रकार के रूप में वापस करें।

वास्तविक उपयोग के लिए, यह ऐसा दिखेगा:

 private static string GenericTypesExample<T>() { var container = new GenericTypes().Container; var instance = container .ForGenericType(typeof (IAdapter<>)) .WithParameters(typeof(T)) .GetInstanceAs<IAdapter>(); return instance.SomeMethod(); } 

विशिष्ट एडाप्टर को पैरामीटर टी के प्रकार द्वारा निर्धारित किया जाएगा।

गुण

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

लेखक खुद को विशेषताओं के साथ नहीं ले जाने की सिफारिश करता है, क्योंकि वे अत्यधिक विशिष्ट हैं, वे केवल मूल विन्यास की अनुमति देते हैं और पूरे प्रोजेक्ट में बिखरे हुए हैं, जिससे समर्थन करना मुश्किल हो जाता है। एक जगह पर सब कुछ घोषित करने के लिए बेहतर है।

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

ValidationMethod

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

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

 public class SelfValidation { public string Name { get; set; } [ValidationMethod] public void IsClassBuildCorrectly() { if(string.IsNullOrWhiteSpace(Name)) throw new ArgumentException("Name can't be null or empty"); } } 

आप देख सकते हैं कि विधि ValidationMethod के रूप में चिह्नित है। सामान्य तौर पर, इस तरह की एक से अधिक विधि हो सकती है; संरचना मानचित्र उन सभी को स्कैन करता है और AssertConfigurationIsValid विधि को कॉल करते समय इसे एक-एक करके निष्पादित करने का प्रयास करता है। इस पद्धति से सावधान रहें, क्योंकि एक बड़े कॉन्फ़िगरेशन के साथ, फ्रेमवर्क सभी निर्भरताओं का निर्माण करने की कोशिश करेगा, सभी क्षेत्रों में भरें, सभी विशेषताओं को प्रश्न में विशेषता के साथ चिह्नित करें।

कक्षा को इस प्रकार पंजीकृत किया जाए:

 public class ValidationShowcase { public IContainer Container; public ValidationShowcase() { Container = new Container(x => x.ForConcreteType<SelfValidation>()); } } 

अब आप इसे कंटेनर से प्राप्त करने का प्रयास कर सकते हैं।

 private static string ValidationShowcaseExample() { var container = new ValidationShowcase().Container; container.AssertConfigurationIsValid(); return ""; } 

जब आप ऊपर दिए गए तरीके को कॉल करते हैं, तो आपको एक StructureMapConfigurationException मिलेगी, जहां स्ट्रक्च्योर मैप आंतरिक डिवाइस के चेक के कारण आंतरिक अपवाद दिखाए जाएंगे।

स्क्रीनशॉट से पता चलता है कि असाधारण स्थिति के बारे में संदेश में हमारा संदेश बिल्कुल दिखाई देता है।

PluginFamily
स्ट्रक्चर्स मैप बताता है कि टैग किए गए प्रकार का उपयोग प्लगइन प्रकार के रूप में किया जाएगा। जैसा हमने लिखा वैसा ही समतुल्य । < Plugin type > के लिए ।

आप उस प्रकार को भी निर्दिष्ट कर सकते हैं जो डिफ़ॉल्ट रूप से वापस आ जाएगा, और आप विशेष रूप से संकेत कर सकते हैं कि यह एक सिंगलटन होगा।

 [PluginFamily("Default", IsSingleton = true)] 

pluggable
चिह्नित प्रकार को प्लगइन्स के संग्रह में शामिल किया जाएगा, जो एक विशिष्ट कार्यान्वयन को दर्शाता है। उपयोग करने के लिए बराबर । < Pluggable प्रकार > का उपयोग करें । आपको हमेशा प्रकार के लिए एक नाम का उपयोग करना चाहिए।

 [Pluggable("Default")] 

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

परीक्षण

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

स्ट्रक्चुरपेज़ में राइनोमॉक और Moq फ्रेमवर्क निर्मित हैं। उनका उपयोग करने के लिए, आपको NuGet स्ट्रक्चरमैप.ओटोमॉकिंग पैकेज देने की आवश्यकता होगी, जिसके बाद ऑब्जेक्ट छिपाना उपयोग करना संभव होगा।

Moq और RhinoMock की समीक्षा इस लेख के दायरे से परे है।

निष्कर्ष

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

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

पहले भाग में शामिल विषय:

• स्थापना
• पंजीकरण (आधार, प्रोफाइल, प्लगइन्स, स्कैनिंग, परिनियोजन)

दूसरे भाग पर चर्चा करेंगे:

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