anchor.diff:    Certain services (e.g., the `Router`) only work when registered in the application root injector.
   
     By contrast, Angular registers `AppComponent` providers with the `AppComponent`'s own injector.
  -  `AppComponent`services are available to that component and its component tree. 
  +  `AppComponent`services are available only to that component and its component tree. 
     They are _component-scoped_.
   
     The `AppComponent`'s injector is a _child_ of the root injector, one down in the injector hierarchy.
  
positive.code: a#q-root-component-or-module
  .l-main-section
  :marked
    ### Should I add providers to the root _AppModule_ or the root _AppComponent_?
  
    Most apps launch with an initial set of service providers. 
    Should we register those providers on the root `AppModule` (`@NgModule.providers`) or
    the root `AppComponent` (`@Component.providers`)?
  
    **_List such providers in the root_ `AppModule` _unless you have a compelling reason to do otherwise_**.
    
    Angular registers all startup module providers with the application root injector.
    The services created from root injector providers are available to the entire application. 
    They are _application-scoped_.
  
negative.code: 
    `AppComponent` services don't exist at the root level where routing operates. 
    Lazy loaded modules can't reach them.
    In the Angular Module Chapter sample applications, if we had registered `UserService` in the `AppComponent`, 
    the `HeroComponent` couldn't inject it.
    The application  would fail the moment a user navigated to "Heroes".
  
  .l-hr
  
  a#q-component-or-module
  .l-main-section
  :marked
    ### Should I add other providers to a module or a component?
  
    In general, prefer registering feature-specific providers in modules (`@NgModule.providers`)
    to registering in components (`@Component.providers`).
    
    Register a provider with a component when you _must_ limit the scope of a service instance
    to that component and its component tree. 
    Apply the same reasoning to registering a provider with a directive.
  
    For example, a hero editing component that needs a private copy of a caching hero service should register
    the `HeroService` with the `HeroEditorComponent`. 
    Then each new instance of the `HeroEditorComponent` gets its own cached service instance. 
    The changes that editor makes to heroes in its service do not touch the hero instances elsewhere in the application.
  
    [Always register _application-wide_ services with the root `AppModule`](q-root-component-or-module), 
    not the root `AppComponent`.
  
  .l-hr
  a#q-why-bad
  .l-main-section
  :marked
  