Changeset 2642 for trunk/sources/HeuristicLab.PluginInfrastructure

Timestamp:

01/19/10 13:40:52 (15 years ago)

Author:

gkronber

Message:

Added a two versions of the type discovery methods in IApplicationManager with a boolean parameter to select if only instantiable types should be returned. #846

Location:

trunk/sources/HeuristicLab.PluginInfrastructure

Files:

• ApplicationManager.cs (modified) (8 diffs)
• Interfaces/IApplicationManager.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.PluginInfrastructure/ApplicationManager.cs

@@ -157 +157 @@
     /// <returns>Enumerable of the created instances.</returns>
     internal static IEnumerable<T> GetInstances<T>(IPluginDescription plugin) where T : class {
-      return from t in GetTypes(typeof(T), plugin)
+      return from t in GetTypes(typeof(T), plugin, true)
              select (T)Activator.CreateInstance(t);
     }
@@ -167 +167 @@
     /// <returns>Enumerable of the created instances.</returns>
     private static IEnumerable<T> GetInstances<T>(Assembly asm) where T : class {
-      return from t in GetTypes(typeof(T), asm)
+      return from t in GetTypes(typeof(T), asm, true)
              select (T)Activator.CreateInstance(t);
     }
@@ -186 +186 @@
     /// <returns>Enumerable of the created instances.</returns>
     internal static IEnumerable<object> GetInstances(Type type) {
-      return from t in GetTypes(type)
+      return from t in GetTypes(type, true)
              select Activator.CreateInstance(t);
     }
@@ -194 +194 @@
     /// </summary>
     /// <param name="type">Most general type for which to find matching types.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
     /// <returns>Enumerable of the discovered types.</returns>
-    internal static IEnumerable<Type> GetTypes(Type type) {
+    internal static IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable) {
       return from asm in AppDomain.CurrentDomain.GetAssemblies()
-             from t in GetTypes(type, asm)
+             from t in GetTypes(type, asm, onlyInstantiable)
              select t;
     }
@@ -207 +208 @@
     /// <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>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
     /// <returns>Enumerable of the discovered types.</returns>
-    internal static IEnumerable<Type> GetTypes(Type type, IPluginDescription pluginDescription) {
+    internal static IEnumerable<Type> GetTypes(Type type, IPluginDescription pluginDescription, bool onlyInstantiable) {
       PluginDescription pluginDesc = (PluginDescription)pluginDescription;
       return from asm in AppDomain.CurrentDomain.GetAssemblies()
-             where !string.IsNullOrEmpty(asm.Location ) && 
+             where !string.IsNullOrEmpty(asm.Location) &&
                    pluginDesc.Assemblies.Any(asmPath => Path.GetFullPath(asmPath) == Path.GetFullPath(asm.Location))
-             from t in GetTypes(type, asm)
+             from t in GetTypes(type, asm, onlyInstantiable)
              select t;
     }
@@ -222 +224 @@
     /// <param name="type">Most general type we want to find.</param>
     /// <param name="assembly">Assembly that should be searched for types.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
     /// <returns>Enumerable of the discovered types.</returns>
-    private static IEnumerable<Type> GetTypes(Type type, Assembly assembly) {
-      return GetTypes(type, assembly, false);
-    }
-
-    private static IEnumerable<Type> GetTypes(Type type, Assembly assembly, bool includeNotInstantiableTypes) {
+    private static IEnumerable<Type> GetTypes(Type type, Assembly assembly, bool onlyInstantiable) {
       return from t in assembly.GetTypes()
              where type.IsAssignableFrom(t)
-             where includeNotInstantiableTypes || (type.IsAssignableFrom(t) && !t.IsAbstract && !t.IsInterface && !t.HasElementType)
+             where onlyInstantiable == false || (!t.IsAbstract && !t.IsInterface && !t.HasElementType)
              select t;
     }
@@ -253 +252 @@
     #region IApplicationManager Members
 
-    IEnumerable<T> IApplicationManager.GetInstances<T>(IPluginDescription plugin) {
-      return GetInstances<T>(plugin);
-    }
-
     IEnumerable<T> IApplicationManager.GetInstances<T>() {
       return GetInstances<T>();
@@ -266 +261 @@
 
     IEnumerable<Type> IApplicationManager.GetTypes(Type type) {
-      return GetTypes(type);
+      return GetTypes(type, true);
+    }
+
+    IEnumerable<Type> IApplicationManager.GetTypes(Type type, bool onlyInstantiable) {
+      return GetTypes(type, onlyInstantiable);
     }
 
     IEnumerable<Type> IApplicationManager.GetTypes(Type type, IPluginDescription plugin) {
-      return GetTypes(type, plugin);
-    }
+      return GetTypes(type, plugin, true);
+    }
+
+    IEnumerable<Type> IApplicationManager.GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable) {
+      return GetTypes(type, plugin, onlyInstantiable);
+    }
+
 
     /// <summary>

trunk/sources/HeuristicLab.PluginInfrastructure/Interfaces/IApplicationManager.cs

@@ -35 +35 @@
     /// </summary>
     IEnumerable<IPluginDescription> Plugins { get; }
+
     /// <summary>
     /// Gets all discovered applications.
@@ -40 +41 @@
     IEnumerable<IApplicationDescription> Applications { get; }
 
-    /// <summary>
-    /// Discovers and creates instances of <typeparamref name="T"/> and all types implementing or inheriting <typeparamref name="T"/> (directly and indirectly) declared in any assembly of <paramref name="plugin"/>.
-    /// </summary>
-    /// <typeparam name="T">The type or super-type to discover.</typeparam>
-    /// <param name="plugin">The declaring plugin.</param>
-    /// <returns>An enumerable of instances of the discovered types.</returns>
-    IEnumerable<T> GetInstances<T>(IPluginDescription plugin) where T : class;
     /// <summary>
     /// Discovers and creates instances of <typeparamref name="T"/> and all types implementing or inheriting <typeparamref name="T"/> (directly and indirectly).
@@ -67 +61 @@
     /// <returns>An enumerable of discovered types.</returns>
     IEnumerable<Type> GetTypes(Type type);
+
+    /// <summary>
+    /// Discovers all types implementing or inheriting <paramref name="type"/> (directly and indirectly).
+    /// </summary>
+    /// <param name="type">The type to discover.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
+    /// <returns>An enumerable of discovered types.</returns>
+    IEnumerable<Type> GetTypes(Type type, bool onlyInstantiable);
+
     /// <summary>
     /// Discovers all types implementing or inheriting <paramref name="type"/> (directly and indirectly) that are declaed in any assembly of <paramref name="plugin"/>.
@@ -74 +77 @@
     /// <returns>An enumerable of discovered types.</returns>
     IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin);
+
+    /// <summary>
+    /// Discovers all types implementing or inheriting <paramref name="type"/> (directly and indirectly) that are declaed in any assembly of <paramref name="plugin"/>.
+    /// </summary>
+    /// <param name="type">The type to discover.</param>
+    /// <param name="plugin">The declaring plugin.</param>
+    /// <param name="onlyInstantiable">Return only types that are instantiable (instance, abstract... are not returned)</param>
+    /// <returns>An enumerable of discovered types.</returns>
+    IEnumerable<Type> GetTypes(Type type, IPluginDescription plugin, bool onlyInstantiable);
+
     /// <summary>
     /// Finds the plugin that declares the <paramref name="type">type</paramref>.