C# में स्क्रूटर का उपयोग करके निर्भरता इंजेक्शन के लिए 3 सरल युक्तियाँ

C# में डिपेंडेंसी इंजेक्शन निर्भरता को व्यवस्थित करते समय एक जीवनरक्षक है - विशेष रूप से अधिक जटिल ASP.NET कोर अनुप्रयोगों में। और यदि आप पहले से ही IServiceCollection से परिचित हैं या जितना संभव हो सके पहले से प्रदान की गई DI पेशकशों के करीब रहना चाहते हैं, तो C# में स्क्रूटर एक महान वृद्धि है।

इस लेख में, मैं आपको C# में डिपेंडेंसी इंजेक्शन और स्क्रूटर का एक उच्च-स्तरीय अवलोकन प्रदान करूंगा। लेकिन वहां से, हम सीधे 3 युक्तियों पर जा रहे हैं जिनका उपयोग आप स्क्रूटर के साथ कर सकते हैं जो आपके आवेदन में बहुत मददगार साबित हो सकती हैं!

C# में स्क्रूटर क्या है?

स्क्रूटर C# में एक शक्तिशाली NuGet पैकेज है जो निर्भरता इंजेक्शन को बढ़ाता है। यह निर्भरता के पंजीकरण और समाधान को सरल बनाता है, जिससे आपके लिए अपना कोड प्रबंधित और व्यवस्थित करना आसान हो जाता है।

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

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

1 - पंजीकरण और समाधान के लिए स्क्रूटर का उपयोग करना

पंजीकरण और रिज़ॉल्यूशन के लिए C# में स्क्रूटर का उपयोग कैसे करें, इसे स्पष्ट करने के लिए, आइए एक सरल परिदृश्य पर विचार करें। कल्पना कीजिए कि हमारे पास एक एप्लिकेशन है जिसके लिए विभिन्न डेटा रिपॉजिटरी, जैसे कि UserRepository और ProductRepostiory के उपयोग की आवश्यकता होती है।

सबसे पहले, हमें अपने प्रोजेक्ट में स्क्रूटर नुगेट पैकेज स्थापित करना होगा। पैकेज प्रबंधक कंसोल खोलें और निम्न आदेश चलाएँ:

 Install-Package Scrutor

इसके बाद, हमें अपने रिपॉजिटरी और उनके संबंधित इंटरफेस को परिभाषित करने की आवश्यकता है। यह उदाहरण मूलतः खाली है, लेकिन हम एक क्षण में इनका उल्लेख करेंगे:

 public interface IUserRepository { // Interface methods } public class UserRepository : IUserRepository { // Implementation } public interface IProductRepository { // Interface methods } public class ProductRepository : IProductRepository { // Implementation }

अब, आइए स्क्रूटर का उपयोग करके अपनी निर्भरता को तार-तार करें। अपने स्टार्टअप कोड में (जैसे कि ASP.NET Core में कॉन्फिगरसर्विसेज विधि में), निम्नलिखित कोड जोड़ें:

 services.Scan(scan => scan .FromAssemblyOf<Startup>() .AddClasses(classes => classes.AssignableToAny( typeof(IUserRepository), typeof(IProductRepository))) .AsImplementedInterfaces() .WithScopedLifetime());

यह कोड स्टार्टअप क्लास वाली असेंबली को स्कैन करने के लिए स्क्रूटर से स्कैन विधि का उपयोग करता है। इसके बाद यह उन कक्षाओं को फ़िल्टर करता है जो IUserRepository या IProductRepository इंटरफेस को असाइन करने योग्य हैं। अंत में, यह इन इंटरफेस के कार्यान्वयन को मैप करता है और उन्हें उनके संबंधित इंटरफेस के साथ पंजीकृत करता है।

अब, हम इन निर्भरताओं को अपनी कक्षाओं में शामिल कर सकते हैं। उदाहरण के लिए, मान लें कि हमारे पास एक UserService क्लास है जिसके लिए IUserRepository की आवश्यकता है:

 public class UserService { private readonly IUserRepository _userRepository; public UserService(IUserRepository userRepository) { _userRepository = userRepository; } // Rest of the class implementation }

IUserRepository को कंस्ट्रक्टर में एक निर्भरता के रूप में घोषित करके, IServiceCollection के साथ स्क्रूटर स्वचालित रूप से हमारे लिए UserRepository इंस्टेंस को हल और इंजेक्ट करेगा।

2 - डेकोरेटर पैटर्न - सेवाओं के लिए लॉगिंग का उदाहरण

कल्पना कीजिए कि आपके पास एक सेवा इंटरफ़ेस IService और एक कार्यान्वयन MyService है। आप लॉगिंग चिंताओं के साथ इसके व्यावसायिक तर्क को प्रदूषित किए बिना MyService में प्रत्येक विधि कॉल की प्रविष्टि और निकास को लॉग करना चाहते हैं।

सबसे पहले, IService इंटरफ़ेस और उसके कार्यान्वयन को परिभाषित करें:

 public interface IService { void DoWork(); } public class MyService : IService { public void DoWork() { // Business logic here } }

इसके बाद, एक डेकोरेटर क्लास LoggingDecorator बनाएं जो IService को लागू करता है। यह वर्ग वास्तविक सेवा को लपेटेगा और प्रत्यायोजित विधि कॉल के आसपास लॉगिंग जोड़ेगा:

 public class LoggingDecorator : IService { private readonly IService _decorated; private readonly ILogger<LoggingDecorator> _logger; public LoggingDecorator(IService decorated, ILogger<LoggingDecorator> logger) { _decorated = decorated; _logger = logger; } public void DoWork() { _logger.LogInformation("Starting work."); _decorated.DoWork(); _logger.LogInformation("Finished work."); } }

अब, अपनी सेवा और उसके डेकोरेटर को Startup.cs में या जहां भी आप अपनी सेवाओं को कॉन्फ़िगर करते हैं, पंजीकृत करने के लिए स्क्रूटर का उपयोग करें:

 public void ConfigureServices(IServiceCollection services) { // Register the base service services.AddScoped<IService, MyService>(); // Use Scrutor to apply the decorator services.Decorate<IService, LoggingDecorator>(); // Make sure to register the ILogger or ILogger<T> dependencies if not already done }

यह सेटअप IService पंजीकरण को LoggingDecorator के साथ लपेटने के लिए Scrutor का उपयोग करता है। IService हल करते समय, DI कंटेनर LoggingDecorator का एक उदाहरण प्रदान करेगा, जो बदले में MyService के एक उदाहरण को लपेटता है। यह दृष्टिकोण लॉगिंग तर्क को आपके व्यावसायिक तर्क से बाहर रखकर चिंताओं को अलग करता है।

3 - सेवा कार्यान्वयन के लिए फ़ीचर टॉगल

जब हम जटिल सिस्टम बना रहे होते हैं, तो अक्सर ऐसे मामले होते हैं जहां हम फीचर फ़्लैग जैसी कोई चीज़ पेश करना चाहते हैं। ये हमें कॉन्फ़िगरेशन के आधार पर अलग-अलग कोड पथ लेने की अनुमति देते हैं और संपूर्ण एप्लिकेशन को पुन: संकलित और तैनात करने की आवश्यकता नहीं होती है। कुछ स्थितियों में, यह केवल एक अलग कोड पथ चुनने के बारे में नहीं है, यह किसी चीज़ के संपूर्ण कार्यान्वयन को बदलने के बारे में है!

आइए मिलकर एक उदाहरण आज़माएँ! मान लें कि आपके पास एकाधिक कार्यान्वयन के साथ एक IFeatureService इंटरफ़ेस है: NewFeatureService (एक नई, प्रयोगात्मक सुविधा) और StandardFeatureService (वर्तमान, स्थिर सुविधा)। आप कॉन्फ़िगरेशन फ़्लैग के आधार पर रनटाइम पर इन कार्यान्वयनों के बीच स्विच करना चाहते हैं।

सबसे पहले, IFeatureService इंटरफ़ेस और उसके कार्यान्वयन को परिभाषित करें:

 public interface IFeatureService { void ExecuteFeature(); } public class NewFeatureService : IFeatureService { public void ExecuteFeature() { // New feature logic } } public class StandardFeatureService : IFeatureService { public void ExecuteFeature() { // Standard feature logic } }

इसके बाद, आपको यह निर्धारित करने का एक तरीका चाहिए कि फीचर टॉगल सेटिंग के आधार पर किस कार्यान्वयन का उपयोग किया जाए। यह appsettings.json , डेटाबेस सेटिंग, या किसी अन्य कॉन्फ़िगरेशन स्रोत में एक मान हो सकता है।

अब, फीचर टॉगल के आधार पर उचित सेवा कार्यान्वयन को गतिशील रूप से पंजीकृत करने के लिए स्क्रूटर का उपयोग करें:

 public void ConfigureServices(IServiceCollection services) { // Assume GetFeatureToggleValue() retrieves the current feature toggle setting var useNewFeature = GetFeatureToggleValue("UseNewFeature"); // Dynamically register the appropriate implementation based on the feature toggle if (useNewFeature) { services.AddScoped<IFeatureService, NewFeatureService>(); } else { services.AddScoped<IFeatureService, StandardFeatureService>(); } // Optional: You could combine this with the previous example // to use the decorator pattern too! // services.Decorate<IFeatureService, FeatureServiceProxy>(); } private bool GetFeatureToggleValue(string featureName) { // This method would typically check your // configuration source to determine if the feature is enabled // For simplicity, this is just a placeholder return false; // or true based on actual configuration }

इस तरह का दृष्टिकोण अपनाने से हमें मदद मिल सकती है:

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

C# में स्क्रूटर को लपेटना

इस लेख में, मैंने आपको C# में स्क्रूटर के साथ निर्भरता इंजेक्शन के लिए 3 सरल युक्तियाँ प्रदान की हैं। निर्भरता इंजेक्शन क्या है और स्क्रूटर इसमें कैसे फिट बैठता है, इसके संक्षिप्त अवलोकन के बाद, हम सीधे अपने उदाहरणों पर आ गए। हमें असेंबली स्कैनिंग, निर्भरता को कैसे सजाना है, और यहां तक कि संपूर्ण कार्यान्वयन को चिह्नित करने वाली सुविधा पर विचार कैसे करना है, यह देखने को मिला!

निर्भरता इंजेक्शन एक ऐसी चीज़ है जो आपके अनुप्रयोगों को बहुत सरल बना सकती है क्योंकि वे जटिलता में बढ़ते हैं, और यदि आप Microsoft से अंतर्निहित IServiceCollection की पेशकश पर टिके रहना चाहते हैं तो स्क्रूटर एक बड़ी मदद हो सकता है। यदि आपको यह उपयोगी लगता है और आप सीखने के अधिक अवसरों की तलाश में हैं, तो मेरे मुफ़्त साप्ताहिक सॉफ़्टवेयर इंजीनियरिंग न्यूज़लेटर की सदस्यता लेने पर विचार करें और YouTube पर मेरे मुफ़्त वीडियो देखें! डिस्कोर्ड पर मेरे और समुदाय के अन्य सदस्यों से जुड़ें!