சார்பு உட்செலுத்துதல்: வலுவான பயன்பாடுகளுக்கான கட்டுப்பாட்டின் தலைகீழ் மாற்றத்தில் தேர்ச்சி பெறுதல்

மென்பொருள் மேம்பாட்டுத் துறையில், வலுவான, பராமரிக்கக்கூடிய, மற்றும் அளவிடக்கூடிய பயன்பாடுகளை உருவாக்குவது மிக முக்கியமானது. சார்பு உட்செலுத்துதல் (DI) மற்றும் கட்டுப்பாட்டின் தலைகீழ் மாற்றம் (IoC) ஆகியவை டெவலப்பர்கள் இந்த இலக்குகளை அடைய உதவும் முக்கியமான வடிவமைப்பு கொள்கைகளாகும். இந்த விரிவான வழிகாட்டி DI மற்றும் IoC பற்றிய கருத்துக்களை ஆராய்ந்து, இந்த அத்தியாவசிய நுட்பங்களில் தேர்ச்சி பெற உங்களுக்கு உதவும் நடைமுறை எடுத்துக்காட்டுகள் மற்றும் செயல் நுண்ணறிவுகளை வழங்குகிறது.

கட்டுப்பாட்டின் தலைகீழ் மாற்றம் (IoC) என்பதைப் புரிந்துகொள்ளுதல்

கட்டுப்பாட்டின் தலைகீழ் மாற்றம் (IoC) என்பது ஒரு வடிவமைப்பு கொள்கையாகும், இதில் ஒரு நிரலின் கட்டுப்பாட்டு ஓட்டம் பாரம்பரிய நிரலாக்கத்துடன் ஒப்பிடும்போது தலைகீழாக மாற்றப்படுகிறது. பொருள்கள் தங்கள் சார்புகளை உருவாக்கி நிர்வகிப்பதற்குப் பதிலாக, அந்தப் பொறுப்பு ஒரு வெளிப்புற நிறுவனத்திற்கு, பொதுவாக ஒரு IoC கொள்கலன் அல்லது கட்டமைப்பிற்கு வழங்கப்படுகிறது. இந்த கட்டுப்பாட்டின் தலைகீழ் மாற்றம் பல நன்மைகளுக்கு வழிவகுக்கிறது, அவற்றுள்:

• தளர்வான இணைப்பு: பொருள்கள் குறைவாக இறுக்கமாக இணைக்கப்பட்டுள்ளன, ஏனெனில் அவை தங்கள் சார்புகளை எப்படி உருவாக்குவது அல்லது கண்டுபிடிப்பது என்று தெரிந்து கொள்ள வேண்டியதில்லை.
• அதிகரிக்கப்பட்ட சோதிக்கக்கூடிய தன்மை: அலகு சோதனைக்காக சார்புகளை எளிதாக போலி (mock) அல்லது ஸ்டப் (stub) செய்யலாம்.
• மேம்பட்ட பராமரிப்பு: சார்புகளில் செய்யப்படும் மாற்றங்களுக்கு சார்பு பொருள்களில் மாற்றங்கள் தேவையில்லை.
• மேம்படுத்தப்பட்ட மறுபயன்பாடு: பொருள்களை வெவ்வேறு சூழல்களில் வெவ்வேறு சார்புகளுடன் எளிதாக மீண்டும் பயன்படுத்தலாம்.

பாரம்பரிய கட்டுப்பாட்டு ஓட்டம்

பாரம்பரிய நிரலாக்கத்தில், ஒரு வகுப்பு பொதுவாக அதன் சொந்த சார்புகளை நேரடியாக உருவாக்குகிறது. உதாரணமாக:

class ProductService {
  private $database;

  public function __construct() {
    $this->database = new DatabaseConnection("localhost", "username", "password");
  }

  public function getProduct(int $id) {
    return $this->database->query("SELECT * FROM products WHERE id = " . $id);
  }
}

இந்த அணுகுமுறை ProductService மற்றும் DatabaseConnection இடையே ஒரு இறுக்கமான இணைப்பை உருவாக்குகிறது. ProductService ஆனது DatabaseConnection-ஐ உருவாக்குவதற்கும் நிர்வகிப்பதற்கும் பொறுப்பாகிறது, இது சோதனை செய்வதையும் மறுபயன்பாடு செய்வதையும் கடினமாக்குகிறது.

IoC உடன் தலைகீழ் கட்டுப்பாட்டு ஓட்டம்

IoC உடன், ProductService ஆனது DatabaseConnection-ஐ ஒரு சார்பாகப் பெறுகிறது:

class ProductService {
  private $database;

  public function __construct(DatabaseConnection $database) {
    $this->database = $database;
  }

  public function getProduct(int $id) {
    return $this->database->query("SELECT * FROM products WHERE id = " . $id);
  }
}

இப்போது, ProductService ஆனது DatabaseConnection-ஐ தானாக உருவாக்குவதில்லை. அது சார்பை வழங்க ஒரு வெளிப்புற நிறுவனத்தை நம்பியுள்ளது. இந்த கட்டுப்பாட்டின் தலைகீழ் மாற்றம் ProductService-ஐ மேலும் நெகிழ்வானதாகவும் சோதிக்கக்கூடியதாகவும் ஆக்குகிறது.

சார்பு உட்செலுத்துதல் (DI): IoC-ஐ செயல்படுத்துதல்

சார்பு உட்செலுத்துதல் (DI) என்பது கட்டுப்பாட்டின் தலைகீழ் மாற்றம் கொள்கையை செயல்படுத்தும் ஒரு வடிவமைப்பு முறையாகும். இது ஒரு பொருளின் சார்புகளை, அந்தப் பொருள் தானாக உருவாக்குவதற்குப் பதிலாக, அதற்கு வழங்குவதை உள்ளடக்கியது. சார்பு உட்செலுத்துதலில் மூன்று முக்கிய வகைகள் உள்ளன:

• கன்ஸ்ட்ரக்டர் உட்செலுத்துதல்: வகுப்பின் கன்ஸ்ட்ரக்டர் மூலம் சார்புகள் வழங்கப்படுகின்றன.
• செட்டர் உட்செலுத்துதல்: வகுப்பின் செட்டர் முறைகள் மூலம் சார்புகள் வழங்கப்படுகின்றன.
• இன்டர்ஃபேஸ் உட்செலுத்துதல்: வகுப்பால் செயல்படுத்தப்படும் ஒரு இன்டர்ஃபேஸ் மூலம் சார்புகள் வழங்கப்படுகின்றன.

கன்ஸ்ட்ரக்டர் உட்செலுத்துதல்

கன்ஸ்ட்ரக்டர் உட்செலுத்துதல் என்பது DI-யின் மிகவும் பொதுவான மற்றும் பரிந்துரைக்கப்படும் வகையாகும். இது பொருள் உருவாக்கப்படும் நேரத்தில் அதன் தேவையான அனைத்து சார்புகளையும் பெறுவதை உறுதி செய்கிறது.

class UserService {
  private $userRepository;

  public function __construct(UserRepository $userRepository) {
    $this->userRepository = $userRepository;
  }

  public function getUser(int $id) {
    return $this->userRepository->find($id);
  }
}

// எடுத்துக்காட்டு பயன்பாடு:
$userRepository = new UserRepository(new DatabaseConnection());
$userService = new UserService($userRepository);
$user = $userService->getUser(123);

இந்த எடுத்துக்காட்டில், UserService அதன் கன்ஸ்ட்ரக்டர் மூலம் ஒரு UserRepository நிகழ்வைப் பெறுகிறது. இது ஒரு போலி UserRepository-ஐ வழங்குவதன் மூலம் UserService-ஐ சோதிப்பதை எளிதாக்குகிறது.

செட்டர் உட்செலுத்துதல்

செட்டர் உட்செலுத்துதல், பொருள் உருவாக்கப்பட்ட பிறகு சார்புகளை உட்செலுத்த அனுமதிக்கிறது.

class OrderService {
  private $paymentGateway;

  public function setPaymentGateway(PaymentGateway $paymentGateway) {
    $this->paymentGateway = $paymentGateway;
  }

  public function processOrder(Order $order) {
    $this->paymentGateway->processPayment($order->getTotal());
    // ...
  }
}

// எடுத்துக்காட்டு பயன்பாடு:
$orderService = new OrderService();
$orderService->setPaymentGateway(new PayPalGateway());
$orderService->processOrder($order);

ஒரு சார்பு விருப்பத் தேர்வாக இருக்கும்போது அல்லது இயக்க நேரத்தில் மாற்றப்படக்கூடியதாக இருக்கும்போது செட்டர் உட்செலுத்துதல் பயனுள்ளதாக இருக்கும். இருப்பினும், இது பொருளின் சார்புகளை குறைவாக தெளிவாக மாற்றக்கூடும்.

இன்டர்ஃபேஸ் உட்செலுத்துதல்

இன்டர்ஃபேஸ் உட்செலுத்துதல் என்பது சார்பு உட்செலுத்துதல் முறையைக் குறிப்பிடும் ஒரு இன்டர்ஃபேஸை வரையறுப்பதை உள்ளடக்கியது.

interface Injectable {
  public function setDependency(Dependency $dependency);
}

class ReportGenerator implements Injectable {
  private $dataSource;

  public function setDependency(Dependency $dataSource) {
    $this->dataSource = $dataSource;
  }

  public function generateReport() {
    // அறிக்கையை உருவாக்க $this->dataSource-ஐப் பயன்படுத்தவும்
  }
}

// எடுத்துக்காட்டு பயன்பாடு:
$reportGenerator = new ReportGenerator();
$reportGenerator->setDependency(new MySQLDataSource());
$reportGenerator->generateReport();

ஒரு குறிப்பிட்ட சார்பு உட்செலுத்துதல் ஒப்பந்தத்தை அமல்படுத்த விரும்பும்போது இன்டர்ஃபேஸ் உட்செலுத்துதல் பயனுள்ளதாக இருக்கும். இருப்பினும், இது குறியீட்டில் சிக்கலையும் சேர்க்கலாம்.

IoC கொள்கலன்கள்: சார்பு உட்செலுத்துதலை தானியக்கமாக்குதல்

சார்புகளை கைமுறையாக நிர்வகிப்பது, குறிப்பாக பெரிய பயன்பாடுகளில், கடினமானதாகவும் பிழை ஏற்படக்கூடியதாகவும் மாறும். IoC கொள்கலன்கள் (சார்பு உட்செலுத்தல் கொள்கலன்கள் என்றும் அழைக்கப்படுகின்றன) சார்புகளை உருவாக்குதல் மற்றும் உட்செலுத்துதல் செயல்முறையை தானியக்கமாக்கும் கட்டமைப்புகள் ஆகும். அவை சார்புகளை உள்ளமைக்கவும், இயக்க நேரத்தில் அவற்றை தீர்க்கவும் ஒரு மையப்படுத்தப்பட்ட இடத்தை வழங்குகின்றன.

IoC கொள்கலன்களைப் பயன்படுத்துவதன் நன்மைகள்

• எளிமைப்படுத்தப்பட்ட சார்பு மேலாண்மை: IoC கொள்கலன்கள் சார்புகளை உருவாக்குவதையும் உட்செலுத்துவதையும் தானாகவே கையாளுகின்றன.
• மையப்படுத்தப்பட்ட உள்ளமைவு: சார்புகள் ஒரே இடத்தில் உள்ளமைக்கப்படுகின்றன, இது பயன்பாட்டை நிர்வகிப்பதையும் பராமரிப்பதையும் எளிதாக்குகிறது.
• மேம்பட்ட சோதிக்கக்கூடிய தன்மை: IoC கொள்கலன்கள் சோதனை நோக்கங்களுக்காக வெவ்வேறு சார்புகளை உள்ளமைப்பதை எளிதாக்குகின்றன.
• மேம்படுத்தப்பட்ட மறுபயன்பாடு: IoC கொள்கலன்கள் பொருள்களை வெவ்வேறு சூழல்களில் வெவ்வேறு சார்புகளுடன் எளிதாக மீண்டும் பயன்படுத்த அனுமதிக்கின்றன.

பிரபலமான IoC கொள்கலன்கள்

பல்வேறு நிரலாக்க மொழிகளுக்கு பல IoC கொள்கலன்கள் கிடைக்கின்றன. சில பிரபலமான எடுத்துக்காட்டுகள் பின்வருமாறு:

• ஸ்பிரிங் ஃபிரேம்வொர்க் (ஜாவா): ஒரு சக்திவாய்ந்த IoC கொள்கலனை உள்ளடக்கிய ஒரு விரிவான கட்டமைப்பு.
• .NET சார்பு உட்செலுத்துதல் (C#): .NET கோர் மற்றும் .NET இல் உள்ளமைக்கப்பட்ட DI கொள்கலன்.
• லாரவெல் (PHP): ஒரு வலுவான IoC கொள்கலனுடன் கூடிய ஒரு பிரபலமான PHP கட்டமைப்பு.
• சிம்பொனி (PHP): ஒரு மேம்பட்ட DI கொள்கலனுடன் கூடிய மற்றொரு பிரபலமான PHP கட்டமைப்பு.
• ஆங்குலர் (டைப்ஸ்கிரிப்ட்): உள்ளமைக்கப்பட்ட சார்பு உட்செலுத்துதலுடன் கூடிய ஒரு முன்-இறுதி கட்டமைப்பு.
• நெஸ்ட்ஜேஎஸ் (டைப்ஸ்கிரிப்ட்): அளவிடக்கூடிய சர்வர்-பக்க பயன்பாடுகளை உருவாக்குவதற்கான ஒரு Node.js கட்டமைப்பு.

லாரவெல்லின் IoC கொள்கலன் (PHP) ஐப் பயன்படுத்தி எடுத்துக்காட்டு

// ஒரு இன்டர்ஃபேஸை ஒரு உறுதியான செயலாக்கத்துடன் பிணைக்கவும்
use App\Interfaces\PaymentGatewayInterface;
use App\Services\PayPalGateway;

$this->app->bind(PaymentGatewayInterface::class, PayPalGateway::class);

// சார்பை தீர்க்கவும்
use App\Http\Controllers\OrderController;

public function store(Request $request, PaymentGatewayInterface $paymentGateway) {
    // $paymentGateway தானாகவே உட்செலுத்தப்படுகிறது
    $order = new Order($request->all());
    $paymentGateway->processPayment($order->total);
    // ...
}

இந்த எடுத்துக்காட்டில், லாரவெல்லின் IoC கொள்கலன் OrderController-இல் உள்ள PaymentGatewayInterface சார்பை தானாகவே தீர்த்து, PayPalGateway-இன் ஒரு நிகழ்வை உட்செலுத்துகிறது.

சார்பு உட்செலுத்துதல் மற்றும் கட்டுப்பாட்டின் தலைகீழ் மாற்றம் ஆகியவற்றின் நன்மைகள்

DI மற்றும் IoC-ஐ ஏற்றுக்கொள்வது மென்பொருள் மேம்பாட்டிற்கு பல நன்மைகளை வழங்குகிறது:

அதிகரிக்கப்பட்ட சோதிக்கக்கூடிய தன்மை

DI அலகு சோதனைகளை எழுதுவதை கணிசமாக எளிதாக்குகிறது. போலி அல்லது ஸ்டப் சார்புகளை உட்செலுத்துவதன் மூலம், நீங்கள் சோதிக்கப்படும் கூறுகளை தனிமைப்படுத்தி, வெளிப்புற அமைப்புகள் அல்லது தரவுத்தளங்களைச் சாராமல் அதன் நடத்தையை சரிபார்க்கலாம். உங்கள் குறியீட்டின் தரம் மற்றும் நம்பகத்தன்மையை உறுதி செய்வதற்கு இது முக்கியமானது.

தளர்வான இணைப்பு

தளர்வான இணைப்பு என்பது நல்ல மென்பொருள் வடிவமைப்பின் ஒரு முக்கிய கொள்கையாகும். DI பொருள்களுக்கு இடையேயான சார்புகளைக் குறைப்பதன் மூலம் தளர்வான இணைப்பை ஊக்குவிக்கிறது. இது குறியீட்டை மேலும் மட்டுப்படுத்தப்பட்டதாகவும், நெகிழ்வானதாகவும், பராமரிக்க எளிதாகவும் ஆக்குகிறது. ஒரு கூறில் செய்யப்படும் மாற்றங்கள் பயன்பாட்டின் பிற பகுதிகளை பாதிக்கும் வாய்ப்பு குறைவு.

மேம்பட்ட பராமரிப்பு

DI உடன் உருவாக்கப்பட்ட பயன்பாடுகள் பொதுவாக பராமரிக்கவும் மாற்றியமைக்கவும் எளிதானவை. மட்டுப்படுத்தப்பட்ட வடிவமைப்பு மற்றும் தளர்வான இணைப்பு ஆகியவை குறியீட்டைப் புரிந்துகொள்வதையும், எதிர்பாராத பக்க விளைவுகளை அறிமுகப்படுத்தாமல் மாற்றங்களைச் செய்வதையும் எளிதாக்குகின்றன. காலப்போக்கில் உருவாகும் நீண்டகால திட்டங்களுக்கு இது மிகவும் முக்கியமானது.

மேம்படுத்தப்பட்ட மறுபயன்பாடு

DI கூறுகளை மேலும் சுதந்திரமானதாகவும், தன்னிறைவு பெற்றதாகவும் ஆக்குவதன் மூலம் குறியீடு மறுபயன்பாட்டை ஊக்குவிக்கிறது. கூறுகளை வெவ்வேறு சூழல்களில் வெவ்வேறு சார்புகளுடன் எளிதாக மீண்டும் பயன்படுத்தலாம், இது குறியீடு நகலெடுப்பின் தேவையைக் குறைத்து, மேம்பாட்டு செயல்முறையின் ஒட்டுமொத்த செயல்திறனை மேம்படுத்துகிறது.

அதிகரிக்கப்பட்ட மட்டுப்படுத்தல்

DI ஒரு மட்டுப்படுத்தப்பட்ட வடிவமைப்பை ஊக்குவிக்கிறது, அங்கு பயன்பாடு சிறிய, சுதந்திரமான கூறுகளாகப் பிரிக்கப்பட்டுள்ளது. இது குறியீட்டைப் புரிந்துகொள்வதையும், அதைச் சோதிப்பதையும், மாற்றியமைப்பதையும் எளிதாக்குகிறது. இது வெவ்வேறு குழுக்கள் ஒரே நேரத்தில் பயன்பாட்டின் வெவ்வேறு பகுதிகளில் வேலை செய்யவும் அனுமதிக்கிறது.

எளிமைப்படுத்தப்பட்ட உள்ளமைவு

IoC கொள்கலன்கள் சார்புகளை உள்ளமைக்க ஒரு மையப்படுத்தப்பட்ட இடத்தை வழங்குகின்றன, இது பயன்பாட்டை நிர்வகிப்பதையும் பராமரிப்பதையும் எளிதாக்குகிறது. இது கைமுறை உள்ளமைவின் தேவையைக் குறைத்து, பயன்பாட்டின் ஒட்டுமொத்த நிலைத்தன்மையை மேம்படுத்துகிறது.

சார்பு உட்செலுத்துதலுக்கான சிறந்த நடைமுறைகள்

DI மற்றும் IoC-ஐ திறம்பட பயன்படுத்த, இந்த சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

• கன்ஸ்ட்ரக்டர் உட்செலுத்துதலை விரும்புங்கள்: முடிந்தவரை கன்ஸ்ட்ரக்டர் உட்செலுத்துதலைப் பயன்படுத்தவும், பொருள்கள் உருவாக்கப்படும் நேரத்தில் அவற்றின் தேவையான அனைத்து சார்புகளையும் பெறுவதை உறுதிசெய்யவும்.
• சேவை இருப்பிட முறையை (Service Locator Pattern) தவிர்க்கவும்: சேவை இருப்பிட முறை சார்புகளை மறைத்து, குறியீட்டை சோதிப்பதை கடினமாக்கலாம். அதற்கு பதிலாக DI-ஐ விரும்புங்கள்.
• இன்டர்ஃபேஸ்களைப் பயன்படுத்துங்கள்: உங்கள் சார்புகளுக்கு இன்டர்ஃபேஸ்களை வரையறுத்து, தளர்வான இணைப்பை ஊக்குவிக்கவும், சோதிக்கக்கூடிய தன்மையை மேம்படுத்தவும்.
• சார்புகளை ஒரு மையப்படுத்தப்பட்ட இடத்தில் உள்ளமைக்கவும்: சார்புகளை நிர்வகிக்க ஒரு IoC கொள்கலனைப் பயன்படுத்தி, அவற்றை ஒரே இடத்தில் உள்ளமைக்கவும்.
• SOLID கொள்கைகளைப் பின்பற்றவும்: DI மற்றும் IoC ஆகியவை பொருள் சார்ந்த வடிவமைப்பின் SOLID கொள்கைகளுடன் நெருக்கமாக தொடர்புடையவை. வலுவான மற்றும் பராமரிக்கக்கூடிய குறியீட்டை உருவாக்க இந்தக் கொள்கைகளைப் பின்பற்றவும்.
• தானியங்கு சோதனையைப் பயன்படுத்தவும்: உங்கள் குறியீட்டின் நடத்தையை சரிபார்க்கவும், DI சரியாக வேலை செய்கிறதா என்பதை உறுதிப்படுத்தவும் அலகு சோதனைகளை எழுதவும்.

பொதுவான எதிர்-முறைகள்

சார்பு உட்செலுத்துதல் ஒரு சக்திவாய்ந்த கருவியாக இருந்தாலும், அதன் நன்மைகளை குறைமதிப்பிற்கு உட்படுத்தக்கூடிய பொதுவான எதிர்-முறைகளைத் தவிர்ப்பது முக்கியம்:

• அதிகப்படியான சுருக்கம்: உண்மையான மதிப்பை வழங்காமல் சிக்கலைச் சேர்க்கும் தேவையற்ற சுருக்கங்கள் அல்லது இன்டர்ஃபேஸ்களை உருவாக்குவதைத் தவிர்க்கவும்.
• மறைக்கப்பட்ட சார்புகள்: அனைத்து சார்புகளும் குறியீட்டிற்குள் மறைக்கப்படாமல், தெளிவாக வரையறுக்கப்பட்டு உட்செலுத்தப்படுவதை உறுதிசெய்யவும்.
• கூறுகளில் பொருள் உருவாக்கும் தர்க்கம்: கூறுகள் தங்கள் சொந்த சார்புகளை உருவாக்குவதற்கோ அல்லது அவற்றின் வாழ்க்கைச் சுழற்சியை நிர்வகிப்பதற்கோ பொறுப்பாக இருக்கக்கூடாது. இந்தப் பொறுப்பு ஒரு IoC கொள்கலனுக்கு வழங்கப்பட வேண்டும்.
• IoC கொள்கலனுடன் இறுக்கமான இணைப்பு: உங்கள் குறியீட்டை ஒரு குறிப்பிட்ட IoC கொள்கலனுடன் இறுக்கமாக இணைப்பதைத் தவிர்க்கவும். கொள்கலனின் API- மீதான சார்பைக் குறைக்க இன்டர்ஃபேஸ்கள் மற்றும் சுருக்கங்களைப் பயன்படுத்தவும்.

பல்வேறு நிரலாக்க மொழிகள் மற்றும் கட்டமைப்புகளில் சார்பு உட்செலுத்துதல்

DI மற்றும் IoC ஆகியவை பல்வேறு நிரலாக்க மொழிகள் மற்றும் கட்டமைப்புகளில் பரவலாக ஆதரிக்கப்படுகின்றன. இங்கே சில எடுத்துக்காட்டுகள் உள்ளன:

ஜாவா

ஜாவா டெவலப்பர்கள் பெரும்பாலும் சார்பு உட்செலுத்துதலுக்காக ஸ்பிரிங் ஃபிரேம்வொர்க் அல்லது குய்ஸ் போன்ற கட்டமைப்புகளைப் பயன்படுத்துகின்றனர்.

@Component
public class ProductServiceImpl implements ProductService {

    private final ProductRepository productRepository;

    @Autowired
    public ProductServiceImpl(ProductRepository productRepository) {
        this.productRepository = productRepository;
    }

    // ...
}

C#

.NET உள்ளமைக்கப்பட்ட சார்பு உட்செலுத்துதல் ஆதரவை வழங்குகிறது. நீங்கள் Microsoft.Extensions.DependencyInjection தொகுப்பைப் பயன்படுத்தலாம்.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient();
        services.AddTransient();
    }
}

பைதான்

பைதான் DI-ஐ செயல்படுத்த injector மற்றும் dependency_injector போன்ற நூலகங்களை வழங்குகிறது.

from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer):
    database = providers.Singleton(Database, db_url="localhost")
    user_repository = providers.Factory(UserRepository, database=database)
    user_service = providers.Factory(UserService, user_repository=user_repository)

container = Container()
user_service = container.user_service()

ஜாவாஸ்கிரிப்ட்/டைப்ஸ்கிரிப்ட்

ஆங்குலர் மற்றும் நெஸ்ட்ஜேஎஸ் போன்ற கட்டமைப்புகள் உள்ளமைக்கப்பட்ட சார்பு உட்செலுத்துதல் திறன்களைக் கொண்டுள்ளன.

import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root',
})
export class ProductService {
  constructor(private http: HttpClient) {}

  // ...
}

நிஜ உலக எடுத்துக்காட்டுகள் மற்றும் பயன்பாட்டு வழக்குகள்

சார்பு உட்செலுத்துதல் பரந்த அளவிலான சூழ்நிலைகளில் பொருந்தும். இங்கே சில நிஜ உலக எடுத்துக்காட்டுகள் உள்ளன:

• தரவுத்தள அணுகல்: ஒரு சேவைக்குள் நேரடியாக ஒரு தரவுத்தள இணைப்பு அல்லது ரெபோசிட்டரியை உருவாக்குவதற்குப் பதிலாக அதை உட்செலுத்துதல்.
• பதிவுசெய்தல்: சேவையை மாற்றியமைக்காமல் வெவ்வேறு பதிவுசெய்தல் செயலாக்கங்களைப் பயன்படுத்த அனுமதிக்க ஒரு லாகர் நிகழ்வை உட்செலுத்துதல்.
• கட்டண நுழைவாயில்கள்: வெவ்வேறு கட்டண வழங்குநர்களை ஆதரிக்க ஒரு கட்டண நுழைவாயிலை உட்செலுத்துதல்.
• தற்காலிக சேமிப்பு: செயல்திறனை மேம்படுத்த ஒரு கேச் வழங்குநரை உட்செலுத்துதல்.
• செய்தி வரிசைகள்: ஒத்திசைவற்ற முறையில் தொடர்பு கொள்ளும் கூறுகளைப் பிரிக்க ஒரு செய்தி வரிசை கிளையண்டை உட்செலுத்துதல்.

முடிவுரை

சார்பு உட்செலுத்துதல் மற்றும் கட்டுப்பாட்டின் தலைகீழ் மாற்றம் ஆகியவை மென்பொருள் பயன்பாடுகளின் தளர்வான இணைப்பை ஊக்குவிக்கும், சோதிக்கக்கூடிய தன்மையை மேம்படுத்தும், மற்றும் பராமரிப்பை மேம்படுத்தும் அடிப்படைக் வடிவமைப்பு கொள்கைகளாகும். இந்த நுட்பங்களில் தேர்ச்சி பெற்று, IoC கொள்கலன்களை திறம்படப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் மேலும் வலுவான, அளவிடக்கூடிய மற்றும் மாற்றியமைக்கக்கூடிய அமைப்புகளை உருவாக்க முடியும். நவீன மேம்பாட்டின் கோரிக்கைகளை பூர்த்தி செய்யும் உயர்தர மென்பொருளை உருவாக்குவதில் DI/IoC-ஐ ஏற்றுக்கொள்வது ஒரு முக்கியமான படியாகும்.