/// <summary>
/// Searches for extensions in a particular file and tries to load them.
/// </summary>
/// <param name="file">The file to load.</param>
/// <param name="extension">The extension that the file contains</param>
/// <returns>Returns an array of loading results, indicating which extension loaded succesfully and which didn't.</returns>
public ExtensionLoadResult[] LoadExtensions(ExtensionLibraryData file)
{
try
{
if (LoadedExtensions.FirstOrDefault(x => x.GetType().Assembly.Location.Equals(file.GetAbsolutePath(), StringComparison.OrdinalIgnoreCase)) != null)
{
throw new InvalidOperationException("The extension library is already loaded.");
}
var extensionTypes = SearchExtensionTypes(file);
if (extensionTypes.Length == 0)
{
throw new BadImageFormatException(string.Format("No extension classes found in file {0}", file));
}
var results = new ExtensionLoadResult[extensionTypes.Length];
for (int i = 0; i < extensionTypes.Length; i++)
{
results[i] = LoadExtension(extensionTypes[i]);
}
return(results);
}
catch (Exception ex)
{
return(new ExtensionLoadResult[] { new ExtensionLoadResult(file.GetAbsolutePath(), ex) });
}
}
/// <summary>
/// Adds all assemblies in a folder to LoadedExtensions.
/// </summary>
/// <param name="folderPath">Full path of folder to load from</param>
public static void AddAllAssembliesInPath(string folderPath)
{
DirectoryInfo di = new DirectoryInfo(folderPath);
FileInfo[] files = di.GetFiles("*", SearchOption.TopDirectoryOnly);
foreach (FileInfo file in files)
{
try
{
Assembly assem = Assembly.LoadFile(file.FullName);
LoadedExtensions.Add(assem);
}
catch (FileLoadException)
{
continue;
}
catch (FileNotFoundException)
{
continue;
}
catch (BadImageFormatException)
{
continue;
}
}
}
/// <summary>
/// Load all Plugins
/// </summary>
public void LoadExtensions()
{
List <Assembly> assemblies = new List <Assembly>();
var tempAssembly = Assembly.GetEntryAssembly();
if (tempAssembly == null)
{
tempAssembly = Assembly.GetAssembly(GetType());
}
DirectoryInfo dir = new DirectoryInfo(Path.GetDirectoryName(tempAssembly.Location));
assemblies.AddRange(LoadAssemblies(dir));
DirectoryInfo plugins = new DirectoryInfo(Path.Combine(dir.FullName, "plugins"));
if (plugins.Exists)
{
assemblies.AddRange(LoadAssemblies(plugins));
}
var disabledExtensions = settings.KeyExists(SETTINGSKEY) ? settings.GetArray <string>(SETTINGSKEY) : new string[0];
List <Type> result = new List <Type>();
foreach (var assembly in assemblies)
{
foreach (var type in assembly.GetTypes())
{
if (!typeof(IExtension).IsAssignableFrom(type))
{
continue;
}
try
{
IExtension extension = (IExtension)Activator.CreateInstance(type);
extension.Register(this);
if (disabledExtensions.Contains(type.FullName))
{
LoadedExtensions.Add(extension);
}
else
{
ActiveExtensions.Add(extension);
}
}
catch (Exception)
{
// TODO: Logging
}
}
}
}
/// <summary>
/// Tries to create a LiteExtension instance of the specified type.
/// </summary>
/// <param name="extensionType">The type to create the instance from.</param>
/// <returns>Returns an instance of an ExtensionLoadResult indicating whenever the extension is loaded or not.</returns>
public ExtensionLoadResult LoadExtension(Type extensionType)
{
try
{
var extension = Activator.CreateInstance(extensionType) as LiteExtension;
LoadedExtensions.Add(extension);
extension.Initialize(_extensionHost);
return(new ExtensionLoadResult(extensionType, extension));
}
catch (Exception ex)
{
return(new ExtensionLoadResult(extensionType, ex));
}
}
public IEnumerable <IAnalogyExtension> GetExtensions()
{
if (LoadedExtensions.Any())
{
return(LoadedExtensions);
}
NameValueCollection appSettings = ConfigurationManager.AppSettings;
List <string> files = appSettings["AssembliesToLoad"]
.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList();
string dir = Environment.CurrentDirectory;
Type isExtension = typeof(IAnalogyExtension);
List <Type> res = new List <Type>();
files.AddRange(Directory.GetFiles(dir, "Analogy.*.Extension.dll"));
foreach (var file in files)
{
var fileToload = Path.Combine(dir, file);
if (!File.Exists(fileToload))
{
Log.LogError("Analogy", $"{file} does not exist. Skipping");
continue;
}
try
{
var assm = Assembly.LoadFrom(fileToload).GetTypes()
.Where(t => t.GetInterfaces().Any(i => i.Name.Equals(isExtension.Name))).ToList();
res.AddRange(assm);
}
catch (Exception ex)
{
Log.LogError("Analogy", $"Error for:{file}: {ex.Message}");
}
}
foreach (Type type in res)
{
try
{
IAnalogyExtension control = (IAnalogyExtension)Activator.CreateInstance(type);
LoadedExtensions.Add(control);
}
catch (Exception exception)
{
Log.LogError("Analogy", $"Error for:{type.Name}: {exception.Message}");
}
}
return(LoadedExtensions);
}
public ExtensionLoadResult LoadExtension(Type extensionType)
{
try
{
var extension = Activator.CreateInstance(extensionType) as LiteExtension;
LoadedExtensions.Add(extension);
extension.Initialize(new ExtensionInitializationContext(LiteDevelopApplication.Current.IsInitialized ? InitializationTime.UserLoad : InitializationTime.Startup));
return(new ExtensionLoadResult(extensionType, extension));
}
catch (Exception ex)
{
return(new ExtensionLoadResult(extensionType, ex));
}
}
public T GetLoadedExtension <T>() where T : LiteExtension
{
return(LoadedExtensions.FirstOrDefault(x => x is T) as T);
}
public LiteExtension GetLoadedExtension(Type extensionType)
{
return(LoadedExtensions.FirstOrDefault(x => x.GetType() == extensionType));
}
private void LoadDefaultExtensions()
{
// Load the default extension
LoadedExtensions.Add(new DefaultExtension());
}
