Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Algorithm.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Algorithm.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Algorithm.cs	(revision 4665)
@@ -165,38 +165,24 @@
       storeAlgorithmInEachRun = true;
     }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    protected Algorithm(Algorithm original, Cloner cloner)
+      : base(original, cloner) {
+      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
+      executionState = original.executionState;
+      executionTime = original.executionTime;
+      problem = cloner.Clone(original.problem);
+      storeAlgorithmInEachRun = original.storeAlgorithmInEachRun;
+      runsCounter = original.runsCounter;
+      runs = cloner.Clone(original.runs);
+      Initialize();
+    }
+
     private void Initialize() {
       if (problem != null) RegisterProblemEvents();
       if (runs != null) RegisterRunsEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
-      Algorithm clone = (Algorithm)base.Clone(cloner);
-      clone.executionState = executionState;
-      clone.executionTime = executionTime;
-      clone.problem = (IProblem)cloner.Clone(problem);
-      clone.storeAlgorithmInEachRun = storeAlgorithmInEachRun;
-      clone.runsCounter = runsCounter;
-      clone.runs = (RunCollection)cloner.Clone(runs);
-      clone.Initialize();
-      return clone;
-    }
-    protected virtual void Clone(IDeepCloneable clone, Cloner cloner) {
-      Algorithm algorithm = clone as Algorithm;
-      if (algorithm != null) {
-        algorithm.name = name;
-        algorithm.description = description;
-        foreach (IParameter param in Parameters)
-          algorithm.Parameters.Add((IParameter)cloner.Clone(param));
-        algorithm.executionState = executionState;
-        algorithm.executionTime = executionTime;
-        algorithm.problem = (IProblem)cloner.Clone(problem);
-        algorithm.storeAlgorithmInEachRun = storeAlgorithmInEachRun;
-        algorithm.runsCounter = runsCounter;
-        algorithm.runs = (RunCollection)cloner.Clone(runs);
-        algorithm.Initialize();
-      }
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/BatchRun.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/BatchRun.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/BatchRun.cs	(revision 4665)
@@ -167,23 +167,28 @@
       stopPending = false;
     }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    protected BatchRun(BatchRun original, Cloner cloner)
+      : base(original, cloner) {
+      executionState = original.executionState;
+      executionTime = original.executionTime;
+      algorithm = cloner.Clone(original.algorithm);
+      repetitions = original.repetitions;
+      repetitionsCounter = original.repetitionsCounter;
+      runs = cloner.Clone(original.runs);
+      stopPending = original.stopPending;
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
+      return new BatchRun(this, cloner);
+    }
+
     private void Initialize() {
       if (algorithm != null) RegisterAlgorithmEvents();
       if (runs != null) RegisterRunsEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
-      BatchRun clone = (BatchRun)base.Clone(cloner);
-      clone.executionState = executionState;
-      clone.executionTime = executionTime;
-      clone.algorithm = (IAlgorithm)cloner.Clone(algorithm);
-      clone.repetitions = repetitions;
-      clone.repetitionsCounter = repetitionsCounter;
-      clone.runs = (RunCollection)cloner.Clone(runs);
-      clone.stopPending = stopPending;
-      clone.Initialize();
-      return clone;
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/EngineAlgorithm.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/EngineAlgorithm.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/EngineAlgorithm.cs	(revision 4665)
@@ -114,6 +114,17 @@
     [StorableConstructor]
     protected EngineAlgorithm(bool deserializing) : base(deserializing) { }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    protected EngineAlgorithm(EngineAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      globalScope = cloner.Clone(original.globalScope);
+      engine = cloner.Clone(original.engine);
+      operatorGraph = cloner.Clone(original.operatorGraph);
+      Initialize();
+    }
+
     private void Initialize() {
       operatorGraph.InitialOperatorChanged += new EventHandler(OperatorGraph_InitialOperatorChanged);
@@ -127,29 +138,6 @@
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      EngineAlgorithm clone = (EngineAlgorithm)base.Clone(cloner);
-      clone.globalScope = (IScope)cloner.Clone(globalScope);
-      clone.engine = (IEngine)cloner.Clone(engine);
-      clone.operatorGraph = (OperatorGraph)cloner.Clone(operatorGraph);
-      clone.Initialize();
-      return clone;
-    }
-    protected override void Clone(IDeepCloneable clone, Cloner cloner) {
-      base.Clone(clone, cloner);
-      EngineAlgorithm algorithm = clone as EngineAlgorithm;
-      if (algorithm != null) {
-        algorithm.globalScope = (IScope)cloner.Clone(globalScope);
-        algorithm.engine = (IEngine)cloner.Clone(engine);
-        algorithm.operatorGraph = (OperatorGraph)cloner.Clone(operatorGraph);
-        algorithm.Initialize();
-      }
-    }
-
     public virtual IAlgorithm CreateUserDefinedAlgorithm() {
-      UserDefinedAlgorithm algorithm = new UserDefinedAlgorithm();
-      Cloner cloner = new Cloner();
-      cloner.RegisterClonedObject(this, algorithm);
-      Clone(algorithm, cloner);
-      return algorithm;
+      return new UserDefinedAlgorithm(this, new Cloner());
     }
 
@@ -183,6 +171,6 @@
     public event EventHandler EngineChanged;
     protected virtual void OnEngineChanged() {
-      if (EngineChanged != null)
-        EngineChanged(this, EventArgs.Empty);
+      EventHandler handler = EngineChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
     }
     public event EventHandler OperatorGraphChanged;
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Experiment.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Experiment.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Experiment.cs	(revision 4665)
@@ -128,6 +128,22 @@
       stopPending = false;
     }
-
     [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    protected Experiment(Experiment original, Cloner cloner)
+      : base(original, cloner) {
+      executionState = original.executionState;
+      executionTime = original.executionTime;
+      optimizers = cloner.Clone(original.optimizers);
+      runs = cloner.Clone(original.runs);
+      stopPending = original.stopPending;
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
+      return new Experiment(this, cloner);
+    }
+
     private void Initialize() {
       RegisterOptimizersEvents();
@@ -135,16 +151,4 @@
         RegisterOptimizerEvents(optimizer);
       if (runs != null) RegisterRunsEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
-      Experiment clone = (Experiment)base.Clone(cloner);
-      clone.executionState = executionState;
-      clone.executionTime = executionTime;
-      clone.optimizers = (OptimizerList)cloner.Clone(optimizers);
-      clone.runs = (RunCollection)cloner.Clone(runs);
-      clone.stopPending = stopPending;
-      clone.Initialize();
-      return clone;
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/OptimizerList.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/OptimizerList.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/OptimizerList.cs	(revision 4665)
@@ -32,4 +32,12 @@
     public OptimizerList(int capacity) : base(capacity) { }
     public OptimizerList(IEnumerable<IOptimizer> collection) : base(collection) { }
+    [StorableConstructor]
+    protected OptimizerList(bool deserializing) : base(deserializing) { }
+    protected OptimizerList(OptimizerList original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OptimizerList(this, cloner);
+    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Problem.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Problem.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Problem.cs	(revision 4665)
@@ -44,4 +44,10 @@
     [StorableConstructor]
     protected Problem(bool deserializing) : base(deserializing) { }
+    protected Problem(Problem<T, U> original, Cloner cloner)
+      : base(original, cloner) {
+      operators = cloner.Clone(original.operators);
+      RegisterEventHandlers();
+    }
+
     protected Problem()
       : base() {
@@ -55,11 +61,4 @@
     private void AfterDeserialization() {
       RegisterEventHandlers();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Problem<T, U> clone = (Problem<T, U>)base.Clone(cloner);
-      clone.operators = (OperatorCollection)cloner.Clone(operators);
-      clone.RegisterEventHandlers();
-      return clone;
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Result.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Result.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Result.cs	(revision 4665)
@@ -104,16 +104,19 @@
     [StorableConstructor]
     private Result(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    protected Result(Result original, Cloner cloner)
+      : base(original, cloner) {
+      value = cloner.Clone(original.value);
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Result(this, cloner);
+    }
 
-    [StorableHook(HookType.AfterDeserialization)]
     private void Initialize() {
       RegisterValueEvents();
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Result clone = new Result(Name, Description, DataType);
-      cloner.RegisterClonedObject(this, clone);
-      clone.value = (IItem)cloner.Clone(value);
-      clone.Initialize();
-      return clone;
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/ResultCollection.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/ResultCollection.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/ResultCollection.cs	(revision 4665)
@@ -21,4 +21,5 @@
 
 using System.Collections.Generic;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -31,4 +32,12 @@
     public ResultCollection(int capacity) : base(capacity) { }
     public ResultCollection(IEnumerable<IResult> collection) : base(collection) { }
+    [StorableConstructor]
+    protected ResultCollection(bool deserializing) : base(deserializing) { }
+    protected ResultCollection(ResultCollection original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ResultCollection(this, cloner);
+    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Run.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Run.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/Run.cs	(revision 4665)
@@ -38,4 +38,21 @@
     [StorableConstructor]
     private Run(bool deserializing) : base(deserializing) { }
+    protected Run(Run original, Cloner cloner)
+      : base(original, cloner) {
+      color = original.color;
+      algorithm = cloner.Clone(original.algorithm);
+
+      parameters = new Dictionary<string, IItem>();
+      foreach (string key in original.parameters.Keys)
+        parameters.Add(key, cloner.Clone(original.parameters[key]));
+
+      results = new Dictionary<string, IItem>();
+      foreach (string key in original.results.Keys)
+        results.Add(key, cloner.Clone(original.results[key]));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Run(this, cloner);
+    }
+
     public Run()
       : base() {
@@ -81,5 +98,5 @@
     }
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserializationHook() {
+    private void AfterDeserialization() {
       if (color == Color.Empty) color = Color.Black;
     }
@@ -128,15 +145,4 @@
         handler(this, EventArgs.Empty);
     }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      Run clone = (Run)base.Clone(cloner);
-      clone.color = this.color;
-      clone.algorithm = (IAlgorithm)cloner.Clone(algorithm);
-      foreach (string key in parameters.Keys)
-        clone.parameters.Add(key, (IItem)cloner.Clone(parameters[key]));
-      foreach (string key in results.Keys)
-        clone.results.Add(key, (IItem)cloner.Clone(results[key]));
-      return clone;
-    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollection.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollection.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollection.cs	(revision 4665)
@@ -38,4 +38,24 @@
     [StorableConstructor]
     protected RunCollection(bool deserializing) : base(deserializing) { }
+
+    protected RunCollection(RunCollection original, Cloner cloner)
+      : base(original, cloner) {
+      resultNames = new List<string>(original.resultNames);
+      parameterNames = new List<string>(original.parameterNames);
+      dataTypes = new Dictionary<string, HashSet<Type>>();
+      foreach (string s in original.dataTypes.Keys)
+        dataTypes[s] = new HashSet<Type>(original.dataTypes[s]);
+
+      constraints = new RunCollectionConstraintCollection(original.constraints.Select(x => cloner.Clone(x)));
+      foreach (IRunCollectionConstraint constraint in constraints)
+        constraint.ConstrainedValue = this;
+      RegisterConstraintsEvents();
+      RegisterConstraintEvents(constraints);
+
+      UpdateFiltering(true);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollection(this, cloner);
+    }
     public RunCollection() : base() { Initialize(); }
     public RunCollection(int capacity) : base(capacity) { Initialize(); }
@@ -175,27 +195,9 @@
 
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserializationHook() {
+    private void AfterDeserialization() {
       if (constraints == null) constraints = new RunCollectionConstraintCollection();
       RegisterConstraintsEvents();
       RegisterConstraintEvents(constraints);
       UpdateFiltering(true);
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      RunCollection clone = (RunCollection)base.Clone(cloner);
-      clone.resultNames = new List<string>(this.resultNames);
-      clone.parameterNames = new List<string>(this.parameterNames);
-      clone.dataTypes = new Dictionary<string, HashSet<Type>>();
-      foreach (string s in this.dataTypes.Keys)
-        clone.dataTypes[s] = new HashSet<Type>(this.dataTypes[s]);
-
-      clone.constraints = new RunCollectionConstraintCollection(this.constraints.Select(x => (IRunCollectionConstraint)cloner.Clone(x)));
-      foreach (IRunCollectionConstraint constraint in clone.constraints)
-        constraint.ConstrainedValue = clone;
-      clone.RegisterConstraintsEvents();
-      clone.RegisterConstraintEvents(clone.constraints);
-
-      clone.UpdateFiltering(true);
-      return clone;
     }
 
@@ -257,12 +259,12 @@
     public event EventHandler<EventArgs<int, int>> ItemChanged;
     protected virtual void OnItemChanged(int rowIndex, int columnIndex) {
-      if (ItemChanged != null)
-        ItemChanged(this, new EventArgs<int, int>(rowIndex, columnIndex));
+      EventHandler<EventArgs<int, int>> handler = ItemChanged;
+      if (handler != null) handler(this, new EventArgs<int, int>(rowIndex, columnIndex));
       OnToStringChanged();
     }
     public event EventHandler Reset;
     protected virtual void OnReset() {
-      if (Reset != null)
-        Reset(this, EventArgs.Empty);
+      EventHandler handler = Reset;
+      if (handler != null) handler(this, EventArgs.Empty);
       OnToStringChanged();
     }
@@ -270,18 +272,15 @@
     protected virtual void OnColumnNamesChanged() {
       EventHandler handler = ColumnNamesChanged;
-      if (handler != null)
-        handler(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
     public event EventHandler RowNamesChanged;
     protected virtual void OnRowNamesChanged() {
       EventHandler handler = RowNamesChanged;
-      if (handler != null)
-        handler(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
     public event EventHandler SortableViewChanged;
     protected virtual void OnSortableViewChanged() {
       EventHandler handler = SortableViewChanged;
-      if (handler != null)
-        handler(this, EventArgs.Empty);
+      if (handler != null) handler(this, EventArgs.Empty);
     }
 
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionComparisonConstraint.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionComparisonConstraint.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionComparisonConstraint.cs	(revision 4665)
@@ -33,4 +33,22 @@
     [StorableConstructor]
     protected RunCollectionComparisonConstraint(bool deserializing) : base(deserializing) { }
+
+    protected RunCollectionComparisonConstraint(RunCollectionComparisonConstraint original, Cloner cloner)
+      : base(original, cloner) {
+      IDeepCloneable constraintDataDeepCloneable = original.ConstraintData as IDeepCloneable;
+      ICloneable constraintDataCloneable = original.ConstraintData as ICloneable;
+      if (constraintDataDeepCloneable != null)
+        ConstraintData = (IStringConvertibleValue)cloner.Clone(constraintDataDeepCloneable);
+      else if (constraintDataCloneable != null)
+        ConstraintData = (IStringConvertibleValue)constraintDataCloneable.Clone();
+      else
+        ConstraintData = original.ConstraintData;
+
+      ConstraintOperation = original.ConstraintOperation;
+      ConstraintColumn = original.constraintColumn;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionComparisonConstraint(this, cloner);
+    }
 
     public RunCollectionComparisonConstraint() : base() { }
@@ -128,22 +146,4 @@
       return s;
     }
-
-    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
-      RunCollectionComparisonConstraint clone = (RunCollectionComparisonConstraint)base.Clone(cloner);
-
-      IItem constraintDataItem = this.ConstraintData as IItem;
-      ICloneable constraintDataCloneable = this.ConstraintData as ICloneable;
-      if (constraintDataItem != null)
-        clone.ConstraintData = (IStringConvertibleValue)cloner.Clone(constraintDataItem);
-      else if (constraintDataCloneable != null)
-        clone.ConstraintData = (IStringConvertibleValue)constraintDataCloneable.Clone();
-      else
-        clone.ConstraintData = this.ConstraintData;
-
-      clone.ConstraintOperation = this.ConstraintOperation;
-      clone.constraintColumn = this.constraintColumn;
-
-      return clone;
-    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionConstraintCollection.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionConstraintCollection.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionConstraintCollection.cs	(revision 4665)
@@ -20,4 +20,5 @@
 #endregion
 using System.Collections.Generic;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -32,4 +33,10 @@
     [StorableConstructor]
     protected RunCollectionConstraintCollection(bool deserializing) : base(deserializing) { }
+    protected RunCollectionConstraintCollection(RunCollectionConstraintCollection original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionConstraintCollection(this, cloner);
+    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionEqualityConstraint.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionEqualityConstraint.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionEqualityConstraint.cs	(revision 4665)
@@ -33,4 +33,14 @@
     [StorableConstructor]
     protected RunCollectionEqualityConstraint(bool deserializing) : base(deserializing) { }
+
+    protected RunCollectionEqualityConstraint(RunCollectionEqualityConstraint original, Cloner cloner)
+      : base(original, cloner) {
+      ConstraintData = original.ConstraintData;
+      ConstraintOperation = original.ConstraintOperation;
+      constraintColumn = original.constraintColumn;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionEqualityConstraint(this, cloner);
+    }
 
     public RunCollectionEqualityConstraint()
@@ -127,13 +137,4 @@
       return s;
     }
-
-    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
-      RunCollectionEqualityConstraint clone = (RunCollectionEqualityConstraint)base.Clone(cloner);
-      clone.ConstraintData = this.ConstraintData;
-      clone.ConstraintOperation = this.ConstraintOperation;
-      clone.constraintColumn = this.constraintColumn;
-
-      return clone;
-    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionTypeCompatiblityConstraint.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionTypeCompatiblityConstraint.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/RunCollectionConstraints/RunCollectionTypeCompatiblityConstraint.cs	(revision 4665)
@@ -31,9 +31,19 @@
   [Item("RunCollectionTypeCompatibilityConstraint", "A constraint which checks the members of the contained runs for type compabitiliby to the constraint data.")]
   public class RunCollectionTypeCompatibilityConstraint : TypeCompatibilityConstraint, IRunCollectionConstraint {
+    [StorableConstructor]
+    protected RunCollectionTypeCompatibilityConstraint(bool deserializing) {
+    }
+    protected RunCollectionTypeCompatibilityConstraint(RunCollectionTypeCompatibilityConstraint original, Cloner cloner)
+      : base(original, cloner) {
+      ConstraintData = original.ConstraintData;
+      ConstraintOperation = original.ConstraintOperation;
+      constraintColumn = original.constraintColumn;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RunCollectionTypeCompatibilityConstraint(this, cloner);
+    }
+
     public RunCollectionTypeCompatibilityConstraint()
       : base() {
-    }
-    [StorableConstructor]
-    protected RunCollectionTypeCompatibilityConstraint(bool deserializing) {
     }
     public RunCollectionTypeCompatibilityConstraint(RunCollection constrainedValue, ConstraintOperation constraintOperation, Type constraintData)
@@ -120,13 +130,4 @@
       return s;
     }
-
-    public override IDeepCloneable Clone(HeuristicLab.Common.Cloner cloner) {
-      RunCollectionTypeCompatibilityConstraint clone = (RunCollectionTypeCompatibilityConstraint)base.Clone(cloner);
-      clone.ConstraintData = this.ConstraintData;
-      clone.ConstraintOperation = this.ConstraintOperation;
-      clone.constraintColumn = this.constraintColumn;
-
-      return clone;
-    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/SingleObjectiveProblem.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/SingleObjectiveProblem.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/SingleObjectiveProblem.cs	(revision 4665)
@@ -20,4 +20,5 @@
 #endregion
 
+using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
@@ -34,4 +35,10 @@
     private const string BestKnownQualityParameterName = "BestKnownQuality";
 
+    [StorableConstructor]
+    protected SingleObjectiveProblem(bool deserializing) : base(deserializing) { }
+    protected SingleObjectiveProblem(SingleObjectiveProblem<T, U> original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
     protected SingleObjectiveProblem()
       : base() {
@@ -39,6 +46,5 @@
       Parameters.Add(new ValueParameter<DoubleValue>(BestKnownQualityParameterName, "The quality of the best known solution of this problem."));
     }
-    [StorableConstructor]
-    protected SingleObjectiveProblem(bool deserializing) : base(deserializing) { }
+
 
     #region properties
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedAlgorithm.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedAlgorithm.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedAlgorithm.cs	(revision 4665)
@@ -55,4 +55,13 @@
     [StorableConstructor]
     private UserDefinedAlgorithm(bool deserializing) : base(deserializing) { }
+    private UserDefinedAlgorithm(UserDefinedAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    private UserDefinedAlgorithm(EngineAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UserDefinedAlgorithm(this, cloner);
+    }
   }
 }
Index: /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedProblem.cs
===================================================================
--- /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedProblem.cs	(revision 4664)
+++ /branches/CloningRefactoring/HeuristicLab.Optimization/3.3/UserDefinedProblem.cs	(revision 4665)
@@ -117,4 +117,8 @@
     [StorableConstructor]
     private UserDefinedProblem(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      AttachEventHandlers();
+    }
     public UserDefinedProblem()
       : base() {
@@ -129,8 +133,10 @@
     }
 
+    private UserDefinedProblem(UserDefinedProblem original, Cloner cloner)
+      : base(original, cloner) {
+      AttachEventHandlers();
+    }
     public override IDeepCloneable Clone(Cloner cloner) {
-      UserDefinedProblem clone = (UserDefinedProblem)base.Clone(cloner);
-      clone.AttachEventHandlers();
-      return clone;
+      return new UserDefinedProblem(this, cloner);
     }
 
@@ -186,5 +192,4 @@
 
     #region Helpers
-    [StorableHook(HookType.AfterDeserialization)]
     private void AttachEventHandlers() {
       SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
@@ -217,4 +222,14 @@
     [StorableClass]
     private class EmptyUserDefinedProblemEvaluator : ParameterizedNamedItem, ISingleObjectiveEvaluator {
+      public EmptyUserDefinedProblemEvaluator() : base() { }
+      [StorableConstructor]
+      private EmptyUserDefinedProblemEvaluator(bool deserializing) : base(deserializing) { }
+      private EmptyUserDefinedProblemEvaluator(EmptyUserDefinedProblemEvaluator original, Cloner cloner)
+        : base(original, cloner) {
+      }
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new EmptyUserDefinedProblemEvaluator(this, cloner);
+      }
+
       #region ISingleObjectiveEvaluator Members
 
@@ -231,8 +246,5 @@
       #region IOperator Members
 
-      public bool Breakpoint {
-        get;
-        set;
-      }
+      public bool Breakpoint { get; set; }
 
       public IOperation Execute(IExecutionContext context) {
@@ -244,9 +256,9 @@
       }
 
-      #pragma warning disable 67
+#pragma warning disable 67
       public event EventHandler BreakpointChanged;
 
       public event EventHandler Executed;
-      #pragma warning restore 67
+#pragma warning restore 67
 
       #endregion
@@ -255,5 +267,5 @@
         get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Method; }
       }
-    } 
+    }
   }
 }
