/// <summary>
/// Dynamically instantiates all features in a given namespaceSuffix
/// </summary>
/// <param name="assembly">Assembly containing the feature types</param>
/// <param name="namespaceSuffix">Namespace containing the feature types</param>
/// <returns>Instances of all features in the namespace with the given suffix</returns>
public static IEnumerable <CompiledFeature> LoadFeaturesFromNamespace(Assembly assembly, string namespaceSuffix)
{
var loadedFeatures = new List <CompiledFeature>();
if (assembly == null || string.IsNullOrEmpty(namespaceSuffix))
{
return(loadedFeatures);
}
var featureScope = FeatureScope.Undefined;
var featureTypes = assembly.GetTypes().Where(t => t.Namespace != null && t.Namespace.EndsWith(namespaceSuffix));
foreach (var featureType in featureTypes)
{
var featureMetadata = new CompiledFeatureMetadata
{
Name = featureType.Name,
ClassName = featureType.Name
};
try
{
var loadedFeature = CompiledFeatureFactory.GetInstance(featureScope, assembly, featureType.Namespace, featureMetadata);
loadedFeatures.Add(loadedFeature);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
}
}
return(loadedFeatures);
}
public void GetInstance_Throws_InvalidFeatureException_If_Type_Is_Not_A_Feature3()
{
var notAFeatureType = typeof(StringBuilder);
var featureMetadata = new CompiledFeatureMetadata
{
Name = "SomeName",
ClassName = notAFeatureType.Name
};
var featureScope = FeatureScope.Undefined;
var assembly = Assembly.GetAssembly(notAFeatureType);
var @namespace = notAFeatureType.Namespace;
Assert.Throws <InvalidFeatureException>(() => CompiledFeatureFactory.GetInstance(featureScope, assembly, @namespace, featureMetadata));
}
public void GetInstance_Returns_Feature_From_Assembly()
{
var featureType = typeof(AspNetMvcFeature);
var assembly = Assembly.GetAssembly(featureType);
var featureScope = FeatureScope.Project;
var @namespace = featureType.Namespace;
var featureName = "FeatureName";
var className = nameof(AspNetMvcFeature);
var metadata = new CompiledFeatureMetadata
{
Name = featureName,
ClassName = className
};
var feature = CompiledFeatureFactory.GetInstance(featureScope, assembly, @namespace, metadata);
Assert.NotNull(feature);
Assert.True(feature.Name == featureName);
Assert.True(feature.FeatureScope == featureScope);
Assert.True(feature is AspNetMvcFeature);
}
/// <summary>
/// Factory method that dynamically instantiates feature classes using assembly and class metadata
/// </summary>
/// <param name="featureScope">The scope in which to look for this feature</param>
/// <param name="assembly">Assembly containing the feature type</param>
/// <param name="namespace">Namespace containing the feature type</param>
/// <param name="featureMetadata">Metadata about the feature type</param>
/// <returns>Instance of the specified feature</returns>
public static CompiledFeature GetInstance(FeatureScope featureScope, Assembly assembly, string @namespace, CompiledFeatureMetadata featureMetadata)
{
var fullyQualifiedClassName = $"{@namespace}.{featureMetadata.ClassName}";
var featureType = assembly.GetType(fullyQualifiedClassName);
if (featureType == null)
{
throw new ClassNotFoundException(assembly, fullyQualifiedClassName);
}
try
{
var name = featureMetadata.Name;
var scope = featureScope;
var featureInstance = GetInstance(featureType, name, scope);
return(featureInstance);
}
catch (InvalidFeatureException)
{
throw new InvalidFeatureException(assembly, fullyQualifiedClassName);
}
}
