ऑटोफैक

Question

में इन कक्षाओं को कैसे पंजीकृत करें IOoc कंटेनर के रूप में ऑटोफैक का उपयोग कर रहा हूं।

class Service 
{ 
    public Service(Repository rep,UnitOfWork context){} 

} 

Class Repository 
{ 
    public Repository(UnitOfWork context){} 
} 

class UnitOfWork{} 

सेवा और भंडार UnitOfWork

का एक ही उदाहरण की जरूरत है कैसे करने के लिए: मैं तीन वर्ग है? और कैसे XmlConfiguration

Answer 1

संपादित में यह wirte रहे हैं: मैं इस पढ़ने में भूलना और सोचा था कि यह कैसे निर्भरता रजिस्टर करने के लिए autofac का उपयोग करने के बारे में एक प्रश्न था। यदि आप एक ही यूनिटऑफवर्क रखना चाहते हैं, तो आपको उदाहरण के जीवनकाल को कुछ करने की आवश्यकता है। आप एक ASP.NET या WCF आवेदन में यह प्रयोग कर रहे हैं तो आप इस तरह अपने निर्भरता रजिस्टर कर सकते हैं:

typeBuilder.RegisterType<UnitOfWork>().InstancePerLifetimeScope(); 
typeBuilder.RegisterType<Repository>(); 
typeBuilder.RegisterType<Service>(); 

---

पहली बात आप एक कंटेनर का उपयोग कर क्या करने की जरूरत Autofac जैसे पंजीकृत है सब अपने निर्भरता। ऑटोफैक में आप कुछ तरीकों से ऐसा कर सकते हैं लेकिन उनमें से सभी ContainerBuilder का उपयोग करने पर भरोसा करते हैं। ContainerBuilder एक्सटेंशन विधियों पर निर्भर करता है ताकि सुनिश्चित करें कि आपके पास ऑटोफ़ैक नामस्थान के लिए using कथन है।

आप स्पष्ट रूप से परिभाषित कर सकते हैं कारखाना तरीके:

// Explicitly 
var builder = new ContainerBuilder(); 
builder.Register<UnitOfWork>(b => new UnitOfWork()); 
builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>())); 
builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>())); 

ContainerBuilder इस्तेमाल करते हुए हम Register<>() विधि का उपयोग सेवा इंटरफेस प्रदान करने (जो कि कैसे हम सेवा के लिए कंटेनर पूछ किया जाएगा) इस मामले में , मैं इंटरफेस का उपयोग नहीं कर रहा हूं, बस वास्तविक प्रकार। किसी भी समय जब आप कंटेनर को UnitOfWork के लिए पूछते हैं तो यह एक उत्पन्न करने के लिए फैक्टरी विधि new UnitOfWork() का उपयोग करेगा। वास्तविक जीवन में, आप शायद IUnitOfWork के लिए पूछ रहे होंगे। यह सब कुछ वर्बोज़ हो सकता है, लेकिन जब आप निर्भरता निर्माण के लिए कस्टम तर्क की आवश्यकता होती है तो यह बहुत आसान है।

आप किसी अन्य निर्भरता कंटेनर की तरह निर्माता का उपयोग कर सकते हैं और केवल प्रकार पंजीकृत कर सकते हैं।

// Implicitly 
var typeBuilder = new ContainerBuilder(); 
typeBuilder.RegisterType<UnitOfWork>(); 
typeBuilder.RegisterType<Repository>(); 
typeBuilder.RegisterType<Service>(); 

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

आप कॉन्फ़िगरेशन दृष्टिकोण का उपयोग कर सकते हैं। नोटिस config अनुभाग (नोटिस <ConfigSections>) को परिभाषित करने के लिए है कि

<?xml version="1.0" encoding="utf-8" ?> 
<configuration> 
    <configSections> 
    <section name="autofac" type="Autofac.Configuration.SectionHandler, Autofac.Configuration"/> 
    </configSections> 

    <autofac defaultAssembly="AutoFacTest"> 
    <components> 
     <component 
       type="AutoFacTest.Repository, AutoFacTest" 
       service="AutoFacTest.Repository" /> 

     <component 
       type="AutoFacTest.UnitOfWork, AutoFacTest" 
       service="AutoFacTest.UnitOfWork" /> 

     <component 
       type="AutoFacTest.Service, AutoFacTest" 
       service="AutoFacTest.Service" /> 
    </components> 
    </autofac> 
</configuration> 

पहले,:

आप एक app.config फ़ाइल का उपयोग कर रहे हैं, तो आप अपने कॉन्फ़िग फ़ाइल इस तरह परिभाषित कर सकते हैं। फिर, हम <autofac> अनुभाग बना सकते हैं जो हमारी सभी निर्भरताओं को परिभाषित करता है। नोटेशन बहुत आसान है, आप मूल रूप से प्रत्येक निर्भरता के लिए <component> बनाते हैं।प्रत्येक घटक में service विशेषता होती है जो अनुरोध किए जाने वाले प्रकार को परिभाषित करता है। एक type विशेषता भी है जो ऑब्जेक्ट को सेवा के उदाहरण के अनुरोध के दौरान बनाए जाने के लिए परिभाषित करता है। यह builder.Register<UnitOfWork>(b => new UnitOfWork()) के समान है जहां UnitOfWork सेवा से अनुरोध किया गया है (और इस मामले में) भी प्रकार का निर्माण किया जाना है।

बिल्डर विन्यास का उपयोग कर बनाने के लिए, का उपयोग एक ConfigurationSettingsReader()

// Config 
var configBuilder = new ContainerBuilder(); 
configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac")); 

आप अपने विन्यास खंड के नाम पर पारित करने के लिए (इस मामले, autofac में) है। एक बार जब आप निर्भरताओं को कॉन्फ़िगर कर लेंगे, तो आपको एक कंटेनर बनाना होगा। ContainerBuilder यह करने के लिए एक विधि शामिल हैं:

var container = builder.Build(); 
var typeContainer = typeBuilder.Build(); 
var configContainer = configBuilder.Build(); 

और जैसे ही आप कंटेनर है, आप अपनी सेवा के उदाहरण अनुरोध कर सकते हैं:

container.Resolve<Service>().DoAwesomeness(); 
typeContainer.Resolve<Service>().DoAwesomeness(); 
configContainer.Resolve<Service>().DoAwesomeness(); 

पूरा कार्यक्रम:

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using Autofac; 
using Autofac.Configuration; 

namespace AutoFacTest 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      // Explicitly 
      var builder = new ContainerBuilder(); 
      builder.Register<UnitOfWork>(b => new UnitOfWork()); 
      builder.Register<Repository>(b => new Repository(b.Resolve<UnitOfWork>())); 

      builder.Register(b => new Service(b.Resolve<Repository>(), b.Resolve<UnitOfWork>())); 

      // Implicitly 
      var typeBuilder = new ContainerBuilder(); 
      typeBuilder.RegisterType<UnitOfWork>(); 
      typeBuilder.RegisterType<Repository>(); 
      typeBuilder.RegisterType<Service>(); 

      // Config 
      var configBuilder = new ContainerBuilder(); 
      configBuilder.RegisterModule(new ConfigurationSettingsReader("autofac")); 

      var container = builder.Build(); 
      var typeContainer = typeBuilder.Build(); 
      var configContainer = configBuilder.Build(); 


      container.Resolve<Service>().DoAwesomeness(); 
      typeContainer.Resolve<Service>().DoAwesomeness(); 
      configContainer.Resolve<Service>().DoAwesomeness(); 
      Console.Read(); 
     } 
    } 

    public class Repository 
    { 
     private readonly UnitOfWork _unitOfWork; 
     public Repository(UnitOfWork uow) 
     { 
      _unitOfWork = uow; 
     } 

     public void PrintStuff(string text) 
     { 
      Console.WriteLine(text); 
     } 
    } 

    public class Service 
    { 
     private readonly Repository _repository; 
     private readonly UnitOfWork _unitOfWork; 

     public Service(Repository repo, UnitOfWork uow) 
     { 
      _repository = repo; 
      _unitOfWork = uow; 
     } 
     public void DoAwesomeness() 
     { 
      _repository.PrintStuff("Did awesome stuff!"); 
      _unitOfWork.Commit(); 
     } 
    } 

    public class UnitOfWork 
    { 
     public bool Commit() 
     { 
      return true; 
     } 
    } 


}