/// <summary> /// Initializes a new instance of the <see cref="GenericCatalog"/> class. /// </summary> /// <param name="catalog"><see cref="ComposablePartCatalog"/> from which <see cref="IGenericContractRegistry"/> instances will be retrieved.</param> /// <param name="registries">Additional registries.</param> public GenericCatalog(ComposablePartCatalog catalog, params IGenericContractRegistry[] registries) { var cfg = new InterceptionConfiguration() .AddHandler(new GenericExportHandler(registries)); this.interceptingCatalog = new InterceptingCatalog(catalog, cfg); }
static void Main(string[] args) { InterceptionConfiguration cfg = new InterceptionConfiguration() .AddInterceptor(new DynamicProxyInterceptor(new LoggingInterceptor())); //GenericTypeCatalog typeCatalog = new GenericTypeCatalog(typeof(GenericClass<int>), typeof(IGenericInterface<>)); //AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); //AggregateCatalog aggregateCatalog = new AggregateCatalog(assemblyCatalog, typeCatalog); //GenericCatalog genericCatalog = new GenericCatalog(aggregateCatalog); //InterceptingCatalog interceptingCatalog = new InterceptingCatalog(genericCatalog, cfg); //CompositionContainer container = new CompositionContainer(interceptingCatalog); // GenericContractTypeMapping mapping = new GenericContractTypeMapping(typeof(IGenericInterface<>), typeof(GenericClass<>)); TypeCatalog typeCatalog = new TypeCatalog(typeof(SampleClass), typeof(OrderProcessor), typeof(CtorOrderProcessor)); AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); GenericCatalog genericCatalog = new GenericCatalog(new TestGenericContractRegistry()); AggregateCatalog aggregateCatalog = new AggregateCatalog(typeCatalog, genericCatalog); //CompositionContainer container = new CompositionContainer(aggregateCatalog); CompositionContainer container = new CompositionContainer(aggregateCatalog); var orderProcessor = container.GetExportedValue <OrderProcessor>(); var generic = container.GetExportedValue <IGenericInterface <string> >(); CatalogExportProvider provider = new CatalogExportProvider(aggregateCatalog); provider.SourceProvider = provider; var instance = provider.GetExportedValue <ISampleInterface>();//container.GetExportedValue<ISampleInterface>(); instance.Method1("test", 5); var genericInstance = provider.GetExportedValue <OrderProcessor>();//container.GetExportedValue<IGenericInterface<int>>(); //var orderProcessor = provider.GetExportedValue<CtorOrderProcessor>(); }
public void When_removing_a_part_from_the_intercepted_catalog_intercepting_catalog_is_recomposed_and_removes_that_part() { var innerCatalog1 = new TypeCatalog(typeof(RecomposablePart1), typeof(RecomposablePartImporter)); var innerCatalog2 = new TypeCatalog(typeof(RecomposablePart2)); var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor()); var aggregateCatalog = new AggregateCatalog(innerCatalog1, innerCatalog2); var catalog = new InterceptingCatalog(aggregateCatalog, cfg); container = new CompositionContainer(catalog); var importer = container.GetExportedValue <RecomposablePartImporter>(); Assert.That(importer, Is.Not.Null); Assert.That(importer.Parts, Is.Not.Null); Assert.That(importer.Parts.Length, Is.EqualTo(2)); Assert.That(importer.Parts[0].Count, Is.EqualTo(1)); Assert.That(importer.Parts[1].Count, Is.EqualTo(1)); Assert.That(catalog.Parts.Count(), Is.EqualTo(3)); // Recompose aggregateCatalog.Catalogs.Remove(innerCatalog2); Assert.That(importer, Is.Not.Null); Assert.That(importer.Parts, Is.Not.Null); Assert.That(importer.Parts.Length, Is.EqualTo(1)); Assert.That(importer.Parts[0].Count, Is.EqualTo(1)); Assert.That(catalog.Parts.Count(), Is.EqualTo(2)); }
public void When_removing_existing_part_from_the_part_handler_intercepting_catalog_is_recomposed_and_removes_that_part() { var partHandler = new RecomposablePartHandler(); var part2Catalog = new TypeCatalog(typeof(RecomposablePart2)); var innerCatalog = new TypeCatalog(typeof(RecomposablePartImporter), typeof(RecomposablePart1)); var aggregateCatalog = new AggregateCatalog(innerCatalog, part2Catalog); var cfg = new InterceptionConfiguration() .AddInterceptor(new RecomposablePartInterceptor()) .AddHandler(partHandler); var catalog = new InterceptingCatalog(aggregateCatalog, cfg); container = new CompositionContainer(catalog); var importer = container.GetExportedValue <RecomposablePartImporter>(); Assert.That(importer, Is.Not.Null); Assert.That(importer.Parts, Is.Not.Null); Assert.That(importer.Parts.Length, Is.EqualTo(2)); Assert.That(importer.Parts[0].Count, Is.EqualTo(1)); Assert.That(importer.Parts[1].Count, Is.EqualTo(1)); Assert.That(catalog.Parts.Count(), Is.EqualTo(3)); Assert.That(catalog.Parts.OfType <InterceptingComposablePartDefinition>().Count(), Is.EqualTo(3)); // Recompose partHandler.RemoveParts(part2Catalog); Assert.That(importer, Is.Not.Null); Assert.That(importer.Parts, Is.Not.Null); Assert.That(importer.Parts.Length, Is.EqualTo(1)); Assert.That(importer.Parts[0].Count, Is.EqualTo(1)); Assert.That(importer.Parts[0].GetType(), Is.EqualTo(typeof(RecomposablePart1))); Assert.That(catalog.Parts.Count(), Is.EqualTo(2)); Assert.That(catalog.Parts.OfType <InterceptingComposablePartDefinition>().Count(), Is.EqualTo(2)); }
public void Adding_interception_criteria_is_reflected_in_the_InterceptionCriteria_collection() { var cfg = new InterceptionConfiguration() .AddInterceptionCriteria(new PredicateInterceptionCriteria(new FakeInterceptor(), part => true)); Assert.That(cfg.InterceptionCriteria.Count(), Is.EqualTo(1)); Assert.That(cfg.InterceptionCriteria.OfType <PredicateInterceptionCriteria>().Any()); }
public MefBuilder(IContainerBuilder builder, ComposablePartCatalog catalog) { var cfg = new InterceptionConfiguration(); builder.ObjectSource.CreationInterceptors.ForEach(i => cfg.AddInterceptor(new CreationInterceptor(i))); cfg.AddInterceptor(new ProxyObjectInterceptor(builder.ObjectSource)); var interceptingCatalog = new InterceptingCatalog(catalog, cfg); Container = new CompositionContainer(interceptingCatalog); }
public void Adding_interceptors_is_reflected_in_the_Interceptors_collection() { var cfg = new InterceptionConfiguration() .AddInterceptor(new CompositeValueInterceptor()) .AddInterceptor(new FakeInterceptor()); Assert.That(cfg.Interceptors.Count(), Is.EqualTo(2)); Assert.That(cfg.Interceptors.OfType <CompositeValueInterceptor>().Any()); Assert.That(cfg.Interceptors.OfType <FakeInterceptor>().Any()); }
public void When_querying_for_a_part_not_being_intercepted_it_should_return_original_part_definition() { var innerCatalog = new TypeCatalog(typeof(Logger)); var cfg = new InterceptionConfiguration(); var catalog = new InterceptingCatalog(innerCatalog, cfg); var partDefinition = catalog.Parts.First(); partDefinition.ShouldNotBeOfType <InterceptingComposablePartDefinition>(); }
public void Adding_part_handlers_is_reflected_in_the_PartHandlers_collection() { var cfg = new InterceptionConfiguration() .AddHandler(new FakePartHandler1()) .AddHandler(new FakePartHandler1()); Assert.That(cfg.PartHandlers.Count(), Is.EqualTo(2)); Assert.That(cfg.PartHandlers.OfType <FakePartHandler1>().Any()); Assert.That(cfg.PartHandlers.OfType <FakePartHandler1>().Any()); }
public void When_querying_for_a_part_it_should_return_an_intercepting_part_definition() { var innerCatalog = new TypeCatalog(typeof(Logger)); var mockInterceptor = new Mock <IExportedValueInterceptor>(); var cfg = new InterceptionConfiguration().AddInterceptor(mockInterceptor.Object); var catalog = new InterceptingCatalog(innerCatalog, cfg); var partDefinition = catalog.Parts.First(); partDefinition.ShouldBeOfType <InterceptingComposablePartDefinition>(); }
public void TestSetUp() { var typeCatalog = new TypeCatalog(typeof(CtorOrderProcessor), typeof(OrderProcessor), typeof(TestGenericContractRegistry)); var cfg = new InterceptionConfiguration().AddHandler(new GenericExportHandler()); var catalog = new InterceptingCatalog(typeCatalog, cfg); var provider = new CatalogExportProvider(catalog); provider.SourceProvider = provider; ExportProvider = provider; }
/// <summary> /// Initializes a new instance of the <see cref="ConventionCatalog"/> class, using the provided array part registries. /// </summary> /// <param name="registries">An array of <see cref="IPartRegistry{T}"/> instance.</param> public ConventionCatalog(params IPartRegistry <IContractService>[] registries) { if (registries == null) { throw new ArgumentNullException("registries", "The registries parameter cannot be null."); } var cfg = new InterceptionConfiguration() .AddHandler(new ConventionPartHandler(registries)); this.interceptingCatalog = new InterceptingCatalog(new EmptyCatalog(), cfg); }
public void TestSetUp() { var innerCatalog = new TypeCatalog(typeof(Part1), typeof(Part2), typeof(Part3)); var cfg = new InterceptionConfiguration() .AddInterceptor(new GeneralInterceptor()) .AddInterceptionCriteria( new PredicateInterceptionCriteria( new PartInterceptor(), d => d.Metadata.ContainsKey("metadata1"))); var catalog = new InterceptingCatalog(innerCatalog, cfg); container = new CompositionContainer(catalog); }
public void TestSetUp() { var innerCatalog = new TypeCatalog(typeof(Customer)); var interceptor = new InterfaceInterceptor(); var valueInterceptor = new DynamicProxyInterceptor(interceptor); var cfg = new InterceptionConfiguration() .AddInterceptor(valueInterceptor); var catalog = new InterceptingCatalog(innerCatalog, cfg); container = new CompositionContainer(catalog); }
public void Catalog_should_call_Initialize_on_a_given_part_handlers() { var innerCatalog = new TypeCatalog(); var partHandlerMock = new Mock <IPartHandler>(MockBehavior.Strict); partHandlerMock.Setup(p => p.Initialize(innerCatalog)).Verifiable(); var cfg = new InterceptionConfiguration() .AddHandler(partHandlerMock.Object); var catalog = new InterceptingCatalog(innerCatalog, cfg); Assert.That(catalog, Is.Not.Null); partHandlerMock.Verify(); }
public Request(ComposablePartCatalog parentCatalog, CompositionContainer parentContainer) { Console.WriteLine("/* Request */"); // Create interception configuration with non-shared parts filter var cfg = new InterceptionConfiguration() .AddHandler(new PartCreationPolicyFilter(CreationPolicy.NonShared)); // Create the InterceptingCatalog with above configuration var interceptingCatalog = new InterceptingCatalog(parentCatalog, cfg); // Create the child container this.requestContainer = new CompositionContainer(interceptingCatalog, parentContainer); }
public void Catalog_should_filter_out_parts() { var innerCatalog = new TypeCatalog(typeof(Part0), typeof(Part1), typeof(Part2), typeof(Part3)); var cfg = new InterceptionConfiguration() .AddHandler(new PartFilter()); var catalog = new InterceptingCatalog(innerCatalog, cfg); container = new CompositionContainer(catalog); var parts = container.GetExportedValues <IPart>(); Assert.That(parts.Count(), Is.EqualTo(1)); Assert.That(parts.First().GetType(), Is.EqualTo(typeof(Part0))); }
static void Main(string[] args) { AssemblyCatalog assemblyCatalog = new AssemblyCatalog(Assembly.GetExecutingAssembly()); InterceptionConfiguration cfg = new InterceptionConfiguration(); cfg.AddInterceptor(new MefContrib.Hosting.Interception.Castle.DynamicProxyInterceptor(new CastleLoggingInterceptor())); InterceptingCatalog interceptingCatalog = new InterceptingCatalog(assemblyCatalog, cfg); CompositionContainer container = new CompositionContainer(interceptingCatalog); ISampleInterface intercepted = container.GetExportedValue <ISampleInterface>(); intercepted.Say("Hello World!"); intercepted.Say(new SayArgs("Hello World with args!")); }
private ComposablePartCatalog GetInterceptionCatalog() { _applicationCatalog = new ApplicationCatalog(); _adapterdirectoryCatalog = new DirectoryCatalog(AdaptersDirectory); _pluginsdirectoryCatalog = new DirectoryCatalog(PluginsDirectory); var catalog = new AggregateCatalog(_applicationCatalog, _adapterdirectoryCatalog, _pluginsdirectoryCatalog); var cfg = new InterceptionConfiguration().AddInterceptionCriteria( new PredicateInterceptionCriteria( new CopyConfigInterceptor(_robot.Settings), def => def.ExportDefinitions.First().ContractName.Contains("IAdapter") || def.ExportDefinitions.First().ContractName.Contains("IRobotPlugin"))); return(new InterceptingCatalog(catalog, cfg)); }
public void Run() { Console.WriteLine("\n*** Interception Demo ***"); // Create source catalog var catalog = new TypeCatalog(typeof(Bar), typeof(Foo)); // Create interception configuration var cfg = new InterceptionConfiguration() // Add catalog wide startable interceptor .AddInterceptor(new StartableStrategy()) /* * .AddInterceptionCriteria( * new LogInterceptionCriteria( * new DynamicProxyInterceptor( * new LoggingInterceptor()))) */ // Add Castle DynamicProxy based logging interceptor for parts // which want to be logged, does exactly the same as the above code .AddInterceptionCriteria( new PredicateInterceptionCriteria( // Apply the interceptor only to parts which contain // Log export metadata which equals to true new DynamicProxyInterceptor(new LoggingInterceptor()), def => def.ExportDefinitions.First().Metadata.ContainsKey("Log") && def.ExportDefinitions.First().Metadata["Log"].Equals(true))); // Create the InterceptingCatalog with above configuration var interceptingCatalog = new InterceptingCatalog(catalog, cfg); // Create the container var container = new CompositionContainer(interceptingCatalog); // Bar part will be intercepted only by the startable strategy var barPart = container.GetExportedValue <IBar>(); barPart.Foo(); // Foo part will be intercepted by both startable and logging strategies var fooPart = container.GetExportedValue <IFoo>(); fooPart.Bar(); }
/// <summary> /// Initializes a new instance of the <see cref="FilteringCatalog"/> class. /// </summary> /// <param name="inner">A <see cref="ComposablePartCatalog"/> whose parts /// are to be filtered based on a given criteria.</param> /// <param name="filter">A filter query.</param> public FilteringCatalog(ComposablePartCatalog inner, Func <ComposablePartDefinition, bool> filter) { if (inner == null) { throw new ArgumentNullException("inner"); } if (filter == null) { throw new ArgumentNullException("filter"); } var cfg = new InterceptionConfiguration() .AddHandler(new FilteringPartHandler(filter)); this.interceptingCatalog = new InterceptingCatalog(inner, cfg); }
private static CompositionContainer CreateContainer1() { // Create source catalog, note we are passing the registry part. // During the runtime, GenericExportHandler will query this catalog for // all types implementing IGenericContractRegistry var typeCatalog = new TypeCatalog(typeof(Trampoline), typeof(MyGenericContractRegistry)); // Create the interception configuration and add support for open generics var cfg = new InterceptionConfiguration() .AddHandler(new GenericExportHandler()); // Create the InterceptingCatalog and pass the configuration var interceptingCatalog = new InterceptingCatalog(typeCatalog, cfg); // Create the container return(new CompositionContainer(interceptingCatalog)); }
public static IInterceptionConfiguration Intercept(this FluentAspectOptions options, Func <IInvocation, bool> predict) { if (null == predict) { throw new ArgumentNullException(nameof(predict)); } if (options.InterceptionConfigurations.TryGetValue (predict, out var interceptionConfiguration)) { return(interceptionConfiguration); } interceptionConfiguration = new InterceptionConfiguration(); options.InterceptionConfigurations[predict] = interceptionConfiguration; return(interceptionConfiguration); }
public void Disposing_catalog_should_dispose_parts_implementing_dispose_pattern() { var innerCatalog = new TypeCatalog(typeof(DisposablePart)); var cfg = new InterceptionConfiguration() .AddInterceptor(new FakeInterceptor()); var catalog = new InterceptingCatalog(innerCatalog, cfg); var partDefinition = catalog.Parts.First(); container = new CompositionContainer(catalog); partDefinition.ShouldBeOfType <InterceptingComposablePartDefinition>(); var part = container.GetExportedValueOrDefault <DisposablePart>(); Assert.That(part.IsDisposed, Is.False); container.Dispose(); Assert.That(part.IsDisposed, Is.True); }
public void When_adding_new_part_to_the_intercepted_catalog_intercepting_catalog_raises_recomposition_events() { var innerCatalog = new TypeCatalog(typeof(RecomposablePart1)); var cfg = new InterceptionConfiguration().AddInterceptor(new RecomposablePartInterceptor()); var aggregateCatalog = new AggregateCatalog(innerCatalog); var catalog = new InterceptingCatalog(aggregateCatalog, cfg); container = new CompositionContainer(catalog); uint changingEventInvokeCount = 0; uint changedEventInvokeCount = 0; catalog.Changing += (s, e) => changingEventInvokeCount++; catalog.Changed += (s, e) => changedEventInvokeCount++; // Recompose aggregateCatalog.Catalogs.Add(new TypeCatalog(typeof(RecomposablePart2))); Assert.That(changingEventInvokeCount, Is.EqualTo(1)); Assert.That(changedEventInvokeCount, Is.EqualTo(1)); }