blocks|key|1439827|text|我不想听起来像个混蛋，但是每种面向对象语言都支持依赖注入。不需要特殊的语法。只需使用它们的依赖项构造您的对象(或稍后设置它们的依赖项)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1439828|实际上，您可以将所有依赖项连接到程序顶部附近的某个位置--不一定是main()，但靠近顶部。|offset|length|style|CODE|1439829|entityMap^0|0|X|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I don't mean to sound like a jerk, but every OO language supports dependency injection. No special syntax is required. Just construct your object with their dependencies (or set their dependencies later). 

You can actually wire up all your dependencies somewhere near the top of the program - not necessarily <code>main()</code>, but close to the top.

blocks|key|1225143|text|Noop应该可以做到这一点，但是我还没有看到语言规范(在我找到它之前，我的耐心就用完了)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1225144|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/p/noop/^0|0|4|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://code.google.com/p/noop/" rel="nofollow noreferrer">Noop</a> supposedly does this, but I haven't seen the language specification (my patience ran out before I found it).

blocks|key|1439945|text|您不会发现依赖注入是一种语言特性，因为它通常被视为一种设计模式。设计模式作为缺少语言功能的变通方法而出现-例如，如果将第一类类型作为语言功能，则不需要工厂模式(请参阅Norvig's+presentation的p12+)，如果将多方法作为语言功能，则不需要双重分派模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1439946|DI是其设计模式的语言特性是“参数模块”。请参阅与Gilad+Bracha的语言Newspeak相关的discussion+of+modules与DI|1439947|entityMap|0|LINK|mutability|MUTABLE|url|http://norvig.com/design-patterns/|1|http://bracha.org/Site/Newspeak.html|2|https://www.blogger.com/comment.g?blogID=2447174102813539049&postID=1844927628139698674&pli=1^0|2B|L|0|0|14|8|1|1F|L|2|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]]|C|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@$A|W|B|X|1|Y]|$A|Z|B|10|1|11]]|C|$]]|$1|F|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|Q]]]]

You won't find dependency injection as a language feature, as it's generally seen as a design pattern. Design patterns arise as workarounds for missing language features - for example if you have first class types as a language feature you don't need the factory pattern ( see p12 of <a href="http://norvig.com/design-patterns/" rel="nofollow noreferrer">Norvig's presentation</a> ), if you have multi-methods as a language feature you don't need the double dispatch pattern. 

The language feature for which DI is the design pattern is "parametric modules". See the <a href="https://www.blogger.com/comment.g?blogID=2447174102813539049&amp;postID=1844927628139698674&amp;pli=1" rel="nofollow noreferrer">discussion of modules</a> vs DI relating to Gilad Bracha's language <a href="http://bracha.org/Site/Newspeak.html" rel="nofollow noreferrer">Newspeak</a>

blocks|key|1225277|text|可以说，在特征和自类型注释的帮助下，Scala支持开箱即用的依赖注入。看一下Cake+Pattern：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225278|http://jonasboner.com/2008/10/06/real-world-scala-dependency-injection-di/|offset|length|1225279|基本上，这种方法使用带有声明依赖项的特征(通过使用自类型)，让编译器将它们连接在一起。|1225280|这是声明注册表：|1225281|object+ComponentRegistry+extends+
++UserServiceComponent+with+
++UserRepositoryComponent+
{
++val+userRepository+=+new+UserRepository
++val+userService+=+new+UserService
}|code-block|syntax|javascript|1225282|...registering用户存储库：|1225283|trait+UserRepositoryComponent+{
++val+userRepository:+UserRepository

++class+UserRepository+{
++++...
++}
}|1225284|...and依赖于存储库的用户服务组件：|1225285|trait+UserServiceComponent+{+
++this:+UserRepositoryComponent+=>+

++val+userService:+UserService++

++class+UserService+{
++++...+
++}
}|1225286|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|22|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@$D|15|E|16|1|17]]|A|$]]|$1|F|3|G|5|6|7|18|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|19|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1A|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Q|3|R|5|L|7|1C|8|@]|9|@]|A|$M|N]]|$1|S|3|T|5|6|7|1D|8|@]|9|@]|A|$]]|$1|U|3|V|5|L|7|1E|8|@]|9|@]|A|$M|N]]|$1|W|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|C]]]]

One could say that Scala supports dependency injection out of the box with the help of traits and self-type annotations. Take a look on a Cake Pattern: 

<a href="http://jonasboner.com/2008/10/06/real-world-scala-dependency-injection-di/" rel="nofollow">http://jonasboner.com/2008/10/06/real-world-scala-dependency-injection-di/</a>

Basically, this approach uses traits with declared dependencies (by using self-types) to let the compiler do the work of wiring them together.

This is the declaration registry:

<pre><code>object ComponentRegistry extends 
 UserServiceComponent with 
 UserRepositoryComponent 
{
 val userRepository = new UserRepository
 val userService = new UserService
}
</code></pre>

...registering the user repository:

<pre><code>trait UserRepositoryComponent {
 val userRepository: UserRepository

 class UserRepository {
 ...
 }
}
</code></pre>

...and the user service component that depends on the repository:

<pre><code>trait UserServiceComponent { 
 this: UserRepositoryComponent =&gt; 

 val userService: UserService 

 class UserService {
 ... 
 }
}
</code></pre>

Are there any existing modern-day programming languages that explicitly have dependency injection as a language feature, and if so, are there any examples of how such programming languages use their syntax to separate program dependencies from their concrete implementations?

(Please Note: I'm not looking for an DI/IOC framework--I'm actually looking for a programming language that actually has this feature built into the language).

Dependency Injection as a Language Feature?

编译器

是否有任何现有的现代编程语言显式地将依赖注入作为一种语言功能，如果是，是否有任何示例说明这些编程语言如何使用其语法将程序依赖项与其具体实现分开？(请注意:我不是在寻找DI/IOC框架--我实际上是在寻找一种编程语言，该语言实际上内置了此功能)。

问依赖注入是一种语言特性吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问依赖注入是一种语言特性吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问依赖注入是一种语言特性吗？
EN