Since angular 2 rc5 dynamic components instantiated via "ComponentFactoryResolver" should be obligatory declared in "entryComponents" declaration of containing module.
Usually such declaration looks like this:
@NgModule({
    entryComponents: [
        DynamicComponent,
        SecondDynamicComponent
    ],
    declarations: [
        DynamicComponent,
        SecondDynamicComponent
    ]
})
From one side this approach is completely great, because according to it we are enforced to declare components separately from place where they are going to be instantiated. And we will also have to declare all module dependencies and contents in obvious and generalized way.

But from other side sometimes we may need to generate our components in completely dynamic way, for example we need to apply some logic to compose template for our component "on fly". And if we have such need then we will not be able to declare such "completely dynamic" components in "entryComponents" components list, because such components are usually composed far after module initialization. It is usually done during the work of our application. For such case I would like to suggest one solution which is not documented in official docs. Let's call it a "component generator".
Here follows the listing for our components generator service:
import {
    Component,
    ComponentFactory,
    NgModule,
    Input,
    Injectable
} from '@angular/core';
import { RuntimeCompiler } from '@angular/compiler';

let find = require('lodash/find');

@Injectable()
export class GeneratorService {

    constructor(
        protected compiler: RuntimeCompiler
    ) { }

    public createComponentFactory(
        tmpl: string,
        selector: string = ''
    ): Promise<ComponentFactory<any>> {
        let type = this._createNewComponent(tmpl, selector);
        let module = this._createComponentModule(type);

        return new Promise((resolve) => {
            this.compiler
                .compileModuleAndAllComponentsAsync(module)
                .then((moduleWithFactories) => {
                    let factory = find(
                        moduleWithFactories.componentFactories,
                        {
                            componentType: type
                        }
                    );
                    resolve(factory);
                });
        });
    }

    protected _createNewComponent(tmpl: string, selector: string) {
        @Component({
            selector: selector || 'dynamic-component',
            template: tmpl
        })
        class DynamicComponent {
            @Input() public entity: any;
        };

        return DynamicComponent;
    }

    protected _createComponentModule(componentType: any) {
        @NgModule({
            imports: [],
            declarations: [
                componentType
            ]
        })
        class DynamicComponentModule {}

        return DynamicComponentModule;
    }
}
Firstly let's see how this service works step by step:
1. createComponentFactory - accepts template which you generated for your dynamic component
2. _createNewComponent - creates a component itself
3. _createComponentModule - generates a new module and assigns component created by _createNewComponent to it.
4. Compiles module generated by _createComponentModule, selects component factory for your dynamic component and returns promise which will resolve with factory for your component.

As you see generator service itself is simple, now let's see how it is going to be used:
@Component({
    selector: 'component-with-dynamic-children',
    template: ''
})
export class SomeComponent {

    constructor(
        private _viewContainerRef: ViewContainerRef,
        private _componentGenerator: GeneratorService
    ) {}

    ngOnInit() {
        this._componentGenerator.createComponentFactory(
            'this will be a template for dynamic component'
        ).then((factory: ComponentFactory<any>) => {
            this._viewContainerRef.createComponent(
                factory
            );
        });
    }
}
Here you have a component which replaces itself with dynamically generated component which is generated and instantiated on init.
This is how generation of components with dynamic templates looks like.