/// <summary> /// Initializes a instance of the <see cref="ExtensionBuilder" /> /// class for an extension in a given <see cref="ExtensionAssembly" />. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> in which the extension is found.</param> /// <exception cref="ArgumentNullException"><paramref name="extensionAssembly" /> is <see langword="null" />.</exception> internal ExtensionBuilder(ExtensionAssembly extensionAssembly) { if (extensionAssembly == null) { throw new ArgumentNullException("extensionAssembly"); } _extensionAssembly = extensionAssembly; }
/// <summary> /// Creates a new instance of the <see cref="FilterBuilder" /> class /// for the specified <see cref="Filter" /> class in the specified /// <see cref="ExtensionAssembly" />. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Filter" />.</param> /// <param name="className">The class representing the <see cref="Filter" />.</param> internal FilterBuilder(ExtensionAssembly extensionAssembly, string className) : base (extensionAssembly) { _className = className; // get Element name from attribute ElementNameAttribute ElementNameAttribute = (ElementNameAttribute) Attribute.GetCustomAttribute(Assembly.GetType(ClassName), typeof(ElementNameAttribute)); _filterName = ElementNameAttribute.Name; }
/// <summary> /// Scans a given <see cref="Type" /> for plugins. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="IPlugin" />; otherwise, <see langword="false" />. /// </returns> public bool ScanTypeForPlugins(ExtensionAssembly extensionAssembly, Type type, Task task) { if (type.IsAbstract) return false; try { bool isplugin = typeof(IPlugin).IsAssignableFrom(type); if (!isplugin) { return false; } PluginBuilder pb = new PluginBuilder(extensionAssembly, type); _pluginBuilders.Add(pb); return true; } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for plugins.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Creates a new instance of the <see cref="TaskBuilder" /> class /// for the specified <see cref="Task" /> class in the specified /// <see cref="ExtensionAssembly" />. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Task" />.</param> /// <param name="className">The class representing the <see cref="Task" />.</param> internal TaskBuilder(ExtensionAssembly extensionAssembly, string className) : base(extensionAssembly) { _className = className; }
/// <summary> /// Creates an <see cref="ExtensionAssembly" /> for the specified /// <see cref="Assembly" /> and caches it for future use. /// </summary> /// <remarks> /// If an <see cref="ExtensionAssembly" /> for the same assembly is /// available in the cache, then this cached instance is returned. /// </remarks> /// <param name="assembly">The <see cref="Assembly" /> for which to construct an <see cref="ExtensionAssembly" />.</param> /// <returns> /// The <see cref="ExtensionAssembly" /> for the specified <see cref="Assembly" />. /// </returns> public static ExtensionAssembly Create(Assembly assembly) { if (assembly == null) throw new ArgumentNullException ("assembly"); string aname = assembly.FullName; ExtensionAssembly ext = _extensionAssemblies [aname] as ExtensionAssembly; if (ext == null) { ext = new ExtensionAssembly (assembly); _extensionAssemblies [aname] = assembly; } return ext; }
/// <summary> /// Scans a given <see cref="Type" /> for tasks. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="Task" />; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForTasks(ExtensionAssembly extensionAssembly, Type type, Task task) { try { TaskNameAttribute taskNameAttribute = (TaskNameAttribute) Attribute.GetCustomAttribute(type, typeof(TaskNameAttribute)); if (type.IsSubclassOf(typeof(Task)) && !type.IsAbstract && taskNameAttribute != null) { task.Log(Level.Debug, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_CreatingTaskBuilder"), type.Name)); TaskBuilder tb = new TaskBuilder(extensionAssembly, type.FullName); if (TaskBuilders[tb.TaskName] == null) { task.Log(Level.Debug, string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_AddingTask"), tb.TaskName, GetAssemblyLocation(tb.Assembly), tb.ClassName)); TaskBuilders.Add(tb); } // specified type represents a task return true; } else { // specified type does not represent valid task return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for tasks.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Scans a given <see cref="Type" /> for filters. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// <see cref="Filter" />; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForFilters(ExtensionAssembly extensionAssembly, Type type, Task task) { try { ElementNameAttribute elementNameAttribute = (ElementNameAttribute) Attribute.GetCustomAttribute(type, typeof(ElementNameAttribute)); if (type.IsSubclassOf(typeof(Filter)) && !type.IsAbstract && elementNameAttribute != null) { task.Log(Level.Debug, "Creating FilterBuilder for \"{0}\".", type.Name); FilterBuilder builder = new FilterBuilder(extensionAssembly, type.FullName); if (FilterBuilders[builder.FilterName] == null) { FilterBuilders.Add(builder); task.Log(Level.Debug, "Adding filter \"{0}\" from {1}:{2}.", builder.FilterName, GetAssemblyLocation(builder.Assembly), builder.ClassName); } // specified type represents a filter return true; } // specified type does not represent a valid filter return false; } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for filters.", type.AssemblyQualifiedName); throw; } }
/// <summary> /// Scans a given <see cref="Type" /> for data type. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="Type" /> to scan.</param> /// <param name="type">The <see cref="Type" /> to scan.</param> /// <param name="task">The <see cref="Task" /> which will be used to output messages to the build log.</param> /// <returns> /// <see langword="true" /> if <paramref name="type" /> represents a /// data type; otherwise, <see langword="false" />. /// </returns> private static bool ScanTypeForDataTypes(ExtensionAssembly extensionAssembly, Type type, Task task) { try { ElementNameAttribute elementNameAttribute = (ElementNameAttribute) Attribute.GetCustomAttribute(type, typeof(ElementNameAttribute)); if (type.IsSubclassOf(typeof(DataTypeBase)) && !type.IsAbstract && elementNameAttribute != null) { logger.Info(string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_CreatingDataTypeBaseBuilder"), type.Name)); DataTypeBaseBuilder dtb = new DataTypeBaseBuilder(extensionAssembly, type.FullName); if (DataTypeBuilders[dtb.DataTypeName] == null) { logger.Debug(string.Format(CultureInfo.InvariantCulture, ResourceUtils.GetString("String_AddingDataType"), dtb.DataTypeName, GetAssemblyLocation(dtb.Assembly), dtb.ClassName)); DataTypeBuilders.Add(dtb); } // specified type represents a data type return true; } else { // specified type does not represent valid data type return false; } } catch { task.Log(Level.Error, "Failure scanning \"{0}\" for data types.", type.AssemblyQualifiedName); throw; } }
public static bool ScanAssembly(Assembly assembly, Task task) { task.Log(Level.Verbose, "Scanning assembly \"{0}\" for extensions.", assembly.GetName().Name); foreach (Type type in assembly.GetExportedTypes()) { foreach (MethodInfo methodInfo in type.GetMethods()) { if (methodInfo.IsStatic) { task.Log(Level.Verbose, "Found method {0}.", methodInfo.Name); } } } bool isExtensionAssembly = false; ExtensionAssembly extensionAssembly = new ExtensionAssembly ( assembly); Type[] types; try { types = assembly.GetTypes(); } catch(ReflectionTypeLoadException ex) { if(ex.LoaderExceptions != null && ex.LoaderExceptions.Length > 0) { throw ex.LoaderExceptions[0]; } throw; } foreach (Type type in types) { // // each extension type is exclusive, meaning a given type // cannot be both a task and data type // // so it doesn't make sense to scan a type for, for example, // data types if the type has already been positively // identified as a task // bool extensionFound = ScanTypeForTasks(extensionAssembly, type, task); if (!extensionFound) { extensionFound = ScanTypeForDataTypes(extensionAssembly, type, task); } if (!extensionFound) { extensionFound = ScanTypeForFunctions(type, task); } if (!extensionFound) { extensionFound = ScanTypeForFilters(extensionAssembly, type, task); } if (!extensionFound) { extensionFound = _pluginScanner.ScanTypeForPlugins( extensionAssembly, type, task); } // if extension is found in type, then mark assembly as // extension assembly isExtensionAssembly = isExtensionAssembly || extensionFound; } // if no extension could be found at all, then we might be dealing // with an extension assembly that was built using an older version // of NAnt(.Core) if (!isExtensionAssembly) { AssemblyName coreAssemblyName = Assembly.GetExecutingAssembly(). GetName(false); foreach (AssemblyName assemblyName in assembly.GetReferencedAssemblies()) { if (assemblyName.Name == coreAssemblyName.Name) { // the given assembly references NAnt.Core, so check whether // it doesn't reference an older version of NAnt.Core if (assemblyName.Version != coreAssemblyName.Version) { task.Log(Level.Warning, "Assembly \"{0}\" is built" + " using version {1} of NAnt. If any problems" + " arise, then try using a version that is built" + " for NAnt version {2}.", assembly.GetName().Name, assemblyName.Version, coreAssemblyName.Version); } } } } return isExtensionAssembly; }
/// <summary> /// Creates a new instance of the <see cref="DataTypeBaseBuilder" /> /// class for the specified <see cref="DataTypeBase" /> class in the /// <see cref="ExtensionAssembly" /> specified. /// </summary> /// <param name="extensionAssembly">The <see cref="ExtensionAssembly" /> containing the <see cref="DataTypeBase" />.</param> /// <param name="className">The class representing the <see cref="DataTypeBase" />.</param> internal DataTypeBaseBuilder(ExtensionAssembly extensionAssembly, string className) : base (extensionAssembly) { _className = className; }
internal PluginBuilder(ExtensionAssembly extensionAssembly, Type pluginType) : base (extensionAssembly) { _pluginType = pluginType; }
internal PluginBuilder(ExtensionAssembly extensionAssembly, Type pluginType) : base(extensionAssembly) { _pluginType = pluginType; }
/// <summary> /// Initializes a instance of the <see cref="ExtensionBuilder" /> /// class for an extension in a given <see cref="Assembly" />. /// </summary> /// <param name="assembly">The <see cref="Assembly" /> in which the extension is found.</param> /// <exception cref="ArgumentNullException"><paramref name="assembly" /> is <see langword="null" />.</exception> protected ExtensionBuilder(Assembly assembly) : this(ExtensionAssembly.Create(assembly)) { }