Changeset 776

trunk/sources/HeuristicLab.Core/AliasEventArgs.cs

-                      r61
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected alias.
+  /// </summary>
   public class AliasEventArgs : EventArgs {
     private string myAlias;
+    /// <summary>
+    /// Gets the affected alias.
+    /// </summary>
     public string Alias {
       get { return myAlias; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="AliasEventArgs"/> with the given <paramref name="alias"/>.
+    /// </summary>
+    /// <param name="alias">The affected alias.</param>
     public AliasEventArgs(string alias) {
       myAlias = alias;

trunk/sources/HeuristicLab.Core/AtomicOperation.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a single operation with one operator and one scope.
+  /// </summary>
   public class AtomicOperation : ItemBase, IOperation {
     private IOperator myOperator;
+    /// <summary>
+    /// Gets the current operator as <see cref="IOperator"/>.
+    /// </summary>
     public IOperator Operator {
       get { return myOperator; }
+    }
+    private IScope myScope;
+    private IScope myScope;
+    /// <summary>
+    /// Gets the current scope as <see cref="IScope"/>.
+    /// </summary>
     public IScope Scope {
       get { return myScope; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="AtomicOperation"/>.
+    /// </summary>
     public AtomicOperation() { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="AtomicOperation"/> with the given <paramref name="op"/>
+    /// and the given <paramref name="scope"/>.
+    /// </summary>
+    /// <param name="op">The operator to assign.</param>
+    /// <param name="scope">The scope to assign.</param>
     public AtomicOperation(IOperator op, IScope scope) {
       myOperator = op;
 …
+    }
+    /// <summary>
+    /// Clones the current instance.
+    /// </summary>
+    /// <remarks>The operator and the scope objects are cloned with the
+    /// <see cref="HeuristicLab.Core.Auxiliary.Clone"/> method of the <see cref="Auxiliary"/> class.</remarks>
+    /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="AtomicOperation"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       AtomicOperation clone = new AtomicOperation();
 …
     #region Persistence Methods
+    /// <summary>
+    ///  Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="HeuristicLab.Core.StorableBase.GetXmlNode"/> of base
+    /// class <see cref="ItemBase"/>. <br/>
+    /// The operator is saved as child node having the tag name <c>Operator</c>.<br/>
+    /// The scope is also saved as a child node having the tag name <c>Scope</c>.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operation from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="HeuristicLab.Core.StorableBase.Populate"/> of base class
+    /// <see cref="ItemBase"/>.<br/>
+    /// The operator must be saved as a child node with the tag name <c>Operator</c>, also the scope must
+    /// be saved as a child node having the tag name <c>Scope</c> (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);

trunk/sources/HeuristicLab.Core/Auxiliary.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Static helper class.
+  /// </summary>
   public static class Auxiliary {
     #region Cloning
+    /// <summary>
+    /// Clones the given <paramref name="obj"/> (deep clone).
+    /// </summary>
+    /// <remarks>Checks before clone if object has not already been cloned.</remarks>
+    /// <param name="obj">The object to clone.</param>
+    /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object.</returns>
     public static object Clone(IStorable obj, IDictionary<Guid, object> clonedObjects) {
       object clone;
 …
     #region Error Messages
+    /// <summary>
+    /// Shows an error message box with a given error <paramref name="message"/> and an OK-Button.
+    /// </summary>
+    /// <param name="message">The error message to display.</param>
     public static void ShowErrorMessageBox(string message) {
       MessageBox.Show(message,
 …
                       MessageBoxIcon.Error);
+    }
+    /// <summary>
+    /// Shows an error message box with a given exception <paramref name="ex"/> and an OK-Button.
+    /// </summary>
+    /// <param name="ex">The exception to display.</param>
     public static void ShowErrorMessageBox(Exception ex) {
       MessageBox.Show(BuildErrorMessage(ex),
 …
                       MessageBoxIcon.Error);
+    }
+    /// <summary>
+    /// Builds an error message out of an exception and formats it accordingly.
+    /// </summary>
+    /// <param name="ex">The exception to format.</param>
+    /// <returns>The formated message.</returns>
     private static string BuildErrorMessage(Exception ex) {
       StringBuilder sb = new StringBuilder();
 …
     #region Constraint Violation Messages
+    /// <summary>
+    /// Shows a warning message box with an OK-Button, indicating that the given constraints were violated and so
+    /// the operation could not be completed.
+    /// </summary>
+    /// <param name="violatedConstraints">The constraints that could not be fulfilled.</param>
     public static void ShowConstraintViolationMessageBox(ICollection<IConstraint> violatedConstraints) {
       string message = BuildConstraintViolationMessage(violatedConstraints);
 …
                       MessageBoxIcon.Warning);
+    }
+    /// <summary>
+    /// Shows a question message box with a yes-no option, where to choose whether to ignore
+    /// the given violated constraints and to complete the operation or not.
+    /// </summary>
+    /// <param name="violatedConstraints">The constraints that could not be fulfilled.</param>
+    /// <returns>The result of the choice ("Yes" = 6, "No" = 7).</returns>
     public static DialogResult ShowIgnoreConstraintViolationMessageBox(ICollection<IConstraint> violatedConstraints) {
       string message = BuildConstraintViolationMessage(violatedConstraints);
 …
                              MessageBoxIcon.Question);
+    }
+    /// <summary>
+    /// Builds a message out of a given collection of violated constraints,
+    /// including the constraints type and description.
+    /// </summary>
+    /// <param name="violatedConstraints">The constraints that could not be fulfilled.</param>
+    /// <returns>The message to display.</returns>
     private static string BuildConstraintViolationMessage(ICollection<IConstraint> violatedConstraints) {
       StringBuilder sb = new StringBuilder();

trunk/sources/HeuristicLab.Core/ChooseItemDialog.cs

-                      r42
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// A dialog to select an item.
+  /// </summary>
   public partial class ChooseItemDialog : Form {
     #region Inner Class TreeNodeSorter
 …
     #endregion
+    /// <summary>
+    /// Gets or sets the caption of the dialog.
+    /// </summary>
+    /// <remarks>Uses property <see cref="Form.Text"/> of base class <see cref="System.Windows.Forms.Form"/>.
+    /// No own data storage present.</remarks>
     public string Caption {
       get { return Text; }
 …
     private IItem myItem;
+    /// <summary>
+    /// Gets the selected item.
+    /// </summary>
     public IItem Item {
       get { return myItem; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ChooseItemDialog"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ChooseItemDialog(System.Type)"/> with the type of <see cref="IItem"/>
+    /// as parameter.</remarks>
     public ChooseItemDialog()
       : this(typeof(IItem)) {
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ChooseItemDialog"/> with
+    /// the given <paramref name="itemType"/>.
+    /// </summary>
+    /// <param name="itemType">The type of the items to choose from.</param>
     public ChooseItemDialog(Type itemType) {
       InitializeComponent();

trunk/sources/HeuristicLab.Core/ChooseOperatorDialog.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// A dialog to select an operator out of a library.
+  /// </summary>
   public partial class ChooseOperatorDialog : Form {
     #region Inner Class TreeNodeSorter
 …
     private IOperator myOperator;
+    /// <summary>
+    /// Gets the selected operator.
+    /// </summary>
     public IOperator Operator {
       get { return myOperator; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ChooseOperatorDialog"/>.
+    /// </summary>
     public ChooseOperatorDialog() {
       InitializeComponent();

trunk/sources/HeuristicLab.Core/ChooseTypeDialog.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// A dialog to select a specific type.
+  /// </summary>
   public partial class ChooseTypeDialog : Form {
     #region Inner Class TreeNodeSorter
 …
     #endregion
+    /// <summary>
+    /// Gets or sets the caption of the dialog.
+    /// </summary>
+    /// <remarks>Uses property <see cref="Form.Text"/> of base class <see cref="Form"/>.
+    /// No own data storage present.</remarks>
     public string Caption {
       get { return Text; }
 …
     private Type myType;
+    /// <summary>
+    /// Gets the selected type.
+    /// </summary>
     public Type Type {
       get { return myType; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ChooseTypeDialog"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ChooseTypeDialog(Type)"/> with the type of <see cref="IItem"/> as
+    /// parameter.</remarks>
     public ChooseTypeDialog()
       : this(typeof(IItem)) {
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ChooseTypeDialog"/> with the given
+    /// <paramref name="baseType"/>.
+    /// </summary>
+    /// <param name="baseType">The base type of all chooseable types.</param>
     public ChooseTypeDialog(Type baseType) {
       InitializeComponent();

trunk/sources/HeuristicLab.Core/CompositeOperation.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a class for operations consisting themselves of several operations.
+  /// Can also be executed in parallel.
+  /// </summary>
   public class CompositeOperation : ItemBase, IOperation {
     private bool myExecuteInParallel;
+    /// <summary>
+    /// Gets or sets the bool value, whether the operation should be executed in parallel or not.
+    /// </summary>
     public bool ExecuteInParallel {
       get { return myExecuteInParallel; }
 …
+    }
     private List<IOperation> myOperations;
+    /// <summary>
+    /// Gets all current operations.
+    /// <note type="caution"> Operations are read-only!</note>
+    /// </summary>
     public IList<IOperation> Operations {
       get { return myOperations.AsReadOnly(); }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="CompositeOperation"/>, the <see cref="ExecuteInParallel"/>
+    /// property set to <c>false</c>.
+    /// </summary>
     public CompositeOperation() {
       myOperations = new List<IOperation>();
 …
+    }
+    /// <summary>
+    /// Adds an operation to the current list of operations.
+    /// </summary>
+    /// <param name="operation">The operation to add.</param>
     public void AddOperation(IOperation operation) {
       myOperations.Add(operation);
+    }
+    /// <summary>
+    /// Removes an operation from the current list.
+    /// </summary>
+    /// <param name="operation">The operation to remove.</param>
     public void RemoveOperation(IOperation operation) {
       myOperations.Remove(operation);
+    }
+    /// <summary>
+    /// Clones the current instance of <see cref="CompositeOperation"/> (deep clone).
+    /// </summary>
+    /// <remarks>All operations of the current instance are cloned, too (deep clone), with the
+    /// <see cref="HeuristicLab.Core.Auxiliary.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned operation as <see cref="CompositeOperation"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       CompositeOperation clone = new CompositeOperation();
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="HeuristicLab.Core.StorableBase.GetXmlNode"/> of base
+    /// class <see cref="ItemBase"/>.<br/>
+    /// The <see cref="ExecuteInParallel"/> property is saved as <see cref="XmlAttribute"/> with the
+    /// tag name <c>ExecuteInParallel</c>. A child node with tag name <c>Operations</c> is created where
+    /// all operations are saved as child nodes.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operation from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The <see cref="ExecuteInParallel"/> property must be saved as <see cref="XmlAttribute"/>
+    /// with the tag name <c>ExecuteInParallel</c>. <br/>
+    /// The single operations must be saved as child nodes of a node with tag name <c>Operations</c>,
+    /// being a child node of the current instance. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</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);

trunk/sources/HeuristicLab.Core/ConstrainedItemBase.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Base class for all items that are subjects to restrictions.
+  /// </summary>
   public abstract class ConstrainedItemBase : ItemBase, IConstrainedItem {
     private List<IConstraint> myConstraints;
+    /// <summary>
+    /// Gets all current constraints.
+    /// <note type="caution"> The constraints are returned read-only.</note>
+    /// </summary>
     public virtual ICollection<IConstraint> Constraints {
       get { return myConstraints.AsReadOnly(); }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ConstrainedItemBase"/>.
+    /// </summary>
     protected ConstrainedItemBase() {
       myConstraints = new List<IConstraint>();
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </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);
 …
+    }
+    /// <summary>
+    /// Adds the given <paramref name="constraint"/> to the current list.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnConstraintAdded"/>.</remarks>
+    /// <param name="constraint">The constraint to add.</param>
     public virtual void AddConstraint(IConstraint constraint) {
       myConstraints.Add(constraint);
       OnConstraintAdded(constraint);
+    }
+    /// <summary>
+    /// Removes the given <paramref name="constraint"/> from the current list.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnConstraintRemoved"/> if the constraint can be successfully removed.</remarks>
+    /// <param name="constraint">The constraint to remove.</param>
     public virtual void RemoveConstraint(IConstraint constraint) {
       if (myConstraints.Remove(constraint))
 …
+    }
+    /// <summary>
+    /// Checks all constraints of the current instance.
+    /// </summary>
+    /// <returns><c>true</c> if all constraints could be fulfilled, <c>false</c> otherwise.</returns>
     public bool IsValid() {
       bool result = true;
 …
       return result;
+    }
+    /// <summary>
+    /// Checks all constraints of the current instance.
+    /// </summary>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if all constraints could be fulfilled, <c>false</c> otherwise.</returns>
     public bool IsValid(out ICollection<IConstraint> violatedConstraints) {
       bool result = true;
 …
+    }
+    /// <summary>
+    /// Creates an instance of <see cref="ConstrainedItemBaseView"/>
+    /// to represent the current instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="ConstrainedItemBase"/>.</returns>
     public override IView CreateView() {
       return new ConstrainedItemBaseView(this);
+    }
+    /// <summary>
+    /// Occurs when a constraint is added.
+    /// </summary>
     public event EventHandler<ConstraintEventArgs> ConstraintAdded;
+    /// <summary>
+    /// Fires a new <c>ConstraintAdded</c> event.
+    /// </summary>
+    /// <param name="constraint">The constraint that was added.</param>
     protected virtual void OnConstraintAdded(IConstraint constraint) {
       if (ConstraintAdded != null)
         ConstraintAdded(this, new ConstraintEventArgs(constraint));
+    }
+    /// <summary>
+    /// Occurs when a constraint is removed.
+    /// </summary>
     public event EventHandler<ConstraintEventArgs> ConstraintRemoved;
+    /// <summary>
+    /// Fires a new <c>ConstraintRemoved</c> event.
+    /// </summary>
+    /// <param name="constraint">The constraint that was removed.</param>
     protected virtual void OnConstraintRemoved(IConstraint constraint) {
       if (ConstraintRemoved != null)
 …
+    }
+    #region Persistence Methods
+    #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>. <br/>
+    /// For saving the constraints a child node is created having the tag name <c>Constraints</c>. Beyond this
+    /// child node all constraints are saved as child nodes themselves.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    ///  Loads the persisted item from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get information about how the constrained item must
+    /// be saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the constrained item is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/ConstrainedItemBaseView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of an <see cref="IConstrainedItem"/>.
+  /// </summary>
   public partial class ConstrainedItemBaseView : ViewBase {
     private ChooseItemDialog chooseItemDialog;
+    /// <summary>
+    /// Gets or sets the current item to represent visually.
+    /// </summary>
     public IConstrainedItem ConstrainedItem {
       get { return (IConstrainedItem)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ConstrainedItemBaseView"/>
+    /// with the caption "Constrained Item".
+    /// </summary>
     public ConstrainedItemBaseView() {
       InitializeComponent();
 …
       Caption = "Constrained Item";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ConstrainedItemBaseView"/> with the given
+    /// <paramref name="constraintItem"/>.
+    /// </summary>
+    /// <param name="constraintItem">The item to represent visually.</param>
     public ConstrainedItemBaseView(IConstrainedItem constraintItem)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the event handlers from the underlying <see cref="IConstrainedItem"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       ConstrainedItem.ConstraintAdded -= new EventHandler<ConstraintEventArgs>(ConstrainedItemBase_ConstraintAdded);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds event handlers to the underlying <see cref="IConstrainedItem"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/ConstraintEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected constraint.
+  /// </summary>
   public class ConstraintEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected constraint.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
     public IConstraint Constraint {
       get { return (IConstraint)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ConstraintEventArgs"/> with the given
+    /// <paramref name="constraint"/>.
+    /// </summary>
+    /// <remarks>Only calls the constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="constraint">The affected constraint.</param>
     public ConstraintEventArgs(IConstraint constraint)
       : base(constraint) {

trunk/sources/HeuristicLab.Core/EditorBase.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Base class for views that can load and save data.
+  /// </summary>
   public partial class EditorBase : ViewBase, IEditor {
     private string myFilename;
+    /// <summary>
+    /// Gets or sets the filename of the current editor.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnFilenameChanged"/> in the setter if the filename is new.</remarks>
     public string Filename {
       get { return myFilename; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="EditorBase"/> with the caption "Editor".
+    /// </summary>
     public EditorBase() {
       InitializeComponent();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
 …
+    }
+    /// <summary>
+    /// Occurs when the filename is changed.
+    /// </summary>
     public event EventHandler FilenameChanged;
+    /// <summary>
+    /// Fires a new <c>FilenameChanged</c> event.
+    /// </summary>
     protected virtual void OnFilenameChanged() {
       if (FilenameChanged != null)

trunk/sources/HeuristicLab.Core/EngineBase.cs

-                      r47
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Base class to represent an engine, which is an interpreter, holding the code, the data and
+  /// the actual state, which is the runtime stack and a pointer onto the next operation. It represents
+  /// one execution and can handle parallel executions.
+  /// </summary>
   public abstract class EngineBase : ItemBase, IEngine {
+    /// <summary>
+    /// Field of the current instance that represent the operator graph.
+    /// </summary>
     protected IOperatorGraph myOperatorGraph;
+    /// <summary>
+    /// Gets the current operator graph.
+    /// </summary>
     public IOperatorGraph OperatorGraph {
       get { return myOperatorGraph; }
+    }
+    /// <summary>
+    /// Field of the current instance that represent the global scope.
+    /// </summary>
     protected IScope myGlobalScope;
+    /// <summary>
+    /// Gets the current global scope.
+    /// </summary>
     public IScope GlobalScope {
       get { return myGlobalScope; }
 …
     private TimeSpan myExecutionTime;
+    /// <summary>
+    /// Gets or sets the execution time.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnExecutionTimeChanged"/> in the setter.</remarks>
     public TimeSpan ExecutionTime {
       get { return myExecutionTime; }
 …
+    }
+    /// <summary>
+    /// Field of the current instance that represent the execution stack.
+    /// </summary>
     protected Stack<IOperation> myExecutionStack;
+    /// <summary>
+    /// Gets the current execution stack.
+    /// </summary>
     public Stack<IOperation> ExecutionStack {
       get { return myExecutionStack; }
+    }
+    /// <summary>
+    /// Flag of the current instance whether it is currently running.
+    /// </summary>
     protected bool myRunning;
+    /// <summary>
+    /// Gets information whether the instance is currently running.
+    /// </summary>
     public bool Running {
       get { return myRunning; }
+    }
+    /// <summary>
+    /// Flag of the current instance whether it is canceled.
+    /// </summary>
     protected bool myCanceled;
+    /// <summary>
+    /// Gets information whether the instance is currently canceled.
+    /// </summary>
     public bool Canceled {
       get { return myCanceled; }
+    }
+    /// <summary>
+    /// Gets information whether the instance has already terminated.
+    /// </summary>
     public virtual bool Terminated {
       get { return ExecutionStack.Count == 0; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="EngineBase"/> with a new global scope.
+    /// </summary>
+    /// <remarks>Calls <see cref="Reset"/>.</remarks>
     protected EngineBase() {
       myOperatorGraph = new OperatorGraph();
 …
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone through <see cref="Auxiliary.Clone"/> method of helper class
+    /// <see cref="Auxiliary"/>.</remarks>
+    /// <param name="clonedObjects">Dictionary of all already clone objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="EngineBase"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       EngineBase clone = (EngineBase)base.Clone(clonedObjects);
 …
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback, object)"/>
+    /// of class <see cref="ThreadPool"/>.</remarks>
     public virtual void Execute() {
       myRunning = true;
 …
       ThreadPool.QueueUserWorkItem(new WaitCallback(Run), null);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback, object)"/>
+    /// of class <see cref="ThreadPool"/>.</remarks>
     public virtual void ExecuteSteps(int steps) {
       myRunning = true;
 …
       ThreadPool.QueueUserWorkItem(new WaitCallback(Run), steps);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="ThreadPool.QueueUserWorkItem(System.Threading.WaitCallback, object)"/>
+    /// of class <see cref="ThreadPool"/>.</remarks>
     public void ExecuteStep() {
       ExecuteSteps(1);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Sets the protected flag <c>myCanceled</c> to <c>true</c>.</remarks>
     public virtual void Abort() {
       myCanceled = true;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Sets <c>myCanceled</c> and <c>myRunning</c> to <c>false</c>. The global scope is cleared,
+    /// the execution time is reseted, the execution stack is cleared and a new <see cref="AtomicOperation"/>
+    /// with the initial operator is added. <br/>
+    /// Calls <see cref="OnInitialized"/>.</remarks>
     public virtual void Reset() {
       myCanceled = false;
 …
+    }
+    /// <summary>
+    /// Performs the next operation.
+    /// </summary>
     protected abstract void ProcessNextOperation();
+    /// <summary>
+    /// Occurs when the current instance is initialized.
+    /// </summary>
     public event EventHandler Initialized;
+    /// <summary>
+    /// Fires a new <c>Initialized</c> event.
+    /// </summary>
     protected virtual void OnInitialized() {
       if (Initialized != null)
         Initialized(this, new EventArgs());
+    }
+    /// <summary>
+    /// Occurs when an operation is executed.
+    /// </summary>
     public event EventHandler<OperationEventArgs> OperationExecuted;
+    /// <summary>
+    /// Fires a new <c>OperationExecuted</c> event.
+    /// </summary>
+    /// <param name="operation">The operation that has been executed.</param>
     protected virtual void OnOperationExecuted(IOperation operation) {
       if (OperationExecuted != null)
         OperationExecuted(this, new OperationEventArgs(operation));
+    }
+    /// <summary>
+    /// Occurs when an exception occured during the execution.
+    /// </summary>
     public event EventHandler<ExceptionEventArgs> ExceptionOccurred;
+    /// <summary>
+    /// Aborts the execution and fires a new <c>ExceptionOccurred</c> event.
+    /// </summary>
+    /// <param name="exception">The exception that was thrown.</param>
     protected virtual void OnExceptionOccurred(Exception exception) {
       Abort();
 …
         ExceptionOccurred(this, new ExceptionEventArgs(exception));
+    }
+    /// <summary>
+    /// Occurs when the execution time changed.
+    /// </summary>
     public event EventHandler ExecutionTimeChanged;
+    /// <summary>
+    /// Fires a new <c>ExecutionTimeChanged</c> event.
+    /// </summary>
     protected virtual void OnExecutionTimeChanged() {
       if (ExecutionTimeChanged != null)
         ExecutionTimeChanged(this, new EventArgs());
+    }
+    /// <summary>
+    /// Occurs when the execution is finished.
+    /// </summary>
     public event EventHandler Finished;
+    /// <summary>
+    /// Fires a new <c>Finished</c> event.
+    /// </summary>
     protected virtual void OnFinished() {
       if (Finished != null)
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Operator graph: </term>
+    /// <description>Saved as a child node with the tag name <c>OperatorGraph</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Global scope: </term>
+    /// <description>Saved as a child node with the tag name <c>GlobalScope</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Execution stack: </term>
+    /// <description>A child node is created with the tag name <c>ExecutionStack</c>. Beyond this child node
+    /// all operations of the execution stack are saved as child nodes.</description>
+    /// </item>
+    /// <item>
+    /// <term>Execution time: </term>
+    /// <description>Saved as a child node with the tag name <c>ExecutionTime</c>, where the execution
+    /// time is saved as string in the node's inner text.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    ///  Loads the persisted instance from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get information on how the instance must be saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the engine is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/EngineBaseEditor.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Base class for editors of engines.
+  /// </summary>
   public partial class EngineBaseEditor : EditorBase {
     private int executionTimeCounter;
+    /// <summary>
+    /// Gets or sets the current engine.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="EditorBase"/>.</remarks>
     public IEngine Engine {
       get { return (IEngine)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="EngineBaseEditor"/>.
+    /// </summary>
     public EngineBaseEditor() {
       InitializeComponent();
+    }
+    /// <summary>
+    /// Removes the event handlers from the underlying <see cref="IEngine"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       Engine.Initialized -= new EventHandler(Engine_Initialized);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds event handlers to the underlying <see cref="IEngine"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="EditorBase.UpdateControls"/> of base class <see cref="EditorBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/ExceptionEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected exception.
+  /// </summary>
   public class ExceptionEventArgs : EventArgs {
     private Exception myException;
+    /// <summary>
+    /// Gets the affected exception.
+    /// </summary>
     public Exception Exception {
       get { return myException; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ExceptionEventArgs"/>
+    /// with the given <paramref name="exception"/>.
+    /// </summary>
+    /// <param name="exception">The affected exception.</param>
     public ExceptionEventArgs(Exception exception) {
       myException = exception;

trunk/sources/HeuristicLab.Core/HeuristicLab.Core.csproj

r582	r776
3	3	<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
4	4	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
5		<ProductVersion>9.0.~~30729~~</ProductVersion>
	5	<ProductVersion>9.0.21022</ProductVersion>
6	6	<SchemaVersion>2.0</SchemaVersion>
7	7	<ProjectGuid>{F43B59AB-2B8C-4570-BC1E-15592086517C}</ProjectGuid>

trunk/sources/HeuristicLab.Core/HeuristicLabCorePlugin.cs

-                      r582
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Core plugin.
+  /// </summary>
   [ClassInfo(Name = "HeuristicLab.Core-3.2")]
   [PluginFile(Filename = "HeuristicLab.Core-3.2.dll", Filetype = PluginFileType.Assembly)]

trunk/sources/HeuristicLab.Core/Interfaces/IConstrainedItem.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent items that are subjects to restrictions.
+  /// </summary>
   public interface IConstrainedItem : IItem {
+    /// <summary>
+    /// All constraints of the current instance.
+    /// </summary>
     ICollection<IConstraint> Constraints { get; }
+    /// <summary>
+    /// Adds a constraint to the current instance.
+    /// </summary>
+    /// <param name="constraint">The constraint to add.</param>
     void AddConstraint(IConstraint constraint);
+    /// <summary>
+    /// Removes a constraint from the current instance.
+    /// </summary>
+    /// <param name="constraint">The constraint to remove.</param>
     void RemoveConstraint(IConstraint constraint);
+    /// <summary>
+    /// Checks whether the current instance fullfills all constraints.
+    /// </summary>
+    /// <returns><c>true</c> if all constraints are fullfilled, <c>false</c> otherwise.</returns>
     bool IsValid();
+    /// <summary>
+    /// Checks whether the current instance fullfills all constraints.
+    /// </summary>
+    /// <param name="violatedConstraints">Output parameter, all constraints that could not be fullfilled.</param>
+    /// <returns><c>true</c> if all constraints are fullfilled, <c>false</c> otherwise.</returns>
     bool IsValid(out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// An <see cref="EventHandler"/> for events when a new constraint is added.
+    /// </summary>
     event EventHandler<ConstraintEventArgs> ConstraintAdded;
+    /// <summary>
+    /// An <see cref="EventHandler"/> for events when a constraint is deleted.
+    /// </summary>
     event EventHandler<ConstraintEventArgs> ConstraintRemoved;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IConstraint.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent restrictions.
+  /// </summary>
   public interface IConstraint : IItem {
+    /// <summary>
+    /// Gets the description of the current instance.
+    /// </summary>
     string Description { get; }
+    /// <summary>
+    /// Checks whether the given <paramref name="data"/> fulfills the current constraint.
+    /// </summary>
+    /// <param name="data">The item to check.</param>
+    /// <returns><c>true</c> if the current instance could be fulfilled, <c>false</c> otherwise.</returns>
     bool Check(IItem data);
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IEditable.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent editable items.
+  /// </summary>
   public interface IEditable : IViewable {
+    /// <summary>
+    /// Creates an editor.
+    /// </summary>
+    /// <returns>The created editor as <see cref="IEditor"/>.</returns>
     IEditor CreateEditor();
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IEditor.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent an editor.
+  /// </summary>
   public interface IEditor : IView {
+    /// <summary>
+    /// Gets or sets the filename.
+    /// </summary>
     string Filename { get; set; }
+    /// <summary>
+    /// Occurs when the filename was changed.
+    /// </summary>
     event EventHandler FilenameChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IEngine.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent one run. (An engine is an interpreter, holding the code,
+  /// the data and the actual state, which is the runtime stack and a pointer onto the next operation.).
+  /// It is responsible for operator execution and able to deal with parallelism.
+  /// </summary>
   public interface IEngine : IItem {
+    /// <summary>
+    /// Gets the operator graph of the current instance.
+    /// </summary>
     IOperatorGraph OperatorGraph { get; }
+    /// <summary>
+    /// Gets the global scope of the current instance.
+    /// </summary>
     IScope GlobalScope { get; }
+    /// <summary>
+    /// Gets the execution time of the current instance.
+    /// </summary>
     TimeSpan ExecutionTime { get; }
+    /// <summary>
+    /// Gets information whether the engine is currently running.
+    /// </summary>
     bool Running { get; }
+    /// <summary>
+    /// Gets information whether the engine is canceled.
+    /// </summary>
     bool Canceled { get; }
+    /// <summary>
+    /// Gets information whether the engine has already terminated.
+    /// </summary>
     bool Terminated { get; }
+    /// <summary>
+    /// Executes the whole run.
+    /// </summary>
     void Execute();
+    /// <summary>
+    /// Executes one step (one operation).
+    /// </summary>
     void ExecuteStep();
+    /// <summary>
+    /// Executes the given number of steps.
+    /// </summary>
+    /// <param name="steps">The number of steps to execute.</param>
     void ExecuteSteps(int steps);
+    /// <summary>
+    /// Aborts the engine run.
+    /// </summary>
     void Abort();
+    /// <summary>
+    /// Resets the current instance.
+    /// </summary>
     void Reset();
+    /// <summary>
+    /// Occurs when the current instance is initialized.
+    /// </summary>
     event EventHandler Initialized;
+    /// <summary>
+    /// Occurs when an operation is executed.
+    /// </summary>
     event EventHandler<OperationEventArgs> OperationExecuted;
+    /// <summary>
+    /// Occurs when an exception was thrown.
+    /// </summary>
     event EventHandler<ExceptionEventArgs> ExceptionOccurred;
+    /// <summary>
+    /// Occurs when the execution time was changed.
+    /// </summary>
     event EventHandler ExecutionTimeChanged;
+    /// <summary>
+    /// Occurs when the engine is finished.
+    /// </summary>
     event EventHandler Finished;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IItem.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent (almost) every HeuristicLab object (an object, an operator,...).
+  /// </summary>
   public interface IItem : IStorable, IViewable {
+    /// <summary>
+    /// Fires a new <c>Changed</c> event.
+    /// </summary>
     void FireChanged();
+    /// <summary>
+    /// Occurs when the current instance has changed.
+    /// </summary>
     event EventHandler Changed;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IOperation.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent an operation (Executes a defined number of operators on a defined scope).
+  /// </summary>
   public interface IOperation : IItem {
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IOperator.cs

-                      r47
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent an operator (e.g. GreaterThanComparator,...),
+  /// a basic instruction of an algorithm.
+  /// </summary>
   public interface IOperator : IConstrainedItem {
+    /// <summary>
+    /// Gets or sets the name of the current instance.
+    /// </summary>
     string Name { get; set; }
+    /// <summary>
+    /// Gets or sets the description of the current instance.
+    /// </summary>
     string Description { get; }
+    /// <summary>
+    /// Gets information whether the current operator has been canceled.
+    /// </summary>
     bool Canceled { get; }
+    /// <summary>
+    /// Gets or sets a boolean value whether the engine should stop here during the run.
+    /// </summary>
     bool Breakpoint { get; set; }
+    /// <summary>
+    /// Gets a list of all sub operators.
+    /// </summary>
     IList<IOperator> SubOperators { get; }
+    /// <summary>
+    /// Gets a collection of all variable (parameter) infos.
+    /// </summary>
     ICollection<IVariableInfo> VariableInfos { get; }
+    /// <summary>
+    /// Gets a collection of all variables of the current operator.
+    /// </summary>
     ICollection<IVariable> Variables { get; }
+    /// <summary>
+    /// Adds the given sub operator to the current instance.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
     void AddSubOperator(IOperator op);
+    /// <summary>
+    /// Adds the given sub operator to the current instance if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
+    /// <returns><c>true</c> if the operator could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddSubOperator(IOperator op);
+    /// <summary>
+    /// Adds the given sub operator to the current instance if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if the operator could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddSubOperator(IOperator op, out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// Adds the given sub operator at a the specified <paramref name="index"/>.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
+    /// <param name="index">The position where to add the operator.</param>
     void AddSubOperator(IOperator op, int index);
+    /// <summary>
+    /// Adds the given operator at the specified <paramref name="index"/> to the current instance
+    /// if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
+    /// <param name="index">The position where to add the operator.</param>
+    /// <returns><c>true</c> if the operator could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddSubOperator(IOperator op, int index);
+    /// <summary>
+    /// Adds the given operator at the specified <paramref name="index"/> to the current instance
+    /// if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
+    /// <param name="index">The position where to add the operator.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if the operator could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddSubOperator(IOperator op, int index, out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// Removes a sub operator at the specified <paramref name="index"/>.
+    /// </summary>
+    /// <param name="index">The position where to delete the operator.</param>
     void RemoveSubOperator(int index);
+    /// <summary>
+    /// Removes a sub operator at the specified <paramref name="index"/> if all constraint can be fulfilled.
+    /// </summary>
+    /// <param name="index">The position where to delete the operator.</param>
+    /// <returns><c>true</c> if the operator could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveSubOperator(int index);
+    /// <summary>
+    /// Deletes the operator at the specified <paramref name="index"/>
+    /// if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="index">The position where to delete the operator.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if the operator could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveSubOperator(int index, out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// Gets the variable info with the given <paramref name="formalName"/>.
+    /// </summary>
+    /// <param name="formalName">The formal name of the variable info.</param>
+    /// <returns>The variable info with the specified formal name.</returns>
     IVariableInfo GetVariableInfo(string formalName);
+    /// <summary>
+    /// Adds the specified variable info to the current instance.
+    /// </summary>
+    /// <param name="variableInfo">The variable info to add.</param>
     void AddVariableInfo(IVariableInfo variableInfo);
+    /// <summary>
+    /// Adds the specified variable info to the current instance, if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="variableInfo">The variable info to add.</param>
+    /// <returns><c>true</c> if the variable info could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddVariableInfo(IVariableInfo variableInfo);
+    /// <summary>
+    /// Adds the specified variable info to the current instance, if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="variableInfo">The variable info to add.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if the variable info could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddVariableInfo(IVariableInfo variableInfo, out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// Removes the variable info with the given formal name.
+    /// </summary>
+    /// <param name="formalName">The formal name of the variable info to remove.</param>
     void RemoveVariableInfo(string formalName);
+    /// <summary>
+    /// Deletes the variable info with the given formal name,
+    /// if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="formalName">The formal name of the variable info to remove.</param>
+    /// <returns><c>true</c> if the variable info could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveVariableInfo(string formalName);
+    /// <summary>
+    /// Deletes the variable info with the given formal name,
+    /// if all constraints can be fulfilled.
+    /// </summary>
+    /// <param name="formalName">The formal name of the variable info to remove.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could not be
+    /// fulfilled.</param>
+    /// <returns><c>true</c> if the variable info could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveVariableInfo(string formalName, out ICollection<IConstraint> violatedConstraints);
+    /// <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>
     IVariable GetVariable(string name);
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
     void AddVariable(IVariable variable);
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance if all constraints can
+    /// be fulfilled.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    /// <returns><c>true</c> if the variable could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddVariable(IVariable variable);
+    /// <summary>
+    /// Adds the specified <paramref name="variable"/> to the current instance if all constraints can
+    /// be fulfilled.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could
+    /// not be fulfillled.</param>
+    /// <returns><c>true</c> if the variable could be added without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryAddVariable(IVariable variable, out ICollection<IConstraint> violatedConstraints);
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
     void RemoveVariable(string name);
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/> if all constraints can be
+    /// fulfilled.
+    /// </summary>
+    /// <param name="name">The name of the variable to remove.</param>
+    /// <returns><c>true</c> if the variable could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveVariable(string name);
+    /// <summary>
+    /// Deletes the variable with the specified <paramref name="name"/> if all constraints can be
+    /// fulfilled.
+    /// </summary>
+    /// <param name="name">The name of the variable to remove.</param>
+    /// <param name="violatedConstraints">Output parameter; contains all constraints that could
+    /// not be fulfilled.</param>
+    /// <returns><c>true</c> if the variable could be deleted without violating constraints,
+    /// <c>false</c> otherwise.</returns>
     bool TryRemoveVariable(string name, out ICollection<IConstraint> violatedConstraints);
+    /// <inheritdoc cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool)"/>
+    /// <typeparam name="T">The type of the value that is searched.</typeparam>
     T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup) where T : class, IItem;
+    /// <inheritdoc cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
+    /// <typeparam name="T">The type of the value that is searched.</typeparam>
     T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) where T : class, IItem;
+    /// <inheritdoc cref="GetVariableValue(System.String, IScope, bool, bool)"
+    /// select="summary"/>
+    /// <param name="formalName">The formal name of the variable info whose variable value is searched.</param>
+    /// <param name="scope">The scope where to look for the variable.</param>
+    /// <param name="recursiveLookup">Boolean value, whether also the parent scopes shall be searched if
+    /// the variable is not found in the specified <paramref name="scope"/>.</param>
+    /// <returns>The value of the searched variable or null if it is not found.</returns>
     IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup);
+    /// <summary>
+    /// Gets the value of the variable in the specified <paramref name="scope"/>
+    /// whose variable(parameter) info has the specified <paramref name="formalName"/>.
+    /// </summary>
+    /// <param name="formalName">The formal name of the variable info whose variable value is searched.</param>
+    /// <param name="scope">The scope where to look for the variable.</param>
+    /// <param name="recursiveLookup">Boolean value, whether also the parent scopes shall be searched if
+    /// the variable is not found in the specified <paramref name="scope"/>.</param>
+    /// <param name="throwOnError">Boolean value, whether an exception shall be thrown, if the variable
+    /// cannot be found or just <c>null</c> shall be returned.</param>
+    /// <returns>The value of the searched variable (or null if the variable is not
+    /// found and <paramref name="throwOnError"/> is set to false).</returns>
     IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup, bool throwOnError);
+    /// <summary>
+    /// Executes the current instance on the specified <paramref name="scope"/>.
+    /// </summary>
+    /// <param name="scope">The scope where to execute the current instance.</param>
+    /// <returns>The next operation.</returns>
     IOperation Execute(IScope scope);
+    /// <summary>
+    /// Aborts the current operator.
+    /// </summary>
     void Abort();
+    /// <summary>
+    /// Occurs when the name of the operator was changed.
+    /// </summary>
     event EventHandler NameChanged;
+    event EventHandler BreakpointChanged;
+    /// <summary>
+    /// Occurs when the breakpoint flag of the current instance was changed.
+    /// </summary>
+    event EventHandler BreakpointChanged;
+    /// <summary>
+    /// Occurs when a sub operator has been added.
+    /// </summary>
     event EventHandler<OperatorIndexEventArgs> SubOperatorAdded;
+    /// <summary>
+    /// Occurs when a sub operator has been deleted.
+    /// </summary>
     event EventHandler<OperatorIndexEventArgs> SubOperatorRemoved;
+    /// <summary>
+    /// Occurs when a variable info has been added.
+    /// </summary>
     event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
+    /// <summary>
+    /// Occurs when a variable info has been deleted.
+    /// </summary>
     event EventHandler<VariableInfoEventArgs> VariableInfoRemoved;
+    /// <summary>
+    /// Occurs when a variable has been added.
+    /// </summary>
     event EventHandler<VariableEventArgs> VariableAdded;
+    /// <summary>
+    /// Occurs when a variable has been deleted.
+    /// </summary>
     event EventHandler<VariableEventArgs> VariableRemoved;
+    /// <summary>
+    /// Occurs when the current instance is executed.
+    /// </summary>
     event EventHandler Executed;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IOperatorGraph.cs

-                      r47
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent an operator graph.
+  /// </summary>
   public interface IOperatorGraph : IItem {
+    /// <summary>
+    /// Gets all operators of the current instance.
+    /// </summary>
     ICollection<IOperator> Operators { get; }
+    /// <summary>
+    /// Gets or sets the initial operator (the starting one) of the current instance.
+    /// </summary>
     IOperator InitialOperator { get; set; }
+    /// <summary>
+    /// Adds the given operator to the current instance.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
     void AddOperator(IOperator op);
+    /// <summary>
+    /// Removes an operator with the specified <paramref name="guid"/> from the current instance.
+    /// </summary>
+    /// <param name="guid">The unique id of the operator to remove.</param>
     void RemoveOperator(Guid guid);
+    /// <summary>
+    /// Gets the operator with the specified <paramref name="guid"/>.
+    /// </summary>
+    /// <param name="guid">The unique id of the operator.</param>
+    /// <returns>The searched operator.</returns>
     IOperator GetOperator(Guid guid);
+    /// <summary>
+    /// Clears the current instance.
+    /// </summary>
     void Clear();
+    /// <summary>
+    /// Occurs when a new operator has been added to the current instance.
+    /// </summary>
     event EventHandler<OperatorEventArgs> OperatorAdded;
+    /// <summary>
+    /// Occurs when an operator has been deleted from the current instance.
+    /// </summary>
     event EventHandler<OperatorEventArgs> OperatorRemoved;
+    /// <summary>
+    /// Occurs when the initial operator (the starting one) has been changed.
+    /// </summary>
     event EventHandler InitialOperatorChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IOperatorGroup.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent a group of operators.
+  /// </summary>
   public interface IOperatorGroup : IStorable {
+    /// <summary>
+    /// Gets or sets the name of the current instance.
+    /// </summary>
     string Name { get; set; }
+    /// <summary>
+    /// Gets all sub groups of operators of the current instance.
+    /// </summary>
     ICollection<IOperatorGroup> SubGroups { get; }
+    /// <summary>
+    /// Gets all operators of the current operator group.
+    /// </summary>
     ICollection<IOperator> Operators { get; }
+    /// <summary>
+    /// Adds the specified sub group of operators to the current operator group.
+    /// </summary>
+    /// <param name="group">The operator group to add.</param>
     void AddSubGroup(IOperatorGroup group);
+    /// <summary>
+    /// Deletes the specified sub group of operators from the current instance.
+    /// </summary>
+    /// <param name="group">The sub group to delete.</param>
     void RemoveSubGroup(IOperatorGroup group);
+    /// <summary>
+    /// Adds the specified operator to the current instance.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
     void AddOperator(IOperator op);
+    /// <summary>
+    /// Deletes the specified operator from the current instance.
+    /// </summary>
+    /// <param name="op">The operator to remove.</param>
     void RemoveOperator(IOperator op);
+    /// <summary>
+    /// Occurs when the name of the operator group has been changed.
+    /// </summary>
     event EventHandler NameChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IOperatorLibrary.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent a library of operators.
+  /// </summary>
   public interface IOperatorLibrary : IItem {
+    /// <summary>
+    /// Gets the operator group of the current instance.
+    /// </summary>
     IOperatorGroup Group { get; }
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IRandom.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents an interface for random number generators.
+  /// </summary>
   public interface IRandom : IItem {
+    /// <summary>
+    /// Resets the random number generator.
+    /// </summary>
     void Reset();
+    /// <summary>
+    /// Resets the random number generator with the given <paramref name="seed"/>.
+    /// </summary>
+    /// <param name="seed">The new seed.</param>
     void Reset(int seed);
+    /// <summary>
+    /// Gets a new random number.
+    /// </summary>
+    /// <returns>A random integer number.</returns>
     int Next();
+    /// <summary>
+    /// Gets a new random number between 0 and <paramref name="maxVal"/>.
+    /// </summary>
+    /// <param name="maxVal">The maximal value of the random number.</param>
+    /// <returns>A random integer number smaller than or equal to <paramref name="maxVal"/>.</returns>
     int Next(int maxVal);
+    /// <summary>
+    /// Gets a new random number between <paramref name="minVal"/> and <paramref name="maxVal"/>.
+    /// </summary>
+    /// <param name="maxVal">The maximal value of the random number.</param>
+    /// <param name="minVal">The minimal value of the random number.</param>
+    /// <returns>A random integer number. (<paramref name="minVal"/> &lt;= x &lt;= <paramref name="maxVal"/>.</returns>
     int Next(int minVal, int maxVal);
+    /// <summary>
+    /// Gets a new double random number.
+    /// </summary>
+    /// <returns>A random double number.</returns>
     double NextDouble();
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IScope.cs

-                      r63
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface for a hierarchical container of variables (containing variables and subscopes).
+  /// </summary>
   public interface IScope : IItem {
+    /// <summary>
+    /// Gets the name of the current instance.
+    /// </summary>
     string Name { get; }
+    /// <summary>
+    /// Gets the varibles of the current scope.
+    /// </summary>
     ICollection<IVariable> Variables { get; }
+    /// <summary>
+    /// Gets all aliases of the current scope.
+    /// </summary>
     IEnumerable<KeyValuePair<string, string>> Aliases { get; }
+    /// <summary>
+    /// Gets all subscopes in the current scope.
+    /// </summary>
     IList<IScope> SubScopes { get; }
+    /// <summary>
+    /// Sets the parent scope for the current instance.
+    /// </summary>
+    /// <param name="scope">The parent scope of the current instance.</param>
     void SetParent(IScope scope);
+    /// <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>
     IVariable GetVariable(string name);
+    /// <summary>
+    /// Adds the specified variable to the curent instance.
+    /// </summary>
+    /// <param name="variable">The variable to add.</param>
     void AddVariable(IVariable variable);
+    /// <summary>
+    /// Deletes a variable with the specified <paramref name="name"/> from the current instance.
+    /// </summary>
+    /// <param name="name">The name of the variable to delete.</param>
     void RemoveVariable(string name);
+    /// <inheritdoc cref="GetVariableValue(string, bool)"/>
+    /// <typeparam name="T">The type of the value that is searched.</typeparam>
     T GetVariableValue<T>(string name, bool recursiveLookup) where T : class, IItem;
+    /// <inheritdoc cref="GetVariableValue(string, bool, bool)"/>
+    /// <typeparam name="T">The type of the value that is searched.</typeparam>
     T GetVariableValue<T>(string name, bool recursiveLookup, bool throwOnError) where T : class, IItem;
+    /// <inheritdoc cref="GetVariableValue(string, bool, bool)" select="summary"/>
+    /// <param name="name">The name of the variable.</param>
+    /// <param name="recursiveLookup">Boolean value, whether the parent scopes shall be searched
+    /// when the variable is not found in the current instance.</param>
+    /// <returns>The value of the variable or <c>null</c> if it was not found.</returns>
     IItem GetVariableValue(string name, bool recursiveLookup);
+    /// <summary>
+    /// Gets the value of the variable with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the variable.</param>
+    /// <param name="recursiveLookup">Boolean value, whether the parent scopes shall be searched
+    /// when the variable is not found in the current instance.</param>
+    /// <param name="throwOnError">Boolean value, whether an exception shall be thrown when the searched
+    /// variable cannot be found, or only <c>null</c> shall be returned.</param>
+    /// <returns>The value of the searched variable or <c>null</c> if <paramref name="throwOnError"/>
+    /// is set to <c>false</c>.</returns>
     IItem GetVariableValue(string name, bool recursiveLookup, bool throwOnError);
+    /// <summary>
+    /// Gets the actual name the given alias.
+    /// </summary>
+    /// <param name="name">The alias whose actual name is searched.</param>
+    /// <returns>The actual name.</returns>
     string TranslateName(string name);
+    /// <summary>
+    /// Adds an alias to the current instance.
+    /// </summary>
+    /// <param name="alias">The alias to add.</param>
+    /// <param name="name">The actual name of the alias.</param>
     void AddAlias(string alias, string name);
+    /// <summary>
+    /// Deletes the specified <paramref name="alias"/> from the current instance.
+    /// </summary>
+    /// <param name="alias">The alias to delete.</param>
     void RemoveAlias(string alias);
+    /// <summary>
+    /// Adds the specified sub scope to the current instance.
+    /// </summary>
+    /// <param name="scope">The sub scope to add.</param>
     void AddSubScope(IScope scope);
+    /// <summary>
+    /// Deletes the specified sub scope from the current instance.
+    /// </summary>
+    /// <param name="scope">The sub scope to delete.</param>
     void RemoveSubScope(IScope scope);
+    /// <summary>
+    /// Reorders all sub scopes according to the specified chronology.
+    /// </summary>
+    /// <param name="sequence">The chronology how to order the sub scopes.</param>
     void ReorderSubScopes(int[] sequence);
+    /// <summary>
+    /// Gets the sub scope with the given <paramref name="guid"/>.
+    /// </summary>
+    /// <param name="guid">The unique identifier of the sub scope.</param>
+    /// <returns>The sub scope with the given <paramref name="guid"/>.</returns>
     IScope GetScope(Guid guid);
+    /// <summary>
+    /// Gets the sub scope with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the sub scope.</param>
+    /// <returns>The sub scope with the given <paramref name="name"/>.</returns>
     IScope GetScope(string name);
+    /// <summary>
+    /// Clears the current instance.
+    /// </summary>
     void Clear();
+    /// <summary>
+    /// Occurs when a variable has been added to the current instance.
+    /// </summary>
     event EventHandler<VariableEventArgs> VariableAdded;
+    /// <summary>
+    /// Occurs when a variable has been deleted from the current instance.
+    /// </summary>
     event EventHandler<VariableEventArgs> VariableRemoved;
+    /// <summary>
+    /// Occurs when an alias has been added to the current instance.
+    /// </summary>
     event EventHandler<AliasEventArgs> AliasAdded;
+    /// <summary>
+    /// Occurs when an alias has been removed from the current instance.
+    /// </summary>
     event EventHandler<AliasEventArgs> AliasRemoved;
+    /// <summary>
+    /// Occurs when a sub scope has been added to the current instance.
+    /// </summary>
     event EventHandler<ScopeIndexEventArgs> SubScopeAdded;
+    /// <summary>
+    /// Occurs when a sub scope has been deleted from the current instance.
+    /// </summary>
     event EventHandler<ScopeIndexEventArgs> SubScopeRemoved;
+    /// <summary>
+    /// Occurs when the sub scopes have been reordered.
+    /// </summary>
     event EventHandler SubScopesReordered;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IStorable.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent objects that are de- and serializeable.
+  /// </summary>
   public interface IStorable {
+    /// <summary>
+    /// Gets the objects unique identifier.
+    /// </summary>
     Guid Guid { get; }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <returns>The cloned object.</returns>
     object Clone();
+    /// <summary>
+    /// Clones the current instance, considering already cloned objects.
+    /// </summary>
+    /// <param name="clonedObjects">All already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object.</returns>
     object Clone(IDictionary<Guid, object> clonedObjects);
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified
+    /// <typeparamref name="document"/>.
+    /// </summary>
+    /// <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>
     XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects);
+    /// <summary>
+    /// Loads the persisted object from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <param name="node">The <see cref="XmlNode"/> where the object is saved.</param>
+    /// <param name="restoredObjects">A dictionary of all already restored objects. (Needed to avoid
+    /// cycles.)</param>
     void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects);
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IVariable.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent a variable (of an operator) having a name and a value.
+  /// </summary>
   public interface IVariable : IItem {
+    /// <summary>
+    /// Gets or sets the name of the variable.
+    /// </summary>
     string Name { get; set; }
+    /// <summary>
+    /// Gets or sets the value of the variable.
+    /// </summary>
     IItem Value { get; set; }
+    /// <summary>
+    /// Gets the value of the variable.
+    /// </summary>
+    /// <typeparam name="T">The type of the variable's value.</typeparam>
+    /// <returns>The value of the current instance.</returns>
     T GetValue<T>() where T : class, IItem;
+    /// <summary>
+    /// Occurs when the name of the variable is currently changing.
+    /// </summary>
     event EventHandler<NameChangingEventArgs> NameChanging;
+    /// <summary>
+    /// Occurs when the name of the current instance has been changed.
+    /// </summary>
     event EventHandler NameChanged;
+    /// <summary>
+    /// Occurs when the value of the current instance has been changed.
+    /// </summary>
     event EventHandler ValueChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IVariableInfo.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to store meta-information about variables/parameters of operators.
+  /// </summary>
   public interface IVariableInfo : IItem {
+    /// <summary>
+    /// Gets or sets the actual name of the variable info.
+    /// </summary>
     string ActualName { get; set; }
+    /// <summary>
+    /// Gets or sets the formal name of the current instance.
+    /// </summary>
     string FormalName { get; }
+    /// <summary>
+    /// Gets the description of the current instance.
+    /// </summary>
     string Description { get; }
+    /// <summary>
+    /// Gets the data type of the current instance.
+    /// </summary>
     Type DataType { get; }
+    /// <summary>
+    /// Gets the kind of the variable info (in, out, new,...).
+    /// </summary>
     VariableKind Kind { get; }
+    /// <summary>
+    /// Gets or sets a boolean value whether the current instance is a local variable info.
+    /// </summary>
     bool Local { get; set; }
+    /// <summary>
+    /// Occurs when the actual name of the current instance has been changed.
+    /// </summary>
     event EventHandler ActualNameChanged;
+    /// <summary>
+    /// Occurs when the local flag has been changed.
+    /// </summary>
     event EventHandler LocalChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// An interface for all kinds visual representations of items (objects, operators...).
+  /// </summary>
   public interface IView : IControl {
+    /// <summary>
+    /// Gets the current item instance.
+    /// </summary>
     IItem Item { get; }
+    /// <summary>
+    /// Gets or sets the caption of the current instance.
+    /// </summary>
     string Caption { get; set; }
+    /// <summary>
+    /// Occurs when the item was changed.
+    /// </summary>
     event EventHandler ItemChanged;
+    /// <summary>
+    /// Occurs when the caption was changed.
+    /// </summary>
     event EventHandler CaptionChanged;
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IViewable.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Interface to represent items that can displayed visually.
+  /// </summary>
   public interface IViewable {
+    /// <summary>
+    /// Creates a view to display the current instance.
+    /// </summary>
+    /// <returns>The created view.</returns>
     IView CreateView();
+  }

trunk/sources/HeuristicLab.Core/Interfaces/IVisualizationItem.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Marker interface for items that can be visualized.
+  /// </summary>
   public interface IVisualizationItem : IItem { }
+}

trunk/sources/HeuristicLab.Core/ItemBase.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents the base class for all basic item types.
+  /// </summary>
   public abstract class ItemBase : StorableBase, IItem {
+    /// <summary>
+    /// Creates a new instance of <see cref="ItemBaseView"/> for
+    /// visual representation of the current instance.
+    /// </summary>
+    /// <returns>The created instance as <see cref="ItemBaseView"/>.</returns>
     public virtual IView CreateView() {
       return new ItemBaseView(this);
+    }
+    /// <summary>
+    /// Gets the string representation of the current instance.
+    /// </summary>
+    /// <returns>The type name of the current instance.</returns>
     public override string ToString() {
       return GetType().Name;
+    }
+    /// <summary>
+    /// Fires a new <c>Changed</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnChanged"/>.</remarks>
     public void FireChanged() {
       OnChanged();
+    }
+    /// <summary>
+    /// Occurs when the current item was changed.
+    /// </summary>
     public event EventHandler Changed;
+    /// <summary>
+    /// Fires a new <c>Changed</c> event.
+    /// </summary>
     protected virtual void OnChanged() {
       if (Changed != null)

trunk/sources/HeuristicLab.Core/ItemBaseView.cs

-                      r2
+                      r776
 using System.Windows.Forms;
+namespace HeuristicLab.Core {
+namespace HeuristicLab.Core {
+  /// <summary>
+  /// The base class for visual representations of items.
+  /// </summary>
   public partial class ItemBaseView : ViewBase {
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemBaseView"/>.
+    /// </summary>
     public ItemBaseView() {
       InitializeComponent();
+    }
+    /// <summary>
+    /// Intializes a new instance of <see cref="ItemBaseView"/> with the given <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The item that should be displayed.</param>
     public ItemBaseView(IItem item)
       : this() {

trunk/sources/HeuristicLab.Core/ItemEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected item.
+  /// </summary>
   public class ItemEventArgs : EventArgs {
     private IItem myItem;
+    /// <summary>
+    /// Gets the affected item.
+    /// </summary>
     public IItem Item {
       get { return myItem; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemEventArgs"/> with the given <paramref name="item"/>.
+    /// </summary>
+    /// <param name="item">The affected item.</param>
     public ItemEventArgs(IItem item) {
       myItem = item;

trunk/sources/HeuristicLab.Core/ItemIndexEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected item at a specified index.
+  /// </summary>
   public class ItemIndexEventArgs : ItemEventArgs {
     private int myIndex;
+    /// <summary>
+    /// Gets the affected index.
+    /// </summary>
     public int Index {
       get { return myIndex; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ItemIndexEventArgs"/> with the given <paramref name="item"/>
+    /// and the given <paramref name="index"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="item">The affected item.</param>
+    /// <param name="index">The affected index.</param>
     public ItemIndexEventArgs(IItem item, int index)
       : base(item) {

trunk/sources/HeuristicLab.Core/KeyValueEventArgs.cs

-                      r187
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected key-value pair.
+  /// </summary>
   public class KeyValueEventArgs : EventArgs {
     private IItem key;
+    /// <summary>
+    /// Gets the affected key.
+    /// </summary>
     public IItem Key {
       get { return key; }
 …
     private IItem value;
+    /// <summary>
+    /// Gets the affected value.
+    /// </summary>
     public IItem Value {
       get { return value; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="KeyValueEventArgs"/> with the given <paramref name="key"/>
+    /// and <paramref name="value"/>.
+    /// </summary>
+    /// <param name="key">The affected key.</param>
+    /// <param name="value">The affected value.</param>
     public KeyValueEventArgs(IItem key, IItem value) {
       this.key = key;

trunk/sources/HeuristicLab.Core/NameChangingEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected name.
+  /// </summary>
   public class NameChangingEventArgs : CancelEventArgs {
     private string myName;
+    /// <summary>
+    /// Gets the affected name.
+    /// </summary>
     public string Name {
       get { return myName; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NameChangingEventArgs"/>
+    /// with the specified <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The affected name.</param>
     public NameChangingEventArgs(string name)
       : base() {
       myName = name;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="NameChangingEventArgs"/>
+    /// with the specified <paramref name="name"/> and a flag whether the event has been canceled.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="CancelEventArgs"/>.</remarks>
+    /// <param name="name">The affected name.</param>
+    /// <param name="cancel">Flag, whether the event has been canceled.</param>
     public NameChangingEventArgs(string name, bool cancel)
       : base(cancel) {

trunk/sources/HeuristicLab.Core/OperationEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected operation.
+  /// </summary>
   public class OperationEventArgs : EventArgs {
     private IOperation myOperation;
+    /// <summary>
+    /// Gets the affected operation.
+    /// </summary>
     public IOperation Operation {
       get { return myOperation; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperationEventArgs"/> with the given
+    /// <paramref name="operation"/>.
+    /// </summary>
+    /// <param name="operation">The affected operation.</param>
     public OperationEventArgs(IOperation operation) {
       myOperation = operation;

trunk/sources/HeuristicLab.Core/OperatorBase.cs

-                      r76
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The base class for all operators.
+  /// </summary>
   public abstract class OperatorBase : ConstrainedItemBase, IOperator {
     private string myName;
+    /// <summary>
+    /// Gets or sets the name of the operator.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnNameChanged"/> in the setter.</remarks>
     public string Name {
       get { return myName; }
 …
+      }
+    }
+    /// <summary>
+    /// Gets the description of the current operator.
+    /// </summary>
+    /// <remarks>Returns "No operator description available" if the method is not overriden.</remarks>
     public virtual string Description {
       get { return "No operator description available."; }
+    }
+    /// <summary>
+    /// Flag whether the current instance has been canceled.
+    /// </summary>
     protected bool myCanceled;
+    /// <inheritdoc/>
     public bool Canceled {
       get { return myCanceled; }
+    }
     private bool myBreakpoint;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnBreakpointChanged"/> in the setter.</remarks>
     public bool Breakpoint {
       get { return myBreakpoint; }
 …
     private List<IOperator> mySubOperators;
+    /// <summary>
+    /// Gets a list of all suboperators.
+    /// <note type="caution"> Returns the suboperators read-only!</note>
+    /// </summary>
     public virtual IList<IOperator> SubOperators {
       get { return mySubOperators.AsReadOnly(); }
+    }
     private Dictionary<string, IVariableInfo> myVariableInfos;
+    /// <inheritdoc/>
     public virtual ICollection<IVariableInfo> VariableInfos {
       get { return myVariableInfos.Values; }
+    }
     private Dictionary<string, IVariable> myVariables;
+    /// <inheritdoc/>
     public virtual ICollection<IVariable> Variables {
       get { return myVariables.Values; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBase"/> setting the breakpoint flag and
+    /// the canceled flag to <c>false</c> and the name of the operator to the type name.
+    /// </summary>
     protected OperatorBase() {
       myName = this.GetType().Name;
 …
+    }
+    /// <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);
 …
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="OperatorBaseView"/> to represent the current operator
+    /// visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="OperatorBaseView"/>.</returns>
     public override IView CreateView() {
       return new OperatorBaseView(this);
 …
     #region SubOperator Methods
+    /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual void AddSubOperator(IOperator subOperator) {
       mySubOperators.Add(subOperator);
       OnSubOperatorAdded(subOperator, mySubOperators.Count - 1);
+    }
+    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual bool TryAddSubOperator(IOperator subOperator) {
       mySubOperators.Add(subOperator);
 …
+      }
+    }
+    /// <inheritdoc cref="HeuristicLab.Core.IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator,
+    /// out System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual bool TryAddSubOperator(IOperator subOperator, out ICollection<IConstraint> violatedConstraints) {
       mySubOperators.Add(subOperator);
 …
+      }
+    }
+    /// <inheritdoc cref="HeuristicLab.Core.IOperator.AddSubOperator(HeuristicLab.Core.IOperator, int)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual void AddSubOperator(IOperator subOperator, int index) {
       mySubOperators.Insert(index, subOperator);
       OnSubOperatorAdded(subOperator, index);
+    }
+    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual bool TryAddSubOperator(IOperator subOperator, int index) {
       mySubOperators.Insert(index, subOperator);
 …
+      }
+    }
+    /// <inheritdoc cref="IOperator.TryAddSubOperator(HeuristicLab.Core.IOperator, int, out
+    /// System.Collections.Generic.ICollection&lt;HeuristicLab.Core.IConstraint&gt;)"/>
+    /// <param name="subOperator">The sub operator to add.</param>
+    /// <remarks>Calls <see cref="OnSubOperatorAdded"/>.</remarks>
     public virtual bool TryAddSubOperator(IOperator subOperator, int index, out ICollection<IConstraint> violatedConstraints) {
       mySubOperators.Insert(index, subOperator);
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
     public virtual void RemoveSubOperator(int index) {
       IOperator op = mySubOperators[index];
 …
       OnSubOperatorRemoved(op, index);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
     public virtual bool TryRemoveSubOperator(int index) {
       IOperator op = mySubOperators[index];
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnSubOperatorRemoved"/>.</remarks>
     public virtual bool TryRemoveSubOperator(int index, out ICollection<IConstraint> violatedConstraints) {
       IOperator op = mySubOperators[index];
 …
     #region VariableInfo Methods
+    /// <inheritdoc/>
     public virtual IVariableInfo GetVariableInfo(string formalName) {
       IVariableInfo info;
 …
         return null;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
     public virtual void AddVariableInfo(IVariableInfo variableInfo) {
       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
       OnVariableInfoAdded(variableInfo);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
     public virtual bool TryAddVariableInfo(IVariableInfo variableInfo) {
       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoAdded"/>.</remarks>
     public virtual bool TryAddVariableInfo(IVariableInfo variableInfo, out ICollection<IConstraint> violatedConstraints) {
       myVariableInfos.Add(variableInfo.FormalName, variableInfo);
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
     public virtual void RemoveVariableInfo(string formalName) {
       IVariableInfo variableInfo;
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
     public virtual bool TryRemoveVariableInfo(string formalName) {
       IVariableInfo variableInfo;
 …
       return true;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableInfoRemoved"/>.</remarks>
     public virtual bool TryRemoveVariableInfo(string formalName, out ICollection<IConstraint> violatedConstraints) {
       IVariableInfo variableInfo;
 …
     #region Variable Methods
+    /// <inheritdoc/>
     public virtual IVariable GetVariable(string name) {
       IVariable variable;
 …
         return null;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual void AddVariable(IVariable variable) {
       myVariables.Add(variable.Name, variable);
 …
       OnVariableAdded(variable);
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual bool TryAddVariable(IVariable variable) {
       myVariables.Add(variable.Name, variable);
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableAdded"/> and adds <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual bool TryAddVariable(IVariable variable, out ICollection<IConstraint> violatedConstraints) {
       myVariables.Add(variable.Name, variable);
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual void RemoveVariable(string name) {
       IVariable variable;
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual bool TryRemoveVariable(string name) {
       IVariable variable;
 …
       return true;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnVariableRemoved"/> and removes <c>NameChanging</c> and <c>NameChanged</c>
+    /// event handlers.</remarks>
     public virtual bool TryRemoveVariable(string name, out ICollection<IConstraint> violatedConstraints) {
       IVariable variable;
 …
       myVariables.Add(variable.Name, variable);
+    }
+    /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool)"/>
+    ///  <remarks>Calls <see cref="GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/>
+    /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
     public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup) where T : class, IItem {
       return GetVariableValue<T>(formalName, scope, recursiveLookup, true);
+    }
+    /// <inheritdoc cref="IOperator.GetVariableValue&lt;T&gt;(string, HeuristicLab.Core.IScope, bool, bool)"/>
+    /// <remarks>Calls
+    /// <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>.</remarks>
     public T GetVariableValue<T>(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) where T : class, IItem {
       return (T)GetVariableValue(formalName, scope, recursiveLookup, throwOnError);
+    }
+    /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool)"/>
+    /// <remarks>Calls <see cref="GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
+    /// with <c>throwOnError</c> set to <c>false</c>.</remarks>
     public IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup) {
       return GetVariableValue(formalName, scope, recursiveLookup, true);
+    }
+    /// <inheritdoc cref="IOperator.GetVariableValue(string, HeuristicLab.Core.IScope, bool, bool)"/>
     public virtual IItem GetVariableValue(string formalName, IScope scope, bool recursiveLookup, bool throwOnError) {
       IVariableInfo info = GetVariableInfo(formalName);
 …
+    }
     #endregion
+    /// <inheritdoc/>
     public virtual IOperation Execute(IScope scope) {
       myCanceled = false;
 …
       return next;
+    }
+    /// <inheritdoc/>
+    /// <remarks>Sets property <see cref="Canceled"/> to <c>true</c>.</remarks>
     public virtual void Abort() {
       myCanceled = true;
+    }
+    /// <summary>
+    /// Performs the current operator on the specified <paramref name="scope"/>.
+    /// </summary>
+    /// <param name="scope">The scope where to execute the operator</param>
+    /// <returns><c>null</c>.</returns>
     public virtual IOperation Apply(IScope scope) {
       return null;
+    }
+    /// <inheritdoc/>
     public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
     protected virtual void OnNameChanged() {
       if (NameChanged != null) {
 …
+      }
+    }
+    /// <inheritdoc/>
     public event EventHandler BreakpointChanged;
+    /// <summary>
+    /// Fires a new <c>BreakpointChanged</c> event.
+    /// </summary>
     protected virtual void OnBreakpointChanged() {
       if (BreakpointChanged != null) {
 …
+      }
+    }
+    /// <inheritdoc/>
     public event EventHandler<OperatorIndexEventArgs> SubOperatorAdded;
+    /// <summary>
+    /// Fires a new <c>SubOperatorAdded</c> event.
+    /// </summary>
+    /// <param name="subOperator">The sub operator that has been added.</param>
+    /// <param name="index">The position where the operator has been added.</param>
     protected virtual void OnSubOperatorAdded(IOperator subOperator, int index) {
       if (SubOperatorAdded != null)
         SubOperatorAdded(this, new OperatorIndexEventArgs(subOperator, index));
+    }
+    /// <inheritdoc/>
     public event EventHandler<OperatorIndexEventArgs> SubOperatorRemoved;
+    /// <summary>
+    /// Fires a new <c>SubOperatorRemoved</c> event.
+    /// </summary>
+    /// <param name="subOperator">The sub operator that has been removed.</param>
+    /// <param name="index">The position where the operator has been removed.</param>
     protected virtual void OnSubOperatorRemoved(IOperator subOperator, int index) {
       if (SubOperatorRemoved != null)
         SubOperatorRemoved(this, new OperatorIndexEventArgs(subOperator, index));
+    }
+    /// <inheritdoc/>
     public event EventHandler<VariableInfoEventArgs> VariableInfoAdded;
+    /// <summary>
+    /// Fires a new <c>VariableInfoAdded</c> event.
+    /// </summary>
+    /// <param name="variableInfo">The variable info that has been added.</param>
     protected virtual void OnVariableInfoAdded(IVariableInfo variableInfo) {
       if (VariableInfoAdded != null)
         VariableInfoAdded(this, new VariableInfoEventArgs(variableInfo));
+    }
+    /// <inheritdoc/>
     public event EventHandler<VariableInfoEventArgs> VariableInfoRemoved;
+    /// <summary>
+    /// Fires a new <c>VariableInfoRemoved</c> event.
+    /// </summary>
+    /// <param name="variableInfo">The variable info that has been removed.</param>
     protected virtual void OnVariableInfoRemoved(IVariableInfo variableInfo) {
       if (VariableInfoRemoved != null)
         VariableInfoRemoved(this, new VariableInfoEventArgs(variableInfo));
+    }
+    /// <inheritdoc/>
     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));
+    }
+    /// <inheritdoc/>
     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));
+    }
+    /// <inheritdoc/>
     public event EventHandler Executed;
+    /// <summary>
+    /// Fires a new <c>Executed</c> event.
+    /// </summary>
     protected virtual void OnExecuted() {
       if (Executed != null) {
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>
+    /// Calls <see cref="ConstrainedItemBase.GetXmlNode"/> of base class <see cref="ConstrainedItemBase"/>.
+    /// <br/>A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Name: </term>
+    /// <description>Saved as an <see cref="XmlAttribute"/> with the name <c>Name</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Breakpoint: </term>
+    /// <description>Is only saved if it set to <c>true</c>.
+    /// Saved as an <see cref="XmlAttribute"/> with the name <c>Breakpoint</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Sub operators: </term>
+    /// <description>Saved as child node with tag name <c>SubOperators</c>. All sub operators are themselves
+    /// saved as child nodes.</description>
+    /// </item>
+    /// <item>
+    /// <term>Variable infos: </term>
+    /// <description>Saved as child node with tag name <c>VariableInfos</c>. All variable infos are themselves
+    /// saved as child nodes.</description>
+    /// </item>
+    /// <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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operation from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ConstrainedItemBase.Populate"/> of base class
+    /// <see cref="ConstrainedItemBase"/>.
+    /// 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);

trunk/sources/HeuristicLab.Core/OperatorBaseDescriptionView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of the description of operators.
+  /// </summary>
   public partial class OperatorBaseDescriptionView : ViewBase {
+    /// <summary>
+    /// Gets or sets the operator whose description should be displayed.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
       set { base.Item = value; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseDescriptionView"/> with caption "Operator".
+    /// </summary>
     public OperatorBaseDescriptionView() {
       InitializeComponent();
       Caption = "Operator";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseDescriptionView"/>
+    /// with the operator <paramref name="op"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBaseDescriptionView()"/>.</remarks>
+    /// <param name="op">The operator whose description to display.</param>
     public OperatorBaseDescriptionView(IOperator op)
       : this() {
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/OperatorBaseVariableInfosView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of the information of the variables of an operator.
+  /// </summary>
   public partial class OperatorBaseVariableInfosView : ViewBase {
+    /// <summary>
+    /// Gets or sets the operator whose variable infos should be represented visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
       set { base.Item = value; }
+    }
+    /// <summary>
+    /// Gets all selected variable infos.
+    /// <note type="caution"> Variable infos are returned read-only!</note>
+    /// </summary>
     public ICollection<IVariableInfo> SelectedVariableInfos {
       get {
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariableInfosView"/> with caption "Operator".
+    /// </summary>
     public OperatorBaseVariableInfosView() {
       InitializeComponent();
 …
       Caption = "Operator";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariableInfosView"/> with the given operator
+    /// <paramref name="op"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBaseVariableInfosView()"/>.</remarks>
+    /// <param name="op">The operator whose variable infos should be displayed.</param>
     public OperatorBaseVariableInfosView(IOperator op)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       Operator.VariableInfoAdded -= new EventHandler<VariableInfoEventArgs>(OperatorBase_VariableInfoAdded);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();
 …
+    }
+    /// <summary>
+    /// Occurs when the variables were changed, whose infos should be displayed.
+    /// </summary>
     public event EventHandler SelectedVariableInfosChanged;
+    /// <summary>
+    /// Fires a new <c>SelectedVariableInfosChanged</c>.
+    /// </summary>
     protected virtual void OnSelectedVariableInfosChanged() {
       if (SelectedVariableInfosChanged != null)

trunk/sources/HeuristicLab.Core/OperatorBaseVariablesView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of the variables of an operator.
+  /// </summary>
   public partial class OperatorBaseVariablesView : ViewBase {
     private ChooseItemDialog chooseItemDialog;
+    /// <summary>
+    /// Gets or sets the operator whose variables to represent.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariablesView"/> with caption "Operator".
+    /// </summary>
     public OperatorBaseVariablesView() {
       InitializeComponent();
 …
       Caption = "Operator";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseVariablesView"/> with the given
+    /// operator <paramref name="op"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBaseVariablesView"/>.</remarks>
+    /// <param name="op">The operator whose variables should be represented visually.</param>
     public OperatorBaseVariablesView(IOperator op)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the unterlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       Operator.VariableAdded -= new EventHandler<VariableEventArgs>(OperatorBase_VariableAdded);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IOperator"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/OperatorBaseView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The base class for visual representation of operators (contains description view, variable view,
+  /// variable info view,...).
+  /// </summary>
   public partial class OperatorBaseView : ViewBase {
+    /// <summary>
+    /// Gets or sets the operator to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseView"/> with caption "Operator".
+    /// </summary>
     public OperatorBaseView() {
       InitializeComponent();
       Caption = "Operator";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorBaseView"/>
+    /// with the given operator <paramref name="op"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBaseView()"/>.</remarks>
+    /// <param name="op">The operator to represent visually.</param>
     public OperatorBaseView(IOperator op)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes event handlers in all children.
+    /// </summary>
     protected override void RemoveItemEvents() {
       operatorBaseVariableInfosView.Operator = null;
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds event handlers in all children.
+    /// </summary>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/OperatorEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected operator.
+  /// </summary>
   public class OperatorEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected operator.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorEventArgs"/> with the specified operator.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="op">The affected operator.</param>
     public OperatorEventArgs(IOperator op)
       : base(op) {

trunk/sources/HeuristicLab.Core/OperatorGraph.cs

-                      r47
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a graph of operators.
+  /// </summary>
   public class OperatorGraph : ItemBase, IOperatorGraph {
     private IDictionary<Guid, IOperator> myOperators;
+    /// <summary>
+    /// Gets all operators of the current instance.
+    /// </summary>
     public ICollection<IOperator> Operators {
       get { return myOperators.Values; }
+    }
     private IOperator myInitialOperator;
+    /// <summary>
+    /// Gets or sets the initial operator (the starting one).
+    /// </summary>
+    /// <remarks>Calls <see cref="OnInitialOperatorChanged"/> in the setter.</remarks>
     public IOperator InitialOperator {
       get { return myInitialOperator; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorGraph"/>.
+    /// </summary>
     public OperatorGraph() {
       myOperators = new Dictionary<Guid, IOperator>();
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="OperatorGraphView"/> to represent the current instance
+    /// visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="OperatorGraphView"/>.</returns>
     public override IView CreateView() {
       return new OperatorGraphView(this);
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>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="OperatorGraph"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       OperatorGraph clone = new OperatorGraph();
 …
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnOperatorAdded"/>.</remarks>
     public void AddOperator(IOperator op) {
       if (!myOperators.ContainsKey(op.Guid)) {
 …
+      }
+    }
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnOperatorRemoved"/>.</remarks>
     public void RemoveOperator(Guid guid) {
       IOperator op = GetOperator(guid);
 …
+      }
+    }
+    /// <inheritdoc/>
     public IOperator GetOperator(Guid guid) {
       IOperator op;
 …
         return null;
+    }
+    /// <inheritdoc/>
     public void Clear() {
       Guid[] guids = new Guid[Operators.Count];
 …
+    }
+    /// <inheritdoc/>
     public event EventHandler<OperatorEventArgs> OperatorAdded;
+    /// <summary>
+    /// Fires a new <c>OperatorAdded</c> event.
+    /// </summary>
+    /// <param name="op">The operator that has been added.</param>
     protected virtual void OnOperatorAdded(IOperator op) {
       if (OperatorAdded != null)
         OperatorAdded(this, new OperatorEventArgs(op));
+    }
+    /// <inheritdoc/>
     public event EventHandler<OperatorEventArgs> OperatorRemoved;
+    /// <summary>
+    /// Fires a new <c>OperatorRemoved</c> event.
+    /// </summary>
+    /// <param name="op">The operator that has been removed.</param>
     protected virtual void OnOperatorRemoved(IOperator op) {
       if (OperatorRemoved != null)
         OperatorRemoved(this, new OperatorEventArgs(op));
+    }
+    /// <inheritdoc/>
     public event EventHandler InitialOperatorChanged;
+    /// <summary>
+    /// Fires a new <c>InitialOperatorChanged</c> event.
+    /// </summary>
     protected virtual void OnInitialOperatorChanged() {
       if (InitialOperatorChanged != null)
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// To save the operators of the current instance a child node is created with the tag name
+    /// <c>Operators</c>. Beyond this child node all operators are saved as child nodes themselves.<br/>
+    /// The initial operator is saved as child node with the tag name <c>InitialOperator</c>.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operator graph from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get more information about how the graph must be saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the operator graph is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/OperatorGraphView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of an <see cref="IOperatorGraph"/>.
+  /// </summary>
   public partial class OperatorGraphView : ViewBase {
     private ChooseOperatorDialog chooseOperatorDialog;
     private Dictionary<IOperator, IList<TreeNode>> operatorNodeTable;
+    /// <summary>
+    /// Gets or sets the operator graph to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IOperatorGraph OperatorGraph {
       get { return (IOperatorGraph)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorGraphView"/> with caption "Operator Graph".
+    /// </summary>
     public OperatorGraphView() {
       InitializeComponent();
 …
       Caption = "Operator Graph";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorGraphView"/>
+    /// with the given <paramref name="operatorGraph"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorGraphView()"/>.</remarks>
+    /// <param name="operatorGraph">The operator graph to represent visually.</param>
     public OperatorGraphView(IOperatorGraph operatorGraph)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IOperatorGraph"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       OperatorGraph.OperatorAdded -= new EventHandler<OperatorEventArgs>(OperatorGraph_OperatorAdded);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IOperatorGraph"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/OperatorGroup.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Representation of a group of operators (can also include subgroups).
+  /// </summary>
   public class OperatorGroup : StorableBase, IOperatorGroup {
     private string myName;
+    /// <summary>
+    /// Gets or sets the name of the current operator group.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnNameChanged"/> in the setter.</remarks>
     public string Name {
       get { return myName; }
 …
+    }
     private List<IOperatorGroup> mySubGroups;
+    /// <summary>
+    /// Gets all subgroups of the current instance.
+    /// <note type="caution"> The subgroups are returned read-only.</note>
+    /// </summary>
     public ICollection<IOperatorGroup> SubGroups {
       get { return mySubGroups.AsReadOnly(); }
+    }
     private List<IOperator> myOperators;
+    /// <summary>
+    /// Gets all operators of the current instance.
+    /// <note type="caution"> The operators are returned read-only.</note>
+    /// </summary>
     public ICollection<IOperator> Operators {
       get { return myOperators.AsReadOnly(); }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorGroup"/> having "Anonymous" as name.
+    /// </summary>
     public OperatorGroup() {
       myName = "Anonymous";
 …
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Deep clone with <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="OperatorGroup"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       OperatorGroup clone = (OperatorGroup)base.Clone(clonedObjects);
 …
+    }
+    /// <summary>
+    /// Adds the given subgroup (<paramref name="group"/>) to the current instance.
+    /// </summary>
+    /// <param name="group">The subgroup to add.</param>
     public virtual void AddSubGroup(IOperatorGroup group) {
       mySubGroups.Add(group);
+    }
+    /// <summary>
+    /// Removes the given subgroup (<paramref name="group"/>) from the current instance.
+    /// </summary>
+    /// <param name="group">The subgroup to remove.</param>
     public virtual void RemoveSubGroup(IOperatorGroup group) {
       mySubGroups.Remove(group);
+    }
+    /// <summary>
+    /// Ads the given operator <paramref name="op"/> to the current instance.
+    /// </summary>
+    /// <param name="op">The operator to add.</param>
     public virtual void AddOperator(IOperator op) {
       myOperators.Add(op);
+    }
+    /// <summary>
+    /// Removes the given operator <paramref name="op"/> from the current instance.
+    /// </summary>
+    /// <param name="op">The operator to remove.</param>
     public virtual void RemoveOperator(IOperator op) {
       myOperators.Remove(op);
+    }
+    /// <summary>
+    /// Occurs when the name of the operator was changed.
+    /// </summary>
     public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
     protected virtual void OnNameChanged() {
       if (NameChanged != null) {
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Name: </term>
+    /// <description>Saved as an <see cref="XmlAttribute"/> with attribute name <c>Name</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Sub groups: </term>
+    /// <description>A child node is created with tag name <c>SubGroups</c>. Beyond this child node
+    /// all sub operator groups are saved as child nodes themselves.</description>
+    /// </item>
+    /// <item>
+    /// <term>Operators: </term>
+    /// <description>A child node is created with tag name <c>Operators</c>. Beyond this child node
+    /// all operators are saved as child nodes themselves.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operator group from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get information about how the data must be saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="StorableBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the boolean value is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/OperatorIndexEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected operator at the specified index.
+  /// </summary>
   public class OperatorIndexEventArgs : ItemIndexEventArgs {
+    /// <summary>
+    /// Gets the affected operator.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class
+    /// <see cref="ItemIndexEventArgs"/>. No own data storage present.</remarks>
     public IOperator Operator {
       get { return (IOperator)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorIndexEventArgs"/> with the given operator
+    /// and the specified <paramref name="index"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemIndexEventArgs"/>.</remarks>
+    /// <param name="op">The affected operator.</param>
+    /// <param name="index">The affected index.</param>
     public OperatorIndexEventArgs(IOperator op, int index)
       : base(op, index) {

trunk/sources/HeuristicLab.Core/OperatorLibrary.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a library of operators consisting of one <see cref="IOperatorGroup"/>.
+  /// </summary>
   public class OperatorLibrary : ItemBase, IOperatorLibrary, IEditable {
     private IOperatorGroup myGroup;
+    /// <summary>
+    /// Gets the operator group of the current instance.
+    /// </summary>
     public IOperatorGroup Group {
       get { return myGroup; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorLibrary"/>.
+    /// </summary>
     public OperatorLibrary() {
       myGroup = new OperatorGroup();
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="OperatorLibraryEditor"/> to display the current instance.
+    /// </summary>
+    /// <returns>The created view as <see cref="OperatorLibraryEditor"/>.</returns>
     public override IView CreateView() {
       return new OperatorLibraryEditor(this);
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="OperatorLibraryEditor"/> to display the current instance.
+    /// </summary>
+    /// <returns>The created editor as <see cref="OperatorLibraryEditor"/>.</returns>
     public virtual IEditor CreateEditor() {
       return new OperatorLibraryEditor(this);
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>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="OperatorLibrary"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       OperatorLibrary clone = new OperatorLibrary();
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// The operator group is saved as a child node with the tag name <c>OperatorGroup</c>.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted operator library from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.<br/>
+    /// See <see cref="GetXmlNode"/> for further information on how the data must be saved.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the operator library is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/OperatorLibraryEditor.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Visual representation of the class <see cref="IOperatorLibrary"/>.
+  /// </summary>
   public partial class OperatorLibraryEditor : EditorBase {
     private ChooseOperatorDialog chooseOperatorDialog;
+    /// <summary>
+    /// Gets or sets the operator library that should be displayed.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="EditorBase"/>.</remarks>
     public IOperatorLibrary OperatorLibrary {
       get { return (IOperatorLibrary)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorLibraryEditor"/> with caption
+    /// <c>Operator Library</c>.
+    /// </summary>
     public OperatorLibraryEditor() {
       InitializeComponent();
 …
       Caption = "Operator Library";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="OperatorLibraryEditor"/> with the
+    /// specified <paramref name="operatorLibrary"/>.
+    /// </summary>
+    /// <param name="operatorLibrary">The operator library to display.</param>
     public OperatorLibraryEditor(IOperatorLibrary operatorLibrary)
       : this() {
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="EditorBase.UpdateControls"/> of base class <see cref="EditorBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/PersistenceManager.cs

-                      r750
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Static class for serializing and deserializing objects.
+  /// </summary>
   public static class PersistenceManager {
+    /// <summary>
+    /// Creates an <see cref="XmlDocument"/> to persist an object with xml declaration.
+    /// </summary>
+    /// <returns>The created <see cref="XmlDocument"/>.</returns>
     public static XmlDocument CreateXmlDocument() {
       XmlDocument document = new XmlDocument();
 …
       return document;
+    }
+    /// <summary>
+    /// Saves the specified <paramref name="instance"/> in the specified <paramref name="document"/>
+    /// if it has not already been serialized.
+    /// </summary>
+    /// <remarks>The tag name of the saved instance is its type name.<br/>
+    /// The guid is saved as an <see cref="XmlAttribute"/> with tag name <c>GUID</c>.</remarks>
+    /// <param name="instance">The object that should be saved.</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 static XmlNode Persist(IStorable instance, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       string name = instance.GetType().Name;
 …
       return Persist(name, instance, document, persistedObjects);
+    }
+    /// <summary>
+    /// Saves the specified <paramref name="instance"/> in the specified <paramref name="document"/>
+    /// if it has not already been serialized.
+    /// </summary>
+    /// <param name="name">The (tag)name of the <see cref="XmlNode"/>.</param>
+    /// <param name="instance">The object that should be saved.</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 static XmlNode Persist(string name, IStorable instance, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       if(persistedObjects.ContainsKey(instance.Guid)) {
 …
+      }
+    }
+    public static IStorable Restore(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+    /// <summary>
+    /// Loads a persisted object from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>The guid is saved as an attribute with tag name <c>GUID</c>. The type of the
+    /// persisted object is saved as attribute with tag name <c>Type</c>.<br/>
+    /// Calls <c>instance.Populate</c>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the object is saved.</param>
+    /// <param name="restoredObjects">A dictionary of all already restored objects.
+    /// (Needed to avoid cycles.)</param>
+    /// <returns>The loaded object.</returns>
+    public static IStorable Restore(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
       Guid guid = new Guid(node.Attributes["GUID"].Value);
       if(restoredObjects.ContainsKey(guid)) {
 …
+      }
+    }
+    /// <summary>
+    /// Saves the specified <paramref name="instance"/> in the specified file through creating an
+    /// <see cref="XmlDocument"/>.
+    /// </summary>
+    /// <param name="instance">The object that should be saved.</param>
+    /// <param name="filename">The name of the file where the <paramref name="object"/> should be saved.</param>
     public static void Save(IStorable instance, string filename) {
       using(FileStream stream = File.Create(filename)) {
 …
+      }
+    }
+    /// <summary>
+    /// Saves the specified <paramref name="instance"/> in the specified <paramref name="stream"/>
+    /// through creating an <see cref="XmlDocument"/>.
+    /// </summary>
+    /// <param name="instance">The object that should be saved.</param>
+    /// <param name="stream">The (file) stream where the object should be saved.</param>
     public static void Save(IStorable instance, Stream stream) {
       XmlDocument document = PersistenceManager.CreateXmlDocument();
 …
       document.Save(stream);
+    }
+    /// <summary>
+    /// Loads an object from a file with the specified <paramref name="filename"/>.
+    /// </summary>
+    /// <remarks>The object must be saved as an <see cref="XmlDocument"/>. <br/>
+    /// Calls <see cref="Restore"/>.</remarks>
+    /// <param name="filename">The filename of the file where the data is saved.</param>
+    /// <returns>The loaded object.</returns>
     public static IStorable Load(string filename) {
       using(FileStream stream = File.OpenRead(filename)) {
 …
+      }
+    }
+    /// <summary>
+    /// Loads an object from the specified <paramref name="stream"/>.
+    /// </summary>
+    /// <remarks>The object must be saved as an <see cref="XmlDocument"/>. <br/>
+    /// Calls <see cref="Restore"/>.</remarks>
+    /// <param name="stream">The stream from where to load the data.</param>
+    /// <returns>The loaded object.</returns>
     public static IStorable Load(Stream stream) {
       XmlDocument doc = new XmlDocument();
 …
+    }
+    /// <summary>
+    /// Loads an object from a zip file.
+    /// </summary>
+    /// <param name="serializedStorable">The zip file from where to load as byte array.</param>
+    /// <returns>The loaded object.</returns>
     public static IStorable RestoreFromGZip(byte[] serializedStorable) {
       GZipStream stream = new GZipStream(new MemoryStream(serializedStorable), CompressionMode.Decompress);
 …
+    }
+    /// <summary>
+    /// Saves the specified <paramref name="storable"/> in a zip file.
+    /// </summary>
+    /// <remarks>Calls <see cref="Save(HeuristicLab.Core.IStorable, Stream)"/>.</remarks>
+    /// <param name="storable">The object to save.</param>
+    /// <returns>The zip stream as byte array.</returns>
     public static byte[] SaveToGZip(IStorable storable) {
       MemoryStream memStream = new MemoryStream();
 …
+    }
+    /// <summary>
+    /// Builds a meaningful string for the given <paramref name="type"/> with the namespace information,
+    /// all its arguments, the assembly name...
+    /// </summary>
+    /// <param name="type">The type for which a string should be created.</param>
+    /// <returns>A string value of this type containing different additional information.</returns>
     public static string BuildTypeString(Type type) {
       string assembly = type.Assembly.FullName;

trunk/sources/HeuristicLab.Core/Scope.cs

-                      r261
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Hierarchical container of variables (and of subscopes).
+  /// </summary>
   public class Scope : ItemBase, IScope {
     private IScope parent;
+    private string myName;
+    private string myName;
+    /// <summary>
+    /// Gets the name of the current scope.
+    /// </summary>
     public string Name {
       get { return myName; }
 …
     private IDictionary<string, IVariable> myVariables;
+    /// <inheritdoc/>
     public ICollection<IVariable> Variables {
       get { return myVariables.Values; }
+    }
     private IDictionary<string, string> myAliases;
+    /// <inheritdoc/>
     public IEnumerable<KeyValuePair<string, string>> Aliases {
       get { return myAliases; }
+    }
     private List<IScope> mySubScopes;
+    /// <summary>
+    /// Gets all subscopes of the current instance.
+    /// <note type="caution"> The subscopes are returned as read-only.</note>
+    /// </summary>
     public IList<IScope> SubScopes {
       get { return mySubScopes.AsReadOnly(); }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Scope"/> having "Anonymous" as default name.
+    /// </summary>
     public Scope() {
       myName = "Anonymous";
 …
       mySubScopes = new List<IScope>();
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Scope"/> with the given <paramref name="name"/>.
+    /// </summary>
+    /// <param name="name">The name of the scope.</param>
     public Scope(string name)
       : this() {
 …
+    }
+    /// <inheritdoc/>
     public void SetParent(IScope scope) {
       parent = scope;
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="ScopeView"/> to represent the current instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="ScopeView"/>.</returns>
     public override IView CreateView() {
       return new ScopeView(this);
+    }
+    /// <inheritdoc/>
     public IVariable GetVariable(string name) {
       IVariable variable;
 …
         return null;
+    }
+    /// <inheritdoc/>
     public void AddVariable(IVariable variable) {
       myVariables.Add(variable.Name, variable);
 …
+    }
+    /// <inheritdoc/>
     public void RemoveVariable(string name) {
       IVariable variable;
 …
       myVariables.Add(variable.Name, variable);
+    }
+    /// <inheritdoc cref="IScope.GetVariableValue&lt;T&gt;(string, bool)"/>
     public T GetVariableValue<T>(string name, bool recursiveLookup) where T : class, IItem {
       return GetVariableValue<T>(name, recursiveLookup, true);
+    }
+    /// <inheritdoc cref="IScope.GetVariableValue&lt;T&gt;(string, bool, bool)"/>
     public T GetVariableValue<T>(string name, bool recursiveLookup, bool throwOnError) where T : class, IItem {
       return (T)GetVariableValue(name, recursiveLookup, throwOnError);
+    }
+    /// <inheritdoc cref="IScope.GetVariableValue(string, bool)"/>
     public IItem GetVariableValue(string name, bool recursiveLookup) {
       return GetVariableValue(name, recursiveLookup, true);
+    }
+    /// <inheritdoc cref="IScope.GetVariableValue(string, bool, bool)"/>
     public IItem GetVariableValue(string name, bool recursiveLookup, bool throwOnError) {
       IVariable variable;
 …
+      }
+    }
+    /// <inheritdoc/>
     public string TranslateName(string name) {
       while (myAliases.ContainsKey(name))
 …
       return name;
+    }
+    /// <inheritdoc/>
     public void AddAlias(string alias, string name) {
       RemoveAlias(alias);
 …
+      }
+    }
+    /// <inheritdoc/>
     public void RemoveAlias(string alias) {
       if (myAliases.ContainsKey(alias)) {
 …
+    }
+    /// <inheritdoc/>
     public void AddSubScope(IScope scope) {
       scope.SetParent(this);
 …
       OnSubScopeAdded(scope, mySubScopes.Count - 1);
+    }
+    /// <inheritdoc/>
     public void RemoveSubScope(IScope scope) {
       int index = mySubScopes.IndexOf(scope);
 …
+      }
+    }
+    /// <inheritdoc/>
     public void ReorderSubScopes(int[] sequence) {
       IScope[] scopes = mySubScopes.ToArray();
 …
       OnSubScopesReordered();
+    }
+    /// <inheritdoc/>
     public IScope GetScope(Guid guid) {
       if (Guid == guid) return this;
 …
       return null;
+    }
+    /// <inheritdoc/>
     public IScope GetScope(string name) {
       if (Name == name) return this;
 …
+    }
+    /// <inheritdoc/>
     public void Clear() {
       string[] variableNames = new string[Variables.Count];
 …
+    }
+    /// <inheritdoc/>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       Scope clone = (Scope)base.Clone(clonedObjects);
 …
+    }
+    /// <inheritdoc />
     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));
+    }
+    /// <inheritdoc />
     public event EventHandler<VariableEventArgs> VariableRemoved;
+    /// <summary>
+    /// Fires a new <c>VariableRemoved</c>.
+    /// </summary>
+    /// <param name="variable">The variable that has been deleted.</param>
     protected virtual void OnVariableRemoved(IVariable variable) {
       if (VariableRemoved != null)
         VariableRemoved(this, new VariableEventArgs(variable));
+    }
+    /// <inheritdoc />
     public event EventHandler<AliasEventArgs> AliasAdded;
+    /// <summary>
+    /// Fires a new <c>AliasAdded</c> event.
+    /// </summary>
+    /// <param name="alias">The alias that has been added.</param>
     protected virtual void OnAliasAdded(string alias) {
       if (AliasAdded != null)
         AliasAdded(this, new AliasEventArgs(alias));
+    }
+    /// <inheritdoc/>
     public event EventHandler<AliasEventArgs> AliasRemoved;
+    /// <summary>
+    /// Fires a new <c>AliasRemoved</c> event.
+    /// </summary>
+    /// <param name="alias">The alias that has been deleted.</param>
     protected virtual void OnAliasRemoved(string alias) {
       if (AliasRemoved != null)
         AliasRemoved(this, new AliasEventArgs(alias));
+    }
+    /// <inheritdoc/>
     public event EventHandler<ScopeIndexEventArgs> SubScopeAdded;
+    /// <summary>
+    /// Fires a new <c>SubScopeAdded</c> event.
+    /// </summary>
+    /// <param name="scope">The sub scope that has been added.</param>
+    /// <param name="index">The index where the scope has been added.</param>
     protected virtual void OnSubScopeAdded(IScope scope, int index) {
       if (SubScopeAdded != null)
         SubScopeAdded(this, new ScopeIndexEventArgs(scope, index));
+    }
+    /// <inheritdoc/>
     public event EventHandler<ScopeIndexEventArgs> SubScopeRemoved;
+    /// <summary>
+    /// Fires a new <c>SubScopeRemoved</c> event.
+    /// </summary>
+    /// <param name="scope">The sub scope that has been deleted.</param>
+    /// <param name="index">The position of the sub scope.</param>
     protected virtual void OnSubScopeRemoved(IScope scope, int index) {
       if (SubScopeRemoved != null)
         SubScopeRemoved(this, new ScopeIndexEventArgs(scope, index));
+    }
+    /// <inheritdoc />
     public event EventHandler SubScopesReordered;
+    /// <summary>
+    /// Fires a new <c>SubScopesReordered</c> event
+    /// </summary>
     protected virtual void OnSubScopesReordered() {
       if (SubScopesReordered != null)
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the given <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>
+    /// Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Name: </term>
+    /// <description>Saved as an <see cref="XmlAttribute"/> having the tag name <c>Name</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Variables: </term>
+    /// <description>A child node is created with the tag name <c>Variables</c>. Beyond this child node,
+    /// all variables are saved as child nodes.</description>
+    /// </item>
+    /// <item>
+    /// <term>Aliases: </term>
+    /// <description>A child node is created with the tag name <c>Aliases</c>. Beyond this child node,
+    /// all aliases are saved as child nodes with the tag name <c>Alias</c>. Each alias has an
+    /// <see cref="XmlAttribute"/> with the tag name "Alias", holding the alias, and an attribute
+    /// with the tag name <c>Name</c>, holding the name of the alias.</description>
+    /// </item>
+    /// <item>
+    /// <term>Sub scopes: </term>
+    /// <description>A child node is created with the tag name <c>SubScopes</c>. Beyond this child node,
+    /// all sub scopes are 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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted scope from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get further information on how the current instance must
+    /// be saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the boolean value is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/ScopeEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected scope.
+  /// </summary>
   public class ScopeEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected scope.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
     public IScope Scope {
       get { return (IScope)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ScopeEventArgs"/> with the specified scope.
+    /// </summary>
+    /// <param name="scope">The affected scope.</param>
     public ScopeEventArgs(IScope scope)
       : base(scope) {

trunk/sources/HeuristicLab.Core/ScopeIndexEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected scope at the specified index.
+  /// </summary>
   public class ScopeIndexEventArgs : ItemIndexEventArgs {
+    /// <summary>
+    /// Gets the affected scope.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class
+    /// <see cref="ItemIndexEventArgs"/>. No own data storage present.</remarks>
     public IScope Scope {
       get { return (IScope)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ScopeIndexEventArgs"/> with the specified
+    /// <paramref name="scope"/> and <paramref name="index"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemIndexEventArgs"/>.</remarks>
+    /// <param name="scope">The affected scope.</param>
+    /// <param name="index">The affected index.</param>
     public ScopeIndexEventArgs(IScope scope, int index)
       : base(scope, index) {

trunk/sources/HeuristicLab.Core/ScopeView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual represenation of <see cref="IScope"/>.
+  /// </summary>
   public partial class ScopeView : ViewBase {
     private Dictionary<IScope, TreeNode> scopeNodeTable;
     private Dictionary<IScope, bool> scopeExpandedTable;
+    /// <summary>
+    /// Gets or sets the scope to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IScope Scope {
       get { return (IScope)Item; }
 …
+    }
     private bool myAutomaticUpdating;
+    /// <summary>
+    /// Gets information whether the scope is automatically updating.
+    /// </summary>
     public bool AutomaticUpdating {
       get { return myAutomaticUpdating; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ScopeView"/> with caption "Scope" and
+    /// property <see cref="AutomaticUpdating"/> set to <c>false</c>.
+    /// </summary>
     public ScopeView() {
       InitializeComponent();
 …
       myAutomaticUpdating = false;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ScopeView"/> with the given <paramref name="scope"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ScopeView()"/>.</remarks>
+    /// <param name="scope">The scope to represent visually.</param>
     public ScopeView(IScope scope)
       : this() {
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/StorableBase.cs

-                      r40
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The base class for all storable objects.
+  /// </summary>
   public abstract class StorableBase : IStorable {
     private Guid myGuid;
+    /// <summary>
+    /// Gets the Guid of the item.
+    /// </summary>
     public Guid Guid {
       get { return myGuid; }
+    }
+    /// <summary>
+    /// Initializes a new instance of the class <see cref="StorableBase"/> with a new <see cref="Guid"/>.
+    /// </summary>
     protected StorableBase() {
       myGuid = Guid.NewGuid();
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <remarks>Uses the <see cref="Auxiliary.Clone"/> method of the class <see cref="Auxiliary"/>.</remarks>
+    /// <returns>The clone.</returns>
     public object Clone() {
       return Auxiliary.Clone(this, new Dictionary<Guid, object>());
+    }
+    /// <summary>
+    /// Clones the current instance with the <see cref="M:Activator.CreateInstance"/>
+    /// method of <see cref="Activator"/>.
+    /// </summary>
+    /// <param name="clonedObjects">All already cloned objects.</param>
+    /// <returns>The clone.</returns>
     public virtual object Clone(IDictionary<Guid, object> clonedObjects) {
       object clone = Activator.CreateInstance(this.GetType());
 …
+    }
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>The type of the current instance is saved as <see cref="XmlAttribute"/> with tag name
+    /// <c>Type</c>, the guid is also saved as an attribute with the tag name <c>GUID</c>.</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 virtual XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
       XmlNode node = document.CreateNode(XmlNodeType.Element, name, null);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted object from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>Loads only guid; type,... already loaded by the <see cref="PersistenceManager"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the object is saved.</param>
+    /// <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) {
       myGuid = new Guid(node.Attributes["GUID"].Value);

trunk/sources/HeuristicLab.Core/Variable.cs

-                      r701
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents a variable of an operator having a name and a value.
+  /// </summary>
   public class Variable : ItemBase, IVariable {
     private string myName;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnNameChanging"/> and also <see cref="OnNameChanged"/>
+    /// eventually in the setter.</remarks>
     public string Name {
       get { return myName; }
 …
+    }
     private IItem myValue;
+    /// <inheritdoc/>
+    /// <remarks>Calls <see cref="OnValueChanged"/> in the setter.</remarks>
     public IItem Value {
       get { return myValue; }
 …
+      }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with name <c>Anonymous</c>
+    /// and value <c>null</c>.
+    /// </summary>
     public Variable() {
       myName = "Anonymous";
       myValue = null;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Variable"/> with the specififed <paramref name="name"/>
+    /// and the specified <paramref name="value"/>.
+    /// </summary>
+    /// <param name="name">The name of the current instance.</param>
+    /// <param name="value">The value of the current instance.</param>
     public Variable(string name, IItem value) {
       myName = name;
 …
+    }
+    /// <inheritdoc cref="IVariable.GetValue&lt;T&gt;"/>
     public T GetValue<T>() where T : class, IItem {
       return (T)Value;
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="VariableView"/> to represent the current instance visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="VariableView"/>.</returns>
     public override IView CreateView() {
       return new VariableView(this);
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="Variable"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       Variable clone = new Variable();
 …
+    }
+    /// <summary>
+    /// Gets the string representation of the current instance in the format: <c>Name: [null|Value]</c>.
+    /// </summary>
+    /// <returns>The current instance as a string.</returns>
     public override string ToString() {
       return Name + ": " + ((Value == null) ? ("null") : (Value.ToString()));
+    }
+    /// <inheritdoc/>
     public event EventHandler<NameChangingEventArgs> NameChanging;
+    /// <summary>
+    /// Fires a new <c>NameChanging</c> event.
+    /// </summary>
+    /// <param name="e">The event arguments of the changing.</param>
     protected virtual void OnNameChanging(NameChangingEventArgs e) {
       if (NameChanging != null)
         NameChanging(this, e);
+    }
+    /// <inheritdoc/>
     public event EventHandler NameChanged;
+    /// <summary>
+    /// Fires a new <c>NameChanged</c> event.
+    /// </summary>
+    /// <remarks>Calls <see cref="ItemBase.OnChanged"/>.</remarks>
     protected virtual void OnNameChanged() {
       if (NameChanged != null)
 …
       OnChanged();
+    }
+    /// <inheritdoc/>
     public event EventHandler ValueChanged;
+    /// <summary>
+    /// Fires a new <c>ValueChanged</c> even.
+    /// </summary>
     protected virtual void OnValueChanged() {
       if (ValueChanged != null)
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>.<br/>
+    /// The name of the current instance is saved as an <see cref="XmlAttribute"/> with the
+    /// tag name <c>Name</c>, the value is saved as child node with the tag name <c>Value</c>.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted variable from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> to get information on how the variable must be saved.<br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the variable is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/VariableEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected variable.
+  /// </summary>
   public class VariableEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected variable.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
     public IVariable Variable {
       get { return (IVariable)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableEventArgs"/> with the specified
+    /// <paramref name="variable"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="variable">The affected variable.</param>
     public VariableEventArgs(IVariable variable)
       : base(variable) {

trunk/sources/HeuristicLab.Core/VariableInfo.cs

-                      r533
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Class for storing meta-information about variables/parameters of an operator.
+  /// </summary>
   public class VariableInfo : ItemBase, IVariableInfo {
     private string myActualName;
+    /// <summary>
+    /// Gets or sets the actual name of the current instance.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnActualNameChanged"/> in the setter.</remarks>
     public string ActualName {
       get { return myActualName; }
 …
+    }
     private string myFormalName;
+    /// <summary>
+    /// Gets the formal name of the current instance.
+    /// </summary>
     public string FormalName {
       get { return myFormalName; }
+    }
     private string myDescription;
+    /// <summary>
+    /// Gets the description of the current instance.
+    /// </summary>
     public string Description {
       get { return myDescription; }
+    }
     private Type myDataType;
+    /// <summary>
+    /// Gets the data type of the parameter.
+    /// </summary>
     public Type DataType {
       get { return myDataType; }
+    }
     private VariableKind myKind;
+    /// <summary>
+    /// Gets the kind of the parameter (input parameter, output parameter,...).
+    /// </summary>
     public VariableKind Kind {
       get { return myKind; }
+    }
     private bool myLocal;
+    /// <summary>
+    /// Gets or sets a boolean value, whether the variable is a local one.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnLocalChanged"/> in the setter.</remarks>
     public bool Local {
       get { return myLocal; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfo"/> with actual and formal name "Anonymous",
+    /// no description, a <c>null</c> data type and the <c>local</c> flag set to <c>false</c>. The type of
+    /// the variable is an input parameter.
+    /// </summary>
     public VariableInfo() {
       myActualName = "Anonymous";
 …
       myLocal = false;
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfo"/> with the given parameters.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariableInfo()"/>.<br/>
+    /// The formal name is assigned to the actual name, too.</remarks>
+    /// <param name="formalName">The formal name of the current instance.</param>
+    /// <param name="description">The description of the current instance.</param>
+    /// <param name="dataType">The data type of the parameter.</param>
+    /// <param name="kind">The type of the parameter.</param>
     public VariableInfo(string formalName, string description, Type dataType, VariableKind kind)
       : this() {
 …
+    }
+    /// <summary>
+    /// Creates a new instance of <see cref="VariableInfoView"/> to represent the current instance
+    /// visually.
+    /// </summary>
+    /// <returns>The created view as <see cref="VariableInfoView"/>.</returns>
     public override IView CreateView() {
       return new VariableInfoView(this);
+    }
+    /// <summary>
+    /// Clones the current instance (deep clone).
+    /// </summary>
+    /// <param name="clonedObjects">Dictionary of all already cloned objects. (Needed to avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="VariableInfo"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       VariableInfo clone = new VariableInfo();
 …
+    }
+    /// <inheritdoc/>
     public event EventHandler ActualNameChanged;
+    /// <summary>
+    /// Fires a new <c>ActualNameChanged</c> event.
+    /// </summary>
     protected virtual void OnActualNameChanged() {
       if (ActualNameChanged != null)
         ActualNameChanged(this, new EventArgs());
+    }
+    /// <inheritdoc />
     public event EventHandler LocalChanged;
+    /// <summary>
+    /// Fires a new <c>LocalChanged</c> event.
+    /// </summary>
     protected virtual void OnLocalChanged() {
       if (LocalChanged != null)
 …
     #region Persistence Methods
+    /// <summary>
+    /// Saves the current instance as <see cref="XmlNode"/> in the specified <paramref name="document"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="StorableBase.GetXmlNode"/> of base class <see cref="ItemBase"/>. <br/>
+    /// A quick overview how the single elements of the current instance are saved:
+    /// <list type="bullet">
+    /// <item>
+    /// <term>Actual name: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>ActualName</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Formal name: </term>
+    /// <description>Saves as <see cref="XmlAttribute"/> with tag name <c>FormalName</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Description: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Description</c>.</description>
+    /// </item>
+    /// <item><term>Data type: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>DataType</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Kind: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Kind</c>.</description>
+    /// </item>
+    /// <item>
+    /// <term>Local: </term>
+    /// <description>Saved as <see cref="XmlAttribute"/> with tag name <c>Local</c>.</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) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
 …
       return node;
+    }
+    /// <summary>
+    /// Loads the persisted variable info from the specified <paramref name="node"/>.
+    /// </summary>
+    /// <remarks>See <see cref="GetXmlNode"/> for further information on how the variable info must be
+    /// saved. <br/>
+    /// Calls <see cref="StorableBase.Populate"/> of base class <see cref="ItemBase"/>.</remarks>
+    /// <param name="node">The <see cref="XmlNode"/> where the variable info is saved.</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

trunk/sources/HeuristicLab.Core/VariableInfoEventArgs.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Event arguments to be able to specify the affected variable info.
+  /// </summary>
   public class VariableInfoEventArgs : ItemEventArgs {
+    /// <summary>
+    /// Gets the affected variable info.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ItemEventArgs.Item"/> of base class <see cref="ItemEventArgs"/>.
+    /// No own data storage present.</remarks>
     public IVariableInfo VariableInfo {
       get { return (IVariableInfo)Item; }
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoEventArgs"/> with the specified
+    /// <paramref name="variableInfo"/>.
+    /// </summary>
+    /// <remarks>Calls constructor of base class <see cref="ItemEventArgs"/>.</remarks>
+    /// <param name="variableInfo">The affected variable info.</param>
     public VariableInfoEventArgs(IVariableInfo variableInfo)
       : base(variableInfo) {

trunk/sources/HeuristicLab.Core/VariableInfoView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of <see cref="IVariableInfo"/>.
+  /// </summary>
   public partial class VariableInfoView : ViewBase {
+    /// <summary>
+    /// Gets or sets the variable information to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IVariableInfo VariableInfo {
       get { return (IVariableInfo)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoView"/> with caption "Variable Info".
+    /// </summary>
     public VariableInfoView() {
       InitializeComponent();
       Caption = "Variable Info";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableInfoView"/>
+    /// with the given <paramref name="variableInfo"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariableInfoView()"/>.</remarks>
+    /// <param name="variableInfo">The variable info to represent visually.</param>
     public VariableInfoView(IVariableInfo variableInfo)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IVariableInfo"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class
+    /// <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       VariableInfo.ActualNameChanged -= new EventHandler(VariableInfo_ActualNameChanged);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IVariableInfo"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
       VariableInfo.LocalChanged += new EventHandler(VariableInfo_LocalChanged);
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/VariableKind.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Represents the type of a variable (input, output,...).
+  /// </summary>
   [FlagsAttribute]
   public enum VariableKind {
+    /// <summary>
+    /// Flag for doing nothing with the variable.
+    /// </summary>
     None = 0,
+    /// <summary>
+    /// Flag for creating a new variable.
+    /// </summary>
     New = 1,
+    /// <summary>
+    /// Flag for changing value of a variable.
+    /// </summary>
     Out = 2,
+    /// <summary>
+    /// Flag for reading value of a variable.
+    /// </summary>
     In = 4,
+    /// <summary>
+    /// Flag for deleting a variable.
+    /// </summary>
     Deleted = 8
+  }

trunk/sources/HeuristicLab.Core/VariableView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of an <see cref="IVariable"/>.
+  /// </summary>
   public partial class VariableView : ViewBase {
     private ChooseItemDialog chooseItemDialog;
+    /// <summary>
+    /// Gets or sets the variable to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No own data storage present.</remarks>
     public IVariable Variable {
       get { return (IVariable)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableView"/> with caption "Variable".
+    /// </summary>
     public VariableView() {
       InitializeComponent();
       Caption = "Variable";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariableView"/> with the given <paramref name="variable"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariableView()"/>.</remarks>
+    /// <param name="variable">The variable to represent visually.</param>
     public VariableView(IVariable variable)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IVariable"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       Variable.NameChanged -= new EventHandler(Variable_NameChanged);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IVariable"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/VariablesScopeView.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// The visual representation of all variables in a specified scope.
+  /// </summary>
   public partial class VariablesScopeView : ViewBase {
     private ChooseItemDialog chooseItemDialog;
+    /// <summary>
+    /// Gets or sets the scope whose variables to represent visually.
+    /// </summary>
+    /// <remarks>Uses property <see cref="ViewBase.Item"/> of base class <see cref="ViewBase"/>.
+    /// No won data storage present.</remarks>
     public IScope Scope {
       get { return (IScope)Item; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariablesScopeView"/> with caption "Variables Scope View".
+    /// </summary>
     public VariablesScopeView() {
       InitializeComponent();
       Caption = "Variables Scope View";
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="VariablesScopeView"/> with
+    /// the given <paramref name="scope"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="VariablesScopeView()"/>.</remarks>
+    /// <param name="scope">The scope whose variables should be represented visually.</param>
     public VariablesScopeView(IScope scope)
       : this() {
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the underlying <see cref="IScope"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.RemoveItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void RemoveItemEvents() {
       Scope.VariableAdded -= new EventHandler<VariableEventArgs>(Scope_VariableAdded);
 …
       base.RemoveItemEvents();
+    }
+    /// <summary>
+    /// Adds eventhandlers to the underlying <see cref="IScope"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.AddItemEvents"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void AddItemEvents() {
       base.AddItemEvents();
 …
+    }
+    /// <summary>
+    /// Updates all controls with the latest data of the model.
+    /// </summary>
+    /// <remarks>Calls <see cref="ViewBase.UpdateControls"/> of base class <see cref="ViewBase"/>.</remarks>
     protected override void UpdateControls() {
       base.UpdateControls();

trunk/sources/HeuristicLab.Core/ViewBase.cs

-                      r2
+                      r776
 namespace HeuristicLab.Core {
+  /// <summary>
+  /// Base class for all visual representations.
+  /// </summary>
   public partial class ViewBase : UserControl, IView {
     private IItem myItem;
+    /// <summary>
+    /// Gets or sets the item to represent visually.
+    /// </summary>
+    /// <remarks>Calls <see cref="OnItemChanged"/>, <see cref="Refresh"/>,
+    /// <see cref="RemoveItemEvents"/> (if the current item is not null) and
+    /// <see cref="AddItemEvents"/> (if the new item is not null) in the setter.</remarks>
     public IItem Item {
       get { return myItem; }
 …
+    }
     private string myCaption;
+    /// <summary>
+    /// Gets or sets the caption of the current instance.
+    /// </summary>
+    /// <remarks>Call <see cref="OnCaptionChanged"/> in the setter if a new item is set.</remarks>
     public string Caption {
       get { return myCaption; }
 …
+    }
+    /// <summary>
+    /// Initializes a new instance of <see cref="ViewBase"/> with the caption "View".
+    /// </summary>
     public ViewBase() {
       InitializeComponent();
 …
+    }
+    /// <summary>
+    /// Removes the eventhandlers from the current instance.
+    /// </summary>
     protected virtual void RemoveItemEvents() { }
+    /// <summary>
+    /// Adds eventhandlers to the current instance.
+    /// </summary>
     protected virtual void AddItemEvents() { }
+    /// <summary>
+    /// Refreshes the current view.
+    /// </summary>
+    /// <remarks>Creates a new <see cref="MethodInvoker"/> if an invoke is required
+    /// (see <see cref="Control.InvokeRequired"/>.<br/>
+    /// Otherwise calls <see cref="UpdateControls"/> and <see cref="Control.Refresh"/> of base class
+    /// <see cref="System.Windows.Forms.UserControl"/>.</remarks>
     public override void Refresh() {
       if (InvokeRequired) {
 …
+      }
+    }
+    /// <summary>
+    /// Updates the controls with the latest values of the model.
+    /// </summary>
     protected virtual void UpdateControls() {
       if (Item == null)
 …
+    }
+    /// <summary>
+    /// Occurs when the current item was changed.
+    /// </summary>
     public event EventHandler ItemChanged;
+    /// <summary>
+    /// Fires a new <c>ItemChanged</c> event.
+    /// </summary>
     protected virtual void OnItemChanged() {
       if (ItemChanged != null)
         ItemChanged(this, new EventArgs());
+    }
+    /// <summary>
+    /// Occurs when the current caption was changed.
+    /// </summary>
     public event EventHandler CaptionChanged;
+    /// <summary>
+    /// Fires a new <c>CaptionChanged</c> event.
+    /// </summary>
     protected virtual void OnCaptionChanged() {
       if (CaptionChanged != null)
 …
+    }
+    /// <summary>
+    /// Asynchron call of GUI updating.
+    /// </summary>
+    /// <param name="method">The delegate to invoke.</param>
     protected new void Invoke(Delegate method) {
       // enforce context switch to improve GUI response time
 …
       if (!IsDisposed) EndInvoke(result);
+    }
+    /// <summary>
+    /// Asynchron call of GUI updating.
+    /// </summary>
+    /// <param name="method">The delegate to invoke.</param>
+    /// <param name="args">The invoke arguments.</param>
     protected new void Invoke(Delegate method, params object[] args) {
       // enforce context switch to improve GUI response time

trunk/sources/HeuristicLab.Data/BoolData.cs

-                      r763
+                      r776
     /// (see <see cref="GetXmlNode"/>).</remarks>
     /// <param name="node">The <see cref="XmlNode"/> where the boolean value is saved.</param>
+    /// <param name="restoredObjects">The dictionary of all already restored objects. (Needed to avoid cycles.)</param>
+    /// <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) {
       base.Populate(node, restoredObjects);

Context Navigation

Legend:

Download in other formats: