खोज…


टिप्पणियों

निर्भरता इंजेक्शन की विकिपीडिया परिभाषा है:

सॉफ्टवेयर इंजीनियरिंग में, निर्भरता इंजेक्शन एक सॉफ्टवेयर डिजाइन पैटर्न है जो निर्भरता को हल करने के लिए नियंत्रण के व्युत्क्रम को लागू करता है। एक निर्भरता एक वस्तु है जिसका उपयोग किया जा सकता है (एक सेवा)। एक इंजेक्शन एक आश्रित वस्तु (एक ग्राहक) के लिए एक निर्भरता से गुजर रहा है जो इसका उपयोग करेगा।

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

** यह कोड MEF का उपयोग गतिशील रूप से dll को लोड करने और निर्भरता को हल करने के लिए करता है। ILogger निर्भरता MEF द्वारा हल की गई है और उपयोगकर्ता वर्ग में इंजेक्ट की गई है। उपयोगकर्ता वर्ग कभी भी आईलॉगर के ठोस कार्यान्वयन को प्राप्त नहीं करता है और इसका उपयोग करने वाले लकड़हारे के किस या किस प्रकार का कोई विचार नहीं है। **

MEF का उपयोग कर निर्भरता इंजेक्शन

public interface ILogger
{
    void Log(string message);
}

[Export(typeof(ILogger))]
[ExportMetadata("Name", "Console")]  
public class ConsoleLogger:ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

[Export(typeof(ILogger))]
[ExportMetadata("Name", "File")]  
public class FileLogger:ILogger
{
    public void Log(string message)
    {
        //Write the message to file
    }
}

public class User
{  
    private readonly ILogger logger;
    public User(ILogger logger)   
    {
        this.logger = logger;
    }
    public void LogUser(string message)
    {
        logger.Log(message)  ;
    }
}

public interface ILoggerMetaData
{
    string Name { get; }
}

internal class Program
{
    private CompositionContainer _container;
    
    [ImportMany]
    private IEnumerable<Lazy<ILogger, ILoggerMetaData>> _loggers;
    
    private static void Main()
    {            
        ComposeLoggers();
        Lazy<ILogger, ILoggerMetaData> loggerNameAndLoggerMapping = _ loggers.First((n) => ((n.Metadata.Name.ToUpper() =="Console"));
        ILogger logger= loggerNameAndLoggerMapping.Value
        var user = new User(logger);
        user.LogUser("user name");
    }
    
    private void ComposeLoggers()
    {
        //An aggregate catalog that combines multiple catalogs
        var catalog = new AggregateCatalog();
        string loggersDllDirectory =Path.Combine(Utilities.GetApplicationDirectory(), "Loggers");
        if (!Directory.Exists(loggersDllDirectory ))
        {
            Directory.CreateDirectory(loggersDllDirectory );
        }
        //Adds all the parts found in the same assembly as the PluginManager class
        catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
        catalog.Catalogs.Add(new DirectoryCatalog(loggersDllDirectory ));
        
        //Create the CompositionContainer with the parts in the catalog
        _container = new CompositionContainer(catalog);
        
        //Fill the imports of this object
        try
        {
            this._container.ComposeParts(this);
        }
        catch (CompositionException compositionException)
        {
            throw new CompositionException(compositionException.Message);
        }
    } 
}

एकता के साथ निर्भरता इंजेक्शन C # और ASP.NET

पहले हमें अपने कोड में डेपिडेंसी इंजेक्शन का उपयोग क्यों करना चाहिए? हम अपने कार्यक्रम में अन्य घटकों से अन्य घटकों को अलग करना चाहते हैं। उदाहरण के लिए हमारे पास क्लास एनिमलकंट्रोलर है जिनके पास कोड इस तरह है:

public class AnimalController()
{
    private SantaAndHisReindeer _SantaAndHisReindeer = new SantaAndHisReindeer();

    public AnimalController(){
            Console.WriteLine("");
    }
}

हम इस कोड को देखते हैं और हमें लगता है कि सब कुछ ठीक है, लेकिन अब हमारा एनिमल कॉन्ट्रोलर ऑब्जेक्ट _SantaAndHisReindeer पर निर्भर है। स्वचालित रूप से मेरा नियंत्रक परीक्षण के लिए बुरा है और मेरे कोड की पुन: प्रयोज्यता बहुत कठिन होगी।

बहुत अच्छी व्याख्या है कि हमें डिपेडेंसी इंजेक्शन और इंटरफेस का उपयोग क्यों करना चाहिए।

अगर हम चाहते हैं कि एकता डि को हैंडल करे, तो इसे प्राप्त करने का मार्ग बहुत आसान है :) नूगेट (पैकेज मैनेजर) के साथ हम आसानी से अपने कोड में एकता का आयात कर सकते हैं।

दृश्य स्टूडियो उपकरण में -> NuGet पैकेज मैनेजर -> समाधान के लिए संकुल प्रबंधित करें -> खोज इनपुट में एकता लिखें -> हमारी परियोजना चुनें -> स्थापित करें पर क्लिक करें

अब अच्छी टिप्पणियों वाली दो फाइलें बनाई जाएंगी।

इन-डेटा फ़ोल्डर UnityConfig.cs और UnityMvcActivator.cs

UnityConfig - RegisterTypes पद्धति में, हम प्रकार को देख सकते हैं जो हमारे निर्माणकर्ताओं में इंजेक्शन होगा।

namespace Vegan.WebUi.App_Start
{

public class UnityConfig
{
    #region Unity Container
    private static Lazy<IUnityContainer> container = new Lazy<IUnityContainer>(() =>
    {
        var container = new UnityContainer();
        RegisterTypes(container);
        return container;
    });

    /// <summary>
    /// Gets the configured Unity container.
    /// </summary>
    public static IUnityContainer GetConfiguredContainer()
    {
        return container.Value;
    }
    #endregion

    /// <summary>Registers the type mappings with the Unity container.</summary>
    /// <param name="container">The unity container to configure.</param>
    /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
    /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
    public static void RegisterTypes(IUnityContainer container)
    {
        // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
        // container.LoadConfiguration();

        // TODO: Register your types here
        // container.RegisterType<IProductRepository, ProductRepository>();

        container.RegisterType<ISanta, SantaAndHisReindeer>();
        
     }
 }
}

UnityMvcActivator -> भी अच्छी टिप्पणियों के साथ जो यह कहती है कि यह वर्ग ASP.NET MVC के साथ एकता को एकीकृत करता है

using System.Linq;
using System.Web.Mvc;
using Microsoft.Practices.Unity.Mvc;

[assembly: WebActivatorEx.PreApplicationStartMethod(typeof(Vegan.WebUi.App_Start.UnityWebActivator), "Start")]
[assembly: WebActivatorEx.ApplicationShutdownMethod(typeof(Vegan.WebUi.App_Start.UnityWebActivator), "Shutdown")]
    
namespace Vegan.WebUi.App_Start
{
/// <summary>Provides the bootstrapping for integrating Unity with ASP.NET MVC.</summary>
public static class UnityWebActivator
{
    /// <summary>Integrates Unity when the application starts.</summary>
    public static void Start() 
    {
        var container = UnityConfig.GetConfiguredContainer();

        FilterProviders.Providers.Remove(FilterProviders.Providers.OfType<FilterAttributeFilterProvider>().First());
        FilterProviders.Providers.Add(new UnityFilterAttributeFilterProvider(container));

        DependencyResolver.SetResolver(new UnityDependencyResolver(container));

        // TODO: Uncomment if you want to use PerRequestLifetimeManager
        // Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));
    }

    /// <summary>Disposes the Unity container when the application is shut down.</summary>
    public static void Shutdown()
    {
        var container = UnityConfig.GetConfiguredContainer();
        container.Dispose();
    }
}
}

अब हम अपने नियंत्रक को SantAndHisReindeer से हटा सकते हैं :)

 public class AnimalController()
    {
        private readonly SantaAndHisReindeer _SantaAndHisReindeer;

        public AnimalController(SantaAndHisReindeer SantaAndHisReindeer){

                _SantAndHisReindeer = SantaAndHisReindeer;
        }
    }

हमारे आवेदन को चलाने से पहले एक अंतिम बात हमें अवश्य करनी चाहिए।

Global.asax.cs में हमें नई पंक्ति जोड़नी होगी: UnityWebActivator.Start () जो शुरू होगी, एकता को कॉन्फ़िगर करेगी और हमारे प्रकारों को पंजीकृत करेगी।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
using Vegan.WebUi.App_Start;

namespace Vegan.WebUi
{
    public class MvcApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            UnityWebActivator.Start();
        }
    }
}


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow