Angular 4 的核心模块中的服务真的是单例提供的吗？

我试图理解 Angular 4 中的核心模块和单例服务。 官方文档（https://angular.io/guide/ngmodule）说了以下几件事：

UserService 是一个应用程序范围的单例。你不想要每一个 模块有自己单独的实例。但确实存在危险 如果 SharedModule 提供 UserService，就会发生这种情况。

CoreModule 提供 UserService。 Angular 注册该提供者 使用应用程序根注入器，创建一个单例实例 UserService 可用于任何需要它的组件，无论是 组件被急切或延迟加载。

我们建议收集此类一次性使用的类并隐藏它们 CoreModule 内的详细信息。简化的根 AppModule 导入 CoreModule 作为应用程序的协调器 所有的。

import { CommonModule }      from '@angular/common';
import { TitleComponent }    from './title.component';
import { UserService }       from './user.service';
import { ModuleWithProviders, NgModule, Optional, SkipSelf }       from '@angular/core';
@NgModule({
  imports:      [ CommonModule ],
  declarations: [ TitleComponent ],
  exports:      [ TitleComponent ],
  providers:    [ UserService ]
})
export class CoreModule {
    constructor (@Optional() @SkipSelf() parentModule: CoreModule) { ... }
}

所以我使用提供单例服务的核心模块和构造函数

constructor (@Optional() @SkipSelf() parentModule: CoreModule) { ... }

防止多次导入核心模块。

1）但是，如果我在另一个模块中提供 UserService （例如在延迟加载模块中）怎么办？这个延迟加载的模块有一个新的服务实例吗？

关于 forRoot 方法：

@NgModule({
  imports:      [ CommonModule ],
  providers:    [ UserService ]
})
export class CoreModule {
}

static forRoot(config: UserServiceConfig): ModuleWithProviders {
  return {
    ngModule: CoreModule,
    providers: [
      {provide: UserServiceConfig, useValue: config }
    ]
  };
}
}

2）如果我在 AppModule 中使用 CoreModule.forRoot() 导入 CoreModule，UserService 会发生什么？也提供了吗？

Thanks

该文档令人困惑，尤其是这一行：

UserService 是一个应用程序范围的单例。你不想要每一个 模块有自己单独的实例。但确实存在危险 如果 SharedModule 提供 UserService 就会发生这种情况.

如果您不使用延迟加载模块，则不会有发生这种情况的危险。让我们看一个例子。你有A导入的模块B模块。两个模块都定义了提供者：

@NgModule({
   providers: {provide: 'b', 'b'}
})
export class BModule {}

@NgModule({
   imports: [AModule]
   providers: {provide: 'a', 'a'}
})
export class AModule {}

当编译器生成模块工厂时会发生什么merges这些供应商一起和工厂仅适用于一个模块将被创建。其外观如下：

var AModuleNgFactory = jit_createNgModuleFactory0(

    // reference to the module class
    jit_AppModule1,  

    // array of bootstrap components
    [jit_AppComponent2],

    function (_l) {
        return jit_moduleDef3([

            // array of providers
            jit_moduleProvideDef4(256, 'b', 'b', []),
            jit_moduleProvideDef4(256, 'a', 'a', [])
            ...,
        ]);

您可以看到提供商已合并。现在，如果您使用以下命令定义两个模块相同的提供商令牌，模块将被合并，导入另一个模块的提供程序将覆盖导入的模块提供程序：

@NgModule({
   providers: {provide: 'a', 'b'}
})
export class BModule {}

@NgModule({
   imports: [AModule]
   providers: {provide: 'a', 'a'}
})
export class AModule {}

工厂定义现在看起来像这样：

function (_l) {
    return jit_moduleDef3([

        // array of providers
        jit_moduleProvideDef4(256, 'a', 'a', []),
        ...,
    ]);

因此，无论您导入多少个模块，都只会创建一个具有合并提供程序的工厂。并且只创建一个根注入器。组件创建的注入器不是“真正的”注入器 - 检查这个答案了解原因。

这个延迟加载的模块有一个新的服务实例吗？

当涉及到延迟加载模块时，Angular 会生成separate为他们建造工厂。这意味着其中定义的提供程序不会合并到主模块注入器中。因此，如果延迟加载的模块使用相同的令牌定义提供者，Angular 将创建该服务的新实例，即使主模块注入器中已经有一个实例。

如果我在 AppModule 中使用 CoreModule.forRoot() 导入 CoreModule

要了解什么forRoot确实，看到RouterModule.forRoot(ROUTES) 与 RouterModule.forChild(ROUTES).