modulos - pasar parametros entre componentes angular 4

¿Pueden los módulos con carga lenta compartir la misma instancia de un servicio proporcionado por su padre?

Question

Acabo de encontrar un problema con un módulo de carga diferida donde el módulo primario y el secundario requieren el mismo servicio pero crean una instancia cada uno. La declaración es idéntica para ambos, es decir

import { MyService } from ''./my.service'';
...
@NgModule({
   ...
   providers: [
      MyService,
      ...
   ]
});

y aquí está la configuración de enrutamiento

export parentRoutes: Routes = [
   { path: '':id'', component: ParentComponent, children: [
      { path: '''', component: ParentDetailsComponent },
      { path: ''child'', loadChildren: ''app/child.module#ChildModule'' },
      ...
   ]}
];

que, por supuesto, se importa en el módulo principal como

RouterModule.forChild(parentRoutes)

¿Cómo hago esto si quisiera compartir la misma instancia de servicio?

Answer 1

Esto debería funcionar, pero aún así sugeriría que vaya con el concepto SharedModule que contiene servicios, tuberías, directivas y componentes comunes .

Shared / SharedModule

import { NgModule,ModuleWithProviders } from ''@angular/core'';
import { CommonModule }        from ''@angular/common'';

import { MyService } from ''./my.service'';

@NgModule({
  imports:      [ CommonModule ],
  declarations: [],
  exports:      [ CommonModule ]
})
export class SharedModule {
  static forRoot(): ModuleWithProviders {
    return {
      ngModule: SharedModule,
      providers: [ MyService ]                       //<<<====here
    };
  }
}

AppModule

import {SharedModule} from ''./shared/shared.module'';
...
@NgModule({
   imports:[ BrowserModule,SharedModule.forRoot()],  //<<<====here
   providers: []
});

Answer 2

Usar un forRoot , como se menciona here , es lo que probablemente necesite. El problema que está destinado a resolver está directamente relacionado con el problema que está experimentando con los módulos con carga lenta que obtienen su propio servicio.

Se explica aquí en Configurar servicios principales con forRoot , pero esa sección no explica sobre el problema de carga diferida. Eso se explica con una pequeña advertencia al final de los módulos compartidos

No especifique providers singleton para toda la aplicación en un módulo compartido. Un módulo con carga lenta que importe ese módulo compartido hará su propia copia del servicio.

@NgModule({})
class SharedModule {
  static forRoot() {
    ngModule: SharedModule,
    providers: [ MyService ]
  }
}

@NgModule({
  import: [ SharedModule.forRoot() ]
})
class AppModule {}

@NgModule({
  imports: [ SharedModule ]
})
class LazyLoadedModule {}

Esto asegura que el módulo con carga lenta no reciba el servicio. Pero ya sea que el módulo tenga una carga lenta o no, este es el patrón que se recomienda para los servicios de toda la aplicación. Aunque debe tenerse en cuenta que si no tiene ningún módulo cargado de forma diferida, no usa el patrón forRoot y solo importa SharedModule , solo será una instancia del servicio. Pero este patrón aún debería recomendarse a seguir.

ACTUALIZAR

Supongo que me apresuré a responder sin mirar completamente la pregunta. En la pregunta, no se menciona ningún módulo compartido. Parece que el OP simplemente está tratando de agregar el servicio a @NgModule.providers tanto en el módulo de la aplicación como en el módulo secundario con carga @NgModule.providers .

En este caso, simplemente elimine el servicio de los providers módulos secundarios. No es necesario El que se agrega en el módulo de la aplicación es suficiente para que se use el niño.

Solo recuerde que los providers son para toda la aplicación (excepto en el caso problemático de esta publicación), mientras que las declarations no lo son.