Angular 2 salida de router-outlet

<router-outlet></router-outlet> no se puede usar para emitir un evento desde el componente hijo. Una forma de comunicarse entre dos componentes es utilizar un servicio común.

Crear un servicio

Servicio compartido.ts

import { Observable } from 'rxjs/Observable';
import { Injectable } from '@angular/core';
import { Subject } from 'rxjs/Subject';
@Injectable()
export class SharedService {
    // Observable string sources
    private emitChangeSource = new Subject<any>();
    // Observable string streams
    changeEmitted$ = this.emitChangeSource.asObservable();
    // Service message commands
    emitChange(change: any) {
        this.emitChangeSource.next(change);
    }
}

Ahora inyecte la instancia del servicio anterior en el constructor del componente padre e hijo.

El componente hijo emitirá un cambio cada vez que se llame al método onClick ()

Niño.componente.ts

import { Component} from '@angular/core';
@Component({
    templateUrl: 'child.html',
    styleUrls: ['child.scss']
})
export class ChildComponent {
    constructor(
        private _sharedService: SharedService
    ) { }

onClick(){
  this._sharedService.emitChange('Data from child');

 }
}

El componente principal recibirá ese cambio. Para ello,captura la suscripción dentro del constructor del padre.

Padre.componente.ts

import { Component} from '@angular/core';
@Component({
    templateUrl: 'parent.html',
    styleUrls: ['parent.scss']
})
export class ParentComponent {
    constructor(
        private _sharedService: SharedService
    ) {
          _sharedService.changeEmitted$.subscribe(
        text => {
            console.log(text);
        });
      }

}

Espero que esto ayude:)

La respuesta dada arriba es correcta y completa. Solo quiero agregar para aquellos que la solución no funcionó para ellos que deben agregar el servicio a los proveedores solo en el componente padre y no en el hijo para asegurarse de que obtenga un singleton del servicio, de lo contrario se crearán dos instancias de servicio. Esta respuesta está inspirada en el comentario de @HeisenBerg en la respuesta anterior.

Cambié un poco de la respuesta de Antara Datta. He creado un servicio de abonado

import {Injectable} from '@angular/core';
import {Subject} from 'rxjs';

@Injectable({
  providedIn: 'root'
})
export class Subscriber<T>
{
  protected observable = new Subject<T>();

  public next(item: T)
  {
    this.observable.next(item);
  }

  public subscribe(callback: (item:T)=>void) {
    this.observable.subscribe(callback);
  }
}

Cada vez que necesito dos componentes para compartir alguna información, inyecto este servicio en el constructor que se suscribe a él:

 constructor(protected layoutOptions: Subscriber<Partial<LayoutOptions>>)
 {
    layoutOptions.subscribe(options => this.options = Object.assign({}, this.options, options));
 }

Y el que lo actualiza

constructor(protected router: Router, protected apiService: ApiService, protected layoutOptions: Subscriber<Partial<LayoutOptions>>)
  {
    this.layoutOptions.next({showNavBar: false});
  }