diff --git a/ObjectFiller.Test/ObjectFiller.Test.csproj b/ObjectFiller.Test/ObjectFiller.Test.csproj
index c9fa1aa..e9e5ba4 100644
--- a/ObjectFiller.Test/ObjectFiller.Test.csproj
+++ b/ObjectFiller.Test/ObjectFiller.Test.csproj
@@ -73,6 +73,7 @@
     <Compile Include="SequenceGeneratorTest.cs" />
     <Compile Include="TestPoco\Person\OrderedPersonProperties.cs" />
     <Compile Include="TestPoco\SimpleList.cs" />
+    <Compile Include="SaveFillerSetupTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ObjectFiller\ObjectFiller.csproj">
diff --git a/ObjectFiller.Test/SaveFillerSetupTest.cs b/ObjectFiller.Test/SaveFillerSetupTest.cs
new file mode 100644
index 0000000..64513d0
--- /dev/null
+++ b/ObjectFiller.Test/SaveFillerSetupTest.cs
@@ -0,0 +1,77 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using ObjectFiller.Test.TestPoco.Person;
+using Tynamix.ObjectFiller;
+
+namespace ObjectFiller.Test
+{
+    [TestClass]
+    public class SaveFillerSetupTest
+    {
+        private FillerSetup _fillerSetup;
+
+        [TestInitialize]
+        public void GetFillerSetup()
+        {
+
+            Filler<Person> filler = new Filler<Person>();
+            _fillerSetup = filler.Setup()
+                 .OnType<IAddress>().CreateInstanceOf<Address>()
+                 .OnProperty(x => x.Age).Use(new IntRange(18, 35))
+                 .OnProperty(x => x.FirstName).Use(new RealNames(RealNameStyle.FirstNameOnly))
+                 .OnProperty(x => x.LastName).Use(new RealNames(RealNameStyle.LastNameOnly))
+                 .SetupFor<Address>()
+                 .OnProperty(x => x.HouseNumber).Use(new IntRange(1, 100))
+                 .Result;
+
+        }
+
+        [TestMethod]
+        public void UseSavedFillerDefaultSetup()
+        {
+            Filler<Person> filler = new Filler<Person>();
+            filler.Setup(_fillerSetup);
+
+            Person p = filler.Create();
+
+            Assert.IsTrue(p.Age < 35 && p.Age >= 18);
+            Assert.IsTrue(p.Address.HouseNumber < 100 && p.Age >= 1);
+        }
+
+
+        [TestMethod]
+        public void UseSavedFillerSetupWithExtensions()
+        {
+            var dateNow = DateTime.Now;
+            Filler<Person> filler = new Filler<Person>();
+            filler.Setup(_fillerSetup)
+                .OnProperty(x => x.Birthdate).Use(() => dateNow);
+
+            Person p = filler.Create();
+
+            Assert.IsTrue(p.Age < 35 && p.Age >= 18);
+            Assert.IsTrue(p.Address.HouseNumber < 100 && p.Age >= 1);
+            Assert.AreEqual(p.Birthdate, dateNow);
+
+        }
+
+        [TestMethod]
+        public void UseSavedFillerSetupWithOverrides()
+        {
+            Filler<Person> filler = new Filler<Person>();
+            filler.Setup(_fillerSetup)
+                .OnProperty(x => x.Age).Use(() => 1000)
+                .SetupFor<Address>()
+                .OnProperty(x => x.HouseNumber).Use(() => 9999);
+
+            Person p = filler.Create();
+
+            Assert.AreEqual(p.Age, 1000);
+            Assert.AreEqual(p.Address.HouseNumber, 9999);
+
+        }
+
+
+
+    }
+}
diff --git a/ObjectFiller/Filler.cs b/ObjectFiller/Filler.cs
index 105097e..29db437 100644
--- a/ObjectFiller/Filler.cs
+++ b/ObjectFiller/Filler.cs
@@ -22,8 +22,6 @@ public class Filler<T> where T : class
         public Filler()
         {
             _setupManager = new SetupManager();
-
-            _setupManager.Clear();
         }
 
         /// <summary>
@@ -32,20 +30,23 @@ public Filler()
         /// <returns>Fluent API setup</returns>
         public FluentFillerApi<T> Setup()
         {
-            return new FluentFillerApi<T>(_setupManager);
+            return Setup(null);
         }
 
-
         /// <summary>
-        /// This will create your object of type <see cref="T"/> and overrides the setup for the generation.
-        /// Use this method if you don't wan't to use the FluentAPI
+        /// Call this to start the setup for the <see cref="Filler{T}"/> and use a setup which you created
+        /// before with the FluentApi
         /// </summary>
-        /// <param name="setup">Setup for the objectfiller</param>
-        /// <returns>Object which is filled with random data</returns>
-        public T Create(ObjectFillerSetup setup)
+        /// <param name="fillerSetupToUse">FillerSetup to use</param>
+        /// <returns>Fluebt API Setup</returns>
+        public FluentFillerApi<T> Setup(FillerSetup fillerSetupToUse)
         {
-            _setupManager.SetMain(setup);
-            return Create();
+            if (fillerSetupToUse != null)
+            {
+                _setupManager.FillerSetup = fillerSetupToUse;
+            }
+            return new FluentFillerApi<T>(_setupManager);
+
         }
 
         /// <summary>
@@ -75,20 +76,6 @@ public IEnumerable<T> Create(int count)
             }
         }
 
-        /// <summary>
-        /// This will fill your instance of an object of type <see cref="T"/> and overrides the setup for the generation.
-        /// Use this method if you don't wan't to use the FluentAPI
-        /// </summary>
-        /// <param name="instanceToFill">The instance which will get filled with random data.</param>
-        /// <param name="setup">Setup for the objectfiller</param>
-        /// <returns>Instance which is filled with random data</returns>
-        public T Fill(T instanceToFill, ObjectFillerSetup setup)
-        {
-            _setupManager.SetMain(setup);
-            return Create();
-        }
-
-
         /// <summary>
         /// Fills your object instance. Call this after you finished your setup with the FluentAPI
         /// </summary>
@@ -100,7 +87,7 @@ public T Fill(T instanceToFill)
         }
 
 
-        private object CreateInstanceOfType(Type type, ObjectFillerSetup currentSetup)
+        private object CreateInstanceOfType(Type type, FillerSetupItem currentSetupItem)
         {
             List<object> constructorArgs = new List<object>();
 
@@ -113,11 +100,11 @@ private object CreateInstanceOfType(Type type, ObjectFillerSetup currentSetup)
                     {
                         Type[] paramTypes = ctorInfo.GetParameters().Select(p => p.ParameterType).ToArray();
 
-                        if (paramTypes.All(t => TypeIsValidForObjectFiller(t, currentSetup)))
+                        if (paramTypes.All(t => TypeIsValidForObjectFiller(t, currentSetupItem)))
                         {
                             foreach (Type paramType in paramTypes)
                             {
-                                constructorArgs.Add(GetFilledObject(paramType, currentSetup));
+                                constructorArgs.Add(GetFilledObject(paramType, currentSetupItem));
                             }
 
                             break;
@@ -142,7 +129,7 @@ private void FillInternal(object objectToFill, HashStack<Type> typeTracker = nul
         {
             var currentSetup = _setupManager.GetFor(objectToFill.GetType());
             var targetType = objectToFill.GetType();
-        
+
             typeTracker = typeTracker ?? new HashStack<Type>();
 
             if (currentSetup.TypeToRandomFunc.ContainsKey(targetType))
@@ -196,18 +183,18 @@ private void SetPropertyValue(PropertyInfo property, object objectToFill, object
             }
         }
 
-        private Queue<PropertyInfo> OrderPropertiers(ObjectFillerSetup currentSetup, PropertyInfo[] properties)
+        private Queue<PropertyInfo> OrderPropertiers(FillerSetupItem currentSetupItem, PropertyInfo[] properties)
         {
             Queue<PropertyInfo> propertyQueue = new Queue<PropertyInfo>();
-            var firstProperties = currentSetup.PropertyOrder
+            var firstProperties = currentSetupItem.PropertyOrder
                                               .Where(x => x.Value == At.TheBegin && ContainsProperty(properties, x.Key))
                                               .Select(x => x.Key).ToList();
 
-            var lastProperties = currentSetup.PropertyOrder
+            var lastProperties = currentSetupItem.PropertyOrder
                                               .Where(x => x.Value == At.TheEnd && ContainsProperty(properties, x.Key))
                                               .Select(x => x.Key).ToList();
 
-            var propertiesWithoutOrder = properties.Where(x => !ContainsProperty(currentSetup.PropertyOrder.Keys, x)).ToList();
+            var propertiesWithoutOrder = properties.Where(x => !ContainsProperty(currentSetupItem.PropertyOrder.Keys, x)).ToList();
 
 
             firstProperties.ForEach(propertyQueue.Enqueue);
@@ -217,9 +204,9 @@ private Queue<PropertyInfo> OrderPropertiers(ObjectFillerSetup currentSetup, Pro
             return propertyQueue;
         }
 
-        private bool IgnoreProperty(PropertyInfo property, ObjectFillerSetup currentSetup)
+        private bool IgnoreProperty(PropertyInfo property, FillerSetupItem currentSetupItem)
         {
-            return ContainsProperty(currentSetup.PropertiesToIgnore, property);
+            return ContainsProperty(currentSetupItem.PropertiesToIgnore, property);
         }
 
         private bool ContainsProperty(IEnumerable<PropertyInfo> properties, PropertyInfo property)
@@ -246,34 +233,34 @@ private IEnumerable<PropertyInfo> GetPropertyFromProperties(IEnumerable<Property
             return properties.Where(x => x.MetadataToken == property.MetadataToken && x.Module.Equals(property.Module));
         }
 
-        private object GetFilledObject(Type type, ObjectFillerSetup currentSetup, HashStack<Type> typeTracker = null)
+        private object GetFilledObject(Type type, FillerSetupItem currentSetupItem, HashStack<Type> typeTracker = null)
         {
-            if (HasTypeARandomFunc(type, currentSetup))
+            if (HasTypeARandomFunc(type, currentSetupItem))
             {
-                return GetRandomValue(type, currentSetup);
+                return GetRandomValue(type, currentSetupItem);
             }
 
             if (TypeIsDictionary(type))
             {
-                IDictionary dictionary = GetFilledDictionary(type, currentSetup);
+                IDictionary dictionary = GetFilledDictionary(type, currentSetupItem);
 
                 return dictionary;
             }
 
             if (TypeIsList(type))
             {
-                IList list = GetFilledList(type, currentSetup);
+                IList list = GetFilledList(type, currentSetupItem);
                 return list;
             }
 
             if (type.IsInterface)
             {
-                return GetInterfaceInstance(type, currentSetup);
+                return GetInterfaceInstance(type, currentSetupItem);
             }
 
             if (TypeIsPoco(type))
             {
-                return GetFilledPoco(type, currentSetup, typeTracker);
+                return GetFilledPoco(type, currentSetupItem, typeTracker);
             }
 
             if (TypeIsEnum(type))
@@ -281,7 +268,7 @@ private object GetFilledObject(Type type, ObjectFillerSetup currentSetup, HashSt
                 return GetRandomEnumValue(type);
             }
 
-            object newValue = GetRandomValue(type, currentSetup);
+            object newValue = GetRandomValue(type, currentSetupItem);
             return newValue;
         }
 
@@ -297,7 +284,7 @@ private object GetRandomEnumValue(Type type)
             return 0;
         }
 
-        private object GetFilledPoco(Type type, ObjectFillerSetup currentSetup, HashStack<Type> typeTracker)
+        private object GetFilledPoco(Type type, FillerSetupItem currentSetupItem, HashStack<Type> typeTracker)
         {
             if (typeTracker != null)
             {
@@ -312,7 +299,7 @@ private object GetFilledPoco(Type type, ObjectFillerSetup currentSetup, HashStac
                 typeTracker.Push(type);
             }
 
-            object result = CreateInstanceOfType(type, currentSetup);
+            object result = CreateInstanceOfType(type, currentSetupItem);
 
             FillInternal(result, typeTracker);
 
@@ -325,17 +312,17 @@ private object GetFilledPoco(Type type, ObjectFillerSetup currentSetup, HashStac
             return result;
         }
 
-        private IDictionary GetFilledDictionary(Type propertyType, ObjectFillerSetup currentSetup)
+        private IDictionary GetFilledDictionary(Type propertyType, FillerSetupItem currentSetupItem)
         {
             IDictionary dictionary = (IDictionary)Activator.CreateInstance(propertyType);
             Type keyType = propertyType.GetGenericArguments()[0];
             Type valueType = propertyType.GetGenericArguments()[1];
 
-            int maxDictionaryItems = Random.Next(currentSetup.DictionaryKeyMinCount,
-                currentSetup.DictionaryKeyMaxCount);
+            int maxDictionaryItems = Random.Next(currentSetupItem.DictionaryKeyMinCount,
+                currentSetupItem.DictionaryKeyMaxCount);
             for (int i = 0; i < maxDictionaryItems; i++)
             {
-                object keyObject = GetFilledObject(keyType, currentSetup);
+                object keyObject = GetFilledObject(keyType, currentSetupItem);
 
                 if (dictionary.Contains(keyObject))
                 {
@@ -344,19 +331,19 @@ private IDictionary GetFilledDictionary(Type propertyType, ObjectFillerSetup cur
                     throw new ArgumentException(message);
                 }
 
-                object valueObject = GetFilledObject(valueType, currentSetup);
+                object valueObject = GetFilledObject(valueType, currentSetupItem);
                 dictionary.Add(keyObject, valueObject);
             }
             return dictionary;
         }
 
-        private static bool HasTypeARandomFunc(Type type, ObjectFillerSetup currentSetup)
+        private static bool HasTypeARandomFunc(Type type, FillerSetupItem currentSetupItem)
         {
-            return currentSetup.TypeToRandomFunc.ContainsKey(type);
+            return currentSetupItem.TypeToRandomFunc.ContainsKey(type);
         }
 
 
-        private IList GetFilledList(Type propertyType, ObjectFillerSetup currentSetup)
+        private IList GetFilledList(Type propertyType, FillerSetupItem currentSetupItem)
         {
             Type genType = propertyType.GetGenericArguments()[0];
 
@@ -379,52 +366,52 @@ private IList GetFilledList(Type propertyType, ObjectFillerSetup currentSetup)
             }
 
 
-            int maxListItems = Random.Next(currentSetup.ListMinCount, currentSetup.ListMaxCount);
+            int maxListItems = Random.Next(currentSetupItem.ListMinCount, currentSetupItem.ListMaxCount);
             for (int i = 0; i < maxListItems; i++)
             {
-                object listObject = GetFilledObject(genType, currentSetup);
+                object listObject = GetFilledObject(genType, currentSetupItem);
                 list.Add(listObject);
             }
             return list;
         }
 
-        private object GetInterfaceInstance(Type interfaceType, ObjectFillerSetup setup)
+        private object GetInterfaceInstance(Type interfaceType, FillerSetupItem setupItem)
         {
             object result;
-            if (setup.TypeToRandomFunc.ContainsKey(interfaceType))
+            if (setupItem.TypeToRandomFunc.ContainsKey(interfaceType))
             {
-                return setup.TypeToRandomFunc[interfaceType]();
+                return setupItem.TypeToRandomFunc[interfaceType]();
             }
-            if (setup.InterfaceToImplementation.ContainsKey(interfaceType))
+            if (setupItem.InterfaceToImplementation.ContainsKey(interfaceType))
             {
-                Type implType = setup.InterfaceToImplementation[interfaceType];
-                result = CreateInstanceOfType(implType, setup);
+                Type implType = setupItem.InterfaceToImplementation[interfaceType];
+                result = CreateInstanceOfType(implType, setupItem);
             }
             else
             {
-                if (setup.InterfaceMocker == null)
+                if (setupItem.InterfaceMocker == null)
                 {
                     string message = string.Format("ObjectFiller Interface mocker missing and type [{0}] not registered", interfaceType.Name);
                     Debug.WriteLine("ObjectFiller: " + message);
                     throw new InvalidOperationException(message);
                 }
 
-                MethodInfo method = setup.InterfaceMocker.GetType().GetMethod("Create");
+                MethodInfo method = setupItem.InterfaceMocker.GetType().GetMethod("Create");
                 MethodInfo genericMethod = method.MakeGenericMethod(new[] { interfaceType });
-                result = genericMethod.Invoke(setup.InterfaceMocker, null);
+                result = genericMethod.Invoke(setupItem.InterfaceMocker, null);
             }
             FillInternal(result);
             return result;
         }
 
-        private object GetRandomValue(Type propertyType, ObjectFillerSetup setup)
+        private object GetRandomValue(Type propertyType, FillerSetupItem setupItem)
         {
-            if (setup.TypeToRandomFunc.ContainsKey(propertyType))
+            if (setupItem.TypeToRandomFunc.ContainsKey(propertyType))
             {
-                return setup.TypeToRandomFunc[propertyType]();
+                return setupItem.TypeToRandomFunc[propertyType]();
             }
 
-            if (setup.IgnoreAllUnknownTypes)
+            if (setupItem.IgnoreAllUnknownTypes)
             {
                 if (propertyType.IsValueType)
                 {
@@ -438,19 +425,19 @@ private object GetRandomValue(Type propertyType, ObjectFillerSetup setup)
             throw new TypeInitializationException(propertyType.FullName, new Exception(message));
         }
 
-        private static bool TypeIsValidForObjectFiller(Type type, ObjectFillerSetup currentSetup)
+        private static bool TypeIsValidForObjectFiller(Type type, FillerSetupItem currentSetupItem)
         {
-            return HasTypeARandomFunc(type, currentSetup)
-                   || (TypeIsList(type) && ListParamTypeIsValid(type, currentSetup))
-                   || (TypeIsDictionary(type) && DictionaryParamTypesAreValid(type, currentSetup))
+            return HasTypeARandomFunc(type, currentSetupItem)
+                   || (TypeIsList(type) && ListParamTypeIsValid(type, currentSetupItem))
+                   || (TypeIsDictionary(type) && DictionaryParamTypesAreValid(type, currentSetupItem))
                    || TypeIsPoco(type)
                    || (type.IsInterface
-                        && currentSetup.InterfaceToImplementation.ContainsKey(type)
-                        || currentSetup.InterfaceMocker != null);
+                        && currentSetupItem.InterfaceToImplementation.ContainsKey(type)
+                        || currentSetupItem.InterfaceMocker != null);
 
         }
 
-        private static bool DictionaryParamTypesAreValid(Type type, ObjectFillerSetup currentSetup)
+        private static bool DictionaryParamTypesAreValid(Type type, FillerSetupItem currentSetupItem)
         {
             if (!TypeIsDictionary(type))
             {
@@ -460,11 +447,11 @@ private static bool DictionaryParamTypesAreValid(Type type, ObjectFillerSetup cu
             Type keyType = type.GetGenericArguments()[0];
             Type valueType = type.GetGenericArguments()[1];
 
-            return TypeIsValidForObjectFiller(keyType, currentSetup) &&
-                   TypeIsValidForObjectFiller(valueType, currentSetup);
+            return TypeIsValidForObjectFiller(keyType, currentSetupItem) &&
+                   TypeIsValidForObjectFiller(valueType, currentSetupItem);
         }
 
-        private static bool ListParamTypeIsValid(Type type, ObjectFillerSetup setup)
+        private static bool ListParamTypeIsValid(Type type, FillerSetupItem setupItem)
         {
             if (!TypeIsList(type))
             {
@@ -472,7 +459,7 @@ private static bool ListParamTypeIsValid(Type type, ObjectFillerSetup setup)
             }
             Type genType = type.GetGenericArguments()[0];
 
-            return TypeIsValidForObjectFiller(genType, setup);
+            return TypeIsValidForObjectFiller(genType, setupItem);
         }
 
         private static bool TypeIsPoco(Type type)
diff --git a/ObjectFiller/ObjectFiller.csproj b/ObjectFiller/ObjectFiller.csproj
index 990827d..6d9605f 100644
--- a/ObjectFiller/ObjectFiller.csproj
+++ b/ObjectFiller/ObjectFiller.csproj
@@ -38,6 +38,7 @@
   <ItemGroup>
     <Compile Include="Plugins\String\Lipsum.cs" />
     <Compile Include="HashStack.cs" />
+    <Compile Include="Setup\FillerSetup.cs" />
     <Compile Include="Setup\FluentFillerApi.cs" />
     <Compile Include="Setup\FluentPropertyApi.cs" />
     <Compile Include="Setup\FluentTypeApi.cs" />
@@ -62,7 +63,7 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="Setup\ObjectFillerSetup.cs" />
+    <Compile Include="Setup\FillerSetupItem.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
diff --git a/ObjectFiller/Setup/FillerSetup.cs b/ObjectFiller/Setup/FillerSetup.cs
new file mode 100644
index 0000000..81d2c45
--- /dev/null
+++ b/ObjectFiller/Setup/FillerSetup.cs
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+
+namespace Tynamix.ObjectFiller
+{
+    public class FillerSetup
+    {
+        public FillerSetup()
+        {
+            TypeToFillerSetup = new Dictionary<Type, FillerSetupItem>();
+            MainSetupItem = new FillerSetupItem();
+        }
+        internal FillerSetupItem MainSetupItem { get; private set; }
+
+        internal Dictionary<Type, FillerSetupItem> TypeToFillerSetup { get; private set; }
+    }
+}
\ No newline at end of file
diff --git a/ObjectFiller/Setup/ObjectFillerSetup.cs b/ObjectFiller/Setup/FillerSetupItem.cs
similarity index 80%
rename from ObjectFiller/Setup/ObjectFillerSetup.cs
rename to ObjectFiller/Setup/FillerSetupItem.cs
index 032db17..9f11c28 100644
--- a/ObjectFiller/Setup/ObjectFillerSetup.cs
+++ b/ObjectFiller/Setup/FillerSetupItem.cs
@@ -4,9 +4,9 @@
 
 namespace Tynamix.ObjectFiller
 {
-    public class ObjectFillerSetup
+    internal class FillerSetupItem
     {
-        public ObjectFillerSetup()
+        internal FillerSetupItem()
         {
             ListMinCount = 1;
             ListMaxCount = 25;
@@ -48,42 +48,42 @@ private void SetDefaultRandomizer()
         /// <summary>
         /// Defines in which order the properties get handled.
         /// </summary>
-        public Dictionary<PropertyInfo, At> PropertyOrder { get; private set; }
+        internal Dictionary<PropertyInfo, At> PropertyOrder { get; private set; }
 
         /// <summary>
         /// Contains the Type to random data generator func
         /// </summary>
-        public Dictionary<Type, Func<object>> TypeToRandomFunc { get; private set; }
+        internal Dictionary<Type, Func<object>> TypeToRandomFunc { get; private set; }
 
         /// <summary>
         /// Contains the Property to random data generator func
         /// </summary>
-        public Dictionary<PropertyInfo, Func<object>> PropertyToRandomFunc { get; private set; }
+        internal Dictionary<PropertyInfo, Func<object>> PropertyToRandomFunc { get; private set; }
 
         /// <summary>
         /// Contains the type of interface with the corresponding implementation
         /// </summary>
-        public Dictionary<Type, Type> InterfaceToImplementation { get; private set; }
+        internal Dictionary<Type, Type> InterfaceToImplementation { get; private set; }
 
         /// <summary>
         /// List with all properties which will be ignored while generating test data
         /// </summary>
-        public List<PropertyInfo> PropertiesToIgnore { get; private set; }
+        internal List<PropertyInfo> PropertiesToIgnore { get; private set; }
 
         /// <summary>
         /// All types which will be ignored completly
         /// </summary>
-        public List<Type> TypesToIgnore { get; private set; }
+        internal List<Type> TypesToIgnore { get; private set; }
 
         /// <summary>
         /// Minimum count of list items which will be generated 
         /// </summary>
-        public int ListMinCount { get; set; }
+        internal int ListMinCount { get; set; }
 
         /// <summary>
         /// Maximum count of list items which will be generated 
         /// </summary>
-        public int ListMaxCount { get; set; }
+        internal int ListMaxCount { get; set; }
 
         /// <summary>
         /// Minimum count of key items within a dictionary which will be generated 
@@ -93,17 +93,17 @@ private void SetDefaultRandomizer()
         /// <summary>
         /// Maximum count of key items within a dictionary which will be generated 
         /// </summary>
-        public int DictionaryKeyMaxCount { get; set; }
+        internal int DictionaryKeyMaxCount { get; set; }
 
         /// <summary>
         /// Interface Mocker for interface generation
         /// </summary>
-        public IInterfaceMocker InterfaceMocker { get; set; }
+        internal IInterfaceMocker InterfaceMocker { get; set; }
 
         /// <summary>
         /// True if all unknown types will be ignored by the objectfiller
         /// </summary>
-        public bool IgnoreAllUnknownTypes { get; set; }
+        internal bool IgnoreAllUnknownTypes { get; set; }
 
     }
 }
diff --git a/ObjectFiller/Setup/FluentFillerApi.cs b/ObjectFiller/Setup/FluentFillerApi.cs
index 04525c0..ae15cad 100644
--- a/ObjectFiller/Setup/FluentFillerApi.cs
+++ b/ObjectFiller/Setup/FluentFillerApi.cs
@@ -20,6 +20,11 @@ internal FluentFillerApi(SetupManager setupManager)
             _setupManager = setupManager;
         }
 
+        public FillerSetup Result
+        {
+            get { return _setupManager.FillerSetup; }
+        }
+
         /// <summary>
         /// Start to configure a type for objectfiller. The follow up methods will be found in the <see cref="FluentTypeApi{TTargetObject,TTargetType}"/>
         /// </summary>
@@ -85,7 +90,7 @@ public FluentFillerApi<TTargetObject> IgnoreAllUnknownTypes()
             _setupManager.GetFor<TTargetObject>().IgnoreAllUnknownTypes = true;
 
             return this;
-        } 
+        }
 
         /// <summary>
         /// Setup the minimum and maximum item count for lists. The ObjectFiller will not generate more or less listitems then this limits.
@@ -134,11 +139,11 @@ public FluentFillerApi<TTargetObject> SetInterfaceMocker(IInterfaceMocker mocker
         {
             if (_setupManager.GetFor<TTargetObject>().InterfaceMocker != null)
             {
-	            const string message = "You can not set a interface mocker more than once!";
-				Debug.WriteLine("ObjectFiller: " + message);
-				throw new ArgumentException(message);
+                const string message = "You can not set a interface mocker more than once!";
+                Debug.WriteLine("ObjectFiller: " + message);
+                throw new ArgumentException(message);
             }
-	        _setupManager.GetFor<TTargetObject>().InterfaceMocker = mocker;
+            _setupManager.GetFor<TTargetObject>().InterfaceMocker = mocker;
             return this;
         }
 
diff --git a/ObjectFiller/Setup/SetupManager.cs b/ObjectFiller/Setup/SetupManager.cs
index 4e920bf..b7d7fac 100644
--- a/ObjectFiller/Setup/SetupManager.cs
+++ b/ObjectFiller/Setup/SetupManager.cs
@@ -4,74 +4,56 @@
 namespace Tynamix.ObjectFiller
 {
     /// <summary>
-    /// Responsible to get the right <see cref="ObjectFillerSetup"/> for a given type.
+    /// Responsible to get the right <see cref="FillerSetupItem"/> for a given type.
     /// </summary>
     internal class SetupManager
     {
-        private ObjectFillerSetup _mainSetup;
-        private Dictionary<Type, ObjectFillerSetup> _typeToSetup;
+       
+        internal FillerSetup FillerSetup { get;  set; }
 
         /// <summary>
         /// static ctor
         /// </summary>
         internal SetupManager()
         {
-            Clear();
+            FillerSetup = new FillerSetup();
         }
 
         /// <summary>
-        /// Gets the <see cref="ObjectFillerSetup"/> for a given type
+        /// Gets the <see cref="FillerSetupItem"/> for a given type
         /// </summary>
-        /// <typeparam name="TTargetObject">Type for which a <see cref="ObjectFillerSetup"/> will be get</typeparam>
-        /// <returns><see cref="ObjectFillerSetup"/> for type <see cref="TTargetObject"/></returns>
-        internal ObjectFillerSetup GetFor<TTargetObject>()
+        /// <typeparam name="TTargetObject">Type for which a <see cref="FillerSetupItem"/> will be get</typeparam>
+        /// <returns><see cref="FillerSetupItem"/> for type <see cref="TTargetObject"/></returns>
+        internal FillerSetupItem GetFor<TTargetObject>()
             where TTargetObject : class
         {
             return GetFor(typeof(TTargetObject));
         }
 
         /// <summary>
-        /// Gets the <see cref="ObjectFillerSetup"/> for a given type
+        /// Gets the <see cref="FillerSetupItem"/> for a given type
         /// </summary>
-        /// <param name="targetType">Type for which a <see cref="ObjectFillerSetup"/> will be get</param>
-        /// <returns><see cref="ObjectFillerSetup"/> for type <see cref="targetType"/></returns>
-        internal ObjectFillerSetup GetFor(Type targetType)
+        /// <param name="targetType">Type for which a <see cref="FillerSetupItem"/> will be get</param>
+        /// <returns><see cref="FillerSetupItem"/> for type <see cref="targetType"/></returns>
+        internal FillerSetupItem GetFor(Type targetType)
         {
-            if (_typeToSetup.ContainsKey(targetType))
+            if (FillerSetup.TypeToFillerSetup.ContainsKey(targetType))
             {
-                return _typeToSetup[targetType];
+                return FillerSetup.TypeToFillerSetup[targetType];
             }
 
-            return _mainSetup;
+            return FillerSetup.MainSetupItem;
         }
 
         /// <summary>
-        /// Sets a new <see cref="ObjectFillerSetup"/> for the given <see cref="TTargetObject"/>
+        /// Sets a new <see cref="FillerSetupItem"/> for the given <see cref="TTargetObject"/>
         /// </summary>
-        /// <typeparam name="TTargetObject">Type of target object for which a new <see cref="ObjectFillerSetup"/> will be set.</typeparam>
+        /// <typeparam name="TTargetObject">Type of target object for which a new <see cref="FillerSetupItem"/> will be set.</typeparam>
         /// <param name="useDefaultSettings">FALSE if the target object will take the settings of the parent object</param>
         internal void SetNewFor<TTargetObject>(bool useDefaultSettings)
             where TTargetObject : class
         {
-            _typeToSetup[typeof(TTargetObject)] = useDefaultSettings ? new ObjectFillerSetup() : _mainSetup;
-        }
-
-        /// <summary>
-        /// Set the main <see cref="ObjectFillerSetup"/>. This will be the root setup.
-        /// </summary>
-        /// <param name="setup">Main setup</param>
-        internal void SetMain(ObjectFillerSetup setup)
-        {
-            _mainSetup = setup;
-        }
-
-        /// <summary>
-        /// Clears all the settings which was made.
-        /// </summary>
-        internal void Clear()
-        {
-            _mainSetup = new ObjectFillerSetup();
-            _typeToSetup = new Dictionary<Type, ObjectFillerSetup>();
+            FillerSetup.TypeToFillerSetup[typeof(TTargetObject)] = useDefaultSettings ? new FillerSetupItem() : FillerSetup.MainSetupItem;
         }
     }
 }