public void SatisfyImportsOnce(ComposablePart part) { if (this.DoNothingOnSatisfyImportsOnce) { return; } CompositionBatch batch = new CompositionBatch(); // We only want to include the standard exports and parts to compose in the first composition if (!this.alreadyComposed) { foreach (object instance in this.PartsToCompose) { batch.AddPart(instance); } foreach (Export export in this.ExportsToCompose) { batch.AddExport(export); } } if (part != null) { batch.AddPart(part); } this.container.Compose(batch); this.alreadyComposed = true; }
public void Compose(BaseParameters parameters) { try { var catalog = new AggregateCatalog(new AssemblyCatalog(Assembly.GetExecutingAssembly()), new AssemblyCatalog(typeof(Logic.SanityCheck).Assembly)); LoadPlugins(catalog, parameters); var container = new CompositionContainer(catalog); var batch = new CompositionBatch(); batch.AddPart(this); batch.AddPart(parameters); var config = new Configuration(parameters.FileSystem, parameters.Path); config.ReadFromFile(); batch.AddExportedValue((IConfiguration)config); container.Compose(batch); } catch (ReflectionTypeLoadException ex) { Console.WriteLine(@"Unable to load: \r\n{0}", string.Join("\r\n", ex.LoaderExceptions.Select(e => e.Message))); throw; } }
private static void ComposeBatchTwo(CompositionContainer container) { var batch = new CompositionBatch(); batch.RemovePart(a); c = batch.AddPart(new PluginC()); batch.AddPart(logger); container.Compose(batch); }
static void Main() { // important to call these before creating application host Application.EnableVisualStyles(); Application.DoEvents(); // see http://www.codeproject.com/buglist/EnableVisualStylesBug.asp?df=100&forumid=25268&exp=0&select=984714 // Set up localization support early on, so that user-readable strings will be localized // during the initialization phase below. Use XML files that are embedded resources. Thread.CurrentThread.CurrentUICulture = System.Globalization.CultureInfo.CurrentCulture; Localizer.SetStringLocalizer(new EmbeddedResourceStringLocalizer()); // Create a catalog with all the components that make up the application, except for // our MainForm. var catalog = new TypeCatalog( typeof(SettingsService), // persistent settings and user preferences dialog typeof(CommandService), // handles commands in menus and toolbars typeof(AtfUsageLogger), // logs computer info to an ATF server typeof(CrashLogger), // logs unhandled exceptions to an ATF server typeof(UnhandledExceptionService), // catches unhandled exceptions, displays info, and gives user a chance to save typeof(StandardFileExitCommand), // standard File exit menu command typeof(HelpAboutCommand), // Help -> About command typeof(FolderViewer), // manages TreeControl to display folder hierarchy typeof(FileViewer), // managed ListView to display last selected folder contents typeof(NameDataExtension), // extension to display file name typeof(SizeDataExtension), // extension to display file size typeof(CreationTimeDataExtension), // extension to display file creation time typeof(UserFeedbackService), // component to send feedback form to SHIP typeof(VersionUpdateService), // component to update to latest version on SHIP typeof(PythonService), // scripting service for automated tests typeof(ScriptConsole), // provides a dockable command console for entering Python commands typeof(AtfScriptVariables), // exposes common ATF services as script variables typeof(AutomationService) // provides facilities to run an automated script using the .NET remoting service ); var container = new CompositionContainer(catalog); // manually add the MainForm var batch = new CompositionBatch(); var mainForm = new MainForm { Icon = GdiUtil.CreateIcon(ResourceUtil.GetImage(Sce.Atf.Resources.AtfIconImage)) }; // our custom main Form with SplitContainer batch.AddPart(mainForm); batch.AddPart(new WebHelpCommands("https://github.com/SonyWWS/ATF/wiki/ATF-File-Explorer-Sample".Localize())); container.Compose(batch); // initialize all components which require it container.InitializeAll(); Application.Run(mainForm); container.Dispose(); }
private static void ComposeBatchOne(CompositionContainer container) { var batch = new CompositionBatch(); a = batch.AddPart(new PluginA()); b = batch.AddPart(new PluginB()); batch.AddPart(bootstrapper); container.Compose(batch); }
public void FunctionsFieldsAndProperties2() { Consumer c; var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(new SubtractProvider()); batch.AddPart(c = new Consumer()); container.Compose(batch); Assert.AreEqual(-1, c.op(c.a, c.b), "1 - 2 == -1"); }
public App() { var catalog = new AggregateCatalog(new DirectoryCatalog(Path.GetDirectoryName(typeof(App).Assembly.Location)), new AssemblyCatalog(typeof(App).Assembly)); _container = new CompositionContainer(catalog); var batch = new CompositionBatch(); batch.AddPart(ExistingComposablePart.Create<ExportProvider>(_container)); batch.AddPart(ExistingComposablePart.Create(_container)); _container.Compose(batch); }
public void PrivateFromPublic() { var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); var importer = new AllPrivateImportOnly(); batch.AddPart(importer); batch.AddPart(new AllPublicExportOnly() { ExportA = 5, ExportB = 10 }); container.Compose(batch); Assert.AreEqual(5, importer.PublicImportA); Assert.AreEqual(10, importer.PublicImportB); }
public void ImportSingleToInternal() { var container = ContainerFactory.Create(); var importer = new Int32ImporterInternal(); var exporter = new Int32Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter); container.Compose(batch); Assert.AreEqual(42, importer.Value, "Expecting value to be imported"); }
public void ConstructorInjectionCycle() { var container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(new ConstructorInjectionComposablePart(typeof(AClass))); batch.AddPart(new ConstructorInjectionComposablePart(typeof(BClass))); CompositionAssert.ThrowsErrors(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ImportEngine_PartCannotSetImport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void ImportTest() { var exporter = new TestExportBinder(); var importer = new TestImportBinder(); CompositionContainer container = ContainerFactory.Create(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter); container.Compose(batch); ExportsAssert.AreEqual(importer.SetImports["single"], 42); ExportsAssert.AreEqual(importer.SetImports["multi"], 1, 2, 3); }
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"); }
/// <summary> /// Initialises a new instance of the <see cref="MainForm"/> class. /// </summary> public MainForm() { this.InitializeComponent(); var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new DirectoryCatalog("..\\..\\Crypto", "*.dll")); var batch = new CompositionBatch(); batch.AddPart(this); this.compositionContainer = new CompositionContainer(catalog); ////get all the exports and load them into the appropriate list tagged with the importmany this.compositionContainer.Compose(batch); this.CryptoAlgorithmComboBox.DataSource = (new List<CryptoAlgorithm> { CryptoAlgorithm.None }).Union( this.CryptoProviders.Select(c => c.Metadata.Algorithm).Distinct()).ToList(); this.JoinedUsers = new BindingList<User>(); this.ConnectedUsersDataGridView.DataSource = this.JoinedUsers; this.userProxy = new UserServiceClient(new InstanceContext(this)); this.userProxy.Open(); this.messagingProxy = new MessagingServiceClient(new InstanceContext(this)); this.messagingProxy.Open(); this.userProxy.Subscribe(); foreach (var u in this.userProxy.GetJoinedUsers()) { this.AddUser(u); } this.uiSyncContext = SynchronizationContext.Current; }
private void Compose() { var container = new CompositionContainer(directories); var batch = new CompositionBatch(); batch.AddPart(this); container.Compose(batch); }
public void FunctionsFieldsAndProperties2_WithCatalog() { var container = ContainerFactory.CreateWithDefaultAttributedCatalog(); ConsumerOfMultiple c = new ConsumerOfMultiple(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(c); container.Compose(batch); foreach (var export in c.opInfo) { if ((string)export.Metadata["Var1"] == "add") { Assert.AreEqual(3, export.Value(1, 2), "1 + 2 == 3"); } else if ((string)export.Metadata["Var1"] == "sub") { Assert.AreEqual(-1, export.Value(1, 2), "1 - 2 == -1"); } else { Assert.Fail("Unexpected value"); } } }
/// <summary> /// Will satisfy the imports on a object instance based on a <see cref="CompositionContainer"/> /// registered with the <see cref="CompositionHost"/>. By default if no <see cref="CompositionContainer"/> /// is registered the first time this is called it will be initialized to a catalog /// that contains all the assemblies in the entry assembly folder, plus, optionally, an Extensions folder. /// </summary> /// <param name="attributedPart"> /// Object instance that contains <see cref="ImportAttribute"/>s that need to be satisfied. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="attributedPart"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="attributedPart"/> contains <see cref="ExportAttribute"/>s applied on its type. /// </exception> /// <exception cref="ChangeRejectedException"> /// One or more of the imports on the object instance could not be satisfied. /// </exception> /// <exception cref="CompositionException"> /// One or more of the imports on the object instance caused an error while composing. /// </exception> public static void SatisfyImports(object attributedPart) { if (attributedPart == null) { throw new ArgumentNullException("attributedPart"); } var batch = new CompositionBatch(); var part = batch.AddPart(attributedPart); if (part.ExportDefinitions.Any()) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, ExceptionStrings.ArgumentException_TypeHasExports, attributedPart.GetType().FullName), "attributedPart"); } CompositionContainer container; // Ignoring return value because we don't need to know if we created it or not CompositionHost.TryGetOrCreateContainer(createContainer, out container); lock (locker) { container.Compose(batch); } }
private bool Compose() { var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new AssemblyCatalog(Assembly.GetExecutingAssembly())); //catalog.Catalogs.Add(new AssemblyCatalog(typeof(IEmailService).Assembly)); _container = new CompositionContainer(catalog); var batch = new CompositionBatch(); batch.AddPart(this); #if DEBUG _container.Compose(batch); #else try { _container.Compose(batch); } catch (CompositionException compositionException) { MessageBox.Show(compositionException.ToString()); Shutdown(1); return false; } #endif return true; }
/// <summary> /// Will satisfy the imports on a object instance based on a <see cref="CompositionContainer"/> /// registered with the <see cref="CompositionHost"/>. By default if no <see cref="CompositionContainer"/> /// is registered the first time this is called it will be initialized to a catalog /// that contains all the assemblies loaded by the initial application XAP. /// </summary> /// <param name="instance"> /// Object instance that contains <see cref="ImportAttribute"/>s that need to be satisfied. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="instance"/> is <see langword="null"/>. /// </exception> /// <exception cref="ArgumentException"> /// <paramref name="instance"/> contains <see cref="ExportAttribute"/>s applied on its type. /// </exception> /// <exception cref="ChangeRejectedException"> /// One or more of the imports on the object instance could not be satisfied. /// </exception> /// <exception cref="CompositionException"> /// One or more of the imports on the object instance caused an error while composing. /// </exception> public static void SatisfyImports(object instance) { if (instance == null) { throw new ArgumentNullException("instance"); } var batch = new CompositionBatch(); var attributedPart = batch.AddPart(instance); if (attributedPart.ExportDefinitions.Any()) { throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, "Cannot call SatisfyImports on a object of type '{0}' because it is marked with one or more ExportAttributes.", instance.GetType().FullName), "instance"); } CompositionContainer container = null; // Ignoring return value because we don't need to know if we created it or not CompositionHost.TryGetOrCreateContainer(_createContainer, out container); container.Compose(batch); }
public void ImportValues() { var container = ContainerFactory.Create(); Importer importer = new Importer(); Exporter exporter42 = new Exporter(42); CompositionBatch batch = new CompositionBatch(); batch.AddPart(importer); batch.AddPart(exporter42); CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () => { container.Compose(batch); }); }
public void GetValuesByType() { var cat = CatalogFactory.CreateDefaultAttributed(); var container = new CompositionContainer(cat); string itestName = AttributedModelServices.GetContractName(typeof(ITest)); var e1 = container.GetExportedValues<ITest>(); var e2 = container.GetExports<ITest, object>(itestName); Assert.IsInstanceOfType(e1.First(), typeof(T1), "First should be T1"); Assert.IsInstanceOfType(e1.Skip(1).First(), typeof(T2), "Second should be T2"); Assert.IsInstanceOfType(e2.First().Value, typeof(T1), "First should be T1"); Assert.IsInstanceOfType(e2.Skip(1).First().Value, typeof(T2), "Second should be T2"); CompositionContainer childContainer = new CompositionContainer(container); CompositionBatch batch = new CompositionBatch(); batch.AddPart(new T1()); container.Compose(batch); var t1 = childContainer.GetExportedValue<ITest>(); var t2 = childContainer.GetExport<ITest, object>(itestName); Assert.IsInstanceOfType(t1, typeof(T1), "First (resolved) should be T1"); Assert.IsInstanceOfType(t2.Value, typeof(T1), "First (resolved) should be T1"); }
public void ConventionCatalog_should_support_type_exports() { var registry = new PartRegistry(); registry.TypeScanner = new AssemblyTypeScanner(Assembly.GetExecutingAssembly()); registry .Part() .ForType<SampleExport>() .Export(); var catalog = new ConventionCatalog(registry); var instance = new ConventionPart<SampleExport>(); var batch = new CompositionBatch(); batch.AddPart(instance); var container = new CompositionContainer(catalog); container.Compose(batch); instance.Imports.Count().ShouldEqual(1); }
private bool Compose() { var catalog = new AggregateCatalog(); catalog.Catalogs.Add(new AssemblyCatalog(typeof(IMefShapesGame).Assembly)); catalog.Catalogs.Add(new AssemblyCatalog(typeof(DefaultDimensions).Assembly)); var partCreatorEP = new DynamicInstantiationExportProvider(); this._container = new CompositionContainer(catalog, partCreatorEP); partCreatorEP.SourceProvider = this._container; CompositionBatch batch = new CompositionBatch(); batch.AddPart(this); batch.AddExportedValue<ICompositionService>(this._container); batch.AddExportedValue<AggregateCatalog>(catalog); try { this._container.Compose(batch); } catch (CompositionException compositionException) { MessageBox.Show(compositionException.ToString()); Shutdown(1); return false; } return true; }
public RestServer(ushort port) : base(port) { this.HttpRequestReceived += new EventHandler<HttpServerEventArgs>(RestServer_RequestReceived); batch = new CompositionBatch(); batch.AddPart(this); }
public void DualContainers() { var container1 = new CompositionContainer(); TypeDescriptorServices dat1 = new TypeDescriptorServices(); CompositionBatch batch = new CompositionBatch(); batch.AddPart(dat1); container1.Compose(batch); MetadataStore.AddAttribute( typeof(DynamicMetadataTestClass), ( type, attributes) => Enumerable.Concat( attributes, new Attribute[] { new TypeConverterAttribute(typeof(DynamicMetadataTestClassConverter)) } ), container1 ); var container2 = new CompositionContainer(); CompositionBatch batch2 = new CompositionBatch(); TypeDescriptorServices dat2 = new TypeDescriptorServices(); batch2.AddPart(dat2); container2.Compose(batch2); DynamicMetadataTestClass val = DynamicMetadataTestClass.Get("42"); var attached1 = dat1.GetConverter(val.GetType()); Assert.IsTrue(attached1.CanConvertFrom(typeof(string)), "The new type converter for DynamicMetadataTestClass should support round tripping"); var attached2 = dat2.GetConverter(val.GetType()); Assert.IsFalse(attached2.CanConvertFrom(typeof(string)), "The default type converter for DynamicMetadataTestClass shouldn't support round tripping"); }
private void OnComponentRegistrationOnActivated(object sender, ActivatedEventArgs<object> activation_event) { // compose by batch to allow for recomposition var batch = new CompositionBatch(); batch.AddPart(activation_event.Instance); _mefContainer.Compose(batch); }
private bool Compose() { var catalog = new System.ComponentModel.Composition.Hosting.AggregateCatalog(); // var catalog = new AggregatingComposablePartCatalog(); catalog.Catalogs.Add( new RubyCatalog(new RubyPartFile("calculator_ops.rb"))); catalog.Catalogs.Add( new AssemblyCatalog(Assembly.GetExecutingAssembly())); _container = new System.ComponentModel.Composition.Hosting.CompositionContainer(catalog); //_container. AddPart(this); var batch = new System.ComponentModel.Composition.Hosting.CompositionBatch(); batch.AddPart(this); //_container.AddPart(this); //_container.Compose(this); try { _container.Compose(batch); } catch (CompositionException compositionException) { MessageBox.Show(compositionException.ToString()); return false; } return true; }
public void SingleContainerPartReplacement() { var container = ContainerFactory.Create(); var importPart = PartFactory.CreateImporter(true, "value1", "value2"); CompositionBatch batch = new CompositionBatch(); var export1Key = batch.AddExportedValue("value1", "Hello"); batch.AddExportedValue("value2", "World"); batch.AddPart(importPart); container.Compose(batch); Assert.AreEqual(2, importPart.ImportSatisfiedCount); Assert.AreEqual("Hello", importPart.GetImport("value1")); Assert.AreEqual("World", importPart.GetImport("value2")); importPart.ResetImportSatisfiedCount(); batch = new CompositionBatch(); batch.RemovePart(export1Key); batch.AddExportedValue("value1", "Goodbye"); container.Compose(batch); Assert.AreEqual(1, importPart.ImportSatisfiedCount); Assert.AreEqual("Goodbye", importPart.GetImport("value1")); Assert.AreEqual("World", importPart.GetImport("value2")); }
public Runner Init(IFeedbackProvider feedbackProvider, string[] args) { var catalog = new AggregateCatalog(new AssemblyCatalog(typeof(Bootstrapper).Assembly)); var currentDir = Environment.CurrentDirectory; var assemblyDir = new FileInfo(new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath).Directory.FullName; var paths = new string[] { assemblyDir, Path.Combine(assemblyDir, "Tasks"), currentDir, Path.Combine(currentDir, "Tasks") }.Unique(); var dirCatalogs = paths.Where(x => Directory.Exists(x)) .Select(x => new DirectoryCatalog(x, "*.Tasks.dll")); dirCatalogs.Apply(x => catalog.Catalogs.Add(x)); var container = new CompositionContainer(catalog); var parsed = new ArgumentParser().Parse(args); var runner = new Runner(parsed.ActualArgs.ToArray()); var batch = new CompositionBatch(); batch.AddExportedValue<IFeedbackProvider>(feedbackProvider); parsed.Options.Apply(x => batch.AddExportedValue<string>(x.Item1, x.Item2)); parsed.Switches.Apply(x => batch.AddExportedValue<bool>(x, true)); batch.AddPart(runner); container.Compose(batch); return runner; }
public static void Compose(object o) { var container = new CompositionContainer(new DirectoryCatalog(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin"))); var batch = new CompositionBatch(); batch.AddPart(o); container.Compose(batch); }
private void LoadExtensions() { var location = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var catalog = new DirectoryCatalog(location + "\\Extensions\\"); var container = new CompositionContainer(catalog); var batch = new CompositionBatch(); batch.AddPart(this); container.Compose(batch); }