Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ComparatorBase.cs	(revision 2027)
@@ -36,7 +36,7 @@
     /// </summary>
     protected ComparatorBase() {
-      AddVariableInfo(new VariableInfo("LeftSide", "Variable on the left side of the comparison", typeof(IItem), VariableKind.In));
-      AddVariableInfo(new VariableInfo("RightSide", "Variable on the right side of the comparison", typeof(IItem), VariableKind.In));
-      AddVariableInfo(new VariableInfo("Result", "Result of the comparison", typeof(BoolData), VariableKind.Out | VariableKind.New));
+      AddParameter(new Parameter("LeftSide", "Variable on the left side of the comparison", typeof(IItem), ParameterType.In));
+      AddParameter(new Parameter("RightSide", "Variable on the right side of the comparison", typeof(IItem), ParameterType.In));
+      AddParameter(new Parameter("Result", "Result of the comparison", typeof(BoolData), ParameterType.Out));
     }
 
@@ -50,18 +50,15 @@
     /// <param name="scope">The scope where to apply the compare operation.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      BoolData result = GetVariableValue<BoolData>("Result", scope, false, false);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      string resultName = env.TranslateName("Result");
+      BoolData result = scope.GetVariableValue<BoolData>(resultName, false, false);
       if (result == null) {
         result = new BoolData(true);
-        IVariableInfo info = GetVariableInfo("Result");
-        if (info.Local)
-          AddVariable(new Variable(info.ActualName, result));
-        else
-          scope.AddVariable(new Variable(scope.TranslateName(info.FormalName), result));
+        scope.AddVariable(new Variable(resultName, result));
       }
-      IItem leftSide = GetVariableValue<IItem>("LeftSide", scope, true);
+      IItem leftSide = scope.GetVariableValue<IItem>(env.TranslateName("LeftSide"), true);
       if (!(leftSide is IComparable)) throw new InvalidOperationException("Comparator: Left side needs to be of type IComparable");
       IComparable left = (IComparable)leftSide;
-      IItem rightSide = GetVariableValue<IItem>("RightSide", scope, true);
+      IItem rightSide = scope.GetVariableValue<IItem>(env.TranslateName("RightSide"), true);
       result.Data = Compare(left, rightSide);
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ConditionalBranch.cs	(revision 2027)
@@ -45,5 +45,5 @@
     public ConditionalBranch()
       : base() {
-      AddVariableInfo(new VariableInfo("Condition", "A boolean variable that decides the branch", typeof(BoolData), VariableKind.In));
+      AddParameter(new Parameter("Condition", "A boolean variable that decides the branch", typeof(BoolData), ParameterType.In));
     }
 
@@ -56,12 +56,11 @@
     /// <returns>A new <see cref="AtomicOperation"/> with either operator 1 or operator 2 applied
     /// to the given <paramref name="scope"/> or <c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      BoolData resultData = GetVariableValue<BoolData>("Condition", scope, true);
-      bool result = resultData.Data;
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      bool result = scope.GetVariableValue<BoolData>(env.TranslateName("Condition"), true).Data;
 
       if ((result) && (SubOperators.Count > 0) && (SubOperators[0] != null))
-        return new AtomicOperation(SubOperators[0], scope);
+        return new AtomicOperation(SubOperators[0], env, scope);
       else if ((!result) && (SubOperators.Count > 1) && (SubOperators[1] != null))
-        return new AtomicOperation(SubOperators[1], scope);
+        return new AtomicOperation(SubOperators[1], env, scope);
       return null;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/Counter.cs	(revision 2027)
@@ -43,5 +43,5 @@
     public Counter()
       : base() {
-      AddVariableInfo(new VariableInfo("Value", "Counter value", typeof(IntData), VariableKind.In | VariableKind.Out));
+      AddParameter(new Parameter("Value", "Counter value", typeof(IntData), ParameterType.InOut));
     }
 
@@ -51,6 +51,6 @@
     /// <param name="scope">The scope whose variable should be incremented.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IntData value = GetVariableValue<IntData>("Value", scope, true);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      IntData value = scope.GetVariableValue<IntData>(env.TranslateName("Value"), true);
       value.Data++;
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/DoubleCounter.cs	(revision 2027)
@@ -44,6 +44,6 @@
     public DoubleCounter()
       : base() {
-      AddVariableInfo(new VariableInfo("Value", "Counter value", typeof(DoubleData), VariableKind.In | VariableKind.Out));
-      AddVariableInfo(new VariableInfo("Interval", "Interval value", typeof(DoubleData), VariableKind.In));
+      AddParameter(new Parameter("Value", "Counter value", typeof(DoubleData), ParameterType.InOut));
+      AddParameter(new Parameter("Interval", "Interval value", typeof(DoubleData), ParameterType.In));
     }
 
@@ -53,7 +53,7 @@
     /// <param name="scope">The scope whose variable should be incremented.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      DoubleData value = GetVariableValue<DoubleData>("Value", scope, true);
-      double interval = GetVariableValue<DoubleData>("Interval", scope, true).Data;
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      DoubleData value = scope.GetVariableValue<DoubleData>(env.TranslateName("Value"), true);
+      double interval = scope.GetVariableValue<DoubleData>(env.TranslateName("Interval"), true).Data;
       value.Data += interval;
       return null;
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/EmptyOperator.cs	(revision 2027)
@@ -47,5 +47,5 @@
     /// <param name="scope">The scope to apply the operator on.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment environment, IScope scope) {
       return null;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLab.Operators-3.2.csproj	(revision 2027)
@@ -81,50 +81,63 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AddVariableInfoDialog.cs">
-      <SubType>Form</SubType>
+    <Compile Include="ComparatorBase.cs">
+      <SubType>Code</SubType>
     </Compile>
-    <Compile Include="AddVariableInfoDialog.Designer.cs">
-      <DependentUpon>AddVariableInfoDialog.cs</DependentUpon>
-    </Compile>
-    <Compile Include="CombinedOperator.cs" />
-    <Compile Include="CombinedOperatorView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="CombinedOperatorView.Designer.cs">
-      <DependentUpon>CombinedOperatorView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="ComparatorBase.cs" />
     <Compile Include="ConditionalBranch.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="DelegatingOperator.cs" />
-    <Compile Include="DoubleCounter.cs" />
-    <Compile Include="ScopeCleaner.cs" />
-    <Compile Include="StochasticMultiBranch.cs" />
-    <Compile Include="SubScopesMixer.cs" />
-    <Compile Include="DataCollector.cs" />
-    <Compile Include="EqualToComparator.cs" />
-    <Compile Include="GreaterOrEqualThanComparator.cs" />
-    <Compile Include="GreaterThanComparator.cs" />
-    <Compile Include="LessOrEqualThanComparator.cs" />
-    <Compile Include="LessThanComparator.cs" />
-    <Compile Include="OperatorExtractor.cs" />
-    <Compile Include="ParallelProcessor.cs" />
-    <Compile Include="EmptyOperator.cs" />
-    <Compile Include="SequentialProcessor.cs" />
-    <Compile Include="SingleObjectiveEvaluatorBase.cs" />
-    <Compile Include="Sorter.cs" />
-    <Compile Include="StochasticBranch.cs" />
-    <Compile Include="SubScopesRemover.cs" />
-    <Compile Include="UnequalToComparator.cs" />
-    <Compile Include="UniformSequentialSubScopesProcessor.cs" />
-    <Compile Include="UniformParallelSubScopesProcessor.cs" />
-    <Compile Include="ParallelSubScopesProcessor.cs" />
-    <Compile Include="SequentialSubScopesProcessor.cs" />
-    <Compile Include="SubScopesCreater.cs" />
-    <Compile Include="Counter.cs" />
+    <Compile Include="Counter.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="DoubleCounter.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="EmptyOperator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="EqualToComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="GreaterOrEqualThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="GreaterThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="HeuristicLabOperatorsPlugin.cs" />
+    <Compile Include="LessOrEqualThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="LessThanComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ParallelProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ParallelSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="VariableInjector.cs" />
+    <Compile Include="SequentialProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SequentialSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="SubScopesCreater.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UnequalToComparator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UniformParallelSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="UniformSequentialSubScopesProcessor.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="VariableInjector.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="VariableInjectorView.cs">
       <SubType>UserControl</SubType>
@@ -135,8 +148,4 @@
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Constraints\3.2\HeuristicLab.Constraints-3.2.csproj">
-      <Project>{FCD62C6F-4793-4593-AE9A-0BDCA256EE99}</Project>
-      <Name>HeuristicLab.Constraints-3.2</Name>
-    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
       <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>
@@ -157,11 +166,6 @@
   </ItemGroup>
   <ItemGroup>
-    <EmbeddedResource Include="AddVariableInfoDialog.resx">
-      <DependentUpon>AddVariableInfoDialog.cs</DependentUpon>
-      <SubType>Designer</SubType>
-    </EmbeddedResource>
-    <EmbeddedResource Include="CombinedOperatorView.resx">
-      <DependentUpon>CombinedOperatorView.cs</DependentUpon>
-      <SubType>Designer</SubType>
+    <EmbeddedResource Include="VariableInjectorView.resx">
+      <DependentUpon>VariableInjectorView.cs</DependentUpon>
     </EmbeddedResource>
   </ItemGroup>
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/HeuristicLabOperatorsPlugin.cs	(revision 2027)
@@ -31,5 +31,4 @@
   [ClassInfo(Name = "HeuristicLab.Operators-3.2")]
   [PluginFile(Filename = "HeuristicLab.Operators-3.2.dll", Filetype = PluginFileType.Assembly)]
-  [Dependency(Dependency = "HeuristicLab.Constraints-3.2")]
   [Dependency(Dependency = "HeuristicLab.Core-3.2")]
   [Dependency(Dependency = "HeuristicLab.Data-3.2")]
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelProcessor.cs	(revision 2027)
@@ -42,9 +42,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>n</c> operators applied 
     /// to the given <paramref name="scope"/> with the <c>ExecuteInParallel</c> set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < SubOperators.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/ParallelSubScopesProcessor.cs	(revision 2027)
@@ -42,9 +42,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
     /// on the <c>i</c>th sub scope, the <c>ExecuteInParallel</c> flag set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>n</c> operators applied 
     /// to the given <paramref name="scope"/>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < SubOperators.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SequentialSubScopesProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <returns>A new <see cref="CompositeOperation"/> with the <c>i</c>th operator applied
     /// on the <c>i</c>th sub scope.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[i], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[i], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/SubScopesCreater.cs	(revision 2027)
@@ -41,5 +41,5 @@
     public SubScopesCreater()
       : base() {
-      AddVariableInfo(new VariableInfo("SubScopes", "Number of sub-scopes", typeof(IntData), VariableKind.In));
+      AddParameter(new Parameter("SubScopes", "Number of sub-scopes", typeof(IntData), ParameterType.In));
     }
 
@@ -49,6 +49,6 @@
     /// <param name="scope">The scope where to create the sub scopes.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IntData count = GetVariableValue<IntData>("SubScopes", scope, true);
+    public override IOperation Apply(IEnvironment env, IScope scope) {
+      IntData count = scope.GetVariableValue<IntData>(env.TranslateName("SubScopes"), true);
 
       for (int i = 0; i < count.Data; i++)
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformParallelSubScopesProcessor.cs	(revision 2027)
@@ -43,9 +43,9 @@
     /// <returns>A new <see cref="CompositeOperation"/> with one operator and all sub scopes and
     /// the <c>ExecuteInParallel</c> flag set to <c>true</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       next.ExecuteInParallel = true;
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[0], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[0], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/UniformSequentialSubScopesProcessor.cs	(revision 2027)
@@ -42,8 +42,8 @@
     /// <param name="scope">The scope on whose sub scopes the operator is applied.</param>
     /// <returns>A new <see cref="CompositeOperation"/> with one operator and all sub scopes.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       CompositeOperation next = new CompositeOperation();
       for (int i = 0; i < scope.SubScopes.Count; i++)
-        next.AddOperation(new AtomicOperation(SubOperators[0], scope.SubScopes[i]));
+        next.AddOperation(new AtomicOperation(SubOperators[0], env, scope.SubScopes[i]));
       return next;
     }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjector.cs	(revision 2027)
@@ -30,11 +30,28 @@
   /// Class to inject local variables into the scope.
   /// </summary>
-  public class VariableInjector : OperatorBase {
-    private Dictionary<IVariable, IVariableInfo> variableVariableInfoTable;
-    private Dictionary<IVariableInfo, IVariable> variableInfoVariableTable;
+  public class VariableInjector : OperatorBase, IVariablesContainer {
+    private Dictionary<string, IVariable> myVariables;
+    /// <summary>
+    /// Gets a collection of all variables of the current operator.
+    /// </summary>
+    public virtual ICollection<IVariable> Variables {
+      get { return myVariables.Values; }
+    }
 
     /// <inheritdoc select="summary"/>
     public override string Description {
-      get { return @"TODO\r\nOperator description still missing ..."; }
+      get { return @"Injects new variable into a scope."; }
+    }
+
+    /// <summary>
+    /// Overrides the Parameters property so that a parameter is returned for each injected variable.
+    /// </summary>
+    public override ICollection<IParameter> Parameters {
+      get {
+        List<IParameter> parameters = new List<IParameter>();
+        foreach (IVariable variable in Variables)
+          parameters.Add(new Parameter(variable.Name, "Injected variable.", variable.Value.GetType(), ParameterType.Out));
+        return parameters;
+      }
     }
 
@@ -44,6 +61,5 @@
     public VariableInjector()
       : base() {
-      variableVariableInfoTable = new Dictionary<IVariable, IVariableInfo>();
-      variableInfoVariableTable = new Dictionary<IVariableInfo, IVariable>();
+      myVariables = new Dictionary<string, IVariable>();
     }
 
@@ -56,7 +72,5 @@
     /// <returns>The cloned object as <see cref="VariableInjector"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
-      VariableInjector clone = new VariableInjector();
-      clonedObjects.Add(Guid, clone);
-      clone.Name = Name;
+      VariableInjector clone = (VariableInjector)base.Clone(clonedObjects);
       foreach (IVariable variable in Variables)
         clone.AddVariable((IVariable)Auxiliary.Clone(variable, clonedObjects));
@@ -65,26 +79,4 @@
 
     /// <summary>
-    /// Adds the specified <paramref name="variable"/> to the current instance to get injected.
-    /// </summary>
-    /// <param name="variable">The variable to add.</param>
-    /// <remarks>Calls private method <see cref="CreateVariableInfo"/> and <see cref="OperatorBase.AddVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    public override void AddVariable(IVariable variable) {
-      base.AddVariable(variable);
-      CreateVariableInfo(variable);
-    }
-
-    /// <summary>
-    /// Removes a variable with the specified <paramref name="name"/> from the current injector.
-    /// </summary>
-    /// <remarks>Calls private method <see cref="DeleteVariableInfo"/> and <see cref="OperatorBase.RemoveVariable"/>
-    /// of base class <see cref="OperatorBase"/>.</remarks>
-    /// <param name="name">The name of the </param>
-    public override void RemoveVariable(string name) {
-      DeleteVariableInfo(name);
-      base.RemoveVariable(name);
-    }
-
-    /// <summary>
     /// Adds the specified variables to the given <paramref name="scope"/> (and removes them first,
     /// if they already exist in the current scope).
@@ -92,5 +84,5 @@
     /// <param name="scope">The scope where to inject the variables.</param>
     /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
+    public override IOperation Apply(IEnvironment env, IScope scope) {
       foreach (IVariable variable in Variables) {
         if (scope.GetVariable(variable.Name) != null)
@@ -109,54 +101,118 @@
     }
 
-    private void CreateVariableInfo(IVariable variable) {
-      IVariableInfo info = new VariableInfo(Guid.NewGuid().ToString(), "Injected variable", variable.Value.GetType(), VariableKind.New);
-      info.ActualName = variable.Name;
-      AddVariableInfo(info);
-      variableVariableInfoTable.Add(variable, info);
-      variableInfoVariableTable.Add(info, variable);
-      info.ActualNameChanged += new EventHandler(VariableInfo_ActualNameChanged);
+    /// <summary>
+    /// Gets a variable with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable.</param>
+    /// <returns>The variable with the specified name.</returns>
+    public virtual IVariable GetVariable(string name) {
+      IVariable variable;
+      if (myVariables.TryGetValue(name, out variable))
+        return variable;
+      else
+        return null;
+    }
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    public virtual void AddVariable(IVariable variable) {
+      myVariables.Add(variable.Name, variable);
+      variable.NameChanging += new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
       variable.NameChanged += new EventHandler(Variable_NameChanged);
-    }
-    private void DeleteVariableInfo(string name) {
-      IVariable variable = GetVariable(name);
-      if (variable != null) {
-        IVariableInfo info = variableVariableInfoTable[variable];
-        RemoveVariableInfo(info.FormalName);
-        variableVariableInfoTable.Remove(variable);
-        variableInfoVariableTable.Remove(info);
-        info.ActualNameChanged -= new EventHandler(VariableInfo_ActualNameChanged);
+      OnVariableAdded(variable);
+    }
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
+    public virtual void RemoveVariable(string name) {
+      IVariable variable;
+      if (myVariables.TryGetValue(name, out variable)) {
+        variable.NameChanging -= new EventHandler<NameChangingEventArgs>(Variable_NameChanging);
         variable.NameChanged -= new EventHandler(Variable_NameChanged);
-      }
-    }
-
-    #region VariableInfo and Variable Events
-    private void VariableInfo_ActualNameChanged(object sender, EventArgs e) {
-      IVariableInfo info = (IVariableInfo)sender;
-      IVariable variable = variableInfoVariableTable[info];
-      variable.Name = info.ActualName;
+        myVariables.Remove(name);
+        OnVariableRemoved(variable);
+      }
+    }
+    private void Variable_NameChanging(object sender, NameChangingEventArgs e) {
+      e.Cancel = myVariables.ContainsKey(e.Name);
     }
     private void Variable_NameChanged(object sender, EventArgs e) {
       IVariable variable = (IVariable)sender;
-      IVariableInfo info = variableVariableInfoTable[variable];
-      info.ActualName = variable.Name;
-    }
-    #endregion
+      string oldName = null;
+      foreach (KeyValuePair<string, IVariable> element in myVariables) {
+        if (element.Value == variable)
+          oldName = element.Key;
+      }
+      myVariables.Remove(oldName);
+      myVariables.Add(variable.Name, variable);
+    }
+
+    /// <summary>
+    /// Occurs when a variable has been added.
+    /// </summary>
+    public event EventHandler<VariableEventArgs> VariableAdded;
+    /// <summary>
+    /// Fires a new <c>VariableAdded</c> event.
+    /// </summary>
+    /// <param name="variable">The variable that has been added.</param>
+    protected virtual void OnVariableAdded(IVariable variable) {
+      if (VariableAdded != null)
+        VariableAdded(this, new VariableEventArgs(variable));
+    }
+    /// <summary>
+    /// Occurs when a variable has been deleted.
+    /// </summary>
+    public event EventHandler<VariableEventArgs> VariableRemoved;
+    /// <summary>
+    /// Fires a new <c>VariableRemoved</c> event.
+    /// </summary>
+    /// <param name="variable">The variable that has been removed</param>
+    protected virtual void OnVariableRemoved(IVariable variable) {
+      if (VariableRemoved != null)
+        VariableRemoved(this, new VariableEventArgs(variable));
+    }
 
     #region Persistence Methods
     /// <summary>
     /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
-    /// <note type="caution"> Variable infos are not persisted!</note>
-    /// </summary>
-    /// <remarks>Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// </summary>
+    /// <remarks>
+    /// Calls <see cref="OperatorBase.GetXmlNode"/> of base class <see cref="OperatorBase"/>.
+    /// <br/>A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Variables: </term>
+    /// <description>Saved as child node with tag name <c>Variables</c>. All variables are themselves
+    /// saved as child nodes.</description>
+    /// </item> 
+    /// </list>
+    /// </remarks>
     /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
     /// <param name="document">The <see cref="XmlDocument"/> where to save the data.</param>
     /// <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);
-      // variable infos should not be persisted
-      XmlNode infosNode = node.SelectSingleNode("VariableInfos");
-      infosNode.RemoveAll();
+      XmlNode variablesNode = document.CreateNode(XmlNodeType.Element, "Variables", null);
+      foreach (IVariable variable in myVariables.Values)
+        variablesNode.AppendChild(PersistenceManager.Persist(variable, document, persistedObjects));
+      node.AppendChild(variablesNode);
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted variable injector from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Populate"/> of base class 
+    /// <see cref="OperatorBase"/>.
+    /// For informations how the different elements must be saved please see <see cref="GetXmlNode"/>.</remarks>
+    /// <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) {
+      base.Populate(node, restoredObjects);
+      XmlNode variablesNode = node.SelectSingleNode("Variables");
+      foreach (XmlNode variableNode in variablesNode.ChildNodes)
+        AddVariable((IVariable)PersistenceManager.Restore(variableNode, restoredObjects));
     }
     #endregion
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.Designer.cs	(revision 2027)
@@ -45,9 +45,54 @@
     /// </summary>
     private void InitializeComponent() {
-      components = new System.ComponentModel.Container();
+      this.variablesTabPage = new System.Windows.Forms.TabPage();
+      this.variablesContainerView = new HeuristicLab.Core.VariablesContainerView();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
+      this.variablesTabPage.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // tabControl
+      // 
+      this.tabControl.Controls.Add(this.variablesTabPage);
+      this.tabControl.Controls.SetChildIndex(this.parametersTabPage, 0);
+      this.tabControl.Controls.SetChildIndex(this.variablesTabPage, 0);
+      // 
+      // variablesTabPage
+      // 
+      this.variablesTabPage.Controls.Add(this.variablesContainerView);
+      this.variablesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.variablesTabPage.Name = "variablesTabPage";
+      this.variablesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.variablesTabPage.Size = new System.Drawing.Size(415, 307);
+      this.variablesTabPage.TabIndex = 4;
+      this.variablesTabPage.Text = "Variables";
+      this.variablesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // variablesContainerView
+      // 
+      this.variablesContainerView.Caption = "Variables Container";
+      this.variablesContainerView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.variablesContainerView.Location = new System.Drawing.Point(3, 3);
+      this.variablesContainerView.Name = "variablesContainerView";
+      this.variablesContainerView.Size = new System.Drawing.Size(409, 301);
+      this.variablesContainerView.TabIndex = 0;
+      this.variablesContainerView.VariablesContainer = null;
+      // 
+      // VariableInjectorView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Name = "VariableInjectorView";
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
+      this.variablesTabPage.ResumeLayout(false);
+      this.ResumeLayout(false);
+
     }
 
     #endregion
+
+    private System.Windows.Forms.TabPage variablesTabPage;
+    private HeuristicLab.Core.VariablesContainerView variablesContainerView;
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs	(revision 1992)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.cs	(revision 2027)
@@ -60,4 +60,20 @@
       VariableInjector = variableInjector;
     }
+
+    /// <summary>
+    /// Removes event handlers in all children.
+    /// </summary>
+    protected override void RemoveItemEvents() {
+      variablesContainerView.VariablesContainer = null;
+      base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds event handlers in all children.
+    /// </summary>
+    protected override void AddItemEvents() {
+      base.AddItemEvents();
+      variablesContainerView.VariablesContainer = VariableInjector;
+    }
+
   }
 }
Index: branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx
===================================================================
--- branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx	(revision 2027)
+++ branches/Operator Architecture Refactoring/HeuristicLab.Operators/3.2/VariableInjectorView.resx	(revision 2027)
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
