private void Add(ConcurrentDictionary <Type, List <IExtension> > extensions, IExtension extension)
{
Trace.Verbose($"Registering extension: {extension.GetType().FullName}");
List <IExtension> list = extensions.GetOrAdd(extension.ExtensionType, new List <IExtension>());
extension.Initialize(HostContext);
list.Add(extension);
}
public void Initialize(IExtension extension)
{
extension.Initialize();
if (extension.IsRunning && !_extensionsRunning.Contains(extension))
{
_extensionsRunning.Add(extension);
}
}
// Called when an extension node is added or removed
private void OnExtensionChanged(object s, ExtensionNodeEventArgs args)
{
IExtension extension = (IExtension)args.ExtensionObject;
if (args.Change == ExtensionChange.Add)
{
extension.Initialize();
}
else
{
extension.Uninitialize();
}
}
private static void InitializeExtensions()
{
IEnumerable <Type> types = Assembly.GetExecutingAssembly().GetTypes()
.Where(t => typeof(IExtension).IsAssignableFrom(t) && t.IsClass);
foreach (Type type in types)
{
try
{
IExtension instance = (IExtension)Activator.CreateInstance(type);
instance?.Initialize();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
}
/// <summary>
/// Loads the extensions.
/// </summary>
/// <exception cref="ConfigurationItemMissingException"></exception>
/// <exception cref="InvalidExtensionException">
/// </exception>
public void LoadExtensions()
{
IConfigurationSection[] extensionConfigurations = _config.GetSections(EXTENSION_CONFIGURATION_KEY).ToArray();
if (extensionConfigurations.Length == 0)
{
return;
}
HashSet <IExtension> extensions = new HashSet <IExtension>();
foreach (IConfigurationSection extensionConfiguration in extensionConfigurations)
{
string name = extensionConfiguration.Key;
string path = _config.Get($"{extensionConfiguration.Path}:path");
_logger.Debug($"Loading extension: {name}");
if (string.IsNullOrEmpty(path) || !File.Exists(path))
{
throw new ConfigurationItemMissingException($"{extensionConfiguration.Path}:path");
}
LoadAssembly(path, name);
}
foreach (var extensionType in _extensionTypes)
{
IExtension extension = Activator.CreateInstance(extensionType.Key.AsType(), extensionType.Value, _dependencyUtility) as IExtension;
if (extension == null)
{
throw new InvalidExtensionException(extensionType.Value, extensionType.Key.AssemblyQualifiedName);
}
extension.Initialize();
extensions.Add(extension);
}
Extensions = extensions;
}
public bool Initialize(TextWriter writer)
{
byte[] moduleData;
try
{
moduleData = File.ReadAllBytes(ModuleFilename);
}
catch (Exception ex)
{
writer.WriteLine($"Impossible to load file '{ModuleFilename}'");
writer.WriteLine(ex);
return(false);
}
try
{
Assembly = Assembly.Load(moduleData);
}
catch (Exception ex)
{
writer.WriteLine($"Impossible to load assembly '{ModuleFilename}'");
writer.WriteLine(ex);
return(false);
}
Type extensionType = typeof(IExtension);
IEnumerable <Type> types = Assembly.GetTypes()
.Where(x => extensionType.IsAssignableFrom(x))
.Where(x => x.IsAbstract == false);
var extensions = new List <ExtensionContainer>();
foreach (Type type in types)
{
IExtension ext = null;
try
{
ext = (IExtension)Activator.CreateInstance(type);
}
catch (Exception ex)
{
writer.WriteLine($"Impossible to load extention '{type.FullName}' from file '{ModuleFilename}'");
writer.WriteLine(ex);
continue;
}
try
{
ext.Initialize(ModuleFilename);
}
catch (Exception ex)
{
writer.WriteLine($"Extension '{ext.Name}' version '{ext.Version}' failed to initialize");
writer.WriteLine(ex);
continue;
}
extensions.Add(new ExtensionContainer(ext));
}
Extensions = extensions.ToArray();
return(extensions.Count > 0);
}