private void Application_Startup(object sender, StartupEventArgs e)
{
var assembly =
new AssemblyCatalog(Assembly.GetEntryAssembly());
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(assembly);
catalog.Catalogs.Add(new DirectoryCatalog("."));
var compositionContainer
= new CompositionContainer(catalog);
compositionContainer.ComposeParts(this);
var locator = new MefServiceLocator(compositionContainer);
ServiceLocator.SetLocatorProvider(() => locator);
ViewModelManager.ViewModelShowEvent
+= vm => ViewManager.ViewShow(vm);
ViewModelManager.ViewModelCloseEvent
+= vm => ViewManager.ViewClose(vm);
var mainWindowViewModel = new MainWindowViewModel();
compositionContainer.ComposeParts(mainWindowViewModel);
MainWindow mainWindow = new MainWindow {DataContext = mainWindowViewModel};
mainWindow.Show();
}
/// <summary>
/// This method loads the plugins.
/// </summary>
private void AssembleComponents()
{
var catalog = new AggregateCatalog();
//Note: we load not only from the plugins folder, but from this assembly as well.
var executingAssemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
if (Directory.Exists(Environment.CurrentDirectory + "\\Plugins"))
{
catalog.Catalogs.Add(new DirectoryCatalog("Plugins"));
}
catalog.Catalogs.Add(executingAssemblyCatalog);
var container = new CompositionContainer(catalog);
try
{
container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
_dialogService.ShowMessageAsync(_mainVm, "Error", string.Format("There was an error loading plugins: {0}", compositionException)).Forget();
}
}
public void TestMefStatusReportable()
{
string dir = AssemblyDirectory;
//Lets get the nlog status reportable from MEF directory..
CompositionContainer _container;
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
//Adds all the parts found in the same assembly as the Program class
catalog.Catalogs.Add(new AssemblyCatalog(typeof(TestMEF).Assembly));
catalog.Catalogs.Add(new DirectoryCatalog(AssemblyDirectory));
//Create the CompositionContainer with the parts in the catalog
_container = new CompositionContainer(catalog);
//Fill the imports of this object
try
{
_container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
reporter.Report(2,1,"Test Report");
}
/// <summary>
/// Default private constructor.
/// </summary>
private ExtensionManager()
{
if (!Config.DisableComposition)
{
// Let MEF scan for imports
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(Config.DisableCatalogSearch ? new DirectoryCatalog("Bin", "Piranha*.dll") : new DirectoryCatalog("Bin"));
#if !NET40
if (!System.Web.Compilation.BuildManager.IsPrecompiledApp)
{
#endif
try
{
// This feature only exists for Web Pages
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.Load("App_Code")));
}
catch { }
#if !NET40
}
#endif
Container = new CompositionContainer(catalog);
Container.ComposeParts(this);
}
}
public static void Main (string[] args)
{
var bootStrapper = new Bootstrapper();
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
//Adds all the parts found in same directory where the application is running!
var currentPath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetAssembly(typeof(MainClass)).Location) ?? "./";
catalog.Catalogs.Add(new DirectoryCatalog(currentPath));
//Create the CompositionContainer with the parts in the catalog
var container = new CompositionContainer(catalog);
//Fill the imports of this object
try
{
container.ComposeParts(bootStrapper);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
//Prints all the languages that were found into the application directory
var i = 0;
foreach (var language in bootStrapper.Languages)
{
Console.WriteLine("[{0}] {1} by {2}.\n\t{3}\n", language.Version, language.Name, language.Author, language.Description);
i++;
}
Console.WriteLine("It has been found {0} supported languages",i);
Console.ReadKey();
}
/// <summary>
/// Initializes the MEF Container.
/// </summary>
/// <param name="root">The root.</param>
public static void Initialize(object root)
{
if (root == null)
throw new NullReferenceException("MEF root");
if (_instance == null) {
lock (_syncRoot) {
if (_instance == null) {
string exePath = null;
string path = null;
if (Assembly.GetEntryAssembly() != null) {
exePath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
} else {
exePath = Path.GetDirectoryName(root.GetType().Assembly.Location);
}
path = Path.Combine(exePath, "\\plugins");
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
var catalog = new AggregateCatalog();
if (path != null)
catalog.Catalogs.Add(new DirectoryCatalog(path));
if (exePath != null)
catalog.Catalogs.Add(new DirectoryCatalog(exePath));
catalog.Catalogs.Add(new AssemblyCatalog(root.GetType().Assembly));
_instance = new CompositionContainer(catalog);
_instance.ComposeParts(root);
}
}
}
}
public void Start()
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(SearchDemo).Assembly));
var container = new CompositionContainer(catalog);
container.ComposeParts();
try
{
var component = container.GetExport<ITestComponent>();
if (component != null)
Console.WriteLine(component.Value.Message);
}
catch (Exception exp)
{
//Why does our call to 'GetExport' throw an exception?
//Search for the string "Test" on the container variable
//You'll find 3 instances in the Catalog.
//Then search for ITestComponent.
//You'll need to click "Search Deeper" to expand the search.
//Another way to do this is to view "container.Catalog.Parts", right click it,
//select 'Edit Filter' and enter the following predicate:
// [obj].Exports(typoef(ITestComponent)
MessageBox.Show(exp.Message, "Exception caught!");
}
}
private void Compose()
{
var container = new CompositionContainer();
// In this example we will use the MessageSender Part to fill the catalog
container.ComposeParts(this, new ConsoleMessageSender());
}
private void Bootstrap()
{
_jobModelRegistry = new ConcurrentDictionary<string, JobModel>();
_compositionContainer = new CatalogConfigurator()
.AddAssembly(Assembly.GetExecutingAssembly())
.AddNestedDirectory(Config.JobsFolderName)
.BuildContainer();
_compositionContainer.ComposeParts(this);
InitTasksRegistry();
_appContainerBuilder = new ContainerBuilder();
_appContainerBuilder.RegisterModule<WorkerModule>();
_appContainerBuilder.RegisterModule<HostingModule>();
_appContainer = _appContainerBuilder.Build();
//TODO: make onchanged to an event
_fileSystemWatcher = new JobsWatcher { OnChanged = OnChanged };
_fileSystemWatcher.Watch(TasksFolderPath);
_logger = _appContainer.Resolve<ILogger>();
_logger.Info("[START] PanteonEngine");
Task.Run(() => MountApi());
}
private bool compose()
{
try {
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new DirectoryCatalog(@".\plugins"));
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
var builder = new ContainerBuilder();
builder.Register((c, p) => new JsonGopherConfigReader(gopherRepositoryManager)).As<IConfigReader>();
Container = builder.Build(Autofac.Builder.ContainerBuildOptions.Default);
return true;
} catch (CompositionException ex) {
if (Logger != null) {
Logger.ErrorException("Unable to compose", ex);
}
System.Console.WriteLine(ex);
return false;
} catch (Exception ex) {
if (Logger != null) {
Logger.ErrorException("Unable to compose", ex);
}
System.Console.WriteLine(ex);
return false;
}
}
#pragma warning restore 649
private CodeProcessorProvider() {
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
catalog.Catalogs.Add(new DirectoryCatalog("."));
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
}
public static void MyClassInitialize(TestContext testContext)
{
// set uo IoC container to use MyRootFakeData
var container = new CompositionContainer();
container.ComposeParts(new MyRootFakeData());
CslaContrib.MEF.Ioc.InjectContainer(container);
}
public void Run()
{
CompositionContainer _CompositionContainer = new CompositionContainer(new ConfigExportProvider());
_CompositionContainer.ComposeParts(this);
CodeCamp.DataServerInterface.IDataServer _DataServer = DataServer;// new DataServer();
Person _Person = new Person();
Sponsor _Sponsor = new Sponsor();
_DataServer.Add<Sponsor>(_Sponsor);
_DataServer.Add<Person>(_Person);
_DataServer.Commit();
IQueryable<Sponsor> _Sponsors = _DataServer.GetTable<Sponsor>();
Console.WriteLine(_Sponsors.ToList().Count().ToString());
//
IQueryable<Person> _Persons = _DataServer.GetTable<Person>();
Console.WriteLine(_Persons.ToList().Count().ToString());
//modify a persom
string _NewName = "Changed:" + DateTime.Now.ToString();
_Persons.First().Name = _NewName;
_DataServer.Commit();
_Person = _DataServer.GetTable<Person>().Where(x => x.Name == _NewName).FirstOrDefault();
if (_Person == null)
throw new Exception("Person name not changed");
Console.WriteLine(_Person.Name);
Console.ReadLine();
}
/// <summary>
/// Default constructor. Creates a new extension container and registers all
/// exported objects.
/// </summary>
public ExtensionContainer()
{
var catalog = new AggregateCatalog() ;
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())) ;
Container = new CompositionContainer(catalog) ;
Container.ComposeParts(this) ;
}
public void Setup()
{
aggregateCatalog = new AggregateCatalog();
container = new CompositionContainer(aggregateCatalog);
container.ComposeParts(this);
}
public void Compose()
{
AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly());
string executionPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
string generatorsPath = Path.Combine(executionPath, "Generators");
CreatePathIfRequied(generatorsPath);
generatorsCatalog = new DirectoryCatalog(generatorsPath);
string uiPath = Path.Combine(executionPath, "UI");
CreatePathIfRequied(uiPath);
UICatalog = new DirectoryCatalog(uiPath);
AggregateCatalog catalog = new AggregateCatalog();
catalog.Catalogs.Add(generatorsCatalog);
catalog.Catalogs.Add(UICatalog);
//Set the defaults....
CatalogExportProvider mainProvider = new CatalogExportProvider(assemblyCatalog);
CompositionContainer container = new CompositionContainer(catalog, mainProvider);
mainProvider.SourceProvider = container;
var batch = new CompositionBatch();
batch.AddPart(this);
RefreshCatalog refreshCatalog = new RefreshCatalog(generatorsCatalog, UICatalog);
container.ComposeParts(refreshCatalog);
container.Compose(batch);
Logger.Write("Compose complete");
}
public LinkThumbnailScreenFactory(CompositionContainer compositionContainer,
Factories.ImageThumbnailScreenFactory imageThumbnailScreenFactory)
{
_imageThumbnailScreenFactory = imageThumbnailScreenFactory;
compositionContainer.ComposeParts(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginController"/> class.
/// </summary>
public PluginController()
{
var sensors = new AggregateCatalog();
sensors.Catalogs.Add(new AssemblyCatalog(typeof(PluginController).Assembly));
var directoryName = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase);
if (directoryName == null)
{
return;
}
var path = directoryName.Replace("file:\\", string.Empty);
{
sensors.Catalogs.Add(new DirectoryCatalog(path));
var compositonContainer = new CompositionContainer(sensors);
try
{
compositonContainer.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Debug.WriteLine(compositionException.ToString());
}
}
if (this.plugins != null)
{
this.loadedPlugins = new ReadOnlyCollection<IPlugin>(this.plugins.Select(plugin => plugin.Value).ToList());
}
if (this.menuPlugins != null)
{
this.menuCommandPlugins = new ReadOnlyCollection<IMenuCommandPlugin>(this.menuPlugins.Select(plugin => plugin.Value).ToList());
}
}
private static void Compose()
{
CompositionContainer container;
var pathToAddInns = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "AddInns");
//if (!Directory.Exists(pathToAddInns))
// Directory.CreateDirectory(pathToAddInns);
IEnumerable<DirectoryCatalog> directoryCatalogs = from i in Directory.EnumerateDirectories(pathToAddInns, "*", SearchOption.TopDirectoryOnly)
select new DirectoryCatalog(i,"*.dll");
// var catalog = new DirectoryCatalog(pathToAddInns,"*.dll");
var aggregateCatalog = new AggregateCatalog(directoryCatalogs);
container = new CompositionContainer(aggregateCatalog);
try
{
container.ComposeParts(importer);
}
catch (CompositionException compositionException)
{
}
}
public static IPlugins GetPlugins(ITranslator translator, IAssemblyInfo config)
{
string path = null;
if (!string.IsNullOrWhiteSpace(config.PluginsPath))
{
path = Path.Combine(translator.FolderMode ? translator.Location : Path.GetDirectoryName(translator.Location), config.PluginsPath);
}
else
{
path = Path.Combine(translator.FolderMode ? translator.Location : Path.GetDirectoryName(translator.Location), "Bridge" + Path.DirectorySeparatorChar + "plugins");
}
if (!System.IO.Directory.Exists(path))
{
return new Plugins() { plugins = new IPlugin[0] };
}
DirectoryCatalog dirCatalog = new DirectoryCatalog(path, "*.dll");
var catalog = new AggregateCatalog(dirCatalog);
CompositionContainer container = new CompositionContainer(catalog);
var plugins = new Plugins();
container.ComposeParts(plugins);
return plugins;
}
public ExtensionRuleStore(string path, ILogger logger)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException(Resource.ArgumentNotNullOrEmpty, "path");
}
using (var catalog = new AggregateCatalog())
{
try
{
var directoryCatalog = new DirectoryCatalog(path);
catalog.Catalogs.Add(directoryCatalog);
using (var container = new CompositionContainer(catalog))
{
container.ComposeParts(this);
}
}
catch (Exception ex)
{
if (!ExceptionHelper.IsCatchableExceptionType(ex))
{
throw;
}
RuntimeException.WrapAndLog(ex, Resource.InvalidExtensionRules + ":" + path, logger);
}
}
}
private Program()
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(typeof(Program).Assembly));
catalog.Catalogs.Add(new DirectoryCatalog(Environment.CurrentDirectory));
_container = new CompositionContainer(catalog);
try
{
_container.ComposeParts(this);
}
catch (System.Reflection.ReflectionTypeLoadException v)
{
foreach (var c in v.LoaderExceptions)
Console.WriteLine(c.ToString());
}
catch (CompositionException e) {
Console.WriteLine(e.ToString());
}
if (plugins != null)
{
foreach (var q in plugins)
{
Console.WriteLine(q.Metadata.name);
}
PluginContainer.plugins= plugins;
}
else
Console.WriteLine("No plugins loaded");
}
public void Init() {
Topic.root.Subscribe("/etc/PLC/#", L_dummy);
Topic.root.Subscribe("/etc/declarers/#", L_dummy);
string path=Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
_id=Topic.root.Get<string>("/local/cfg/id");
#region Load statements
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly()));
catalog.Catalogs.Add(new DirectoryCatalog(path));
var _container = new CompositionContainer(catalog);
try {
_container.ComposeParts(this);
}
catch(CompositionException ex) {
Log.Error("Load statements - {0}", ex.ToString());
return;
}
#endregion Load statements
foreach(var i in _statement) {
PiStatement.AddStatemen(i.Metadata.declarer, i.Value.GetType());
i.Value.Load();
}
_statement=null;
}
public void ComposeParts(object target)
{
var path = PathProvider.BinaryPath;
var directoryCatalog = new DirectoryCatalog(path);
var container = new CompositionContainer(directoryCatalog);
container.ComposeParts(target);
}
public void Initialize()
{
try
{
directoryCatalog = new DirectoryCatalog(PluginPath);
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(directoryCatalog);
container = new CompositionContainer(catalog);
container.ComposeParts(this);
}
catch (ReflectionTypeLoadException ex)
{
if (ex.LoaderExceptions.Length == 1)
{
throw ex.LoaderExceptions[0];
}
var sb = new StringBuilder();
var i = 1;
sb.AppendLine("Multiple Exception Occured Attempting to Intialize the Plugin Manager");
foreach (var exception in ex.LoaderExceptions)
{
sb.AppendLine("Exception " + i++);
sb.AppendLine(exception.ToString());
sb.AppendLine();
sb.AppendLine();
}
throw new ReflectionTypeLoadException(ex.Types, ex.LoaderExceptions, sb.ToString());
}
}
public void Initialize()
{
var catalog = new AggregateCatalog();
//Adds the program's assembly
catalog.Catalogs.Add(new AssemblyCatalog(typeof(PluginInfrastructureImports).Assembly));
string programassembly = System.Reflection.Assembly.GetAssembly(typeof(PluginInfrastructureImports)).Location;
string programpath = Path.GetDirectoryName(programassembly);
//add the program's path
catalog.Catalogs.Add(new DirectoryCatalog(programpath));
_container = new CompositionContainer(catalog);
try
{
//Initialize types found and assign new instances to Plugins
_container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
throw;
}
}
public StyleOptionsFactory()
{
var catalog = new AggregateCatalog(
new AssemblyCatalog(Assembly.GetExecutingAssembly()));
var container = new CompositionContainer(catalog);
container.ComposeParts(this);
}
public void DoImport()
{
//An aggregate catalog that combines multiple catalogs
var catalog = new AggregateCatalog();
directoryCatalog = new DirectoryCatalog(GetDirectory());
directoryCatalog.Changing += directoryCatalog_Changing;
directoryCatalog.Changed += directoryCatalog_Changed;
//Adds all the parts found in all assemblies in
//the same directory as the executing program
catalog.Catalogs.Add(directoryCatalog);
//Create the CompositionContainer with the parts in the catalog
var container = new CompositionContainer(catalog);
try
{
//Fill the imports of this object
container.ComposeParts(this);
}
catch (Exception ex)
{
Out.WriteLine("Unable to load plugins: {0}", ex.Message);
}
}
public PluginContainer()
{
var registration = new RegistrationBuilder();
registration.ForTypesDerivedFrom<BasicPlugin>()
.SetCreationPolicy(CreationPolicy.Shared)
.Export<BasicPlugin>();
bool tryAgain = true;
while (tryAgain)
{
try
{
DirectoryCatalog dircat = new DirectoryCatalog(PluginDirectory, registration);
tryAgain = false;
Container = new CompositionContainer(dircat, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe);
Container.ComposeParts();
}
catch (DirectoryNotFoundException)
{
Directory.CreateDirectory(PluginDirectory);
}
}
}
public void LoadPlugins(IEnumerable<ComposablePartCatalog> catalogs = null)
{
var catalog = new AggregateCatalog();
catalog.Catalogs.Add(new AssemblyCatalog(GetType().Assembly));
if (catalogs != null)
{
foreach (var additionalCatalog in catalogs)
{
catalog.Catalogs.Add(additionalCatalog);
}
}
//Create the CompositionContainer with the parts in the catalog
Container = new CompositionContainer(catalog);
//Fill the imports of this object
try
{
Container.ComposeParts(this);
}
catch (CompositionException compositionException)
{
Console.WriteLine(compositionException.ToString());
}
}
public static void ComposeParts(params object[] attributedParts)
{
lock (syncRoot)
{
try
{
container.ComposeParts(attributedParts);
}
catch (CompositionException compositionException)
{
Debug.WriteLine(compositionException.ToString());
throw;
}
}
}
