anchor.diff:      It didn't need `@Injectable()` because that component class has the `@Component` decorator.
       In Angular with TypeScript, a *single* decorator &mdash; *any* decorator &mdash; is sufficient to identify dependency types.
       
  -    `AppComponent`类有两个依赖，但是没有`@Injectable()`。它不需要`@Injectable()`是因为组件类有`@Component`装饰器。
  -    在用TypeScript的Angular（应用程序）里，一个 *单独的* 装饰器 &mdash; *任何* 装饰器 &mdash; 来辨识依赖类别就足够了。
  +    `AppComponent`类有两个依赖，但是没有`@Injectable()`。
  +    它不需要`@Injectable()`是因为组件类有`@Component`装饰器。
  +    在用TypeScript的Angular应用里，有一个 *单独的* 装饰器 &mdash; *任何* 装饰器 &mdash; 来辨识依赖类别就足够了。
  +    
   <a id="service-scope"></a>
   .l-main-section
   :marked
     ## Limit service scope to a component subtree
     ## 限制服务作用范围到一个组件支树
  +  
     All injected service dependencies are singletons meaning that, 
     for a given dependency injector ("injector"), there is only one instance of service. 
       
  -  所有注入的服务依赖都是单例（singletons)，意思是，在任意一个依赖注入器("injector")中，每个服务只有一个唯一的实例。
  +  所有注入的服务依赖都是单例（singletons)的，也就是说，在任意一个依赖注入器("injector")中，每个服务只有一个唯一的实例。
     
     But an Angular application has multiple dependency injectors, arranged in a tree hierarchy that parallels the component tree.
     So a particular service can be *provided* (and created) at any component level and multiple times
     if provided in multiple components.
       
  -  但是一个Angular应用程序有多个依赖注入器，组织在一个与组件树平行的树形结构中。所以，在任何组件级别，一个特定的服务能被*提供*（和被建立）。如果在多个组件中注入，可以被新建或提供多次。
  +  但是Angular应用程序有多个依赖注入器，组织在一个与组件树平行的树形结构中。所以，可以在任何组件级别*提供*（和建立）特定的服务。如果在多个组件中注入，服务就会被新建多个实例，分别组件中提供。
     
     By default, a service dependency provided in one component is visible to all of its child components and 
     Angular injects the same service instance into all child components that ask for that service.
     
  -  默认情况下，在一个组件中注入的服务依赖，在所有该组件的子组件中都可见，而且Angular会注入同样的服务实例，到所有要求该服务的子组件中。
  +  默认情况下，一个组件中注入的服务依赖，会在所有该组件的子组件中能见，而且Angular会注入同样的服务实例到要求该服务的子组件中。
     
     Accordingly, dependencies provided in the root `AppComponent` can be injected into *any* component *anywhere* in the application.
     
  -  同样，在根部`AppComponent`提供的依赖能被注入到*任何*组件，到应用程序的*任何地方*。
  +  同样，在根部`AppComponent`提供的依赖的单一实例能被注入到*任何*组件，到应用程序的*任何地方*。
     
     That isn't always desireable. 
     Sometimes we want to restrict service availability to a particular region of the application.
     
  -  这不一定总是想要的。有时候我们想要把服务的有效性限制到应用程序的一个特定区域。
  +  这不一定总是我们想要的。有时候我们想要把服务的有效性限制到应用程序的一个特定区域。
     
     We can limit the scope of an injected service to a *branch* of the application hierarchy
     by providing that service *at the sub-root component for that branch*.
     Here we provide the `HeroService` to the `HeroesBaseComponent` by listing it in the `providers` array:
     
  -  通过*在该分支的子级根部组件*中提供该服务， 我们能把一个注入服务的作用范围局限到一个应用程序结构的该*分支*中。
  -  这里我们通过列入`供应商`数列，在`HeroesBaseComponent`中提供了`HeroService`：
  +  通过*在组件树分支的子级根部组件*中提供服务，把一个被注入的服务的作用范围局限到应用程序结构中的某个*分支*中。
  +  这里通过列入`providers`数列，在`HeroesBaseComponent`中提供了`HeroService`：
  +  
   +makeExample('cb-dependency-injection/ts/app/sorted-heroes.component.ts','injection','app/sorted-heroes.component.ts (HeroesBaseComponent excerpt)')
   :marked
     When Angular creates the `HeroesBaseComponent`, it also creates a new instance of `HeroService` 
  
positive.code:   *Barry*'s `providers` array looks just like [*Alex*'s](#alex-providers).
    If we're going to keep writing [*alias providers*](#useexisting) like this we should create a [helper function](#provideparent).
    
    *Barry*的`供应商`数组看起来像[*Alex*的]（#alex-providers).
    如果我们一直要像这样编写[*别名供应商*](#useexisting)的话，我们应该建立一个[帮助函数](#provideparent)。
    
    For now, focus on *Barry*'s constructor:
  
negative.code:   For example, we inject both the `LoggerService` and the `UserContext` in the `AppComponent`. 
    
    比如，我们在`AppComponent`里注入`LoggerService`和`UserContext`。
    
  +makeExample('cb-dependency-injection/ts/app/app.component.ts','ctor','app/app.component.ts')(format='.') 
  
  :marked
    The `UserContext` in turn has dependencies on both the `LoggerService` (again) and 
    a `UserService` that gathers information about a particular user.
    
    `UserContext`有两个依赖`LoggerService`（再一次）和负责获取特定用户信息的`UserService`。
    
  +makeExample('cb-dependency-injection/ts/app/user-context.service.ts','injectables','user-context.service.ts (injection)')(format='.')
  
  