diff --git a/SmallInjector.cs b/SmallInjector.cs
index 98a2dee..7b6ea80 100644
--- a/SmallInjector.cs
+++ b/SmallInjector.cs
@@ -16,16 +16,17 @@ namespace SmallInjectorDemo
         /// <typeparam name="TService">Type of the service.</typeparam>
         /// <typeparam name="TInterface">Type of the interface of the service.</typeparam>
         /// <param name="isSingleton">True if the service should be singleton. False otherwise.</param>
-        public void RegisterType<TService, TInterface>(bool isSingleton)
+        /// <param name="instance">instance of the service</param>
+        public void RegisterType<TService, TInterface>(bool isSingleton, TService instance = default(TService))
         {
-            _container.Add(typeof(TInterface), new RegisteredType(typeof(TService), isSingleton));
+            _container.Add(typeof(TInterface), new RegisteredType(typeof(TService), isSingleton, null));
         }
 
         /// <summary>
         /// Register types in the resolve container.
         /// </summary>
         /// <typeparam name="TService">Type of the service.</typeparam>
-        public void RegisterType<TService>(bool isSingleton) => RegisterType<TService, TService>(isSingleton);
+        public void RegisterType<TService>(bool isSingleton, TService instance = default(TService)) => RegisterType<TService, TService>(isSingleton, instance);
 
         /// <summary>
         /// Resolve service of specified type.
@@ -42,38 +43,33 @@ namespace SmallInjectorDemo
         public object Resolve(Type serviceInterface)
         {
             if (!_container.TryGetValue(serviceInterface, out var registeredType))
-            {
                 throw new Exception("Can't resolve dependency " + serviceInterface);
-            }
 
-            if (registeredType.IsSingleton && registeredType.SingletonInstance != null)
-                return registeredType.SingletonInstance;
-            var constructor = registeredType.ConcreteType.GetConstructors()[0];
+            if (registeredType.IsSingleton && registeredType.Instance != null)
+                return registeredType.Instance;
+            var constructor = registeredType.ServiceType.GetConstructors()[0];
             var parameters = constructor.GetParameters();
             var constructorParameters = new object[parameters.Length];
             for (var i = 0; i < parameters.Length; i++)
             {
                 constructorParameters[i] = Resolve(parameters[i].ParameterType);
             }
-
-            if (registeredType.IsSingleton)
-            {
-                return registeredType.SingletonInstance ?? (registeredType.SingletonInstance = constructor.Invoke(constructorParameters));
-            }
-            return constructor.Invoke(constructorParameters);
+            var instance = constructor.Invoke(constructorParameters);
+            return registeredType.IsSingleton ? (registeredType.Instance = instance) : instance;
         }
 
         private class RegisteredType
         {
-            public RegisteredType(Type concreteType, bool isSingleton)
+            public RegisteredType(Type serviceType, bool isSingleton, object instance)
             {
-                ConcreteType = concreteType;
+                ServiceType = serviceType;
                 IsSingleton = isSingleton;
+                Instance = instance;
             }
 
             public readonly bool IsSingleton;
-            public readonly Type ConcreteType;
-            public object SingletonInstance { get; set; }
+            public readonly Type ServiceType;
+            public object Instance { get; set; }
         }
     }
 }
\ No newline at end of file