🅱️ 🎒 ⌛️ ASP.NET MVC पाठ 2: निर्भरता इंजेक्शन 🖖🏿 🕵🏾 🤘🏾

सबक उद्देश्य : लर्निंग डि (निर्भरता इंजेक्शन)। Ninject, Unity, Autofac, और Winsor पर उदाहरण।

कई मामलों में, आपके एप्लिकेशन को अलग-अलग मॉड्यूल में एक ही श्रेणी का उपयोग किया जाता है। इसे लागू करने का एक आसान तरीका सिंगलटन टेम्पलेट का उपयोग करना है।

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

उदाहरण के लिए, सेवा का उपयोग करने से पहले। आइए कुछ वर्गों का वर्णन करते हैं, किल विधि के साथ IWeapon इंटरफ़ेस, दो कार्यान्वयन कक्षाएं Bazuka और Sword, और वारियर वर्ग, जो हथियारों का उपयोग करता है:

public interface IWeapon { void Kill(); } public class Bazuka : IWeapon { public void Kill() { Console.WriteLine("BIG BADABUM!"); } } public class Sword : IWeapon { public void Kill() { Console.WriteLine("Chuk-chuck"); } } public class Warrior { readonly IWeapon Weapon; public Warrior(IWeapon weapon) { this.Weapon = weapon; } public void Kill() { Weapon.Kill(); } }

हम इसका उपयोग करते हैं:

  class Program { static void Main(string[] args) { Warrior warrior = new Warrior(new Bazuka()); warrior.Kill(); Console.ReadLine(); } }

हम लाइनों के बीच पढ़ते हैं। हम एक योद्धा बनाते हैं और उसे एक बाजुका देते हैं, वह जाता है और मारता है। कंसोल में हमें मिलता है:

 BIG BADABUM!

ध्यान दें कि हमारे पास लाइन में एक अशक्त चेक नहीं है

 Weapon.Kill();

यहाँ क्या गलत है? योद्धा को पता नहीं है कि क्या उसके पास हथियार है, और हथियारों को जारी करना एक अलग मॉड्यूल नहीं है, लेकिन मुख्य कार्यक्रम है।
DI का सार किसी अन्य मॉड्यूल को हथियारों की डिलीवरी का निर्देश देना है।

हम Ninject को कनेक्ट करते हैं:

 Install-Package Ninject

हम एक मॉड्यूल बनाते हैं जो हथियारों को जारी करने से संबंधित है:

  public class WeaponNinjectModule : NinjectModule { public override void Load() { this.Bind<IWeapon>().To<Sword>(); } }

जिसका शाब्दिक अर्थ है: "यदि वे हथियार मांगते हैं, तो तलवारें दे दें।"
हम एक "सेवा लोकेटर" बनाते हैं और हथियारों का उपयोग करते हैं:

  class Program { public static IKernel AppKernel; static void Main(string[] args) { AppKernel = new StandardKernel(new WeaponNinjectModule()); var warrior = AppKernel.Get<Warrior>(); warrior.Kill(); Console.ReadLine(); } }

जैसा कि आप देख सकते हैं, हम नए निर्माण का उपयोग करके योद्धा वस्तु नहीं बना रहे हैं, लेकिन AppKernel.Get<>() माध्यम से। AppKernel बनाते समय, हम एक निर्माता के रूप में हथियार (इस मामले में, एक तलवार) जारी करने के लिए जिम्मेदार मॉड्यूल से गुजरते हैं। कोई भी वस्तु जिसे हम AppKernel.Get माध्यम से प्राप्त करने का प्रयास कर रहे हैं। (जहाँ तक संभव हो) इनिशियलाइज़ किया जाएगा यदि ऐसे मॉड्यूल हैं जो जानते हैं कि यह कैसे करना है।

आवेदन का एक और क्षण, जब Warrior वस्तु हर बार अपने साथ एक हथियार नहीं ले जाती है, लेकिन अगर इसका पता नहीं लगाया जाता है, तो यह सेवा लोकेटर तक पहुंचता है और इसे प्राप्त करता है:

  public class OtherWarrior { private IWeapon _weapon; public IWeapon Weapon { get { if (_weapon == null) { _weapon = Program.AppKernel.Get<IWeapon>(); } return _weapon; } } public void Kill() { Weapon.Kill(); } }

हम निष्पादित करते हैं:

  var otherWarrior = new OtherWarrior(); otherWarrior.Kill();

हमारे योद्धा सीधे प्रसव के लिए हथियार प्राप्त करते हैं - सुपर!

Ninject का एक और बहुत अच्छा विवरण है। यदि ( public property ) public property चिह्नित किया जाता है [Inject] , तो AppKernel.Get<>() माध्यम से वर्ग बनाते समय, क्षेत्र को लोकेटर सेवा द्वारा आरंभीकृत किया जाता है:

  public class AnotherWarrior { [Inject] public IWeapon Weapon { get; set; } public void Kill() { Weapon.Kill(); } } var anotherWarrior = AppKernel.Get<AnotherWarrior>(); anotherWarrior.Kill();

एकता

सब कुछ ठीक वैसा ही है:

स्थापना
```
 Install-Package Unity 
```
लोकेटर सर्विस (कंटेनर) की शुरुआत
```
 Container = new UnityContainer(); 
```

पंजीकरण प्रकार

 Container.RegisterType(typeof(IWeapon), typeof(Bazuka));

वस्तु प्राप्त करना और उपयोग करना:
```
 var warrior = Container.Resolve<Warrior>(); warrior.Kill(); 
```
इसके अलावा, यूनिटी में एक सिंगलटन क्लास (Singleton) ServiceLocator , जो एक कंटेनर को पंजीकृत करता है और आपको कहीं से भी सेवाओं तक पहुंचने की अनुमति देता है।
```
 var serviceProvider = new UnityServiceLocator(Container); ServiceLocator.SetLocatorProvider(() => serviceProvider); 
```

चालाक OtherWarrior अब इस तरह एक हथियार हो जाता है:

  public class OtherWarrior { private IWeapon _weapon; public IWeapon Weapon { get { if (_weapon == null) { _weapon = ServiceLocator.Current.GetInstance<IWeapon>(); } return _weapon; } } public void Kill() { Weapon.Kill(); } }

Autofac

तो, वास्तव में, सब कुछ होता है:

स्थापना
```
 Install-Package Autofac 
```
सर्विस-लोकेटर ( ContainerBuilder ) के निर्माणकर्ता का आरम्भ - नहीं, नहीं, यह स्वयं कंटेनर नहीं है, यह मॉड्यूल की तरह है
```
 var builder = new ContainerBuilder(); 
```
प्रकार का पंजीकरण। सभी आवश्यक वर्गों को पंजीकृत करना आवश्यक है, क्योंकि अपंजीकृत वर्गों के उदाहरणों को बनाना यहां लागू नहीं है।
```
 builder.RegisterType<Bazuka>(); builder.RegisterType<Warrior>(); builder.Register<IWeapon>(x => x.Resolve<Bazuka>()); 
```
एक लोकेटर सेवा (कंटेनर) बनाना
```
 var container = builder.Build(); 
```
एक वस्तु प्राप्त करना और उपयोग करना:
```
 var warrior = container.Resolve<Warrior>(); warrior.Kill(); 
```

महल की हवा

स्थापना
```
 Install-Package Castle.Windsor 
```
सेवा लोकेटर को प्रारंभ करना
```
 var container = new WindsorContainer(); 
```

प्रकार का पंजीकरण। ऑटोफेक के समान।

 container.Register(Component.For<IWeapon>().ImplementedBy<Bazuka>(), Component.For<Warrior>().ImplementedBy<Warrior>());

एक वस्तु प्राप्त करना और उपयोग करना:
```
 var warrior = container.Resolve<Warrior>(); warrior.Kill(); 
```

छोटा उप योग

वास्तव में, निर्भरता इंजेक्शन कार्यान्वयन बहुत अधिक नहीं हैं, लेकिन वे अभी भी अलग हैं। कुछ Web.config (App.config) फ़ाइलों में आरंभीकरण का समर्थन करते हैं। आरंभीकरण के लिए कुछ नियम निर्धारित करते हैं, जैसा कि हम अब asp.net mvc के लिए Ninject एक्सटेंशन को देखते हैं - यह सेवा लोकेटर को साझा ऑब्जेक्ट्स के जनरेटर के रूप में या प्रत्येक स्ट्रीम या वेब अनुरोध के लिए अलग से लागू करने पर लागू होता है।

क्षेत्र ऑब्जेक्ट्स (निन्जेक्ट)

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

क्षेत्र	बंधन विधि	व्याख्या
अस्थायी	`.InTransientScope()`	प्रत्येक आवश्यकता (डिफ़ॉल्ट विधि) के लिए एक क्लास ऑब्जेक्ट बनाया जाएगा।
अविवाहित	`.InSingletonScope()`	वर्ग ऑब्जेक्ट एक बार बनाया जाएगा और पुन: उपयोग किया जाएगा।
धारा	`.InThreadScope()`	प्रति धागा एक वस्तु।
जांच	`.InRequestScope()`	प्रत्येक वेब अनुरोध के लिए एक ऑब्जेक्ट होगा

एकता में लाइफटाइम मैनेजर

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

  _container.RegisterType<DbContext, SavecashTravelContext>(new PerRequestLifetimeManager());

जहां PerRequestLifetimeManager लाइफटाइम मैनजर का कार्यान्वयन है:

 public class PerRequestLifetimeManager : LifetimeManager { /// <summary> /// Key to store data /// </summary> private readonly string _key = String.Format("SingletonPerRequest{0}", Guid.NewGuid()); /// <summary> /// Retrieve a value from the backing store associated with this Lifetime policy. /// </summary> /// <returns> /// the object desired, or null if no such object is currently stored. /// </returns> public override object GetValue() { if (HttpContext.Current != null && HttpContext.Current.Items.Contains(_key)) return HttpContext.Current.Items[_key]; return null; } /// <summary> /// Stores the given value into backing store for retrieval later. /// </summary> /// <param name="newValue">The object being stored.</param> public override void SetValue(object newValue) { if (HttpContext.Current != null) HttpContext.Current.Items[_key] = newValue; } /// <summary> /// Remove the given object from backing store. /// </summary> public override void RemoveValue() { if (HttpContext.Current != null && HttpContext.Current.Items.Contains(_key)) HttpContext.Current.Items.Remove(_key); } }

नीचे की रेखा। सभी वस्तुओं को HttpContext.Current.Items[_key] में संग्रहीत किया जाता है और केवल तभी जारी किया जाता है जब वे एक ही संदर्भ ( HttpContext.Current ) में हों। अन्यथा, एक नई वस्तु बनाई जाती है। यदि वर्तमान संदर्भ ( HttpContext.Current ) कोड क्षेत्र में मौजूद नहीं है (हम कंसोल एप्लिकेशन में या अलग थ्रेड में ऐसे LifetimeManager उपयोग करते हैं), तो यह कंटेनर काम नहीं करेगा।

Asp.net mvc में Ninject का उपयोग करना

एक asp.net mvc वातावरण में Ninject स्थापित करें। अलग से, अपना स्वयं का सबकप्रोजेक्ट प्रोजेक्ट बनाएं, एक विधि के साथ होमकंट्रोलर बनाएं और वहां इंडेक्स देखें। (/Contollers/HomeController.cs):

 public class HomeController : Controller { public ActionResult Index() { return View(); } }

और (/ दृश्य / होम / इंडेक्स.क्स्ट एमएल):

 @{ ViewBag.Title = "LessonProject"; Layout = "~/Views/Shared/_Layout.cshtml"; } <h2>LessonProject</h2>

लॉन्च - यह काम करता है।

नोट: भविष्य में, हम इस परियोजना को बाद के पाठों में स्थानांतरित करेंगे।

अब इस प्रोजेक्ट के लिए Ninject मॉड्यूल और Ninject.MVC3 इंस्टॉल करें।

 Install-Package Ninject.MVC3

App_Start फ़ोल्डर (/App_Start/NinjectWebCommon.cs) पर कक्षा जोड़ें:

 [assembly: WebActivator.PreApplicationStartMethod(typeof(LessonProject.App_Start.NinjectWebCommon), "Start")] [assembly: WebActivator.ApplicationShutdownMethodAttribute(typeof(LessonProject.App_Start.NinjectWebCommon), "Stop")] namespace LessonProject.App_Start { using System; using System.Web; using Microsoft.Web.Infrastructure.DynamicModuleHelper; using Ninject; using Ninject.Web.Common; public static class NinjectWebCommon { private static readonly Bootstrapper bootstrapper = new Bootstrapper(); /// <summary> /// Starts the application /// </summary> public static void Start() { DynamicModuleUtility.RegisterModule(typeof(OnePerRequestHttpModule)); DynamicModuleUtility.RegisterModule(typeof(NinjectHttpModule)); bootstrapper.Initialize(CreateKernel); } /// <summary> /// Stops the application. /// </summary> public static void Stop() { bootstrapper.ShutDown(); } /// <summary> /// Creates the kernel that will manage your application. /// </summary> /// <returns>The created kernel.</returns> private static IKernel CreateKernel() { var kernel = new StandardKernel(); kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel); kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>(); RegisterServices(kernel); return kernel; } /// <summary> /// Load your modules or register your services here! /// </summary> /// <param name="kernel">The kernel.</param> private static void RegisterServices(IKernel kernel) { } } }

RegisterServices में, हम अपनी सेवाओं के आरंभ को जोड़ रहे हैं। शुरू करने के लिए, हम एक चंचल IWeapon जोड़ेंगे, और भविष्य में हम अन्य सेवाओं को पंजीकृत करने के लिए इस पद्धति पर लौटेंगे:

  public interface IWeapon { string Kill(); } … public class Bazuka : IWeapon { public string Kill() { return "BIG BADABUM!"; } } … private static void RegisterServices(IKernel kernel) { kernel.Bind<IWeapon>().To<Bazuka>(); }

नियंत्रक में, [Inject] विशेषता का उपयोग करें:

  public class HomeController : Controller { [Inject] public IWeapon weapon { get; set; } public ActionResult Index() { return View(weapon); } }

दृश्य देखें:

 @model LessonProject.Models.IWeapon @{ ViewBag.Title = "LessonProject"; Layout = "~/Views/Shared/_Layout.cshtml"; } <h2>LessonProject</h2> <p> @Model.Kill() </p>

आउटपुट है:

Ninject WebActivator का उपयोग करता है:

अपने OnePerRequestHttpModule और NinjectHttpModule मॉड्यूल पंजीकृत करता है
स्टैंडआर्ट कर्नेल बनाता है
हमारी सेवाओं को इनिशियलाइज़ करता है।

DependencyResolver

Asp.net mvc3 डिपेंडेंसीResolver वर्ग का परिचय देता है। यह वर्ग सेवा का एक उदाहरण प्रदान करता है। हम इस वर्ग के माध्यम से अपनी पंजीकृत सेवाएं (और यहां तक कि इस्तेमाल किए गए DI कंटेनर) भी प्राप्त कर सकते हैं।

  public class HomeController : Controller { private IWeapon weapon { get; set; } public HomeController() { weapon = DependencyResolver.Current.GetService<IWeapon>(); } public ActionResult Index() { return View(weapon); } }

परिणाम

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

सभी स्रोत https://bitbucket.org/chernikov/lessons पर स्थित हैं

ASP.NET MVC पाठ 2: निर्भरता इंजेक्शन