TypeScript में डिपेंडेंसी इंजेक्शन (Dependency Injection): एक संपूर्ण गाइड

TypeScript में Dependency Injection का परिचय

Dependency Injection (DI) एक प्रमुख डिज़ाइन पैटर्न है जो कमजोर रूप से जुड़े, परीक्षण योग्य और आसानी से रखरखाव योग्य एप्लिकेशन बनाने में मदद करता है। TypeScript के संदर्भ में, सख्त टाइपिंग और डेकोरेटर की क्षमताओं के कारण, DI का कार्यान्वयन विशेष रूप से सुरुचिपूर्ण और सुरक्षित हो जाता है।

इस लेख में, हम देखेंगे कि Dependency Injection क्या है, इसे TypeScript में कैसे लागू किया जाए, और कौन से उपकरण इस प्रक्रिया को सरल बना सकते हैं। आप सीखेंगे कि DI कैसे कक्षाओं के बीच कठोर संबंधों से निपटने में मदद करता है और आपके कोड को अधिक लचीला बनाता है।

Dependency Injection क्या है और इसकी आवश्यकता क्यों है?

Dependency Injection (निर्भरता इंजेक्शन) एक पैटर्न है जिसमें कोई ऑब्जेक्ट अपनी निर्भरताएँ बाहर से प्राप्त करता है, न कि उन्हें स्वयं बनाता है। यह Inversion of Control (IoC) के सिद्धांत को लागू करता है।

DI के बिना समस्या:

class Logger {    log(message: string): void {        console.log(message);    }}

class UserService {    private logger: Logger;

    constructor() {        this.logger = new Logger(); // कठोर संबंध    }

    createUser(name: string): void {        this.logger.log(`User ${name} created`);    }}

इस उदाहरण में, UserService Logger के एक विशिष्ट कार्यान्वयन से कठोर रूप से जुड़ा हुआ है। यदि हम लॉगर को, मान लीजिए, फ़ाइल या रिमोट लॉगर से बदलना चाहते हैं, तो हमें UserService का कोड बदलना होगा।

DI के साथ समाधान:

interface ILogger {    log(message: string): void;}

class ConsoleLogger implements ILogger {    log(message: string): void {        console.log(message);    }}

class FileLogger implements ILogger {    log(message: string): void {        // फ़ाइल में लिखना    }}

class UserService {    constructor(private logger: ILogger) {} // निर्भरता इंजेक्ट की गई

    createUser(name: string): void {        this.logger.log(`User ${name} created`);    }}

// उपयोगconst service = new UserService(new ConsoleLogger());

DI के लाभ:

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

TypeScript में मैन्युअल रूप से Dependency Injection का कार्यान्वयन

सबसे सरल तरीका है कंस्ट्रक्टर या प्रॉपर्टी के माध्यम से निर्भरताएँ इंजेक्ट करना। TypeScript अपने इंटरफ़ेस और एक्सेस मॉडिफायर के साथ इसे बहुत सुविधाजनक बनाता है।

कंस्ट्रक्टर के माध्यम से इंजेक्शन (Constructor Injection)

interface IRepository<T> {    getAll(): Promise<T[]>;    getById(id: number): Promise<T | null>;}

class UserRepository implements IRepository<User> {    async getAll(): Promise<User[]> {        // डेटाबेस के साथ वास्तविक कार्य तर्क        return [];    }

    async getById(id: number): Promise<User | null> {        return null;    }}

class UserController {    constructor(        private repository: IRepository<User>,        private logger: ILogger    ) {}

    async getUsers(): Promise<User[]> {        this.logger.log('Fetching users...');        return this.repository.getAll();    }}

// निर्भरता ग्राफ बनानाconst logger = new ConsoleLogger();const repository = new UserRepository();const controller = new UserController(repository, logger);

प्रॉपर्टी के माध्यम से इंजेक्शन (Property Injection)

class EmailService {    private sender!: ISender;

    setSender(sender: ISender): void {```