ऑटोफैक निर्भरता इंजेक्शन कार्यान्वयन

Question

मैंने एक नई परियोजना पर काम करना शुरू किया और मैं प्रत्यक्ष और 'बेवकूफ' प्रोग्रामिंग से आया हूं।

अभी मैं आईओसी कंटेनर का उपयोग करने के बारे में चिंतित हूं, विशेष रूप से ऑटोफैक का उपयोग करके निर्भरता इंजेक्शन पटर पर।

namespace Warehouse.Data 
{ 
    public class SessionFactory 
    { 
     private static ISessionFactory _sessionFactory; 
     private static ISystemSetting _systemSetting; 

     SessionFactory(ISystemSetting systemSetting) 
     { 
      _systemSetting = systemSetting; 

      InitializeSessionFactory(); 
     } 

     private static void InitializeSessionFactory() 
     { 
      _sessionFactory = Fluently.Configure() 
       .Database(DatabaseConfiguration) 
       .Mappings(m => m.FluentMappings.AddFromAssemblyOf<MyMap>()) 
       .BuildSessionFactory(); 
     } 

     public static ISession OpenSession() 
     { 
      return _sessionFactory.OpenSession(); 
     } 
    } 
} 

और Bootstrap.cs में, मैं इस तरह autofac कॉन्फ़िगर करें::

1. :

   namespace Warehouse.Infrastructure 
   { 
       using Autofac; 
   
       public class Bootstrap 
       { 
        public IContainer Configure() 
        { 
         var builder = new ContainerBuilder(); 
   
         builder.RegisterType<SystemSetting>().As<ISystemSetting>(); 
         builder.RegisterType<UserRepository>().As<IUserRepository>(); 
   
         return builder.Build(); 
        } 
       } 
   } 
   

   मेरा प्रश्न यह है

   चलो कहते हैं कि मैं एक साधारण सत्र कारखाने करते हैं IystemSetting पर सत्र फैक्टरी निर्भरता को हल करने के लिए मैं ऑटोफैक का उपयोग कैसे करूं? क्या मुझे हर बार पैरामीटर के रूप में builder.Resolve<ISystemSetting> पैरामीटर के रूप में उपयोग करने की आवश्यकता है?

2. निर्भरता इंजेक्शन पैटर्न, या शायद ऑटोफैक, सेवा, संकल्प, सिंगलटन, आदि जैसे कई नए शब्द के साथ आता है। मैं इन चीज़ों को खरोंच से कहां से सीख सकता हूं? क्या यह हर दूसरे डी फ्रेमवर्क के लिए समान है?
3. मुझे समझने की जरूरत है कि आईओसी कंटेनर एक परत में कई परतों के साथ कैसे काम करता है, क्या प्रत्येक परत को ऑटोफैक के संदर्भ की आवश्यकता होती है?

धन्यवाद।

Answer 1

1. आपने इसे पहले से ही अपने बूटस्ट्रैप में किया है।

   builder.RegisterType<SystemSetting>().As<ISystemSetting>(); 
   

   इसका मतलब है कि प्रत्येक इंजेक्शन जिस पर आईएसआई सिस्टम सेटिंग्स पर निर्भरता है सिस्टम सिस्टमिंग का एक उदाहरण मिलता है। इसलिए यदि आप अपने कोड में

   var mySessionFactory = myContainer.Resolve<SessionFactory>(); 
   

   कहीं का उपयोग कंटेनर आप के लिए काम करेगा (तुम सच है कि आपकी रचना जड़ में करना चाहिए)। यदि आपके पास कई निर्भरताएं हैं, तो कई निर्भरताओं के साथ आप समझना शुरू कर देंगे कि क्यों आईओसी कंटेनर "जादू" हैं;)

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

3. नहीं। वास्तव में यह कोई नहीं होगा। सर्विसेलोकेटर नामक एक पैटर्न है जिसे कुछ लोगों द्वारा एंटीपाटर माना जाता है। यदि आप इस पैटर्न का पालन करते हैं, तो आपके सभी ऑब्जेक्ट्स में बिल्कुल एक निर्भरता है, कंटेनर! और वे खुद से बाहर निकलते हैं जो उन्हें चाहिए।

   public class MyClass 
   { 
       private DependencyOne dep1; 
   
       public MyClass(WhatEverContainer container) 
       { 
        dep1 = container.Resolve<DependencyOne>(); 
       } 
   } 
   

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

   अपनी वस्तुओं को कंटेनर अज्ञेयवादी होने दें।और अपनी कंटेनर रूट में अपने कंटेनर का उपयोग करें, जहां आप ऑब्जेक्ट्स और आपके एप्लिकेशन की परतों को एक साथ चिपकाते हैं। पढ़ने के यहाँ कुछ करने के लिए: http://blog.ploeh.dk/2011/07/28/CompositionRoot/