anchor.diff:    Recall that every component _instance_ has its own injector.
     Providing the service at the component level ensures that _every_ instance of the component gets its own, private instance of the service.
     No tax return overwriting. No mess.
  +  
  +  `HeroTaxReturnComponent`有它自己的`HeroTaxReturnService`提供商。
  +  回忆一下，每个组件的*实例*都有它自己的注入器。
  +  在组件级提供服务可以确保组件的*每个*实例都得到一个自己的、私有的服务实例。
  +  报税单不会再被意外覆盖，这下清楚了。
   
   .l-sub-section
     :marked
       The rest of the scenario code relies on other Angular features and techniques that you can learn about elsewhere in the documentation.
       You can review it and download it from the <live-example></live-example>.
  +    
  +    该场景代码中的其它部分依赖另一些Angular的特性和技术，我们将会在本文档的其它章节学到。
  +    你可以到<live-example></live-example>查看代码和下载它。
   
   :marked
     ### Scenario: specialized providers
  +  
  +  ### 场景：专门的提供商
   
     Another reason to re-provide a service is to substitute a _more specialized_ implementation of that service,
     deeper in the component tree.
  +  
  +  重新提供服务的另一个原因，是在组件树的深层中把该服务替换为一个*更特殊的*实现。
   
     Consider again the Car example from the [Dependency Injection](./dependency-injection.html) guide.
     Suppose you configured the root injector (marked as A) with _generic_ providers for
     `CarService`, `EngineService` and `TiresService`.
  +  
  +  再次考虑[依赖注入](./dependency-injection.html)一章中车辆（Car）的例子。
  +  假设我们在根注入器（代号A）中配置了*通用的*提供商：`CarService`、`EngineService`和`TiresService`。
   
     You create a car component (A) that displays a car constructed from these three generic services.
  +  
  +  我们创建了一个车辆组件（A），它显示一个从另外三个通用服务构造出的车辆。
   
     Then you create a child component (B) that defines its own, _specialized_ providers for `CarService` and `EngineService`
     that have special capabilites suitable for whatever is going on in component (B).
  +  
  +  然后，我们创建一个子组件（B），它为`CarService`和`EngineService`定义了自己的*特殊的*提供商，它们具有更特殊的能力，适用于组件B的。
   
     Component (B) is the parent of another component (C) that defines its own, even _more specialized_ provider for `CarService`.
  +  
  +  组件B是另一个组件C的父组件，而组件C又定义了自己的，*更特殊的*`CarService`提供商。
   
   figure.image-display
     img(src="/resources/images/devguide/dependency-injection/car-components.png" alt="car components" width="220")
   
   :marked
     Behind the scenes, each component sets up its own injector with zero, one, or more providers defined for that component itself.
  +  
  +  在幕后，每个组件都有自己的注入器，这个注入器带有为组件本身准备的0个、1个或多个提供商。
   
     When you resolve an instance of `Car` at the deepest component (C),
     its injector produces an instance of `Car` resolved by injector (C) with an `Engine` resolved by injector (B) and
     `Tires` resolved by the root injector (A).
  +  
  +  当我们在最深层的组件C解析`Car`的实例时，它使用注入器C解析生成了一个`Car`的实例，使用注入器B解析了`Engine`，而`Tires`则是由根注入器A解析的。
   
   figure.image-display
     img(src="/resources/images/devguide/dependency-injection/injector-tree.png" alt="car injector tree" width="600")
  
positive.code:   By providing `VillainsService` in the `VillainsListComponent` metadata and nowhere else,
    the service becomes available only in the `VillainsListComponent` and its sub-component tree.
    It's still a singleton, but it's a singleton that exist solely in the _villain_ domain.
  
    Now you know that a hero component can't access it. You've reduced your exposure to error.
  
    ### Scenario: multiple edit sessions
  
    Many applications allow users to work on several open tasks at the same time.
    For example, in a tax preparation application, the preparer could be working on several tax returns,
    switching from one to the other throughout the day.
  
    This guide demonstrates that scenario with an example in the Tour of Heroes theme.
    Imagine an outer `HeroListComponent` that displays a list of super heroes.
  
    To open a hero's tax return, the preparer clicks on a hero name, which opens a component for editing that return.
    Each selected hero tax return opens in its own component and multiple returns can be open at the same time.
  
    Each tax return component has the following characteristics:
  
    * Is its own tax return editing session.
    * Can change a tax return without affecting a return in another component.
    * Has the ability to save the changes to its tax return or cancel them.
  
  figure.image-display
    img(src="/resources/images/devguide/dependency-injection/hid-heroes-anim.gif" width="400" alt="Heroes in action")
  
negative.code:   :marked
      The code for this _cars_ scenario is in the `car.components.ts` and `car.services.ts` files of the sample
      which you can review and download from the <live-example></live-example>.
      
      *车辆*场景下的代码位于`car.components.ts`和`car.services.ts`文件中，这个例子你可以在<live-example></live-example>查看和下载。
      
  //- ## Advanced Dependency Injection in Angular
  //- Restrict Dependency Lookups
  //- [TODO] (@Host) This has been postponed for now until we come up with a decent use case
  