Dependency injection
http://dbpedia.org/resource/Dependency_injection an entity of type: WikicatSoftwareDesignPatterns
Vkládání závislostí (anglicky Dependency injection (DI)) je v objektově orientovaném programování technika pro vkládání závislostí mezi jednotlivými komponentami programu tak, aby jedna komponenta mohla používat druhou, aniž by na ni měla v době sestavování programu referenci. Dependency injection lze chápat jako novější název pro Inversion of Control (IoC), ale v užším významu.[zdroj?] Jedná se o konkrétní techniku IoC.
rdf:langString
Als Dependency Injection (DI, englisch dependency ‚Abhängigkeit‘ und injection ‚Injektion‘, deutsch Abhängigkeitsinjektion oder Einbringen von Abhängigkeiten) wird in der objektorientierten Programmierung ein Entwurfsmuster bezeichnet, welches die Abhängigkeiten eines Objekts zur Laufzeit reglementiert: Benötigt ein Objekt beispielsweise bei seiner Initialisierung ein anderes Objekt, ist diese Abhängigkeit an einem zentralen Ort hinterlegt – es wird also nicht vom initialisierten Objekt selbst erzeugt.
rdf:langString
L'injection de dépendances (dependency injection en anglais) est un mécanisme qui permet d'implémenter le principe de l'inversion de contrôle. Il consiste à créer dynamiquement (injecter) les dépendances entre les différents objets en s'appuyant sur une description (fichier de configuration ou métadonnées) ou de manière programmatique. Ainsi les dépendances entre composants logiciels ne sont plus exprimées dans le code de manière statique mais déterminées dynamiquement à l'exécution.
rdf:langString
依存性の注入（いぞんせいのちゅうにゅう、英: Dependency injection）とは、あるオブジェクトや関数が、依存する他のオブジェクトや関数を受け取るデザインパターンである。英語の頭文字からDIと略される。DIは制御の反転の一種で、オブジェクトの作成と利用について関心の分離を行い、疎結合なプログラムを実現することを目的としている。 dependencyを「依存性」と訳すのは本来の意味 から外れているため「依存オブジェクト注入」の用語を採用する文献も複数存在する。
rdf:langString
Dependency injection is een geavanceerd ontwerppatroon uit de informatica dat het mogelijk maakt klassen losjes te koppelen. Dit wil zeggen dat ze data kunnen uitwisselen zonder dat deze relatie hard (in de broncode) vastgelegd is; althans niet door de programmeurs van die (beide) klassen. Traditioneel gebeurt dat vaak wel, waardoor die klassen moeilijk te hergebruiken zijn. Soms wordt 'dependency injection' gezien als een bijzondere vorm van 'inversion of control', wat voor het eerst beschreven werd door Martin Fowler.
rdf:langString
在软件工程中，依赖注入（dependency injection，缩写为 DI）是一种软件设计模式，也是实现控制反转的其中一种技术。這种模式能让一个物件接收它所依赖的其他物件。“依赖”是指接收方所需的对象。“注入”是指将“依赖”传递给接收方的过程。在“注入”之后，接收方才会调用该“依赖”。此模式确保了任何想要使用给定服务的物件不需要知道如何建立這些服务。取而代之的是，连接收方物件（像是 client）也不知道它存在的外部代码（注入器）提供接收方所需的服务。 注：编程语言层次下，“接收方”为对象和 class，“依赖”为变量。在提供服务的角度下，“接收方”为客户端，“依赖”为服务。 该设计的目的是为了分离关注点，分离接收方和依赖，从而提供松耦合以及代码重用性。 传统编程方式，客户对象自己创建一个服务实例并使用它。这带来的缺点和问题是：
* 如果使用不同类型的服务对象，就需要修改、重新编译客户类。
* 客户类需要通过配置来适配服务类及服务类的依赖。如果程序有多个类都使用同一个服务类，这些配置就会变得复杂并分散在程序各处。
* 难以单元测试。本来需要使用服务类的 mock 或 stub，在这种方式下不太可行。 依赖注入可以解决上述问题：
* 使用接口或抽象基类，来抽象化依赖实现。
* 依赖在一个服务容器中注册。客户类构造函数被注入服务实例。框架负责创建依赖实例并在没有使用者时销毁它。
rdf:langString
Внедрение зависимости (англ. Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (англ. Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму.
rdf:langString
في هندسة البرمجيات، يعد حقن التبعية (بالإنجليزية: dependency injection) تقنية يتلقى فيها كائن كائنات أخرى يعتمد عليها. تسمى هذه الكائنات الأخرى التبعيات. في العلاقة النموذجية «باستخدام» يسمى الكائن المتلقي عميل (بالإنجليزية: Client) ويسمى الكائن الذي تم تمريره (أي تم حقنه) خدمة (بالإنجليزية: Service). يمكن أن يكون الكود الذي ينقل الخدمة إلى العميل أنواعًا كثيرة ويسمى الحاقن. بدلاً من تحديد العميل للخدمة التي سيستخدمها، يخبر الحاقن العميل بالخدمة التي سيستخدمها. تشير «الحقن» إلى تمرير التبعية (خدمة) إلى الكائن (العميل) الذي قد يستخدمها.
rdf:langString
In software engineering, dependency injection is a design pattern in which an object or function receives other objects or functions that it depends on. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services. Instead, the receiving 'client' (object or function) is provided with its dependencies by external code (an 'injector'), which it is not aware of. Dependency injection helps by making implicit dependencies explicit and helps solve the following problems:
rdf:langString
En informática, inyección de dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase la que cree dichos objetos. Esos objetos cumplen contratos que necesitan nuestras clases para poder funcionar (de ahí el concepto de dependencia). Nuestras clases no crean los objetos que necesitan, sino que se los suministra otra clase 'contenedora' que inyectará la implementación deseada a nuestro contrato.
rdf:langString
Dependency injection (DI) è un design pattern della Programmazione orientata agli oggetti il cui scopo è quello di semplificare lo sviluppo e migliorare la testabilità di software di grandi dimensioni. Il pattern Dependency Injection coinvolge almeno tre elementi:
* una componente dipendente,
* la dichiarazione delle dipendenze del componente, definite come interface contract,
* un injector (chiamato anche provider o container) che crea, a richiesta, le istanze delle classi che implementano delle dependency interface.
rdf:langString
소프트웨어 엔지니어링에서 의존성 주입(dependency injection)은 하나의 객체가 다른 객체의 의존성을 제공하는 테크닉이다. "의존성"은 예를 들어 서비스로 사용할 수 있는 객체이다. 클라이언트가 어떤 서비스를 사용할 것인지 지정하는 대신, 클라이언트에게 무슨 서비스를 사용할 것인지를 말해주는 것이다. "주입"은 의존성(서비스)을 사용하려는 객체(클라이언트)로 전달하는 것을 의미한다. 서비스는 클라이언트 상태의 일부이다. 클라이언트가 서비스를 구축하거나 찾는 것을 허용하는 대신 클라이언트에게 서비스를 전달하는 것이 패턴의 기본 요건이다. 의존성 주입의 의도는 객체의 생성과 사용의 관심을 분리하는 것이다. 이는 가독성과 코드 재사용을 높혀준다.
rdf:langString
Wstrzykiwanie zależności (ang. Dependency Injection, DI) – wzorzec projektowy i wzorzec architektury oprogramowania polegający na usuwaniu bezpośrednich zależności pomiędzy komponentami na rzecz architektury typu plug-in. Polega na przekazywaniu gotowych, utworzonych instancji obiektów udostępniających swoje metody i właściwości obiektom, które z nich korzystają (np. jako parametry konstruktora). Stanowi alternatywę do podejścia, gdzie obiekty tworzą instancję obiektów, z których korzystają np. we własnym konstruktorze. DI jest sposobem osiągnięcia (ang. loose coupling).
rdf:langString
Injeção de dependência (Dependency Injection, em inglês) é um padrão de desenvolvimento de programas de computadores utilizado quando é necessário manter baixo o nível de acoplamento entre diferentes módulos de um sistema. Nesta solução as dependências entre os módulos não são definidas programaticamente, mas sim pela configuração de uma infraestrutura de software que é responsável por "injetar" em cada componente suas dependências declaradas. A Injeção de dependência se relaciona com o padrão Inversão de controle mas não pode ser considerada um sinônimo deste.
rdf:langString
Впровадження залежності (англ. Dependency injection, DI) — шаблон проєктування програмного забезпечення, що передбачає надання зовнішньої залежності програмному компоненту, використовуючи «інверсію управління» (англ. Inversion of control, IoC) для розв'язання (отримання) залежностей. Впровадження — це передача залежності (тобто, сервісу) залежному об'єкту (тобто, клієнту). Передавати залежності клієнту замість дозволити клієнту створити сервіс є фундаментальною вимогою до цього шаблону проєктування. Існує три найбільш поширені форми впровадження залежностей:
rdf:langString
rdf:langString
حقن التبعية
rdf:langString
Vkládání závislostí
rdf:langString
Dependency Injection
rdf:langString
Inyección de dependencias
rdf:langString
Dependency injection
rdf:langString
Injection de dépendances
rdf:langString
Dependency injection
rdf:langString
의존성 주입
rdf:langString
依存性の注入
rdf:langString
Wstrzykiwanie zależności
rdf:langString
Dependency injection
rdf:langString
Внедрение зависимости
rdf:langString
Injeção de dependência
rdf:langString
Впровадження залежностей
rdf:langString
依赖注入
xsd:integer
1484696
xsd:integer
1118304741
rdf:langString
right
xsd:date
2008-03-11
rdf:langString
Dependency injection for five-year-olds
When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy don't want you to have. You might even be looking for something we don't even have or which has expired.
What you should be doing is stating a need, "I need something to drink with lunch," and then we will make sure you have something when you sit down to eat.
xsd:gMonthDay
--10-28
<perCent>
33.0
rdf:langString
Vkládání závislostí (anglicky Dependency injection (DI)) je v objektově orientovaném programování technika pro vkládání závislostí mezi jednotlivými komponentami programu tak, aby jedna komponenta mohla používat druhou, aniž by na ni měla v době sestavování programu referenci. Dependency injection lze chápat jako novější název pro Inversion of Control (IoC), ale v užším významu.[zdroj?] Jedná se o konkrétní techniku IoC.
rdf:langString
في هندسة البرمجيات، يعد حقن التبعية (بالإنجليزية: dependency injection) تقنية يتلقى فيها كائن كائنات أخرى يعتمد عليها. تسمى هذه الكائنات الأخرى التبعيات. في العلاقة النموذجية «باستخدام» يسمى الكائن المتلقي عميل (بالإنجليزية: Client) ويسمى الكائن الذي تم تمريره (أي تم حقنه) خدمة (بالإنجليزية: Service). يمكن أن يكون الكود الذي ينقل الخدمة إلى العميل أنواعًا كثيرة ويسمى الحاقن. بدلاً من تحديد العميل للخدمة التي سيستخدمها، يخبر الحاقن العميل بالخدمة التي سيستخدمها. تشير «الحقن» إلى تمرير التبعية (خدمة) إلى الكائن (العميل) الذي قد يستخدمها. الخدمة تصبح جزءاً من حالة العميل. يعد تمرير الخدمة إلى العميل، بدلاً من السماح للعميل ببناء الخدمة أو العثور عليها، شرطاً أساسياً للنمط. النية من حقن التبعية هو تحقيق فصل الاهتمامات الخاصة بالبناء واستخدام الكائنات. يمكن أن يؤدي ذلك إلى زيادة إمكانية القراءة وإعادة استخدام الكود. حقن التبعية هو شكل من أشكال التقنية الأوسع لعكس التحكم. لا يجب على العميل الذي يريد استدعاء بعض الخدمات معرفة كيفية إنشاء هذه الخدمات. بدلاً من ذلك، يفوض العميل مسؤولية توفير خدماته للكود الخارجي (الحاقن). لا يُسمح للعميل باستدعاء كود الحاقن ؛ الحاقن هو الذي يبني الخدمات. ثم يقوم الحاقن بحقن (تمرير) الخدمات في العميل التي قد تكون موجودة بالفعل أو قد يتم بناؤها بواسطة الحاقن. ثم يستخدم العميل الخدمات. هذا يعني أن العميل لا يحتاج إلى معرفة الحاقن، وكيفية إنشاء الخدمات، أو حتى الخدمات الفعلية التي يستخدمها. يحتاج العميل فقط إلى معرفة الواجهات الجوهرية للخدمات لأن هذه تحدد كيفية استخدام العميل للخدمات. وهذا يفصل مسؤولية «الاستخدام» (بالإنجليزية: "use") عن مسؤولية «البناء» (بالإنجليزية: "construction").
rdf:langString
Als Dependency Injection (DI, englisch dependency ‚Abhängigkeit‘ und injection ‚Injektion‘, deutsch Abhängigkeitsinjektion oder Einbringen von Abhängigkeiten) wird in der objektorientierten Programmierung ein Entwurfsmuster bezeichnet, welches die Abhängigkeiten eines Objekts zur Laufzeit reglementiert: Benötigt ein Objekt beispielsweise bei seiner Initialisierung ein anderes Objekt, ist diese Abhängigkeit an einem zentralen Ort hinterlegt – es wird also nicht vom initialisierten Objekt selbst erzeugt.
rdf:langString
In software engineering, dependency injection is a design pattern in which an object or function receives other objects or functions that it depends on. A form of inversion of control, dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services. Instead, the receiving 'client' (object or function) is provided with its dependencies by external code (an 'injector'), which it is not aware of. Dependency injection helps by making implicit dependencies explicit and helps solve the following problems:
* How can a class be independent from the creation of the objects it depends on?
* How can an application, and the objects it uses support different configurations?
* How can the behavior of a piece of code be changed without editing it directly? In addition, dependency injection is used for keeping code in-line with the dependency inversion principle. Fundamentally, dependency injection consists of passing parameters to a method. Because the client does not build or find the service itself, it typically only needs to declare the interfaces of the services it uses, rather than their concrete implementations. This makes it easier to change which services are actually used at runtime, especially in statically-typed languages where changing the underlying objects would otherwise require re-compiling the source code. An example of inversion of control without dependency injection is the template method pattern, where polymorphism is achieved through subclassing. In contrast, dependency injection implements inversion of control through composition, and is often similar to the strategy pattern. A difference is that the strategy pattern is intended for dependencies that are interchangeable throughout an object's lifetime, whereas with dependency injection typically only a single instance of a dependency is used.
rdf:langString
En informática, inyección de dependencias (en inglés Dependency Injection, DI) es un patrón de diseño orientado a objetos, en el que se suministran objetos a una clase en lugar de ser la propia clase la que cree dichos objetos. Esos objetos cumplen contratos que necesitan nuestras clases para poder funcionar (de ahí el concepto de dependencia). Nuestras clases no crean los objetos que necesitan, sino que se los suministra otra clase 'contenedora' que inyectará la implementación deseada a nuestro contrato. En otras palabras, se trata de un patrón de diseño que se encarga de extraer la responsabilidad de la creación de instancias de un componente para delegarla en otro. El término fue acuñado por primera vez por Martin Fowler.
rdf:langString
L'injection de dépendances (dependency injection en anglais) est un mécanisme qui permet d'implémenter le principe de l'inversion de contrôle. Il consiste à créer dynamiquement (injecter) les dépendances entre les différents objets en s'appuyant sur une description (fichier de configuration ou métadonnées) ou de manière programmatique. Ainsi les dépendances entre composants logiciels ne sont plus exprimées dans le code de manière statique mais déterminées dynamiquement à l'exécution.
rdf:langString
依存性の注入（いぞんせいのちゅうにゅう、英: Dependency injection）とは、あるオブジェクトや関数が、依存する他のオブジェクトや関数を受け取るデザインパターンである。英語の頭文字からDIと略される。DIは制御の反転の一種で、オブジェクトの作成と利用について関心の分離を行い、疎結合なプログラムを実現することを目的としている。 dependencyを「依存性」と訳すのは本来の意味 から外れているため「依存オブジェクト注入」の用語を採用する文献も複数存在する。
rdf:langString
Dependency injection (DI) è un design pattern della Programmazione orientata agli oggetti il cui scopo è quello di semplificare lo sviluppo e migliorare la testabilità di software di grandi dimensioni. Per utilizzare tale design pattern è sufficiente dichiarare le dipendenze di cui un componente necessita (dette anche interface contract). Quando il componente verrà istanziato, un iniettore si prenderà carico di risolvere le dipendenze (attuando dunque l'inversione del controllo). Se è la prima volta che si tenta di risolvere una dipendenza l'injector istanzierà il componente dipendente, lo salverà in un contenitore di istanze e lo restituirà. Se non è la prima volta, allora restituirà la copia salvata nel contenitore. Una volta risolte tutte le dipendenze, il controllo può tornare al componente applicativo. Il pattern Dependency Injection coinvolge almeno tre elementi:
* una componente dipendente,
* la dichiarazione delle dipendenze del componente, definite come interface contract,
* un injector (chiamato anche provider o container) che crea, a richiesta, le istanze delle classi che implementano delle dependency interface.
rdf:langString
Dependency injection is een geavanceerd ontwerppatroon uit de informatica dat het mogelijk maakt klassen losjes te koppelen. Dit wil zeggen dat ze data kunnen uitwisselen zonder dat deze relatie hard (in de broncode) vastgelegd is; althans niet door de programmeurs van die (beide) klassen. Traditioneel gebeurt dat vaak wel, waardoor die klassen moeilijk te hergebruiken zijn. Soms wordt 'dependency injection' gezien als een bijzondere vorm van 'inversion of control', wat voor het eerst beschreven werd door Martin Fowler.
rdf:langString
소프트웨어 엔지니어링에서 의존성 주입(dependency injection)은 하나의 객체가 다른 객체의 의존성을 제공하는 테크닉이다. "의존성"은 예를 들어 서비스로 사용할 수 있는 객체이다. 클라이언트가 어떤 서비스를 사용할 것인지 지정하는 대신, 클라이언트에게 무슨 서비스를 사용할 것인지를 말해주는 것이다. "주입"은 의존성(서비스)을 사용하려는 객체(클라이언트)로 전달하는 것을 의미한다. 서비스는 클라이언트 상태의 일부이다. 클라이언트가 서비스를 구축하거나 찾는 것을 허용하는 대신 클라이언트에게 서비스를 전달하는 것이 패턴의 기본 요건이다. 의존성 주입의 의도는 객체의 생성과 사용의 관심을 분리하는 것이다. 이는 가독성과 코드 재사용을 높혀준다. 의존성 주입은 광범위한 역제어 테크닉의 한 형태이다. 어떤 서비스를 호출하려는 클라이언트는 그 서비스가 어떻게 구성되었는지 알지 못해야 한다. 클라이언트는 대신 서비스 제공에 대한 책임을 외부 코드(주입자)로 위임한다. 클라이언트는 주입자 코드를 호출할 수 없다. 그 다음, 주입자는 이미 존재하거나 주입자에 의해 구성되었을 서비스를 클라이언트로 주입(전달)한다. 그리고 나서 클라이언트는 서비스를 사용한다. 이는 클라이언트가 주입자와 서비스 구성 방식 또는 사용중인 실제 서비스에 대해 알 필요가 없음을 의미한다. 클라이언트는 서비스의 사용 방식을 정의하고 있는 서비스의 고유한 인터페이스에 대해서만 알면 된다. 이것은 "구성"의 책임으로부터 "사용"의 책임을 구분한다.
rdf:langString
Wstrzykiwanie zależności (ang. Dependency Injection, DI) – wzorzec projektowy i wzorzec architektury oprogramowania polegający na usuwaniu bezpośrednich zależności pomiędzy komponentami na rzecz architektury typu plug-in. Polega na przekazywaniu gotowych, utworzonych instancji obiektów udostępniających swoje metody i właściwości obiektom, które z nich korzystają (np. jako parametry konstruktora). Stanowi alternatywę do podejścia, gdzie obiekty tworzą instancję obiektów, z których korzystają np. we własnym konstruktorze. Jest on często utożsamiany z odwróceniem sterowania (ang. Inversion of Control, IoC), jakkolwiek z technicznego punktu widzenia DI jest jedną ze szczególnych (obecnie najpopularniejszą) realizacji paradygmatu IoC. DI silnie preferuje zewnętrzne tworzenie połączeń (zależności) pomiędzy komponentami oprogramowania (np. asocjacje w klasach), nad zlecaniem tworzenia zależności im samym. Jest to wzorzec, w którym odpowiedzialność za tworzenie i łączenie obiektów jest przeniesiona z obiektów do fabryki (np. kontenera IoC). Na żądanie kodu fabryka tworzy obiekt, lub udostępnia obiekt z puli obiektów, ustawiając mu powiązania z innymi obiektami (np. wstrzykiwanie konstruktorem – Constructor Injection, wstrzykiwanie mutatorami – Setter Injection, użycie interfejsu – Interface Injection lub w mieszany sposób). DI jest więc realizacją „odwrócenia sterowania” w sensie tworzenia i wiązania obiektów. W rozbudowanych implementacjach fabryka może wykonywać czynności dodatkowe, np. Spring Framework pozwala na używanie aspektów, można więc do obiektu dodać automatycznie obsługę transakcji, logowania, itp. DI jest sposobem osiągnięcia (ang. loose coupling). Użycie tej techniki pozwala tworzyć łatwo testowalne obiekty. Sprawdza się szczególnie w powiązaniu z programowaniem sterowanym testami (ang. test-driven development). Polega ono w skrócie na następującym tworzeniu oprogramowania: opracowujemy interfejsy (diagram klas), opracowujemy testy jednostkowe, które testują funkcjonalność interfejsu (w jaki sposób przetestować, czy działanie jest poprawne), a dopiero później piszemy implementację. Unikanie zależności od konkretnych implementacji współpracujących klas, a bazowanie tylko na interfejsach umożliwia tworzenie kontrolowanych testów - jesteśmy w stanie skupić się wyłącznie na funkcjonalności wybranej klasy; zwłaszcza, gdy wykorzystamy obiekty-zaślepki (ang. mock-objects, proste pseudoimplementacje, używane w celu testowania). DI pozwala wstrzyknąć do obiektów testowanych zależności od obiektów-zaślepek. W środowisku produkcyjnym do obiektów tych wstrzykiwane są zależności od prawdziwych obiektów.
rdf:langString
Injeção de dependência (Dependency Injection, em inglês) é um padrão de desenvolvimento de programas de computadores utilizado quando é necessário manter baixo o nível de acoplamento entre diferentes módulos de um sistema. Nesta solução as dependências entre os módulos não são definidas programaticamente, mas sim pela configuração de uma infraestrutura de software que é responsável por "injetar" em cada componente suas dependências declaradas. A Injeção de dependência se relaciona com o padrão Inversão de controle mas não pode ser considerada um sinônimo deste. Alguns dos frameworks mais utilizados que fazem uso de injeção de dependência são o Spring, , Laravel e o AngularJS.
rdf:langString
在软件工程中，依赖注入（dependency injection，缩写为 DI）是一种软件设计模式，也是实现控制反转的其中一种技术。這种模式能让一个物件接收它所依赖的其他物件。“依赖”是指接收方所需的对象。“注入”是指将“依赖”传递给接收方的过程。在“注入”之后，接收方才会调用该“依赖”。此模式确保了任何想要使用给定服务的物件不需要知道如何建立這些服务。取而代之的是，连接收方物件（像是 client）也不知道它存在的外部代码（注入器）提供接收方所需的服务。 注：编程语言层次下，“接收方”为对象和 class，“依赖”为变量。在提供服务的角度下，“接收方”为客户端，“依赖”为服务。 该设计的目的是为了分离关注点，分离接收方和依赖，从而提供松耦合以及代码重用性。 传统编程方式，客户对象自己创建一个服务实例并使用它。这带来的缺点和问题是：
* 如果使用不同类型的服务对象，就需要修改、重新编译客户类。
* 客户类需要通过配置来适配服务类及服务类的依赖。如果程序有多个类都使用同一个服务类，这些配置就会变得复杂并分散在程序各处。
* 难以单元测试。本来需要使用服务类的 mock 或 stub，在这种方式下不太可行。 依赖注入可以解决上述问题：
* 使用接口或抽象基类，来抽象化依赖实现。
* 依赖在一个服务容器中注册。客户类构造函数被注入服务实例。框架负责创建依赖实例并在没有使用者时销毁它。
rdf:langString
Впровадження залежності (англ. Dependency injection, DI) — шаблон проєктування програмного забезпечення, що передбачає надання зовнішньої залежності програмному компоненту, використовуючи «інверсію управління» (англ. Inversion of control, IoC) для розв'язання (отримання) залежностей. Впровадження — це передача залежності (тобто, сервісу) залежному об'єкту (тобто, клієнту). Передавати залежності клієнту замість дозволити клієнту створити сервіс є фундаментальною вимогою до цього шаблону проєктування. Існує три найбільш поширені форми впровадження залежностей:
* впровадження в конструктор,
* впровадження у властивість,
* впровадження в метод.
rdf:langString
Внедрение зависимости (англ. Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (англ. Inversion of control, IoC), когда она применяется к управлению зависимостями. В полном соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему, специально предназначенному для этого общему механизму.
xsd:nonNegativeInteger
30176
