TypeScript में डिपेंडेंसी इंजेक्शन: उदाहरणों के साथ पूर्ण गाइड

TypeScript में डिपेंडेंसी इंजेक्शन क्या है और इसकी आवश्यकता क्यों है?

डिपेंडेंसी इंजेक्शन (DI) एक डिज़ाइन पैटर्न है जो इनवर्ज़न ऑफ़ कंट्रोल (IoC) सिद्धांत को लागू करता है। किसी ऑब्जेक्ट द्वारा स्वयं अपनी निर्भरताएँ बनाने के बजाय, उन्हें बाहर से "इंजेक्ट" किया जाता है। TypeScript में, सख्त टाइपिंग और डेकोरेटर की क्षमताओं के कारण यह पैटर्न विशेष रूप से उपयोगी है।

कल्पना करें कि आप एक ऑनलाइन स्टोर के लिए एप्लिकेशन बना रहे हैं। आपके पास एक OrderService क्लास है जिसे नोटिफिकेशन भेजने होंगे। DI के बिना, यह एक विशिष्ट भेजने के तरीके (जैसे, Email) से कसकर जुड़ा होगा। DI के साथ, आप OrderService के कोड को बदले बिना Email को SMS या Push-नोटिफिकेशन से आसानी से बदल सकते हैं।

TypeScript में DI का उपयोग क्यों करें?

• परीक्षण क्षमता: यूनिट टेस्ट में वास्तविक सेवाओं को mock-ऑब्जेक्ट से बदलना आसान है।
• लचीलापन: सिस्टम मॉड्यूलर बन जाता है, क्लाइंट कोड को बदले बिना निर्भरताएँ बदली जा सकती हैं।
• रखरखाव में सरलता: प्रत्येक क्लास केवल अपने व्यावसायिक तर्क के लिए जिम्मेदार है, न कि अन्य ऑब्जेक्ट बनाने के लिए।
• टाइप सुरक्षा: TypeScript कंपाइलेशन के समय टाइप की जाँच करता है, जिससे रनटाइम के दौरान त्रुटियाँ कम होती हैं।

फ्रेमवर्क के बिना TypeScript में DI का बुनियादी कार्यान्वयन

एक सरल उदाहरण से शुरू करते हैं। नोटिफिकेशन सेवा के लिए एक इंटरफ़ेस और इसके दो कार्यान्वयन बनाएँ।

// इंटरफ़ेस परिभाषित करेंinterface INotificationService {    send(message: string): void;}

// Email के लिए कार्यान्वयनclass EmailNotificationService implements INotificationService {    send(message: string): void {        console.log(`Email भेजा जा रहा है: ${message}`);    }}

// SMS के लिए कार्यान्वयनclass SMSNotificationService implements INotificationService {    send(message: string): void {        console.log(`SMS भेजा जा रहा है: ${message}`);    }}

// वह क्लास जो DI का उपयोग करता हैclass OrderService {    constructor(private notificationService: INotificationService) {}

    processOrder(orderId: number): void {        // ऑर्डर प्रोसेसिंग का तर्क        this.notificationService.send(`ऑर्डर #${orderId} संसाधित किया गया`);    }}

// उपयोगconst emailService = new EmailNotificationService();const orderService = new OrderService(emailService);orderService.processOrder(123); // Email भेजा जा रहा है: ऑर्डर #123 संसाधित किया गया

इस उदाहरण में, OrderService को यह नहीं पता कि कौन सी नोटिफिकेशन सेवा उपयोग की जा रही है। यह केवल इंटरफ़ेस के माध्यम से send विधि को कॉल करता है।

उन्नत DI: एक सरल IoC कंटेनर बनाना

बड़े प्रोजेक्ट्स के लिए, मैन्युअल रूप से निर्भरताएँ इंजेक्ट करना बोझिल हो जाता है। यहाँ IoC-कंटेनर मदद करता है। आइए देखें कि TypeScript डेकोरेटर का उपयोग करके इसे कैसे कार्यान्वित किया जाए।

चरण 1: tsconfig.json में डेकोरेटर के लिए समर्थन सक्षम करें

{    "compilerOptions": {        "experimentalDecorators": true,        "emitDecoratorMetadata": true    }}

चरण 2: DI कंटेनर बनाएँ

// di-container.tstype Constructor<T> = new (...args: any[]) => T;

class DIContainer {    private services = new Map<string, any>();

    register<T>(token: string, implementation: Constructor<T>): void {        this.services.set(token, implementation);    }

    resolve<T>(token: string): T {        const Implementation = this.services.get(token);        if (!Implementation) {            throw new Error(`सेवा "${token}" पंजीकृत नहीं है`);        }

        // रिफ्लेक्शन के माध्यम से कंस्ट्रक्टर के पैरामीटर प्रकार प्राप्त करें        const paramTypes: Constructor<any>[] =             Reflect.getMetadata('design:paramtypes', Implementation) || [];

        // निर्भरताओं को पुनरावर्ती रूप से हल करें        const dependencies = param