diff --git a/src/main/ts/di/LifetimeManager.ts b/src/main/ts/di/LifetimeManager.ts
--- a/src/main/ts/di/LifetimeManager.ts
+++ b/src/main/ts/di/LifetimeManager.ts
@@ -1,6 +1,7 @@
 import { IDestroyable, MapOf } from "../interfaces";
 import { argumentNotNull, isDestroyable } from "../safe";
-import { ILifetimeManager } from "./interfaces";
+import { ILifetimeManager, ILifetime } from "./interfaces";
+import { ActivationContext } from "./ActivationContext";
 
 function safeCall(item: () => void) {
     try {
@@ -15,32 +16,53 @@ export class LifetimeManager implements 
     private _cache: MapOf<any> = {};
     private _destroyed = false;
 
-    has(id: string) {
-        return id in this._cache;
-    }
+    initialize(id: string, context: ActivationContext<any>): ILifetime {
+        const self = this;
+        let pending = false;
+        return {
+            has() {
+                return (id in self._cache);
+            },
+
+            get() {
+                const t = self._cache[id];
+                if (t === undefined)
+                    throw new Error(`The item with with the key ${id} isn't found`);
+                return t;
+            },
 
-    get(id: string) {
-        const t = this._cache[id];
-        if (t === undefined)
-            throw new Error(`The item with with the key ${id} isn't found`);
-        return t;
+            enter() {
+                if (pending)
+                    throw Error(`Cyclic reference detected: the item with the key ${id} is already activating.`);
+                pending = true;
+            },
+
+            store(item: any, cleanup?: (item: any) => void) {
+                argumentNotNull(id, "id");
+                argumentNotNull(item, "item");
+
+                if (this.has())
+                    throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
+                pending = false;
+
+                self._cache[id] = item;
+
+                if (self._destroyed)
+                    throw new Error("Lifetime manager is destroyed");
+                if (cleanup) {
+                    self._cleanup.push(() => cleanup(item));
+                } else if (isDestroyable(item)) {
+                    self._cleanup.push(() => item.destroy());
+                }
+            }
+        };
     }
 
-    register(id: string, item: any, cleanup?: (item: any) => void) {
-        argumentNotNull(id, "id");
-        argumentNotNull(item, "item");
-        if (this.has(id))
-            throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
-        this._cache[id] = item;
+
+
 
-        if (this._destroyed)
-            throw new Error("Lifetime manager is destroyed");
-        if (cleanup) {
-            this._cleanup.push(() => cleanup(item));
-        } else if (isDestroyable(item)) {
-            this._cleanup.push(() => item.destroy());
-        }
-    }
+
+
 
     destroy() {
         if (!this._destroyed) {
diff --git a/src/main/ts/di/ServiceDescriptor.ts b/src/main/ts/di/ServiceDescriptor.ts
--- a/src/main/ts/di/ServiceDescriptor.ts
+++ b/src/main/ts/di/ServiceDescriptor.ts
@@ -22,14 +22,15 @@ function injectMethod<T, M extends keyof
         return m.call(target, _parse(args, context, "." + method));
 }
 
-function makeClenupCallback<T>(method: Cleaner<T>) {
+function makeCleanupCallback<T>(method: Cleaner<T>) {
     if (typeof (method) === "function") {
         return (target: T) => {
             method(target);
         };
     } else {
         return (target: T) => {
-            (target[method] as any)();
+            const m = target[method] as any;
+            m.apply(target);
         };
     }
 }
@@ -102,7 +103,7 @@ export class ServiceDescriptor<S extends
                 throw new Error(
                     "The cleanup parameter must be either a function or a function name");
 
-            this._cleanup = makeClenupCallback(opts.cleanup);
+            this._cleanup = makeCleanupCallback(opts.cleanup);
         }
     }
 
@@ -112,6 +113,7 @@ export class ServiceDescriptor<S extends
         if (lifetime.has()) {
             return lifetime.get();
         } else {
+            lifetime.enter();
             const instance = this._create(context);
             lifetime.store(this._cacheId, this._cleanup);
             return instance;
diff --git a/src/main/ts/di/interfaces.ts b/src/main/ts/di/interfaces.ts
--- a/src/main/ts/di/interfaces.ts
+++ b/src/main/ts/di/interfaces.ts
@@ -46,6 +46,10 @@ export interface ILifetimeManager extend
 
 export interface ILifetime {
     has(): boolean;
+
     get(): any;
+
+    enter(): void;
+
     store(item: any, cleanup?: (item: any) => void): void;
 }
\ No newline at end of file