Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/BasicProblems/MultiObjectiveBasicProblem.cs	(revision 16310)
@@ -20,6 +20,4 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MetaOptimizers/TimeLimitRun.cs	(revision 16310)
@@ -188,4 +188,5 @@
           TimeSpan.FromSeconds(15) });
       snapshotTimesIndex = 0;
+      snapshots = new RunCollection();
       Runs = new RunCollection { OptimizerName = Name };
       Initialize();
@@ -199,4 +200,5 @@
           TimeSpan.FromSeconds(15) });
       snapshotTimesIndex = 0;
+      snapshots = new RunCollection();
       Runs = new RunCollection { OptimizerName = Name };
       Initialize();
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/CrowdingCalculator.cs	(revision 16310)
@@ -35,6 +35,5 @@
   /// Beware that CrowdingCalculator is not normalized for the number of dimensions. A higher number of dimensions normally causes higher CrowdingCalculator values
   /// </summary>
-  public static class CrowdingCalculator
-  {
+  public static class CrowdingCalculator {
 
     public static double CalculateCrowding<TP>(IEnumerable<TP> qualities) where TP : IReadOnlyList<double> {
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/GenerationalDistanceCalculator.cs	(revision 16310)
@@ -23,10 +23,8 @@
 
 #region
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
-
 #endregion
 
@@ -40,11 +38,10 @@
   public static class GenerationalDistanceCalculator {
     public static double CalculateGenerationalDistance<TP1, TP2>(IEnumerable<TP1> qualities, IEnumerable<TP2> bestKnownFront, double p) where TP1 : IReadOnlyList<double> where TP2 : IReadOnlyList<double> {
-      if (qualities == null || bestKnownFront == null) throw new ArgumentNullException("Fronts must not be null");
+      if (qualities == null || bestKnownFront == null) throw new ArgumentNullException(nameof(qualities));
       if (p.IsAlmost(0.0)) throw new ArgumentException("p must not be zero.");
       var mat = bestKnownFront.ToMatrix();
       if (mat.GetLength(0) == 0) throw new ArgumentException("Fronts must not be empty.");
 
-      alglib.kdtree tree;
-      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out tree);
+      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out var tree);
       var sum = 0.0;
       var summand = new double[1];
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/HypervolumeCalculator.cs	(revision 16310)
@@ -23,5 +23,4 @@
 using System.Linq;
 using HeuristicLab.Common;
-using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Optimization {
@@ -64,5 +63,5 @@
     public static double CalculateHypervolume(double[][] qualities, double[] referencePoint, bool[] maximization){
       qualities = qualities.Where(vec => DominationCalculator.Dominates(vec, referencePoint, maximization, false) == DominationResult.Dominates).ToArray();
-      if (!qualities.Any()) return 0;//TODO replace with negative computation
+      if (qualities.Length == 0 ) return 0;//TODO computation for negative hypervolume?
       if (maximization.Length == 2)
         return Calculate2D(qualities, referencePoint, maximization);
@@ -73,9 +72,17 @@
     }
 
+
+    /// <summary>
+    /// Caluclates the Hypervolume for a 2 dimensional problem
+    /// </summary>
+    /// <param name="front">All points within the front need to be Non-Dominated and need to dominate the reference point</param>
+    /// <param name="referencePoint"></param>
+    /// <param name="maximization"></param>
+    /// <returns></returns>
     public static double Calculate2D(double[][] front, double[] referencePoint, bool[] maximization) {
-      if (front == null) throw new ArgumentNullException("Front must not be null.");
+      if (front == null) throw new ArgumentNullException(nameof(front));
+      if (referencePoint == null) throw new ArgumentNullException(nameof(referencePoint));
+      if (maximization == null) throw new ArgumentNullException(nameof(maximization));
       if (!front.Any()) throw new ArgumentException("Front must not be empty.");
-
-      if (referencePoint == null) throw new ArgumentNullException("ReferencePoint must not be null.");
       if (referencePoint.Length != 2) throw new ArgumentException("ReferencePoint must have exactly two dimensions.");
 
@@ -87,6 +94,5 @@
       double sum = 0;
       for (var i = 0; i < set.Length - 1; i++) 
-        sum += Math.Abs((set[i][0] - set[i + 1][0])) * Math.Abs((set[i][1] - referencePoint[1]));
-      
+        sum += Math.Abs(set[i][0] - set[i + 1][0]) * Math.Abs(set[i][1] - referencePoint[1]);
       var lastPoint = set[set.Length - 1];
       sum += Math.Abs(lastPoint[0] - referencePoint[0]) * Math.Abs(lastPoint[1] - referencePoint[1]);
@@ -112,4 +118,7 @@
     }
 
+
+    //within Stream a number of equality comparisons on double values are performed
+    //this is intentional and required
     private static double Stream(double[] regionLow, double[] regionUp, List<double[]> front, int split, double cover, int sqrtNoPoints, int objectives) {
       var coverOld = cover;
@@ -135,5 +144,5 @@
       var piles = new int[coverIndex];
       for (var i = 0; i < coverIndex; i++) {
-        piles[i] = IsPile(front[i], regionLow, regionUp, objectives);
+        piles[i] = IsPile(front[i], regionLow, objectives);
         if (piles[i] == -1) {
           allPiles = false;
@@ -145,9 +154,8 @@
         var trellis = new double[regionUp.Length];
         for (var j = 0; j < trellis.Length; j++) trellis[j] = regionUp[j];
-        double current = 0;
-        double next = 0;
+        double next;
         var i = 0;
         do {
-          current = front[i][objectives - 1];
+          var current = front[i][objectives - 1];
           do {
             if (front[i][piles[i]] < trellis[piles[i]]) trellis[piles[i]] = front[i][piles[i]];
@@ -176,7 +184,6 @@
         } while (bound == -1.0);
 
-        List<double[]> pointsChildLow, pointsChildUp;
-        pointsChildLow = new List<double[]>();
-        pointsChildUp = new List<double[]>();
+        var pointsChildLow = new List<double[]>();
+        var pointsChildUp = new List<double[]>();
         var regionUpC = new double[regionUp.Length];
         for (var j = 0; j < regionUpC.Length; j++) regionUpC[j] = regionUp[j];
@@ -205,9 +212,8 @@
       double result = 0;
       var noSummands = BinarayToInt(bs);
-      int oneCounter; double summand;
       for (uint i = 1; i <= noSummands; i++) {
-        summand = 1;
+        double summand = 1;
         IntToBinary(i, bs);
-        oneCounter = 0;
+        var oneCounter = 0;
         for (var j = 0; j < objectives - 1; j++) {
           if (bs[j]) {
@@ -244,5 +250,5 @@
     }
 
-    private static int IsPile(double[] cuboid, double[] regionLow, double[] regionUp, int objectives) {
+    private static int IsPile(double[] cuboid, double[] regionLow, int objectives) {
       var pile = cuboid.Length;
       for (var i = 0; i < objectives - 1; i++) {
Index: branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs
===================================================================
--- branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs	(revision 16171)
+++ branches/2943_MOBasicProblem_MOCMAES/HeuristicLab.Optimization/3.3/MultiObjective/SpacingCalculator.cs	(revision 16310)
@@ -34,5 +34,5 @@
 
     public static double CalculateSpacing<TP>(IEnumerable<TP> qualities) where TP: IReadOnlyList<double> {
-      if (qualities == null) throw new ArgumentException("Front must not be null.");
+      if (qualities == null) throw new ArgumentNullException(nameof(qualities));
       var l = qualities.ToList();
       if (l.Count == 0) throw new ArgumentException("Front must not be empty.");
@@ -40,6 +40,5 @@
 
       var mat = l.ToMatrix();
-      alglib.kdtree tree;
-      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out tree);
+      alglib.kdtreebuild(mat, mat.GetLength(0), mat.GetLength(1), 0, 2, out var tree);
       var summand = new double[2];
       var dists = new List<double>();
@@ -51,6 +50,4 @@
       return dists.StandardDeviationPop();
     }
-
-    
   }
 }
