Index: branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs	(revision 10978)
+++ branches/DataPreprocessing/HeuristicLab.DataPreprocessing/3.4/Implementations/PreprocessingData.cs	(revision 10991)
@@ -126,99 +126,41 @@
     #region IPreprocessingData Members
 
-    public T GetCell<T>(int columnIndex, int rowIndex) {
-      return (T)variableValues[columnIndex][rowIndex];
-    }
+    public abstract T GetCell<T>(int columnIndex, int rowIndex);
 
-    public virtual void SetCell<T>(int columnIndex, int rowIndex, T value) {
-      variableValues[columnIndex][rowIndex] = value;
-    }
+    public abstract void SetCell<T>(int columnIndex, int rowIndex, T value);
 
-    public string GetCellAsString(int columnIndex, int rowIndex) {
-      return variableValues[columnIndex][rowIndex].ToString();
-    }
+    public abstract string GetCellAsString(int columnIndex, int rowIndex);
 
-    public string GetVariableName(int columnIndex) {
-      return variableNames[columnIndex];
-    }
+    public abstract string GetVariableName(int columnIndex);
 
-    public int GetColumnIndex(string variableName) {
-      return variableNames.IndexOf(variableName);
-    }
+    public abstract int GetColumnIndex(string variableName);
 
-    public bool IsType<T>(int columnIndex) {
-      return variableValues[columnIndex] is List<T>;
-    }
+    public abstract bool IsType<T>(int columnIndex);
 
     [Obsolete("use the index based variant, is faster")]
-    public IList<T> GetValues<T>(string variableName, bool considerSelection) {
-      return GetValues<T>(GetColumnIndex(variableName), considerSelection);
-    }
+    public abstract IList<T> GetValues<T>(string variableName, bool considerSelection);
 
-    public IList<T> GetValues<T>(int columnIndex, bool considerSelection) {
-      if (considerSelection) {
-        var list = new List<T>();
-        foreach (var rowIdx in selection[columnIndex]) {
-          list.Add((T)variableValues[columnIndex][rowIdx]);
-        }
-        return list;
-      } else {
-        return (IList<T>)variableValues[columnIndex];
-      }
-    }
+    public abstract IList<T> GetValues<T>(int columnIndex, bool considerSelection);
 
-    public virtual void SetValues<T>(int columnIndex, IList<T> values) {
-      if (IsType<T>(columnIndex)) {
-        variableValues[columnIndex] = (IList)values;
-      } else {
-        throw new ArgumentException("The datatype of column " + columnIndex + " must be of type " + variableValues[columnIndex].GetType().Name + " but was " + typeof(T).Name);
-      }
-    }
+    public abstract void SetValues<T>(int columnIndex, IList<T> values);
 
-    public virtual void InsertRow(int rowIndex) {
-      foreach (IList column in variableValues) {
-        Type type = column.GetType().GetGenericArguments()[0];
-        column.Insert(rowIndex, type.IsValueType ? Activator.CreateInstance(type) : null);
-      }
-    }
+    public abstract void InsertRow(int rowIndex);
 
-    public virtual void DeleteRow(int rowIndex) {
-      foreach (IList column in variableValues) {
-        column.RemoveAt(rowIndex);
-      }
-    }
+    public abstract void DeleteRow(int rowIndex);
 
-    public virtual void InsertColumn<T>(string variableName, int columnIndex) {
-      variableValues.Insert(columnIndex, new List<T>(Rows));
-      variableNames.Insert(columnIndex, variableName);
-    }
+    public abstract void InsertColumn<T>(string variableName, int columnIndex);
 
-    public virtual void DeleteColumn(int columnIndex) {
-      variableValues.RemoveAt(columnIndex);
-      variableNames.RemoveAt(columnIndex);
-    }
+    public abstract void DeleteColumn(int columnIndex);
 
-    public Dataset ExportToDataset() {
-      IList<IList> values = new List<IList>();
+    public abstract Dataset ExportToDataset();
 
-      for (int i = 0; i < Columns; ++i) {
-        values.Add(variableValues[i]);
-      }
+    public abstract void ClearSelection();
 
-      var dataset = new Dataset(variableNames, values);
-      return dataset;
-    }
-
-    public void ClearSelection() {
-      Selection = new Dictionary<int, IList<int>>();
-    }
-
-    public event EventHandler SelectionChanged;
-    protected virtual void OnSelectionChanged() { 
-       var listeners = SelectionChanged;
-       if (listeners != null) listeners(this, EventArgs.Empty);
-    }
+    public abstract event EventHandler SelectionChanged;
+    protected abstract void OnSelectionChanged();
 
     public event DataPreprocessingChangedEventHandler Changed;
-    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row) {
+    protected virtual void OnChanged(DataPreprocessingChangedEventType type, int column, int row)
+    {
       var listeners = Changed;
       if (listeners != null) listeners(this, new DataPreprocessingChangedEventArgs(type, column, row));
