Changeset 2488 for branches/PluginInfrastructure Refactoring

Timestamp:

11/12/09 17:45:45 (15 years ago)

Author:

gkronber

Message:

Worked on plugin infrastructure refactoring. (Fully functional revision). #799

Location:

branches/PluginInfrastructure Refactoring

Files:

• HeuristicLab.PluginInfrastructure.Manager/ApplicationDescription.cs (modified) (2 diffs)
• HeuristicLab.PluginInfrastructure.Manager/ApplicationManager.cs (modified) (1 diff)
• HeuristicLab.PluginInfrastructure.Manager/HeuristicLab.PluginInfrastructure.Manager.csproj (modified) (1 diff)
• HeuristicLab.PluginInfrastructure.Manager/Loader.cs (modified) (12 diffs)
• HeuristicLab.PluginInfrastructure.Manager/PluginDescription.cs (modified) (5 diffs)
• HeuristicLab.PluginInfrastructure.Manager/PluginManager.cs (modified) (5 diffs)
• HeuristicLab.PluginInfrastructure.Manager/Runner.cs (modified) (3 diffs)
• HeuristicLab.PluginInfrastructure/ApplicationManager.cs (added)
• HeuristicLab.PluginInfrastructure/Attributes/ApplicationAttribute.cs (moved) (moved from branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Attributes/ApplicationDescriptionAttribute.cs) (4 diffs)
• HeuristicLab.PluginInfrastructure/Attributes/PluginAttribute.cs (moved) (moved from branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Attributes/PluginDescriptionAttribute.cs) (2 diffs)
• HeuristicLab.PluginInfrastructure/BaseClasses/ApplicationBase.cs (modified) (6 diffs)
• HeuristicLab.PluginInfrastructure/BaseClasses/PluginBase.cs (modified) (2 diffs)
• HeuristicLab.PluginInfrastructure/ControlManager.cs (modified) (1 diff)
• HeuristicLab.PluginInfrastructure/DiscoveryService.cs (modified) (4 diffs)
• HeuristicLab.PluginInfrastructure/HeuristicLab.PluginInfrastructure.csproj (modified) (1 diff)
• HeuristicLab.PluginInfrastructure/Interfaces/IApplicationDescription.cs (added)
• HeuristicLab.PluginInfrastructure/Interfaces/IApplicationManager.cs (added)
• HeuristicLab.PluginInfrastructure/Interfaces/IPluginDescription.cs (added)
• HeuristicLab.PluginInfrastructure/PluginDescriptionIterator.cs (moved) (moved from branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginDescriptionIterator.cs) (2 diffs)
• HeuristicLab.PluginInfrastructure/PluginState.cs (moved) (moved from branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginState.cs) (1 diff)
• HeuristicLab/MainForm.cs (modified) (5 diffs)
• HeuristicLab/Program.cs (modified) (1 diff)

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/ApplicationDescription.cs

@@ -29 +29 @@
   /// </summary>
   [Serializable]
-  public class ApplicationDescription {
+  public class ApplicationDescription : IApplicationDescription {
     private string name;
 
@@ -67 +67 @@
     }
 
-    private string pluginAssembly;
+    private string declaringAssemblyName;
     /// <summary>
     /// Gets or sets the name of the assembly that contains the IApplication type.
     /// </summary>
-    public string PluginAssembly {
-      get { return pluginAssembly; }
-      set { pluginAssembly = value; }
+    public string DeclaringAssemblyName {
+      get { return declaringAssemblyName; }
+      set { declaringAssemblyName = value; }
     }
 
-    private string pluginType;
+    private string declaringTypeName;
     /// <summary>
     /// Gets or sets the name of the type that implements the interface IApplication.
     /// </summary>
-    public string PluginType {
-      get { return pluginType; }
-      set { pluginType = value; }
+    public string DeclaringTypeName {
+      get { return declaringTypeName; }
+      set { declaringTypeName = value; }
     }
   }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/ApplicationManager.cs

@@ -27 +27 @@
 using System.Security.Permissions;
 using System.Security;
+using System.Linq;
 
 namespace HeuristicLab.PluginInfrastructure.Manager {
 
-  public class ApplicationManager {
+  public class ApplicationManager : MarshalByRefObject, IApplicationManager {
+    private List<IPluginDescription> plugins;
     /// <summary>
-    /// Event handler for actions in the application manager.
+    /// Gets all plugins.
     /// </summary>
-    public event PluginManagerActionEventHandler Action;
-
-    // singleton pattern
-    public ApplicationManager() {
-      applications = new List<ApplicationDescription>();
+    public IEnumerable<IPluginDescription> Plugins {
+      get { return plugins; }
     }
 
-    private ApplicationManager singleton = new ApplicationManager();
-    public ApplicationManager Manager {
-      get { return singleton; }
+    private List<IApplicationDescription> applications;
+    /// <summary>
+    /// Gets all installed applications.
+    /// </summary>
+    public IEnumerable<IApplicationDescription> Applications {
+      get { return applications; }
+    }
+
+    public ApplicationManager() : base() { }
+
+    internal void PrepareApplicationDomain(IEnumerable<IApplicationDescription> apps, IEnumerable<IPluginDescription> plugins) {
+      this.plugins = new List<IPluginDescription>(plugins);
+      this.applications = new List<IApplicationDescription>(apps);
+      PluginInfrastructure.ApplicationManager.RegisterApplicationManager(this);
+      LoadPlugins(plugins);
+    }
+
+    private void LoadPlugins(IEnumerable<IPluginDescription> plugins) {
+      // load all loadable plugins (all dependencies available) into the execution context
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(plugins.Where(x => x.PluginState != PluginState.Disabled))) {
+        foreach (var plugin in GetInstances<IPlugin>(desc)) {
+          plugin.OnLoad();
+        }
+        desc.Load();
+      }
+    }
+
+    internal void Run(IApplicationDescription appInfo) {
+      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.DeclaringAssemblyName, appInfo.DeclaringTypeName).Unwrap();
+      try {
+        runnablePlugin.Run();
+      }
+      catch (Exception e) {
+        throw new Exception(String.Format(
+          "Unexpected exception caught: \"{0}\"\r\n" +
+          "Type: {1}\r\n" +
+          "Plugin {2}:\r\n{3}",
+          e.Message,
+          e.GetType().FullName,
+          appInfo.Name,
+          e.ToString()));
+      }
+    }
+
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type and declared in <paramref name="plugin"/>
+    /// </summary>
+    /// <typeparam name="T">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>(IPluginDescription plugin) where T : class {
+      return from t in GetTypes(typeof(T), plugin)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select (T)Activator.CreateInstance(t);
+    }
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type
+    /// </summary>
+    /// <typeparam name="T">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>() where T : class {
+      return from i in GetInstances(typeof(T))
+             select (T)i;
+    }
+
+    /// <summary>
+    /// Creates an instance of all types that are subtypes or the same type of the specified type
+    /// </summary>
+    /// <typeparam name="type">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<object> GetInstances(Type type) {
+      return from t in GetTypes(type)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select Activator.CreateInstance(t);
+    }
+
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             from t in GetTypes(type, asm)
+             select t;
+    }
+
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type if they are part of the given
+    /// <paramref name="plugin"/>.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <param name="plugin">The plugin the subtypes must be part of.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type, IPluginDescription pluginDescription) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             where pluginDescription.Assemblies.Contains(asm.Location)
+             from t in GetTypes(type, asm)
+             select t;
+    }
+
+    /// <summary>
+    /// Gets types that are assignable (same of subtype) to the specified type only from the given assembly.
+    /// </summary>
+    /// <param name="type">Most general type we want to find.</param>
+    /// <param name="assembly">Assembly that should be searched for types.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    private IEnumerable<Type> GetTypes(Type type, Assembly assembly) {
+      return from t in assembly.GetTypes()
+             where type.IsAssignableFrom(t)
+             select t;
     }
 
 
-    private void NotifyListeners(string action, string text) {
-      if (Action != null) {
-        Action(this, new PluginManagerActionEventArgs(text, action));
-      }
+    // infinite lease time
+    /// <summary>
+    /// Initializes the life time service with infinite lease time.
+    /// </summary>
+    /// <returns><c>null</c>.</returns>
+    public override object InitializeLifetimeService() {
+      return null;
     }
   }
 }
+

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/HeuristicLab.PluginInfrastructure.Manager.csproj

@@ -49 +49 @@
   <ItemGroup>
     <Compile Include="ApplicationDescription.cs" />
-    <Compile Include="PluginDescriptionIterator.cs" />
+    <Compile Include="ApplicationManager.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Loader.cs" />
-    <Compile Include="PluginState.cs" />
     <Compile Include="PluginDescription.cs" />
     <Compile Include="PluginManager.cs" />
     <Compile Include="PluginManagerActionEventArgs.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Runner.cs" />
   </ItemGroup>
   <ItemGroup>

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Loader.cs

@@ -55 +55 @@
       this.plugins = new List<PluginDescription>();
       this.pluginDependencies = new Dictionary<PluginDescription, List<string>>();
+
+      AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += ReflectionOnlyAssemblyResolveEventHandler;
+    }
+
+    private Assembly ReflectionOnlyAssemblyResolveEventHandler(object sender, ResolveEventArgs args) {
+      //try {
+      return Assembly.ReflectionOnlyLoad(args.Name);
+      //}
+      //catch (FileLoadException ex) {
+      //  return null;
+      //}
     }
 
@@ -70 +81 @@
     /// </summary>
     internal void Init() {
-      //AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += delegate(object sender, ResolveEventArgs args) {
-      //  try {
-      //    return Assembly.ReflectionOnlyLoad(args.Name);
-      //  }
-      //  catch (FileLoadException ex) {
-      //    return null;
-      //  }
-      //};
       pluginDependencies.Clear();
 
@@ -91 +94 @@
       CheckPluginDependencies(pluginDescriptions);
 
+      // mark all plugins as enabled that were not disabled in CheckPluginFiles or CheckPluginDependencies
+      foreach (var desc in pluginDescriptions)
+        if (desc.PluginState != PluginState.Disabled)
+          desc.Enable();
+
       // test full loading (in contrast to reflection only loading) of plugins
       // disables plugins that are not loaded correctly
@@ -100 +108 @@
 
     private void DiscoverApplications() {
-      DiscoveryService service = new DiscoveryService();
-      IApplication[] apps = service.GetInstances<IApplication>();
       applications = new List<ApplicationDescription>();
 
-      foreach (IApplication application in apps) {
+      foreach (IApplication application in GetApplications()) {
         ApplicationDescription info = new ApplicationDescription();
         info.Name = application.Name;
@@ -110 +116 @@
         info.Description = application.Description;
         info.AutoRestart = application.RestartOnErrors;
-        info.PluginAssembly = application.GetType().Assembly.GetName().Name;
-        info.PluginType = application.GetType().Namespace + "." + application.GetType().Name;
+        info.DeclaringAssemblyName = application.GetType().Assembly.GetName().Name;
+        info.DeclaringTypeName = application.GetType().Namespace + "." + application.GetType().Name;
 
         applications.Add(info);
       }
+    }
+
+    private IEnumerable<IApplication> GetApplications() {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             from t in asm.GetTypes()
+             where typeof(IApplication).IsAssignableFrom(t) &&
+               !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select (IApplication)Activator.CreateInstance(t);
     }
 
@@ -198 +212 @@
       // iterate through all custom attributes and search for attributed that we are interested in 
       foreach (CustomAttributeData attributeData in attributes) {
-        if (IsAttributeDataForType(attributeData, typeof(PluginDescriptionAttribute))) {
+        if (IsAttributeDataForType(attributeData, typeof(PluginAttribute))) {
           pluginName = (string)attributeData.ConstructorArguments[0].Value;
         } else if (IsAttributeDataForType(attributeData, typeof(PluginDependencyAttribute))) {
@@ -222 +236 @@
         info.AddAssemblies(pluginAssemblies);
         info.AddFiles(pluginFiles);
-        info.PluginState = PluginState.Undefined;
 
         this.pluginDependencies[info] = pluginDependencies;
@@ -246 +259 @@
           } else {
             // no plugin description that matches the dependency name is available => plugin is disabled
-            desc.PluginState = PluginState.Disabled;
+            desc.Disable();
             break; // stop processing more dependencies
           }
@@ -257 +270 @@
         if (IsAnyDependencyDisabled(pluginDescription)) {
           // PluginDescription.Message = "Disabled: missing plugin dependency.";
-          pluginDescription.PluginState = PluginState.Disabled;
+          pluginDescription.Disable();
         }
       }
@@ -273 +286 @@
     private void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
       // load all loadable plugins (all dependencies available) into the execution context
-      foreach (PluginDescription desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions
+                                                                                .Cast<IPluginDescription>()
+                                                                                .Where(x => x.PluginState != PluginState.Disabled))) {
         List<Type> types = new List<Type>();
         foreach (string assembly in desc.Assemblies) {
@@ -288 +303 @@
             IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
             plugin.OnLoad();
+            desc.Load();
             PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.PluginLoaded));
           }
@@ -335 +351 @@
         if (!CheckPluginFiles(desc)) {
           //plugin.Message = "Disabled: missing plugin file.";
-          desc.PluginState = PluginState.Disabled;
+          desc.Disable();
         }
       }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginDescription.cs

@@ -30 +30 @@
   /// </summary>
   [Serializable]
-  public class PluginDescription {
+  public class PluginDescription : IPluginDescription {
     private string name;
     /// <summary>
@@ -62 +62 @@
     public PluginState PluginState {
       get { return pluginState; }
-      set { pluginState = value; }
+    }
+
+    private int nTimesLoaded;
+    public void Disable() {
+      if (pluginState != PluginState.Undefined)
+        throw new InvalidOperationException("Can't disabled a plugin in state " + pluginState);
+      pluginState = PluginState.Disabled;
+    }
+
+    public void Enable() {
+      if (pluginState != PluginState.Undefined)
+        throw new InvalidOperationException("Can't enabled a plugin in state " + pluginState);
+      pluginState = PluginState.Enabled;
+    }
+
+    public void Load() {
+      if (!(pluginState == PluginState.Enabled || pluginState == PluginState.Loaded))
+        throw new InvalidOperationException("Can't loaded a plugin in state " + pluginState);
+      pluginState = PluginState.Loaded;
+      nTimesLoaded++;
+    }
+
+    public void Unload() {
+      if (pluginState != PluginState.Loaded)
+        throw new InvalidOperationException("Can't unload a plugin in state " + pluginState);
+      nTimesLoaded--;
+      if (nTimesLoaded == 0) pluginState = PluginState.Enabled;
     }
 
@@ -78 +104 @@
     }
 
-    private List<PluginDescription> dependencies = new List<PluginDescription>();
+    private List<IPluginDescription> dependencies = new List<IPluginDescription>();
     /// <summary>
     /// Gets all dependencies of the plugin.
     /// </summary>
-    public IEnumerable<PluginDescription> Dependencies {
+    public IEnumerable<IPluginDescription> Dependencies {
       get { return dependencies; }
     }
@@ -104 +130 @@
     }
 
+    public PluginDescription() {
+      nTimesLoaded = 0;
+      pluginState = PluginState.Undefined;
+    }
+
+
     //private string message;
     ///// <summary>
@@ -121 +153 @@
     }
 
-    // equals and hashcode have to be implemented because we want to compare PluginDescriptions from 
-    // different AppDomains and serialization destroys reference equality
-    /// <summary>
-    /// Checks whether the given object is equal to the current plugin.
-    /// </summary>
-    /// <param name="obj">The object to compare.</param>
-    /// <returns><c>true</c> if it is equal, <c>false</c> otherwise.</returns>
-    public override bool Equals(object obj) {
-      if (!(obj is PluginDescription))
-        return false;
-      PluginDescription other = (PluginDescription)obj;
+    //// equals and hashcode have to be implemented because we want to compare PluginDescriptions from 
+    //// different AppDomains and serialization destroys reference equality
+    ///// <summary>
+    ///// Checks whether the given object is equal to the current plugin.
+    ///// </summary>
+    ///// <param name="obj">The object to compare.</param>
+    ///// <returns><c>true</c> if it is equal, <c>false</c> otherwise.</returns>
+    //public override bool Equals(object obj) {
+    //  if (!(obj is PluginDescription))
+    //    return false;
+    //  PluginDescription other = (PluginDescription)obj;
 
-      return other.Name == this.Name && other.Version == this.Version;
-    }
-    /// <summary>
-    /// Gets the hash code of the current plugin.
-    /// </summary>
-    /// <returns>The hash code of the plugin.</returns>
-    public override int GetHashCode() {
-      if (version != null) {
-        return name.GetHashCode() + version.GetHashCode();
-      } else return name.GetHashCode();
-    }
+    //  return other.Name == this.Name && other.Version == this.Version;
+    //}
+    ///// <summary>
+    ///// Gets the hash code of the current plugin.
+    ///// </summary>
+    ///// <returns>The hash code of the plugin.</returns>
+    //public override int GetHashCode() {
+    //  if (version != null) {
+    //    return name.GetHashCode() + version.GetHashCode();
+    //  } else return name.GetHashCode();
+    //}
   }
 }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/PluginManager.cs

@@ -27 +27 @@
 using System.Security.Permissions;
 using System.Security;
+using System.Linq;
 
 namespace HeuristicLab.PluginInfrastructure.Manager {
@@ -81 +82 @@
 
     private List<PluginDescription> plugins;
-    public IEnumerable<PluginDescription> Plugins {
-      get { return plugins; }
-    }
+    //public IEnumerable<PluginDescription> Plugins {
+    //  get { return plugins; }
+    //}
 
     private List<ApplicationDescription> applications;
@@ -109 +110 @@
       plugins = new List<PluginDescription>(remoteLoader.Plugins);
       applications = new List<ApplicationDescription>(remoteLoader.Applications);
-      throw new NotImplementedException();
+
+      // discard the AppDomain that was used for plugin discovery
+      UnloadAppDomain(pluginDomain);
+    }
+
+    private void UnloadAppDomain(AppDomain appDomain) {
+      AppDomain.Unload(appDomain);
+
+      // set all loaded plugins back to enabled
+      foreach (var pluginDescription in plugins)
+        pluginDescription.Unload();
     }
 
@@ -130 +141 @@
     public void Run(ApplicationDescription appInfo) {
       // create a separate AppDomain for the application
-      // activate a PluginRunner instance in the application
+      // initialize the static ApplicationManager in the AppDomain
       // and remotely tell it to start the application
 
@@ -139 +150 @@
         setup.PrivateBinPath = pluginDir;
         applicationDomain = AppDomain.CreateDomain(appInfo.Name, null, setup);
-        Runner remoteRunner = (Runner)applicationDomain.CreateInstanceAndUnwrap(typeof(Runner).Assembly.GetName().Name, typeof(Runner).FullName);
-        remoteRunner.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
-        remoteRunner.LoadPlugins(Plugins);
+        ApplicationManager applicationManager =
+          (ApplicationManager)applicationDomain.CreateInstanceAndUnwrap("HeuristicLab.PluginInfraStructure.Manager", "HeuristicLab.PluginInfrastructure.Manager.ApplicationManager");
+        //applicationManager.PluginAction += delegate(object sender, PluginManagerActionEventArgs args) { if (Action != null) Action(this, args); };
+        applicationManager.PrepareApplicationDomain(
+          new List<IApplicationDescription>(applications.Cast<IApplicationDescription>()),
+          new List<IPluginDescription>(plugins.Cast<IPluginDescription>()));
         NotifyListeners(PluginManagerAction.Initialized, "All plugins");
-        remoteRunner.Run(appInfo);
+        applicationManager.Run(appInfo);
       }
       finally {

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure.Manager/Runner.cs

@@ -44 +44 @@
     }
 
-    public void LoadPlugins(IEnumerable<PluginDescription> pluginDescriptions) {
+    public void LoadPlugins(IEnumerable<IPluginDescription> pluginDescriptions) {
       //FileIOPermission fileperm = new FileIOPermission(FileIOPermissionAccess.AllAccess, @"C:\Program Files\HeuristicLab 3.0\plugins\");
       //fileperm.Assert();
 
       // load all loadable plugins (all dependencies available) into the execution context
-      foreach (PluginDescription desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
+      foreach (var desc in PluginDescriptionIterator.IterateInDependencyOrder(pluginDescriptions.Where(x => x.PluginState != PluginState.Disabled))) {
         List<Type> types = new List<Type>();
         foreach (string assembly in desc.Assemblies) {
@@ -64 +64 @@
             IPlugin plugin = (IPlugin)Activator.CreateInstance(pluginType);
             plugin.OnLoad();
+            desc.Load();
             PluginAction(this, new PluginManagerActionEventArgs(plugin.Name, PluginManagerAction.PluginLoaded));
           }
@@ -88 +89 @@
 
     public void Run(ApplicationDescription appInfo) {
-      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.PluginAssembly, appInfo.PluginType).Unwrap();
+      IApplication runnablePlugin = (IApplication)Activator.CreateInstance(appInfo.DeclaringAssemblyName, appInfo.DeclaringTypeName).Unwrap();
       try {
         runnablePlugin.Run();

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Attributes/ApplicationAttribute.cs

@@ -30 +30 @@
   /// </summary>
   [AttributeUsage(AttributeTargets.Class)]
-  public class ApplicationDescriptionAttribute : System.Attribute {
+  public class ApplicationAttribute : System.Attribute {
     private string name;
     /// <summary>
@@ -40 +40 @@
     }
 
-    private string version;
-    /// <summary>
-    /// Gets or sets the version of the application.
-    /// </summary>
-    public string Version {
-      get { return version; }
-      set { version = value; }
-    }
+    //private string version;
+    ///// <summary>
+    ///// Gets or sets the version of the application.
+    ///// </summary>
+    //public string Version {
+    //  get { return version; }
+    //  set { version = value; }
+    //}
 
     private string description;
@@ -68 +68 @@
 
     /// <summary>
-    /// Initializes a new instance of <see cref="ApplicationDescriptionAttribute"/>.
+    /// Initializes a new instance of <see cref="ApplicationAttribute"/>.
     /// <param name="name">Name of the application</param>
     /// </summary>
-    public ApplicationDescriptionAttribute(string name)
+    public ApplicationAttribute(string name)
       : this(name, "") {
     }
 
     /// <summary>
-    /// Initializes a new instance of <see cref="ApplicationDescriptionAttribute"/>.
+    /// Initializes a new instance of <see cref="ApplicationAttribute"/>.
     /// <param name="name">Name of the application</param>
     /// <param name="description">Description of the application</param>
     /// </summary>
-    public ApplicationDescriptionAttribute(string name, string description)
-      : this(name, description, "") {
+    public ApplicationAttribute(string name, string description)
+      : this(name, description, false) {
     }
 
-    /// <summary>
-    /// Initializes a new instance of <see cref="ApplicationDescriptionAttribute"/>.
-    /// <param name="name">Name of the application</param>
-    /// <param name="description">Description of the application</param>
-    /// <param name="version">Version string of the application</param>
-    /// </summary>
-    public ApplicationDescriptionAttribute(string name, string description, string version)
-      : this(name, description, version, false) {
-    }
+    ///// <summary>
+    ///// Initializes a new instance of <see cref="ApplicationAttribute"/>.
+    ///// <param name="name">Name of the application</param>
+    ///// <param name="description">Description of the application</param>
+    ///// <param name="version">Version string of the application</param>
+    ///// </summary>
+    //public ApplicationAttribute(string name, string description, string version)
+    //  : this(name, description, version, false) {
+    //}
 
     /// <summary>
-    /// Initializes a new instance of <see cref="ApplicationDescriptionAttribute"/>.
+    /// Initializes a new instance of <see cref="ApplicationAttribute"/>.
     /// <param name="name">Name of the application</param>
     /// <param name="description">Description of the application</param>
@@ -101 +101 @@
     /// <param name="restartOnErrors">Flag that indicates if the application should be restarted on exceptions (for services)</param>
     /// </summary>
-    public ApplicationDescriptionAttribute(string name, string description, string version, bool restartOnErrors) {
+    public ApplicationAttribute(string name, string description, bool restartOnErrors) {
       this.name = name;
-      this.version = version;
       this.description = description;
       this.restartOnErrors = restartOnErrors;

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/Attributes/PluginAttribute.cs

@@ -30 +30 @@
   /// </summary>
   [AttributeUsage(AttributeTargets.Class)]
-  public class PluginDescriptionAttribute : System.Attribute {
+  public class PluginAttribute : System.Attribute {
     private string name;
     /// <summary>
@@ -49 +49 @@
     //}
 
-    //private string description;
-    ///// <summary>
-    ///// Gets or sets the description of the plugin.
-    ///// </summary>
-    //public string Description {
-    //  get { return description; }
-    //  set { description = value; }
-    //}
+    private string description;
+    /// <summary>
+    /// Gets or sets the description of the plugin.
+    /// </summary>
+    public string Description {
+      get { return description; }
+      // set { description = value; }
+    }
 
     /// <summary>
-    /// Initializes a new instance of <see cref="PluginDescriptionAttribute"/>.
+    /// Initializes a new instance of <see cref="PluginAttribute"/>.
     /// <param name="name">Name of the plugin</param>
     /// </summary>
-    public PluginDescriptionAttribute(string name) {
-      this.name = name;
+    public PluginAttribute(string name)
+      : this(name, "") {
     }
 
-    ///// <summary>
-    ///// Initializes a new instance of <see cref="PluginDescriptionAttribute"/>.
-    ///// <param name="name">Name of the plugin</param>
-    ///// <param name="description">Description of the plugin</param>
-    ///// </summary>
-    //public PluginDescriptionAttribute(string name, string description)
-    //  : this(name, description, "") {
-    //}
+    /// <summary>
+    /// Initializes a new instance of <see cref="PluginAttribute"/>.
+    /// <param name="name">Name of the plugin</param>
+    /// <param name="description">Description of the plugin</param>
+    /// </summary>
+    public PluginAttribute(string name, string description) {
+      this.name = name;
+      this.description = description;
+    }
 
     ///// <summary>

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/BaseClasses/ApplicationBase.cs

@@ -29 +29 @@
   /// Default implementation for the IApplication interface.
   /// </summary>
-  internal abstract class ApplicationBase : IApplication {
+  public abstract class ApplicationBase : IApplication {
     /// <summary>
     /// Initializes a new instance of <see cref="ApplicationBase"/>.
@@ -35 +35 @@
     public ApplicationBase() { }
 
-    private ApplicationDescriptionAttribute ApplicationDescriptionAttribute {
+    private ApplicationAttribute ApplicationAttribute {
       get {
-        object[] appDescAttributes = this.GetType().GetCustomAttributes(typeof(ApplicationDescriptionAttribute), false);
+        object[] appAttributes = this.GetType().GetCustomAttributes(typeof(ApplicationAttribute), false);
 
         // exactly one attribute of the type ClassInfoAttribute must be given
-        if (appDescAttributes.Length != 1) {
-          throw new InvalidPluginException("Found multiple ApplicationDescriptionAttributes on type " + this.GetType());
+        if (appAttributes.Length != 1) {
+          throw new InvalidPluginException("Found multiple ApplicationAttributes on type " + this.GetType());
         }
 
-        return (ApplicationDescriptionAttribute)appDescAttributes[0];
+        return (ApplicationAttribute)appAttributes[0];
       }
     }
@@ -54 +54 @@
     /// </summary>
     public string Name {
-      get { return ApplicationDescriptionAttribute.Name; }
+      get { return ApplicationAttribute.Name; }
     }
 
@@ -62 +62 @@
     public Version Version {
       get {
-        var appDescAttribute = ApplicationDescriptionAttribute;
-        // if the version is not explicitly set in the attribute then the version of the assembly is used as default
-        if (string.IsNullOrEmpty(appDescAttribute.Version)) {
-          return this.GetType().Assembly.GetName().Version;
-        } else {
-          return new Version(appDescAttribute.Version);
-        }
+        return this.GetType().Assembly.GetName().Version;
       }
     }
@@ -77 +71 @@
     public string Description {
       get {
-        var appDescAttribute = ApplicationDescriptionAttribute;
+        var appDescAttribute = ApplicationAttribute;
         // if the description is not explicitly set in the attribute then the name of the application is used as default
         if (string.IsNullOrEmpty(appDescAttribute.Description)) {
@@ -92 +86 @@
     public bool RestartOnErrors {
       get {
-        return ApplicationDescriptionAttribute.RestartOnErrors;
+        return ApplicationAttribute.RestartOnErrors;
       }
     }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/BaseClasses/PluginBase.cs

@@ -37 +37 @@
     public PluginBase() { }
 
-    private PluginDescriptionAttribute PluginDescriptionAttribute {
+    private PluginAttribute PluginAttribute {
       get {
-        object[] pluginAttributes = this.GetType().GetCustomAttributes(typeof(PluginDescriptionAttribute), false);
+        object[] pluginAttributes = this.GetType().GetCustomAttributes(typeof(PluginAttribute), false);
         // exactly one attribute of the type PluginDescriptionAttribute must be given
         if (pluginAttributes.Length != 1) {
-          throw new InvalidPluginException("Found multiple PluginDescriptionAttributes on type " + this.GetType());
+          throw new InvalidPluginException("Found multiple PluginAttributes on type " + this.GetType());
         }
-        return (PluginDescriptionAttribute)pluginAttributes[0];
+        return (PluginAttribute)pluginAttributes[0];
       }
     }
@@ -52 +52 @@
     public string Name {
       get {
-        return PluginDescriptionAttribute.Name;
+        return PluginAttribute.Name;
       }
     }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/ControlManager.cs

@@ -38 +38 @@
     public static IControlManager Manager {
       get { return controlManager; }
-      set { controlManager = value; }
+    }
+
+    public static void RegisterManager(IControlManager manager) {
+      if (controlManager != null) throw new InvalidOperationException("An control manager has already been set.");
+      controlManager = manager;
     }
   }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/DiscoveryService.cs

@@ -24 +24 @@
 using System.Text;
 using System.Reflection;
+using System.Linq;
 
 namespace HeuristicLab.PluginInfrastructure {
@@ -30 +31 @@
   /// </summary>
   public class DiscoveryService {
+    //internal static IEnumerable<IPluginDescription> plugins;
 
-    //public PluginDescription[] Plugins {
+    //public IEnumerable<IPluginDescription> Plugins {
     //  get {
-    //    PluginInfo[] plugins = new PluginInfo[PluginManager.Manager.LoadedPlugins.Count];
-    //    PluginManager.Manager.LoadedPlugins.CopyTo(plugins, 0);
-    //    return plugins;
+    //    return DiscoveryService.plugins;
     //  }
     //}
 
     /// <summary>
-    /// Finds all types that are subtypes or equal to the specified type.
+    /// Creates an instance of all types that are subtypes or the same type of the specified type and declared in <paramref name="plugin"/>
     /// </summary>
-    /// <param name="type">Most general type for which to find matching types.</param>
-    /// <returns>The found types as array.</returns>
-    public Type[] GetTypes(Type type) {
-      Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
-      List<Type> types = new List<Type>();
-      foreach (Assembly asm in assemblies) {
-        Array.ForEach<Type>(GetTypes(type, asm), delegate(Type t) {
-          types.Add(t);
-        });
-      }
-      return types.ToArray();
+    /// <typeparam name="T">Most general type.</typeparam>
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>(IPluginDescription plugin) where T : class {
+      return from t in GetTypes(typeof(T), plugin)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select (T)Activator.CreateInstance(t);
     }
-
     /// <summary>
     /// Creates an instance of all types that are subtypes or the same type of the specified type
     /// </summary>
     /// <typeparam name="T">Most general type.</typeparam>
-    /// <returns>The created instances as array.</returns>
-    public T[] GetInstances<T>() where T : class {
-      Type[] types = GetTypes(typeof(T));
-      List<T> instances = new List<T>();
-      foreach (Type t in types) {
-        if (!t.IsAbstract && !t.IsInterface && !t.HasElementType) {
-          instances.Add((T)Activator.CreateInstance(t));
-        }
-      }
-      return instances.ToArray();
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<T> GetInstances<T>() where T : class {
+      return from i in GetInstances(typeof(T))
+             select (T)i;
     }
 
@@ -75 +63 @@
     /// </summary>
     /// <typeparam name="type">Most general type.</typeparam>
-    /// <returns>The created instances as array.</returns>
-    public object[] GetInstances(Type type) {
-      Type[] types = GetTypes(type);
-      List<object> instances = new List<object>();
-      foreach (Type t in types) {
-        if (!t.IsAbstract && !t.IsInterface && !t.HasElementType) {
-          instances.Add(Activator.CreateInstance(t));
-        }
-      }
-      return instances.ToArray();
+    /// <returns>Enumerable of the created instances.</returns>
+    public IEnumerable<object> GetInstances(Type type) {
+      return from t in GetTypes(type)
+             where !t.IsAbstract && !t.IsInterface && !t.HasElementType
+             select Activator.CreateInstance(t);
     }
 
-    ///// <summary>
-    ///// Finds all types that are subtypes or equal to the specified type if they are part of the given
-    ///// <paramref name="plugin"/>.
-    ///// </summary>
-    ///// <param name="type">Most general type for which to find matching types.</param>
-    ///// <param name="plugin">The plugin the subtypes must be part of.</param>
-    ///// <returns>The found types as array.</returns>
-    //public Type[] GetTypes(Type type, PluginInfo plugin) {
-    //  Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
-    //  List<Type> types = new List<Type>();
-    //  foreach (Assembly asm in assemblies) {
-    //    if (plugin.Assemblies.Contains(asm.Location)) {
-    //      Array.ForEach<Type>(GetTypes(type, asm), delegate(Type t) {
-    //        types.Add(t);
-    //      });
-    //    }
-    //  }
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             from t in GetTypes(type, asm)
+             select t;
+    }
 
-    //  return types.ToArray();
-    //}
+    /// <summary>
+    /// Finds all types that are subtypes or equal to the specified type if they are part of the given
+    /// <paramref name="plugin"/>.
+    /// </summary>
+    /// <param name="type">Most general type for which to find matching types.</param>
+    /// <param name="plugin">The plugin the subtypes must be part of.</param>
+    /// <returns>Enumerable of the discovered types.</returns>
+    public IEnumerable<Type> GetTypes(Type type, IPluginDescription pluginDescription) {
+      return from asm in AppDomain.CurrentDomain.GetAssemblies()
+             where pluginDescription.Assemblies.Contains(asm.Location)
+             from t in GetTypes(type, asm)
+             select t;
+    }
 
     ///// <summary>
@@ -130 +117 @@
     /// <param name="type">Most general type we want to find.</param>
     /// <param name="assembly">Assembly that should be searched for types.</param>
-    /// <returns>The found types as array.</returns>
-    internal Type[] GetTypes(Type type, Assembly assembly) {
-      List<Type> types = new List<Type>();
-      foreach (Type t in assembly.GetTypes()) {
-        if (type.IsAssignableFrom(t)) {
-          types.Add(t);
-        }
-      }
-      return types.ToArray();
+    /// <returns>Enumerable of the discovered types.</returns>
+    private IEnumerable<Type> GetTypes(Type type, Assembly assembly) {
+      return from t in assembly.GetTypes()
+             where type.IsAssignableFrom(t)
+             select t;
     }
 

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/HeuristicLab.PluginInfrastructure.csproj

@@ -86 +86 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Attributes\ApplicationDescriptionAttribute.cs" />
+    <Compile Include="Attributes\ApplicationAttribute.cs" />
     <Compile Include="Attributes\AssemblyBuildDateAttribute.cs" />
+    <Compile Include="Attributes\PluginAttribute.cs" />
     <Compile Include="Attributes\PluginDependencyAttribute.cs" />
-    <Compile Include="Attributes\PluginDescriptionAttribute.cs" />
     <Compile Include="Attributes\PluginFileAttribute.cs" />
     <Compile Include="BaseClasses\ApplicationBase.cs" />
     <Compile Include="BaseClasses\PluginBase.cs" />
+    <Compile Include="Interfaces\IApplicationManager.cs" />
+    <Compile Include="Interfaces\IApplicationDescription.cs" />
     <Compile Include="Interfaces\IApplication.cs" />
     <Compile Include="Interfaces\IControl.cs" />
     <Compile Include="Interfaces\IControlManager.cs" />
     <Compile Include="Interfaces\IPlugin.cs" />
-    <Compile Include="DiscoveryService.cs" />
     <Compile Include="ControlManager.cs" />
+    <Compile Include="Interfaces\IPluginDescription.cs" />
     <Compile Include="InvalidPluginException.cs" />
+    <Compile Include="PluginDescriptionIterator.cs" />
+    <Compile Include="ApplicationManager.cs" />
+    <Compile Include="PluginState.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <EmbeddedResource Include="Properties\Resources.resx">

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/PluginDescriptionIterator.cs

@@ -24 +24 @@
 using System.Text;
 
-namespace HeuristicLab.PluginInfrastructure.Manager {
+namespace HeuristicLab.PluginInfrastructure {
   public static class PluginDescriptionIterator {
-    public static IEnumerable<PluginDescription> IterateInDependencyOrder(IEnumerable<PluginDescription> pluginDescriptions) {
+    public static IEnumerable<IPluginDescription> IterateInDependencyOrder(IEnumerable<IPluginDescription> pluginDescriptions) {
       // list to make sure we yield each description only once
-      List<PluginDescription> yieldedDescriptions = new List<PluginDescription>();
+      List<IPluginDescription> yieldedDescriptions = new List<IPluginDescription>();
       foreach (var desc in pluginDescriptions) {
         foreach (var dependency in IterateInDependencyOrder(desc.Dependencies)) {
@@ -35 +35 @@
             yield return dependency;
           }
-          if (!yieldedDescriptions.Contains(desc)) {
-            yieldedDescriptions.Add(desc);
-            yield return desc;
-          }
+        }
+        if (!yieldedDescriptions.Contains(desc)) {
+          yieldedDescriptions.Add(desc);
+          yield return desc;
         }
       }

branches/PluginInfrastructure Refactoring/HeuristicLab.PluginInfrastructure/PluginState.cs

@@ -24 +24 @@
 using System.Text;
 
-namespace HeuristicLab.PluginInfrastructure.Manager {
+namespace HeuristicLab.PluginInfrastructure {
   [Serializable]
   public enum PluginState {

branches/PluginInfrastructure Refactoring/HeuristicLab/MainForm.cs

@@ -37 +37 @@
     private ListViewItem pluginManagerListViewItem;
     private bool abortRequested;
+    private PluginManager pluginManager;
 
     public MainForm()
@@ -43 +44 @@
 
       abortRequested = false;
-      PluginManager pluginManager = new PluginManager(HeuristicLab.PluginInfrastructure.Properties.Settings.Default.PluginDir);
+      pluginManager = new PluginManager(HeuristicLab.PluginInfrastructure.Properties.Settings.Default.PluginDir);
       SplashScreen splashScreen = new SplashScreen(pluginManager, 1000, "Loading HeuristicLab...");
       splashScreen.Owner = this;
@@ -83 +84 @@
         if (selected == pluginManagerListViewItem) {
           try {
-            Cursor = Cursors.AppStarting;
-            ManagerForm form = new ManagerForm();
-            this.Visible = false;
-            form.ShowDialog(this);
-            // RefreshApplicationsList();
-            this.Visible = true;
+            //Cursor = Cursors.AppStarting;
+            //ManagerForm form = new ManagerForm();
+            //this.Visible = false;
+            //form.ShowDialog(this);
+            //// RefreshApplicationsList();
+            //this.Visible = true;
           }
           finally {
@@ -95 +96 @@
         } else {
           ApplicationDescription app = (ApplicationDescription)applicationsListView.SelectedItems[0].Tag;
-          SplashScreen splashScreen = new SplashScreen(2000, "Loading " + app.Name);
+          SplashScreen splashScreen = new SplashScreen(pluginManager, 2000, "Loading " + app.Name);
           splashScreen.Owner = this;
           splashScreen.Show();
-          PluginManager.Manager.Action += new PluginManagerActionEventHandler(splashScreen.Manager_Action);
           Thread t = new Thread(delegate() {
             bool stopped = false;
@@ -104 +104 @@
               try {
                 if (!abortRequested)
-                  PluginManager.Manager.Run(app);
+                  pluginManager.Run(app);
                 stopped = true;
               }

branches/PluginInfrastructure Refactoring/HeuristicLab/Program.cs

@@ -38 +38 @@
           Application.Run(new MainForm());
         } else if (args.Length == 1) {  // start specific application
-          PluginManager.Manager.Initialize();
+          //PluginManager.Manager.Initialize();
 
-          ApplicationInfo app = null;
-          foreach (ApplicationInfo info in PluginManager.Manager.InstalledApplications) {
-            if (info.Name == args[0])
-              app = info;
-          }
-          if (app == null) {  // application not found
-            MessageBox.Show("Cannot start application.\nApplication " + args[0] + " is not installed.\n\nStarting HeuristicLab in normal mode ...",
-                            "HeuristicLab",
-                            MessageBoxButtons.OK,
-                            MessageBoxIcon.Warning);
-            Application.EnableVisualStyles();
-            Application.SetCompatibleTextRenderingDefault(false);
-            Application.Run(new MainForm());
-          } else {
-            PluginManager.Manager.Run(app);
-          }
+          //ApplicationInfo app = null;
+          //foreach (ApplicationInfo info in PluginManager.Manager.InstalledApplications) {
+          //  if (info.Name == args[0])
+          //    app = info;
+          //}
+          //if (app == null) {  // application not found
+          //  MessageBox.Show("Cannot start application.\nApplication " + args[0] + " is not installed.\n\nStarting HeuristicLab in normal mode ...",
+          //                  "HeuristicLab",
+          //                  MessageBoxButtons.OK,
+          //                  MessageBoxIcon.Warning);
+          //  Application.EnableVisualStyles();
+          //  Application.SetCompatibleTextRenderingDefault(false);
+          //  Application.Run(new MainForm());
+          //} else {
+          //  PluginManager.Manager.Run(app);
+          //}
         }
       }