Index: branches/CloningRefactorBranch/HeuristicLab.Core/AtomicOperation.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/AtomicOperation.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/AtomicOperation.cs	(revision 836)
@@ -47,4 +47,5 @@
     /// <summary>
     /// Initializes a new instance of <see cref="AtomicOperation"/>.
+    /// Empty constructor is needed for the persistence mechanism.
     /// </summary>
     public AtomicOperation() { }
Index: branches/CloningRefactorBranch/HeuristicLab.Core/ConstrainedItemBase.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/ConstrainedItemBase.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/ConstrainedItemBase.cs	(revision 836)
@@ -47,19 +47,13 @@
 
     /// <summary>
-    /// Clones the current instance (deep clone).
+    /// Copy constructor for deep cloning.
     /// </summary>
-    /// <remarks>Calls <see cref="StorableBase.Clone
-    /// (System.Collections.Generic.IDictionary&lt;System.Guid, object&gt;)"/> 
-    /// of base class <see cref="ItemBase"/>.<br/>
-    /// Deep clone through <see cref="Auxiliary.Clone"/> method of helper class 
-    /// <see cref="Auxiliary"/>.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="ConstrainedItemBase"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      ConstrainedItemBase clone = (ConstrainedItemBase)base.Clone(clonedObjects);
-      clone.myConstraints.Clear();
-      foreach (IConstraint constraint in Constraints)
-        clone.AddConstraint((IConstraint)Auxiliary.Clone(constraint, clonedObjects));
-      return clone;
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ConstrainedItemBase(ConstrainedItemBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      myConstraints = new List<IConstraint>();
+      foreach (IConstraint constraint in original.myConstraints)
+        AddConstraint((IConstraint)Auxiliary.Clone(constraint, clonedObjects));
     }
 
@@ -145,5 +139,5 @@
     }
 
-    #region Persistence Methods  
+    #region Persistence Methods
     /// <summary>
     /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
@@ -157,5 +151,5 @@
     /// (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
       if (Constraints.Count > 0) {
@@ -176,5 +170,5 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       XmlNode constraintsNode = node.SelectSingleNode("Constraints");
Index: branches/CloningRefactorBranch/HeuristicLab.Core/EngineBase.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/EngineBase.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/EngineBase.cs	(revision 836)
@@ -118,4 +118,22 @@
 
     /// <summary>
+    /// Copy constructor.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected EngineBase(EngineBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(original.OperatorGraph, clonedObjects);
+      this.myGlobalScope = (IScope)Auxiliary.Clone(original.GlobalScope, clonedObjects);
+      this.myExecutionTime = original.ExecutionTime;
+      IOperation[] operations = new IOperation[original.ExecutionStack.Count];
+      original.ExecutionStack.CopyTo(operations, 0);
+      for (int i = operations.Length - 1; i >= 0; i--)
+        this.myExecutionStack.Push((IOperation)Auxiliary.Clone(operations[i], clonedObjects));
+      this.myRunning = original.Running;
+      this.myCanceled = original.Canceled;
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -125,16 +143,5 @@
     /// <returns>The cloned object as <see cref="EngineBase"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      EngineBase clone = (EngineBase)base.Clone(clonedObjects);
-      clone.myOperatorGraph = (IOperatorGraph)Auxiliary.Clone(OperatorGraph, clonedObjects);
-      clone.myGlobalScope = (IScope)Auxiliary.Clone(GlobalScope, clonedObjects);
-      clone.myExecutionTime = ExecutionTime;
-      IOperation[] operations = new IOperation[ExecutionStack.Count];
-      ExecutionStack.CopyTo(operations, 0);
-      for (int i = operations.Length - 1; i >= 0; i--)
-        clone.myExecutionStack.Push((IOperation)Auxiliary.Clone(operations[i], clonedObjects));
-      clone.myRunning = Running;
-      clone.myCanceled = Canceled;
-      return clone;
-      
+      return new EngineBase(this, clonedObjects);
     }
 
Index: branches/CloningRefactorBranch/HeuristicLab.Core/ItemBase.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/ItemBase.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/ItemBase.cs	(revision 836)
@@ -30,4 +30,16 @@
   /// </summary>
   public abstract class ItemBase : StorableBase, IItem {
+    /// <summary>
+    /// Creates an instance of an ItemBase.
+    /// </summary>
+    protected ItemBase() { }
+
+    /// <summary>
+    /// Copy constructor for deep cloning of items.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected ItemBase(ItemBase original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) { }
+
     /// <summary>
     /// Creates a new instance of <see cref="ItemBaseView"/> for 
Index: branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/OperatorBase.cs	(revision 836)
@@ -105,22 +105,20 @@
 
     /// <summary>
-    /// Clones the current instance (deep clone).
-    /// </summary>
-    /// <remarks>Clones also sub operators, variables and variable infos.</remarks>
-    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
-    /// <returns>The cloned object as <see cref="OperatorBase"/>.</returns>
-    public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorBase clone = (OperatorBase)base.Clone(clonedObjects);
-      clone.myName = Name;
-      clone.mySubOperators.Clear();
-      for (int i = 0; i < SubOperators.Count; i++)
-        clone.AddSubOperator((IOperator)Auxiliary.Clone(SubOperators[i], clonedObjects));
-      clone.myVariableInfos.Clear();
-      foreach (IVariableInfo variableInfo in myVariableInfos.Values)
-        clone.AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
-      clone.myVariables.Clear();
-      foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
-      return clone;
+    /// Copy constructor
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected OperatorBase(OperatorBase original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myName = original.Name;
+      this.mySubOperators = new List<IOperator>();
+      for (int i = 0; i < original.SubOperators.Count; i++)
+        AddSubOperator((IOperator)Auxiliary.Clone(original.SubOperators[i], clonedObjects));
+      this.myVariableInfos = new Dictionary<string, IVariableInfo>();
+      foreach (IVariableInfo variableInfo in original.myVariableInfos.Values)
+        AddVariableInfo((IVariableInfo)Auxiliary.Clone(variableInfo, clonedObjects));
+      this.myVariables = new Dictionary<string, IVariable>();
+      foreach (IVariable variable in original.myVariables.Values)
+        AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
     }
 
@@ -628,5 +626,5 @@
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
       XmlAttribute nameAttribute = document.CreateAttribute("Name");
@@ -660,5 +658,5 @@
     /// <param name="node">The <see cref="XmlNode"/> where the operation is saved.</param>
     /// <param name="restoredObjects">A dictionary of all already restored objects. (Needed to avoid cycles.)</param>
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       myName = node.Attributes["Name"].Value;
Index: branches/CloningRefactorBranch/HeuristicLab.Core/OperatorGroup.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/OperatorGroup.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/OperatorGroup.cs	(revision 836)
@@ -71,4 +71,19 @@
 
     /// <summary>
+    /// Copy constructor for deep cloning
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected OperatorGroup(OperatorGroup original, IDictionary<Guid, object> clonedObjects) : base(original, clonedObjects) {
+      this.myName = original.myName;
+      mySubGroups = new List<IOperatorGroup>();
+      myOperators = new List<IOperator>();
+      foreach (IOperatorGroup group in original.SubGroups)
+        AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
+      foreach (IOperator op in original.Operators)
+        AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -78,10 +93,5 @@
     /// <returns>The cloned object as <see cref="OperatorGroup"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      OperatorGroup clone = (OperatorGroup)base.Clone(clonedObjects);
-      clone.myName = Name;
-      foreach (IOperatorGroup group in SubGroups)
-        clone.AddSubGroup((IOperatorGroup)Auxiliary.Clone(group, clonedObjects));
-      foreach (IOperator op in Operators)
-        clone.AddOperator((IOperator)Auxiliary.Clone(op, clonedObjects));
+      OperatorGroup clone = new OperatorGroup(this, clonedObjects);
       return clone;
     }
Index: branches/CloningRefactorBranch/HeuristicLab.Core/Scope.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/Scope.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/Scope.cs	(revision 836)
@@ -32,5 +32,5 @@
     private IScope parent;
 
-    private string myName; 
+    private string myName;
     /// <summary>
     /// Gets the name of the current scope.
@@ -75,4 +75,20 @@
       : this() {
       if (name != null) myName = name;
+    }
+
+    /// <summary>
+    /// Copy constructor to create deep clones.
+    /// </summary>
+    /// <param name="original"></param>
+    /// <param name="clonedObjects"></param>
+    protected Scope(Scope original, IDictionary<Guid, object> clonedObjects)
+      : base(original, clonedObjects) {
+      this.myName = original.Name;
+      foreach (IVariable variable in original.myVariables.Values)
+        AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
+      foreach (KeyValuePair<string, string> alias in original.myAliases)
+        AddAlias(alias.Key, alias.Value);
+      for (int i = 0; i < original.SubScopes.Count; i++)
+        AddSubScope((IScope)Auxiliary.Clone(original.SubScopes[i], clonedObjects));
     }
 
@@ -238,5 +254,5 @@
         RemoveVariable(variableNames[j]);
 
-      KeyValuePair<string, string>[] aliases = new KeyValuePair<string,string>[myAliases.Count];
+      KeyValuePair<string, string>[] aliases = new KeyValuePair<string, string>[myAliases.Count];
       myAliases.CopyTo(aliases, 0);
       for (int j = 0; j < aliases.Length; j++)
@@ -249,15 +265,5 @@
     /// <inheritdoc/>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      Scope clone = (Scope)base.Clone(clonedObjects);
-      clone.myName = Name;
-
-      foreach (IVariable variable in myVariables.Values)
-        clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
-      foreach (KeyValuePair<string, string> alias in myAliases)
-        clone.AddAlias(alias.Key, alias.Value);
-      for (int i = 0; i < SubScopes.Count; i++)
-        clone.AddSubScope((IScope)Auxiliary.Clone(SubScopes[i], clonedObjects));
-
-      return clone;
+      return new Scope(this, clonedObjects);
     }
 
@@ -369,5 +375,5 @@
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
       XmlAttribute nameAttribute = document.CreateAttribute("Name");
@@ -409,5 +415,5 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       myName = node.Attributes["Name"].Value;
Index: branches/CloningRefactorBranch/HeuristicLab.Core/StorableBase.cs
===================================================================
--- branches/CloningRefactorBranch/HeuristicLab.Core/StorableBase.cs	(revision 810)
+++ branches/CloningRefactorBranch/HeuristicLab.Core/StorableBase.cs	(revision 836)
@@ -46,4 +46,12 @@
 
     /// <summary>
+    ///  Copy constructor to create a deep clone of the original object
+    /// </summary>
+    /// <param name="original">The object to be cloned</param>
+    protected StorableBase(StorableBase original, IDictionary<Guid, object> clonedObjects) : this() {
+      clonedObjects.Add(myGuid, this);
+    }
+
+    /// <summary>
     /// Clones the current instance (deep clone).
     /// </summary>
@@ -54,13 +62,11 @@
     }
     /// <summary>
-    /// Clones the current instance with the <see cref="M:Activator.CreateInstance"/> 
-    /// method of <see cref="Activator"/>.
+    /// Default implementation of clone throws NotSupportedException. 
+    /// All actually cloneable objects must override this method.
     /// </summary>
     /// <param name="clonedObjects">All already cloned objects.</param>
-    /// <returns>The clone.</returns>
+    /// <returns>Nothing</returns>
     public virtual object Clone(IDictionary<Guid, object> clonedObjects) {
-      object clone = Activator.CreateInstance(this.GetType());
-      clonedObjects.Add(Guid, clone);
-      return clone;
+      throw new NotSupportedException("Can't clone abstract type StorableBase.");
     }
 
@@ -74,5 +80,5 @@
     /// <param name="persistedObjects">The dictionary of all already persisted objects. (Needed to avoid cycles.)</param>
     /// <returns>The saved <see cref="XmlNode"/>.</returns>
-    public virtual XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public virtual XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = document.CreateNode(XmlNodeType.Element, name, null);
       XmlAttribute typeAttribute = document.CreateAttribute("Type");
@@ -91,5 +97,5 @@
     /// <param name="restoredObjects">The dictionary of all already restored objects. 
     /// (Needed to avoid cycles.)</param>
-    public virtual void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public virtual void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       myGuid = new Guid(node.Attributes["GUID"].Value);
     }
