Creating a Dependency Injection Project in a Console Application

कंसोल एप्लीकेशन में डिपेंडेंसी इंजेक्शन

इस लेख में हम सीखेंगे कि कैसे कंसोल एप्लीकेशन में डिपेंडेंसी इंजेक्शन का प्रयोग कर के किसी सर्विस का उपयोग किया जा सकता है।

कंसोल एप्लीकेशन में डिपेंडेंसी इंजेक्शन प्रोजेक्ट बनाना

ASP.NET Core एप्लीकेशन में डिपेंडेंसी इंजेक्शन का सपोर्ट बिल्ट-इन होता है, लेकिन कंसोल एप्लीकेशन में हमें इसे मैन्युअल तरीके से जोड़ना होता है। इसके लिए हमें कुछ NuGet पैकेज इंस्टॉल करने होंगे और फिर अपना सर्विस कलेक्शन बनाना होगा।

स्टेप 1: नया कंसोल एप्लीकेशन प्रोजेक्ट बनाएं

सबसे पहले, विजुअल स्टूडियो (Visual Studio) या .NET CLI का उपयोग करके एक नया कंसोल एप्लीकेशन प्रोजेक्ट बनाएं।

विजुअल स्टूडियो का उपयोग करके:

1. विजुअल स्टूडियो खोलें।
2. "Create a new project" पर क्लिक करें।
3. "Console Application" (C#) टेम्पलेट चुनें और "Next" पर क्लिक करें।
4. प्रोजेक्ट का नाम (जैसे ConsoleDIExample) और लोकेशन चुनें, फिर "Next" पर क्लिक करें।
5. .NET संस्करण चुनें (जैसे .NET 8.0) और "Create" पर क्लिक करें।

.NET CLI का उपयोग करके (कमांड प्रॉम्प्ट/टर्मिनल में):

1. dotnet new console -n ConsoleDIExample
2. cd ConsoleDIExample

स्टेप 2: आवश्यक NuGet पैकेज इंस्टॉल करें

डिपेंडेंसी इंजेक्शन के लिए हमें Microsoft.Extensions.DependencyInjection पैकेज की आवश्यकता होगी। इसे अपने प्रोजेक्ट में इंस्टॉल करें।

विजुअल स्टूडियो का उपयोग करके:

1. सॉल्यूशन एक्सप्लोरर में अपने प्रोजेक्ट पर राइट-क्लिक करें।
2. "Manage NuGet Packages..." चुनें।
3. "Browse" टैब पर जाएं।
4. Microsoft.Extensions.DependencyInjection सर्च करें और इसे इंस्टॉल करें।

.NET CLI का उपयोग करके:

• dotnet add package Microsoft.Extensions.DependencyInjection
• dotnet add package Microsoft.Extensions.Hosting

Microsoft.Extensions.Hosting पैकेज हमें कंसोल एप्लीकेशन में ASP.NET Core के जेनेरिक होस्ट (Generic Host) के समान एक होस्ट बनाने की सुविधा देता है, जो डिपेंडेंसी इंजेक्शन कंटेनर को सेटअप करने में मदद करता है।

स्टेप 3: अपनी सर्विस और इंटरफेस बनाएं

अब हम कुछ सरल क्लास और इंटरफेस बनाएंगे जो सर्विस और उसके उपभोक्ता के रूप में काम करेंगे।

इंटरफेस (IMessageService.cs):

// IMessageService.cs
namespace ConsoleDIExample
{
    public interface IMessageService
    {
        void SendMessage(string message);
    }
}

सर्विस क्लास (EmailService.cs):

// EmailService.cs
namespace ConsoleDIExample
{
    public class EmailService : IMessageService
    {
        public void SendMessage(string message)
        {
            Console.WriteLine($"Sending Email: {message}");
        }
    }
}

सर्विस उपभोक्ता क्लास (App.cs):

// App.cs
namespace ConsoleDIExample
{
    public class App
    {
        private readonly IMessageService _messageService;

        public App(IMessageService messageService)
        {
            _messageService = messageService;
        }

        public void Run()
        {
            _messageService.SendMessage("Hello from Dependency Injection in Console App!");
        }
    }
}

स्टेप 4: डिपेंडेंसी इंजेक्शन कंटेनर सेट अप करें

अब Program.cs फ़ाइल में हम डिपेंडेंसी इंजेक्शन कंटेनर को सेट अप करेंगे, सर्विसेज को रजिस्टर करेंगे और फिर उनका उपयोग करेंगे। हम यहां जेनेरिक होस्ट का उपयोग करेंगे ताकि हम ASP.NET Core जैसे स्ट्रक्चर का लाभ उठा सकें।

// Program.cs
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using ConsoleDIExample;

class Program
{
    static async Task Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();

        using (var scope = host.Services.CreateScope())
        {
            var services = scope.ServiceProvider;
            try
            {
                var app = services.GetRequiredService();
                app.Run();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"एक त्रुटि हुई: {ex.Message}");
            }
        }

        await Task.Delay(1); 
        Console.WriteLine("प्रेस एनी की टू एग्जिट...");
        Console.ReadKey();
    }

    static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
        .ConfigureServices((hostContext, services) =>
        {
            services.AddTransient();
            services.AddTransient();
        });
}

कोड का स्पष्टीकरण:

1. CreateHostBuilder(args).Build();: यह जेनेरिक होस्ट का निर्माण करता है। .ConfigureServices() मेथड का उपयोग करके हम अपनी सर्विसेज को सर्विस कलेक्शन (IServiceCollection) में जोड़ते हैं।
2. services.AddTransient<IMessageService, EmailService>();: यह लाइन IMessageService इंटरफेस के लिए EmailService क्लास को रजिस्टर करती है।
• AddTransient<TService, TImplementation>(): हर बार जब आप TService का अनुरोध करते हैं, तो TImplementation का एक नया इंस्टेंस बनाया जाता है।
• AddScoped<TService, TImplementation>(): एक दिए गए स्कोप (जैसे कंसोल ऐप में एक CreateScope() के भीतर) के लिए एक ही इंस्टेंस बनाया जाता है।
• AddSingleton<TService, TImplementation>(): एप्लीकेशन के पूरे जीवनकाल के लिए TImplementation का केवल एक ही इंस्टेंस बनाया जाता है।
3. services.AddTransient<App>();: हम अपनी App क्लास को भी रजिस्टर करते हैं, क्योंकि यह भी एक सर्विस उपभोक्ता है।
4. using (var scope = host.Services.CreateScope()): यह सुनिश्चित करता है कि स्कोप खत्म होने पर स्कोपड सर्विसेज ठीक से डिस्पोज हो जाएं।
5. var app = services.GetRequiredService<App>();: यह लाइन डिपेंडेंसी इंजेक्शन कंटेनर से App क्लास का एक इंस्टेंस प्राप्त करती है।
6. app.Run();: अंत में, हम App क्लास के Run मेथड को कॉल करते हैं।

प्रोजेक्ट को चलाएं

अपने कंसोल एप्लीकेशन को चलाने के लिए, विजुअल स्टूडियो में F5 दबाएं या "Start Debugging" पर क्लिक करें। या .NET CLI का उपयोग करके: dotnet run कमांड को रन कीजिए।

आप देखेंगे कि आउटपुट में "Sending Email: Hello from Dependency Injection in Console App!" प्रिंट होता है। यह दर्शाता है कि App क्लास को EmailService का इंस्टेंस बिना मैन्युअल रूप से बनाए प्राप्त हो गया है।

इस उदाहरण के साथ, हमने देखा कि कैसे एक कंसोल एप्लीकेशन में Microsoft.Extensions.DependencyInjection और Microsoft.Extensions.Hosting पैकेजों का उपयोग करके डिपेंडेंसी इंजेक्शन कंटेनर को सेट अप किया जाता है। यह हमें टाइट कपलिंग (Tight Coupling) की समस्या से बचने और आपके कोड को अधिक मॉड्यूलर, टेस्टेबल और मैनेजेबल बनाने में मदद करता है।

---

Next: ASP.NET Core एप्लीकेशन में विभिन्न प्रकार की सर्विसेज का उपयोग